org.gluu.oxtrust.ldap.service.StatusCheckerTimer クラス

org.gluu.oxtrust.ldap.service.StatusCheckerTimer 連携図

公開メンバ関数
void	create ()
void	initTimer ()
void	process (@Observes @Scheduled StatusCheckerTimerEvent statusCheckerTimerEvent)

非公開メンバ関数
void	processInt ()
void	setCertificateExpiryAttributes (ApplianceStatus appliance)
void	setHttpdAttributes (ApplianceStatus appliance)
String	getHttpdPage (String idpUrl, String httpdTestPageName)
void	setFactorAttributes (ApplianceStatus appliance)
void	getFacterBandwidth (String facterResult, ApplianceStatus appliance)
void	setDfAttributes (ApplianceStatus appliance)
boolean	isLinux ()
String	getFacterResult (String[] lines, String param)
Number	getFacterNumberResult (String[] lines, String param)
Number	getFacterPercentResult (String[] lines, String paramValue, String paramTotal)
Number	getNumber (String value)
Number	getNumber (Number value, Number total)
String	toIntString (Number number)

非公開変数類
Logger	log
Event< TimerEvent >	timerEvent
ApplianceService	applianceService
IGroupService	groupService
IPersonService	personService
CentralLdapService	centralLdapService
ConfigurationFactory	configurationFactory
AppConfiguration	appConfiguration
NumberFormat	numberFormat
AtomicBoolean	isActive

静的非公開変数類
static final int	DEFAULT_INTERVAL = 60

詳解

Gather periodically site and server status

著者

Yuriy Movchan Date: 11.22.2010

関数詳解

create()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.create ( )

inline

                             {
                this.numberFormat = NumberFormat.getNumberInstance(Locale.US);
        }

getFacterBandwidth()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getFacterBandwidth ( String  facterResult, ApplianceStatus  appliance  )

inlineprivate

                                                                                        {
                log.debug("Setting bandwidth attributes");
                if (facterResult != null) {
                        String[] lines = facterResult.split("\n");
                        SimpleDateFormat monthFormat = new SimpleDateFormat("MMM ''yy");
                        String month = monthFormat.format(new Date());
                        Pattern curent = Pattern.compile("^\\s*" + month);

                        for (String line : lines) {
                                Matcher match = curent.matcher(line);
                                if (match.find()) {
                                        line = line.replaceAll("^\\s*" + month, "");
                                        String[] values = line.split("\\|");
                                        appliance.setGluuBandwidthRX(values[0].replaceAll("^\\s*", "").replaceAll("\\s*$", ""));
                                        appliance.setGluuBandwidthTX(values[1].replaceAll("^\\s*", "").replaceAll("\\s*$", ""));
                                }
                        }
                } else {
                        appliance.setGluuBandwidthRX("-1");
                        appliance.setGluuBandwidthTX("-1");
                }

        }

getFacterNumberResult()

Number org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getFacterNumberResult ( String []  lines, String  param  )

inlineprivate

                                                                           {
                String value = getFacterResult(lines, param);
                if (value == null) {
                        return null;
                }

                return getNumber(value);
        }

getFacterPercentResult()

Number org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getFacterPercentResult ( String []  lines, String  paramValue, String  paramTotal  )

inlineprivate

                                                                                                    {
                Number value = getFacterNumberResult(lines, paramValue);
                Number total = getFacterNumberResult(lines, paramTotal);

                return getNumber(value, total);
        }

getFacterResult()

String org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getFacterResult ( String []  lines, String  param  )

inlineprivate

                                                                     {
                log.debug("Setting facter param: " + param);
                String paramPattern = param + OxTrustConstants.FACTER_PARAM_VALUE_DIVIDER;
                boolean valueStarted = false;
                String value = "";
                List<String> facterLines = Arrays.asList(lines);
                Iterator<String> lineIterator = facterLines.iterator();
                while (lineIterator.hasNext()) {
                        String line = lineIterator.next();

                        if (!valueStarted) { // start searching for the line with param
                                if (line.startsWith(paramPattern)) {
                                        valueStarted = true;
                                        int index = line.indexOf(OxTrustConstants.FACTER_PARAM_VALUE_DIVIDER);
                                        if (index > -1) {
                                                value = line.substring(index + OxTrustConstants.FACTER_PARAM_VALUE_DIVIDER.length());
                                        }
                                } else {
                                        continue;
                                }

                                log.debug(line);

                        } else { //check if there are any additional lines
                                int index = line.indexOf(OxTrustConstants.FACTER_PARAM_VALUE_DIVIDER);
                                if (index == -1) { // this line has no value name, so it must be continuation of the previous value.
                                        value += "\n" + line;
                                }else{ // this line has it's own value, so the value we were looking for has ended. 
                                        valueStarted = false;
                                        continue;
                                }
                        }
                }

                return value.equals("") ? null : value;
        }

getHttpdPage()

String org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getHttpdPage ( String  idpUrl, String  httpdTestPageName  )

inlineprivate

                                                                             {
                String[] urlParts = idpUrl.split("://");
                if ("https".equals(urlParts[0])) {
                        // Create a trust manager that does not validate certificate chains
                        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
                                public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                                        return null;
                                }

                                public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
                                }

                                public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
                                }
                        } };

                        // Install the all-trusting trust manager
                        try {
                                SSLContext sc = SSLContext.getInstance("SSL");
                                sc.init(null, trustAllCerts, new java.security.SecureRandom());
                                HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
                        } catch (Exception e) {
                        }
                }

                StringBuilder sb = new StringBuilder();
                // Now you can access an https URL without having the certificate in the
                // truststore
                try {
                        String[] hostAndPort = urlParts[1].split(":");
                        URL url = null;
                        if (hostAndPort.length < 2) {
                                url = new URL(urlParts[0], hostAndPort[0], httpdTestPageName);
                        } else {
                                url = new URL(urlParts[0], hostAndPort[0], Integer.parseInt(hostAndPort[1]), httpdTestPageName);
                        }
                        InputStream in = url.openConnection().getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                        String line = null;
                        while ((line = reader.readLine()) != null) {
                                sb.append(line + "\n");
                        }
                        in.close();

                } catch (Exception e) {
                        // log.error("Failed to get test page: ", e);
                }
                return sb.toString();
        }

getNumber() [1/2]

Number org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getNumber ( String  value )

inlineprivate

                                               {
                int multiplier = 1;
                if (value.contains("KB")) {
                        multiplier = 1024;
                } else if (value.contains("MB")) {
                        multiplier = 1024 * 1024;
                } else if (value.contains("GB")) {
                        multiplier = 1024 * 1024 * 1024;
                }

                try {
                        return multiplier * numberFormat.parse(value).doubleValue();
                } catch (ParseException ex) {
                }

                return null;
        }

getNumber() [2/2]

Number org.gluu.oxtrust.ldap.service.StatusCheckerTimer.getNumber ( Number  value, Number  total  )

inlineprivate

                                                             {
                if ((value == null) || (total == null) || (value.doubleValue() == 0.0d) || (total.doubleValue() == 0.0)) {
                        return null;
                }

                return NumberHelper.round(value.doubleValue() / total.doubleValue(), 2) * 100;
        }

initTimer()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.initTimer ( )

inline

                            {
        log.info("Initializing Daily Status Cheker Timer");
        this.isActive = new AtomicBoolean(false);

                final int delay = 1 * 60;
                final int interval = DEFAULT_INTERVAL;

                timerEvent.fire(new TimerEvent(new TimerSchedule(delay, interval), new StatusCheckerTimerEvent(),
                                Scheduled.Literal.INSTANCE));
    }

isLinux()

boolean org.gluu.oxtrust.ldap.service.StatusCheckerTimer.isLinux ( )

inlineprivate

                                  {
                String osName = System.getProperty("os.name");
                return !StringHelper.isEmpty(osName) && osName.toLowerCase().contains("linux");
        }

process()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.process ( @Observes @Scheduled StatusCheckerTimerEvent  statusCheckerTimerEvent )

inline

                                                                                              {
        if (this.isActive.get()) {
            return;
        }

        if (!this.isActive.compareAndSet(false, true)) {
            return;
        }

        try {
            processInt();
        } finally {
            this.isActive.set(false);
        }
    }

processInt()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.processInt ( )

inlineprivate

Gather periodically site and server status

引数

when	Date
interval	Interval

                                  {
                log.debug("Starting update of appliance status");
                AppConfiguration appConfiguration = configurationFactory.getAppConfiguration();
                if (!appConfiguration.isUpdateApplianceStatus()) {
                        return;
                }

                ApplianceStatus applianceStatus = new ApplianceStatus();

                // Execute facter and update appliance attributes
                setFactorAttributes(applianceStatus);

                // Execute df and update appliance attributes
                setDfAttributes(applianceStatus);

                // Set HTTPD attributes
                setHttpdAttributes(applianceStatus);

                try {
                        setCertificateExpiryAttributes(applianceStatus);
                } catch (Exception ex) {
                        log.error("Failed to check certificate expiration", ex);
                }

        GluuAppliance appliance = applianceService.getAppliance();
        try {
            // Copy gathered values
            BeanUtils.copyProperties(appliance, applianceStatus);
        } catch (Exception ex) {
            log.error("Failed to copy status attributes", ex);
        }

        Date currentDateTime = new Date();
        appliance.setLastUpdate(currentDateTime);

        applianceService.updateAppliance(appliance);

                if (centralLdapService.isUseCentralServer()) {
                        try {
                            GluuAppliance tmpAppliance = new GluuAppliance();
                                tmpAppliance.setDn(appliance.getDn());
                                boolean existAppliance = centralLdapService.containsAppliance(tmpAppliance);
        
                                if (existAppliance) {
                                        centralLdapService.updateAppliance(appliance);
                                } else {
                                        centralLdapService.addAppliance(appliance);
                                }
                        } catch (BasePersistenceException ex) {
                                log.error("Failed to update appliance at central server", ex);
                                return;
                        }
                }

                log.debug("Appliance status update finished");
        }

setCertificateExpiryAttributes()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.setCertificateExpiryAttributes ( ApplianceStatus  appliance )

inlineprivate

                                                                               {
                try {
                        URL destinationURL = new URL(appConfiguration.getApplianceUrl());
                        HttpsURLConnection conn = (HttpsURLConnection) destinationURL.openConnection();
                        conn.connect();
                        Certificate[] certs = conn.getServerCertificates();
                        if(certs.length > 0) {
                                if(certs[0] instanceof X509Certificate) {
                                        X509Certificate x509Certificate = (X509Certificate) certs[0];
                                        Date expirationDate = x509Certificate.getNotAfter();
                                        long expiresAfter = TimeUnit.MILLISECONDS.toDays(expirationDate.getTime() - new Date().getTime());
                                        appliance.setSslExpiry(toIntString(expiresAfter));
                                }
                        }
                }
                catch (IOException e){
                        log.error("Can not download ssl certificate", e);
                }
        }

setDfAttributes()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.setDfAttributes ( ApplianceStatus  appliance )

inlineprivate

                                                                {
                log.debug("Setting df attributes");
                // Run df only on linux
                if (!isLinux()) {
                        return;
                }

                String programPath = OxTrustConstants.PROGRAM_DF;
                CommandLine commandLine = new CommandLine(programPath);
                commandLine.addArgument("/");
                commandLine.addArgument("--human-readable");

                ByteArrayOutputStream bos = new ByteArrayOutputStream(4096);
                try {
                        boolean result = ProcessHelper.executeProgram(commandLine, false, 0, bos);
                        if (!result) {
                                return;
                        }
                } finally {
                        IOUtils.closeQuietly(bos);
                }

                String resultOutput = null;
                try {
                        resultOutput = new String(bos.toByteArray(), "UTF-8");
                } catch (UnsupportedEncodingException ex) {
                        log.error("Failed to parse program {} output", programPath, ex);
                        return;
                }

                String[] outputLines = resultOutput.split("\\r?\\n");
                String[] outputValues = null;
                if (outputLines.length == 2) {
                        outputValues = outputLines[1].split("\\s+");
                } else if (outputLines.length == 3) {
                        outputValues = outputLines[2].split("\\s+");
                }

                if (outputValues != null) {
                        if (outputValues.length < 6) {
                                return;
                        }

                        Number usedDiskSpace = getNumber(outputValues[4]);
                        Number freeDiskSpace = usedDiskSpace == null ? null : 100 - usedDiskSpace.doubleValue();

                        // Update appliance attributes
                        appliance.setFreeDiskSpace(toIntString(freeDiskSpace));
                }
        }

setFactorAttributes()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.setFactorAttributes ( ApplianceStatus  appliance )

inlineprivate

                                                                    {
                log.debug("Setting facter attributes");
                // Run facter only on linux
                if (!isLinux()) {
                        return;
                }

                String programPath = OxTrustConstants.PROGRAM_FACTER;

                ByteArrayOutputStream bos = new ByteArrayOutputStream(4096);
                try {
                        boolean result = ProcessHelper.executeProgram(programPath, false, 0, bos);
                        if (!result) {
                                return;
                        }
                } finally {
                        IOUtils.closeQuietly(bos);
                }

                String resultOutput = null;
                try {
                        resultOutput = new String(bos.toByteArray(), "UTF-8");
                } catch (UnsupportedEncodingException ex) {
                        log.error("Failed to parse program {} output", programPath, ex);
                        return;
                }

                String[] outputLines = resultOutput.split("\\r?\\n");

                // Update appliance attributes
                appliance.setFreeMemory(toIntString(getFacterPercentResult(outputLines, OxTrustConstants.FACTER_FREE_MEMORY,
                                OxTrustConstants.FACTER_FREE_MEMORY_TOTAL)));
                appliance.setFreeSwap(toIntString(getFacterPercentResult(outputLines, OxTrustConstants.FACTER_FREE_SWAP,
                                OxTrustConstants.FACTER_FREE_SWAP_TOTAL)));
                appliance.setHostname(getFacterResult(outputLines, OxTrustConstants.FACTER_HOST_NAME));
                appliance.setIpAddress(getFacterResult(outputLines, OxTrustConstants.FACTER_IP_ADDRESS));

                appliance.setLoadAvg(getFacterResult(outputLines, OxTrustConstants.FACTER_LOAD_AVERAGE));

                getFacterBandwidth(getFacterResult(outputLines, OxTrustConstants.FACTER_BANDWIDTH_USAGE), appliance);
                appliance.setSystemUptime(getFacterResult(outputLines, OxTrustConstants.FACTER_SYSTEM_UP_TIME));
        }

setHttpdAttributes()

void org.gluu.oxtrust.ldap.service.StatusCheckerTimer.setHttpdAttributes ( ApplianceStatus  appliance )

inlineprivate

                                                                   {
                log.debug("Setting httpd attributes");
                AppConfiguration appConfiguration = configurationFactory.getAppConfiguration();
                String page = getHttpdPage(appConfiguration.getIdpUrl(), OxTrustConstants.HTTPD_TEST_PAGE_NAME);
                appliance.setGluuHttpStatus(Boolean.toString(OxTrustConstants.HTTPD_TEST_PAGE_CONTENT.equals(page)));

        }

toIntString()

String org.gluu.oxtrust.ldap.service.StatusCheckerTimer.toIntString ( Number  number )

inlineprivate

                                                  {
                return (number == null) ? null : String.valueOf(number.intValue());
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.ldap.service.StatusCheckerTimer.appConfiguration

private

applianceService

ApplianceService org.gluu.oxtrust.ldap.service.StatusCheckerTimer.applianceService

private

centralLdapService

CentralLdapService org.gluu.oxtrust.ldap.service.StatusCheckerTimer.centralLdapService

private

configurationFactory

ConfigurationFactory org.gluu.oxtrust.ldap.service.StatusCheckerTimer.configurationFactory

private

DEFAULT_INTERVAL

final int org.gluu.oxtrust.ldap.service.StatusCheckerTimer.DEFAULT_INTERVAL = 60

staticprivate

groupService

IGroupService org.gluu.oxtrust.ldap.service.StatusCheckerTimer.groupService

private

isActive

AtomicBoolean org.gluu.oxtrust.ldap.service.StatusCheckerTimer.isActive

private

log

Logger org.gluu.oxtrust.ldap.service.StatusCheckerTimer.log

private

numberFormat

NumberFormat org.gluu.oxtrust.ldap.service.StatusCheckerTimer.numberFormat

private

personService

IPersonService org.gluu.oxtrust.ldap.service.StatusCheckerTimer.personService

private

timerEvent

Event<TimerEvent> org.gluu.oxtrust.ldap.service.StatusCheckerTimer.timerEvent

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/ldap/service/StatusCheckerTimer.java