Example usage for org.apache.commons.collections MapUtils getIntValue

List of usage examples for org.apache.commons.collections MapUtils getIntValue

Introduction

In this page you can find the example usage for org.apache.commons.collections MapUtils getIntValue.

Prototype

public static int getIntValue(final Map map, final Object key, int defaultValue) 

Source Link

Document

Gets an int from a Map in a null-safe manner, using the default value if the the conversion fails.

Usage

From source file:net.me2day.async.processor.sample.DummyDistributableEventProcessor.java

@Override
public void initializeCompleted(Scope scope, Map<String, Object> configurationMap) {
    if (!ticket.equals(scope.getTarget())) {
        return;//from   www.  j  av  a  2  s. c  o  m
    }

    int percentage = MapUtils.getIntValue(configurationMap, "failPercentage", 10);
    if (percentage > 100) {
        percentage = 100;
    }
    configurationMap.put("failPercentage", percentage);

    long time = MapUtils.getLongValue(configurationMap, "sleepTime", 100);
    configurationMap.put("sleepTime", time);

    failPercentage = percentage;
    sleepTime = time;
}

From source file:com.navercorp.pinpoint.common.server.bo.codec.stat.v1.ActiveTraceCodecV1.java

@Override
public void encodeValues(Buffer valueBuffer, List<ActiveTraceBo> activeTraceBos) {
    if (CollectionUtils.isEmpty(activeTraceBos)) {
        throw new IllegalArgumentException("activeTraceBos must not be empty");
    }//  ww w.j a va2 s  . c  om
    final int numValues = activeTraceBos.size();
    valueBuffer.putVInt(numValues);

    List<Long> timestamps = new ArrayList<Long>(numValues);
    UnsignedShortEncodingStrategy.Analyzer.Builder versionAnalyzerBuilder = new UnsignedShortEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder schemaTypeAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder fastTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder normalTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder slowTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder verySlowTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    for (ActiveTraceBo activeTraceBo : activeTraceBos) {
        timestamps.add(activeTraceBo.getTimestamp());
        versionAnalyzerBuilder.addValue(activeTraceBo.getVersion());
        schemaTypeAnalyzerBuilder.addValue(activeTraceBo.getHistogramSchemaType());
        final Map<SlotType, Integer> activeTraceCounts = activeTraceBo.getActiveTraceCounts();
        fastTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.FAST,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
        normalTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.NORMAL,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
        slowTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.SLOW,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
        verySlowTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.VERY_SLOW,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
    }
    this.codec.encodeTimestamps(valueBuffer, timestamps);
    this.encodeDataPoints(valueBuffer, versionAnalyzerBuilder.build(), schemaTypeAnalyzerBuilder.build(),
            fastTraceCountsAnalyzerBuilder.build(), normalTraceCountsAnalyzerBuilder.build(),
            slowTraceCountsAnalyzerBuilder.build(), verySlowTraceCountsAnalyzerBuilder.build());
}

From source file:com.navercorp.pinpoint.common.server.bo.codec.stat.v2.ActiveTraceCodecV2.java

@Override
public void encodeValues(Buffer valueBuffer, List<ActiveTraceBo> activeTraceBos) {
    if (CollectionUtils.isEmpty(activeTraceBos)) {
        throw new IllegalArgumentException("activeTraceBos must not be empty");
    }//from  w  w  w  .j  a v a 2s  . c om
    final int numValues = activeTraceBos.size();
    valueBuffer.putVInt(numValues);

    List<Long> startTimestamps = new ArrayList<Long>(numValues);
    List<Long> timestamps = new ArrayList<Long>(numValues);
    UnsignedShortEncodingStrategy.Analyzer.Builder versionAnalyzerBuilder = new UnsignedShortEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder schemaTypeAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder fastTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder normalTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder slowTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    UnsignedIntegerEncodingStrategy.Analyzer.Builder verySlowTraceCountsAnalyzerBuilder = new UnsignedIntegerEncodingStrategy.Analyzer.Builder();
    for (ActiveTraceBo activeTraceBo : activeTraceBos) {
        startTimestamps.add(activeTraceBo.getStartTimestamp());
        timestamps.add(activeTraceBo.getTimestamp());
        versionAnalyzerBuilder.addValue(activeTraceBo.getVersion());
        schemaTypeAnalyzerBuilder.addValue(activeTraceBo.getHistogramSchemaType());
        final Map<SlotType, Integer> activeTraceCounts = activeTraceBo.getActiveTraceCounts();
        fastTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.FAST,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
        normalTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.NORMAL,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
        slowTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.SLOW,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
        verySlowTraceCountsAnalyzerBuilder.addValue(MapUtils.getIntValue(activeTraceCounts, SlotType.VERY_SLOW,
                ActiveTraceBo.UNCOLLECTED_ACTIVE_TRACE_COUNT));
    }
    this.codec.encodeValues(valueBuffer, UnsignedLongEncodingStrategy.REPEAT_COUNT, startTimestamps);
    this.codec.encodeTimestamps(valueBuffer, timestamps);
    this.encodeDataPoints(valueBuffer, versionAnalyzerBuilder.build(), schemaTypeAnalyzerBuilder.build(),
            fastTraceCountsAnalyzerBuilder.build(), normalTraceCountsAnalyzerBuilder.build(),
            slowTraceCountsAnalyzerBuilder.build(), verySlowTraceCountsAnalyzerBuilder.build());
}

From source file:net.sf.zekr.ui.BrowserCallbackHandler.java

public Object newCallbackHandler(Object[] args) {
    String method = (String) args[0];
    if (ArrayUtils.contains(new String[] { "ZEKR::GOTO", "ZEKR::REDIRECT" }, method)) {
        int sura = 0, aya = 0, page = 0;
        try {/*from  w  ww  . jav  a 2s. co m*/
            sura = Integer.parseInt(((String) args[1]).trim());
            aya = Integer.parseInt(((String) args[2]).trim());
            if (args.length > 3) {
                page = Integer.parseInt(((String) args[3]).trim());
            }
        } catch (Exception e) {
            return null; // do nothing
        }
        logger.info("Goto (sura: " + sura + ", aya: " + aya + ", page: " + page + ")");
        form.browserGoto(sura, aya, page, method.startsWith("ZEKR::REDIRECT"));
    } else if ("ZEKR::TRANS".equals(method) && config.getTranslation().getDefault() != null) {
        int sura;
        int aya;
        try {
            sura = Integer.parseInt(((String) args[1]).trim());
            aya = Integer.parseInt(((String) args[2]).trim());
        } catch (Exception e1) {
            return null; // do nothing
        }
        PopupBox pe = null;
        boolean isQuranTarget = false;
        if (form.uvc.getViewMode() == IUserView.VM_ADVANCED_SEARCH) {
            isQuranTarget = form.advancedQuranTargetBut.getSelection();
        } else if (form.uvc.getViewMode() == IUserView.VM_SEARCH) {
            isQuranTarget = form.quranTargetBut.getSelection();
        } else { // root
            isQuranTarget = true;
        }

        if (isQuranTarget) {
            logger.info("Show translation: (" + sura + ", " + aya + ")");
            TranslationData td = config.getTranslation().getDefault();
            pe = new PopupBox(form.shell, form.meaning("TRANSLATION_SCOPE"), td.get(sura, aya),
                    FormUtils.toSwtDirection(td.direction));
        } else {
            logger.info("Show quran: (" + sura + ", " + aya + ")");
            try {
                pe = new PopupBox(form.shell, form.meaning("QURAN_SCOPE"),
                        new FilteredQuranText(IQuranText.SIMPLE_MODE, IQuranFilter.NONE).get(sura, aya),
                        SWT.RIGHT_TO_LEFT);
            } catch (IOException e) {
                logger.log(e);
            }
        }
        Point p = form.display.getCursorLocation();
        p.y += 15;
        int x = 300;
        pe.open(new Point(x, 100), new Point(p.x - x / 2, p.y));
    } else if ("ZEKR::NEXT".equals(method)) {
        form.quranFormController.gotoNextAya();
    } else if ("ZEKR::PLAY".equals(method)) {
        IQuranLocation loc = QuranPropertiesUtils.getLocation((String) args[1]);
        boolean play = Boolean.parseBoolean((String) args[2]);
        if (play) {
            PlayableObject playableObject = config.getAudioCacheManager().getPlayableObject(loc, 0);
            if (playableObject == null) {
                logger.error("Search result audio for this location cannot be loaded: " + loc);
            } else {
                logger.debug(String.format("Open search result playable object: %s.", playableObject));
                form.searchPlayerController.open(playableObject);
                form.searchPlayerController.setVolume(config.getPlayerController().getVolume());
                form.searchPlayerController.play();
            }
        } else {
            form.searchPlayerController.stop();
        }
    } else if ("ZEKR::ZOOM".equals(method)) {
        int zoom = (int) Double.parseDouble(args[1].toString());
        String layout = config.getViewLayout();
        boolean onlyTrans = false;
        boolean onlyQuran = false;
        if (ApplicationConfig.SEPARATE_LAYOUT.equals(layout)) {
            onlyTrans = Boolean.parseBoolean(args[2].toString());
            onlyQuran = !Boolean.parseBoolean(args[2].toString());
        }

        ThemeData themeData = config.getTheme().getCurrent();
        Map<String, String> props = themeData.props;

        if (!onlyQuran) {
            for (Entry<String, String> entry : props.entrySet()) {
                String key = entry.getKey();
                if (key.startsWith("trans_") && key.endsWith("fontSize")) {
                    int transFontSize = MapUtils.getIntValue(props, key, 10);
                    transFontSize += zoom;
                    props.put(key, String.valueOf(transFontSize));
                }
            }
        }

        if (!onlyTrans) {
            String quranFontSizeKey = "quran_fontSize";
            int quranFontSize = MapUtils.getIntValue(props, quranFontSizeKey, 10);
            quranFontSize += zoom;
            props.put(quranFontSizeKey, String.valueOf(quranFontSize));
        }

        EventUtils.sendEvent(EventProtocol.REFRESH_VIEW);
    }
    return null;
}

From source file:com.ctrip.infosec.rule.executor.ModelRulesExecutorService.java

/**
 * /*  www . j  av a  2s  .  co  m*/
 */
public void execute(RiskFact fact) {

    // matchRules      
    List<ModelRule> matchedRules = Configs.matchModelRules(fact);
    List<String> scriptRulePackageNames = Collections3.extractToList(matchedRules, "ruleNo");
    logger.debug(
            Contexts.getLogPrefix() + "matched model rules: " + StringUtils.join(scriptRulePackageNames, ", "));
    TraceLogger.traceLog("? " + matchedRules.size() + " ? ...");

    StatelessModelRuleEngine statelessModelRuleEngine = SpringContextHolder
            .getBean(StatelessModelRuleEngine.class);
    for (ModelRule rule : matchedRules) {
        RuleMonitorHelper.newTrans(fact, RuleMonitorType.MODEL_RULE, rule.getRuleNo());
        TraceLogger.beginNestedTrans(fact.eventId);
        TraceLogger.setNestedLogPrefix("[" + rule.getRuleNo() + "]");
        Contexts.setPolicyOrRuleNo(rule.getRuleNo());
        try {
            long start = System.currentTimeMillis();

            // add current execute ruleNo and logPrefix before execution
            fact.ext.put(Constants.key_ruleNo, rule.getRuleNo());
            fact.ext.put(Constants.key_isAsync, true);

            statelessModelRuleEngine.execute(rule.getRuleNo(), fact);

            // remove current execute ruleNo when finished execution.
            fact.ext.remove(Constants.key_ruleNo);
            fact.ext.remove(Constants.key_isAsync);

            long handlingTime = System.currentTimeMillis() - start;
            if (handlingTime > 100) {
                logger.info(Contexts.getLogPrefix() + "modelRule: " + rule.getRuleNo() + ", usage: "
                        + handlingTime + "ms");
            }

            Map<String, Object> result = fact.modelResults.get(rule.getRuleNo());
            if (result != null) {
                int riskLevel = MapUtils.getIntValue(result, Constants.riskLevel, 0);
                if (riskLevel > 0) {
                    TraceLogger.traceLog(">>>> [" + rule.getRuleNo() + "] : [] riskLevel = "
                            + result.get(Constants.riskLevel) + ", riskMessage = "
                            + result.get(Constants.riskMessage) + ", usage = " + result.get(Constants.timeUsage)
                            + "ms");
                }
            }

        } catch (Throwable ex) {
            logger.warn(Contexts.getLogPrefix() + ". modelRule: " + rule.getRuleNo(),
                    ex);
            TraceLogger.traceLog("[" + rule.getRuleNo() + "] EXCEPTION: " + ex.toString());
        } finally {
            TraceLogger.commitNestedTrans();
            RuleMonitorHelper.commitTrans(fact);
            Contexts.clearLogPrefix();
        }
    }

}

From source file:com.pinterest.teletraan.ConfigHelper.java

public static void scheduleWorkers(TeletraanServiceConfiguration configuration,
        TeletraanServiceContext serviceContext) throws Exception {
    List<WorkerConfig> workerConfigs = configuration.getWorkerConfigs();
    for (WorkerConfig config : workerConfigs) {
        String workerName = config.getName();
        Map<String, String> properties = config.getProperties();
        int defaultValue = new Random().nextInt(30);
        int initDelay = MapUtils.getIntValue(properties, "initialDelay", defaultValue);
        int period = MapUtils.getIntValue(properties, "period", DEFAULT_PERIOD);

        if (workerName.equalsIgnoreCase(StateTransitioner.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new StateTransitioner(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled StateTransitioner.");
        }//from w ww  . j  av  a2  s  . c o  m

        if (workerName.equalsIgnoreCase(AutoPromoter.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new AutoPromoter(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled AutoPromoter.");
        }

        if (workerName.equalsIgnoreCase(HotfixStateTransitioner.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new HotfixStateTransitioner(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled HotfixStateTransitioner.");
        }

        if (workerName.equalsIgnoreCase(SimpleAgentJanitor.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            int minStaleHostThreshold = MapUtils.getIntValue(properties, "minStaleHostThreshold",
                    DEFAULT_MIN_STALE_HOST_THRESHOLD);
            int maxStaleHostThreshold = MapUtils.getIntValue(properties, "maxStaleHostThreshold",
                    DEFAULT_MAX_STALE_HOST_THRESHOLD);
            Runnable worker = new SimpleAgentJanitor(serviceContext, minStaleHostThreshold,
                    maxStaleHostThreshold);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled SimpleAgentJanitor.");
        }

        if (workerName.equalsIgnoreCase(AgentJanitor.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            int minStaleHostThreshold = MapUtils.getIntValue(properties, "minStaleHostThreshold",
                    DEFAULT_MIN_STALE_HOST_THRESHOLD);
            int maxStaleHostThreshold = MapUtils.getIntValue(properties, "maxStaleHostThreshold",
                    DEFAULT_MAX_STALE_HOST_THRESHOLD);
            int maxLaunchLatencyThreshold = MapUtils.getIntValue(properties, "maxLaunchLaencyThreshold",
                    DEFAULT_LAUNCH_LATENCY_THRESHOLD);
            Runnable worker = new AgentJanitor(serviceContext, minStaleHostThreshold, maxStaleHostThreshold,
                    maxLaunchLatencyThreshold);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled AgentJanitor.");
        }

        // Schedule cron like jobs
        JobDetail deployJanitorJob = null;
        CronTrigger deployJanitorTrigger = null;
        if (workerName.equalsIgnoreCase(DeployJanitor.class.getSimpleName())) {
            String schedule = MapUtils.getString(properties, "schedule", DEFAULT_DEPLOY_JANITOR_SCHEDULE);
            deployJanitorJob = JobBuilder.newJob(DeployJanitor.class).withIdentity("deployJanitorJob", "group1")
                    .build();
            deployJanitorTrigger = TriggerBuilder.newTrigger().forJob(deployJanitorJob)
                    .withSchedule(CronScheduleBuilder.cronSchedule(schedule)).build();
        }
        JobDetail buildJanitorJob = null;
        CronTrigger buildJanitorTrigger = null;
        if (workerName.equalsIgnoreCase(BuildJanitor.class.getSimpleName())) {
            String schedule = MapUtils.getString(properties, "schedule", DEFAULT_BUILD_JANITOR_SCHEDULE);
            int maxDaysToKeep = MapUtils.getIntValue(properties, "minStaleHostThreshold",
                    DEFAULT_MAX_DAYS_TO_KEEP);
            int maxBuildsToKeep = MapUtils.getIntValue(properties, "maxStaleHostThreshold",
                    DEFAULT_MAX_BUILDS_TO_KEEP);
            serviceContext.setMaxDaysToKeep(maxDaysToKeep);
            serviceContext.setMaxBuildsToKeep(maxBuildsToKeep);
            buildJanitorJob = JobBuilder.newJob(BuildJanitor.class).withIdentity("buildJanitorJob", "group1")
                    .build();
            buildJanitorTrigger = TriggerBuilder.newTrigger().forJob(buildJanitorJob)
                    .withSchedule(CronScheduleBuilder.cronSchedule(schedule)).build();
        }

        if (deployJanitorTrigger != null || buildJanitorTrigger != null) {
            Scheduler cronScheduler = new StdSchedulerFactory().getScheduler();
            cronScheduler.getContext().put("serviceContext", serviceContext);
            cronScheduler.start();
            if (deployJanitorTrigger != null) {
                cronScheduler.scheduleJob(deployJanitorJob, deployJanitorTrigger);
                LOG.info("Scheduled DeployJanitor.");
            }
            if (buildJanitorTrigger != null) {
                cronScheduler.scheduleJob(buildJanitorJob, buildJanitorTrigger);
                LOG.info("Scheduled BuildJanitor.");
            }
        }

        // TODO Arcee specific workers
        if (workerName.equalsIgnoreCase(LaunchLatencyUpdater.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new LaunchLatencyUpdater(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled LaunchLatencyUpdater.");
        }

        if (workerName.equalsIgnoreCase(MetricsCollector.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new MetricsCollector(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.SECONDS);
            LOG.info("Scheduled MetricsCollector.");
        }

        if (workerName.equalsIgnoreCase(GroupInfoCollector.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new GroupInfoCollector(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled GroupInfoCollector.");
        }

        if (workerName.equalsIgnoreCase(GroupInfoUpdater.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new GroupInfoUpdater(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled GroupInfoUpdater.");
        }

        if (workerName.equalsIgnoreCase(LaunchEventCollector.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new LaunchEventCollector(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled LaunchEventCollector.");
        }

        if (workerName.equalsIgnoreCase(HostTerminator.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new HostTerminator(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled HostTerminator.");
        }

        if (workerName.equalsIgnoreCase(HealthChecker.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new HealthChecker(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled HealthChecker.");
        }

        if (workerName.equalsIgnoreCase(HealthCheckInserter.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new HealthCheckInserter(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled HealthCheckInserter.");
        }

        if (workerName.equalsIgnoreCase(HealthCheckHostTerminator.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new HealthCheckHostTerminator(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled HealthCheckHostTerminator.");
        }

        if (workerName.equalsIgnoreCase(NewInstanceChecker.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new NewInstanceChecker(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled NewInstanceChecker.");
        }

        if (workerName.equalsIgnoreCase(LifecycleUpdator.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new LifecycleUpdator(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled LifecycleUpdator.");
        }

        if (workerName.equalsIgnoreCase(ReservedInstanceScheduler.class.getSimpleName())) {
            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
            Runnable worker = new ReservedInstanceScheduler(serviceContext);
            scheduler.scheduleAtFixedRate(worker, initDelay, period, TimeUnit.MINUTES);
            LOG.info("Scheduled ReservedInstanceScheduler.");
        }
    }
}

From source file:com.ctrip.infosec.rule.executor.RulesExecutorService.java

/**
 * //  w  ww. j  a  va2s. c  om
 */
void executeSerial(RiskFact fact) {

    // matchRules      
    List<Rule> matchedRules = Configs.matchRules(fact, true);
    TraceLogger.traceLog("? " + matchedRules.size() + " ? ...");
    StatelessRuleEngine statelessRuleEngine = SpringContextHolder.getBean(StatelessRuleEngine.class);

    StopWatch clock = new StopWatch();
    for (Rule rule : matchedRules) {
        String packageName = rule.getRuleNo();
        RuleMonitorHelper.newTrans(fact, RuleMonitorType.RULE, packageName);
        TraceLogger.beginNestedTrans(fact.eventId);
        TraceLogger.setNestedLogPrefix("[" + packageName + "]");
        Contexts.setPolicyOrRuleNo(packageName);
        try {
            clock.reset();
            clock.start();

            // set default result
            if (!Constants.eventPointsWithScene.contains(fact.eventPoint)) {
                Map<String, Object> defaultResult = Maps.newHashMap();
                defaultResult.put(Constants.riskLevel, 0);
                defaultResult.put(Constants.riskMessage, "PASS");
                fact.results4Async.put(rule.getRuleNo(), defaultResult);
            }

            // add current execute ruleNo and logPrefix before execution
            fact.ext.put(Constants.key_ruleNo, rule.getRuleNo());
            fact.ext.put(Constants.key_isAsync, true);

            statelessRuleEngine.execute(packageName, fact);

            // remove current execute ruleNo when finished execution.
            fact.ext.remove(Constants.key_ruleNo);
            fact.ext.remove(Constants.key_isAsync);

            clock.stop();
            long handlingTime = clock.getTime();

            if (!Constants.eventPointsWithScene.contains(fact.eventPoint)) {

                Map<String, Object> resultWithScene = fact.resultsGroupByScene4Async.get(packageName);
                if (resultWithScene != null) {
                    resultWithScene.put(Constants.async, false);
                    resultWithScene.put(Constants.timeUsage, handlingTime);

                    TraceLogger.traceLog(">>>> [" + packageName
                            + "] : [???] riskLevel = "
                            + resultWithScene.get(Constants.riskLevel) + ", riskMessage = "
                            + resultWithScene.get(Constants.riskMessage) + ", riskScene = "
                            + resultWithScene.get(Constants.riskScene) + ", usage = "
                            + resultWithScene.get(Constants.timeUsage) + "ms");
                }

                Map<String, Object> result = fact.results4Async.get(packageName);
                if (result != null) {
                    result.put(Constants.async, true);
                    result.put(Constants.timeUsage, handlingTime);

                    TraceLogger.traceLog(">>>> [" + packageName + "] : riskLevel = "
                            + result.get(Constants.riskLevel) + ", riskMessage = "
                            + result.get(Constants.riskMessage) + ", usage = " + result.get(Constants.timeUsage)
                            + "ms");
                }

            } else {

                Map<String, Object> result = fact.results4Async.get(packageName);
                if (result != null) {
                    result.put(Constants.async, false);
                    result.put(Constants.timeUsage, handlingTime);
                    int riskLevel = MapUtils.getIntValue(result, Constants.riskLevel, 0);
                    if (riskLevel > 0) {
                        TraceLogger.traceLog(">>>> [" + packageName
                                + "] : [?] riskLevel = "
                                + result.get(Constants.riskLevel) + ", riskMessage = "
                                + result.get(Constants.riskMessage) + ", usage = "
                                + result.get(Constants.timeUsage) + "ms");
                    }
                }

                Map<String, Object> resultWithScene = fact.resultsGroupByScene4Async.get(packageName);
                if (resultWithScene != null) {
                    resultWithScene.put(Constants.async, true);
                    resultWithScene.put(Constants.timeUsage, handlingTime);

                    TraceLogger.traceLog(">>>> [" + packageName + "] [?]: riskLevel = "
                            + resultWithScene.get(Constants.riskLevel) + ", riskMessage = "
                            + resultWithScene.get(Constants.riskMessage) + ", riskScene = "
                            + resultWithScene.get(Constants.riskScene) + ", usage = "
                            + resultWithScene.get(Constants.timeUsage) + "ms");
                } else {
                    TraceLogger.traceLog(
                            ">>>> [" + packageName + "] [?]: ?");
                }
            }

        } catch (Throwable ex) {
            logger.warn(Contexts.getLogPrefix() + ". packageName: " + packageName, ex);
            TraceLogger.traceLog("[" + rule.getRuleNo() + "] EXCEPTION: " + ex.toString());
        } finally {
            TraceLogger.commitNestedTrans();
            RuleMonitorHelper.commitTrans(fact);
            Contexts.clearLogPrefix();
        }
    }
}

From source file:com.ctrip.infosec.rule.executor.RulesExecutorService.java

/**
 * /*from   w w w .ja  v  a  2s  . com*/
 */
void executeParallel(RiskFact fact) {

    // matchRules        
    List<Rule> matchedRules = Configs.matchRules(fact, false);

    TraceLogger.traceLog("? " + matchedRules.size() + " ? ...");
    List<Callable<RuleExecuteResultWithEvent>> runs = Lists.newArrayList();
    for (Rule rule : matchedRules) {
        final RiskFact factCopy = BeanMapper.copy(fact, RiskFact.class);

        // set default result
        if (!Constants.eventPointsWithScene.contains(factCopy.eventPoint)) {
            Map<String, Object> defaultResult = Maps.newHashMap();
            defaultResult.put(Constants.riskLevel, 0);
            defaultResult.put(Constants.riskMessage, "PASS");
            factCopy.results.put(rule.getRuleNo(), defaultResult);
        }

        final StatelessRuleEngine statelessRuleEngine = SpringContextHolder.getBean(StatelessRuleEngine.class);
        final String packageName = rule.getRuleNo();
        final String _logPrefix = Contexts.getLogPrefix();
        final String _traceLoggerParentTransId = TraceLogger.getTransId();

        try {
            // add current execute ruleNo before execution
            factCopy.ext.put(Constants.key_ruleNo, rule.getRuleNo());
            factCopy.ext.put(Constants.key_isAsync, false);

            runs.add(new Callable<RuleExecuteResultWithEvent>() {

                @Override
                public RuleExecuteResultWithEvent call() throws Exception {
                    RuleMonitorHelper.newTrans(factCopy, RuleMonitorType.RULE, packageName);
                    TraceLogger.beginTrans(factCopy.eventId);
                    TraceLogger.setParentTransId(_traceLoggerParentTransId);
                    TraceLogger.setLogPrefix("[" + packageName + "]");
                    Contexts.setPolicyOrRuleNo(packageName);
                    try {
                        long start = System.currentTimeMillis();
                        // remove current execute ruleNo when finished execution.
                        statelessRuleEngine.execute(packageName, factCopy);

                        long handlingTime = System.currentTimeMillis() - start;

                        if (!Constants.eventPointsWithScene.contains(factCopy.eventPoint)) {

                            Map<String, Object> resultWithScene = factCopy.resultsGroupByScene.get(packageName);
                            if (resultWithScene != null) {
                                resultWithScene.put(Constants.async, false);
                                resultWithScene.put(Constants.timeUsage, handlingTime);

                                TraceLogger.traceLog(">>>> [" + packageName
                                        + "] : [???] riskLevel = "
                                        + resultWithScene.get(Constants.riskLevel) + ", riskMessage = "
                                        + resultWithScene.get(Constants.riskMessage) + ", riskScene = "
                                        + resultWithScene.get(Constants.riskScene) + ", usage = "
                                        + resultWithScene.get(Constants.timeUsage) + "ms");
                            }

                            Map<String, Object> result = factCopy.results.get(packageName);
                            if (result != null) {
                                result.put(Constants.async, false);
                                result.put(Constants.timeUsage, handlingTime);

                                TraceLogger.traceLog(">>>> [" + packageName + "] : riskLevel = "
                                        + result.get(Constants.riskLevel) + ", riskMessage = "
                                        + result.get(Constants.riskMessage) + ", usage = "
                                        + result.get(Constants.timeUsage) + "ms");
                            }

                        } else {

                            Map<String, Object> result = factCopy.results.get(packageName);
                            if (result != null) {
                                result.put(Constants.async, false);
                                result.put(Constants.timeUsage, handlingTime);
                                int riskLevel = MapUtils.getIntValue(result, Constants.riskLevel, 0);
                                if (riskLevel > 0) {
                                    TraceLogger.traceLog(">>>> [" + packageName
                                            + "] [?]: [??] riskLevel = "
                                            + result.get(Constants.riskLevel) + ", riskMessage = "
                                            + result.get(Constants.riskMessage) + ", usage = "
                                            + result.get(Constants.timeUsage) + "ms");
                                }
                            }

                            Map<String, Object> resultWithScene = factCopy.resultsGroupByScene.get(packageName);
                            if (resultWithScene != null) {
                                resultWithScene.put(Constants.async, false);
                                resultWithScene.put(Constants.timeUsage, handlingTime);

                                TraceLogger.traceLog(
                                        ">>>> [" + packageName + "] [?]: riskLevel = "
                                                + resultWithScene.get(Constants.riskLevel) + ", riskMessage = "
                                                + resultWithScene.get(Constants.riskMessage) + ", riskScene = "
                                                + resultWithScene.get(Constants.riskScene) + ", usage = "
                                                + resultWithScene.get(Constants.timeUsage) + "ms");
                            } else {
                                TraceLogger.traceLog(">>>> [" + packageName
                                        + "] [?]: ?");
                            }
                        }
                        return new RuleExecuteResultWithEvent(packageName, factCopy.results,
                                factCopy.resultsGroupByScene, factCopy.eventBody, factCopy.ext);
                    } catch (Exception e) {
                        logger.warn(_logPrefix + ". packageName: " + packageName, e);
                    } finally {
                        TraceLogger.commitTrans();
                        RuleMonitorHelper.commitTrans2Trunk(factCopy);
                        Contexts.clearLogPrefix();
                    }
                    return null;
                }

            });

        } catch (Throwable ex) {
            logger.warn(_logPrefix + ". packageName: " + packageName, ex);
        }

    }
    List<RuleExecuteResultWithEvent> rawResult = new ArrayList<RuleExecuteResultWithEvent>();
    try {
        List<Future<RuleExecuteResultWithEvent>> results = ParallelExecutorHolder.excutor.invokeAll(runs,
                timeout, TimeUnit.MILLISECONDS);
        for (Future f : results) {
            try {
                if (f.isDone()) {
                    RuleExecuteResultWithEvent r = (RuleExecuteResultWithEvent) f.get();
                    rawResult.add(r);
                } else {
                    f.cancel(true);
                }
            } catch (Exception e) {
                // ignored
            }
        }
    } catch (Exception e) {
        // ignored
    }
    if (rawResult.size() > 0) {
        for (RuleExecuteResultWithEvent item : rawResult) {
            // merge eventBody
            if (item.getEventBody() != null) {
                for (String key : item.getEventBody().keySet()) {
                    Object value = item.getEventBody().get(key);
                    if (!fact.eventBody.containsKey(key) && value != null) {
                        fact.eventBody.put(key, value);
                    }
                }
            }
            // merge ext
            if (item.getExt() != null) {
                for (String key : item.getExt().keySet()) {
                    Object value = item.getExt().get(key);
                    if (!fact.ext.containsKey(key) && value != null) {
                        fact.ext.put(key, value);
                    }
                }
            }
            // merge results
            if (item.getResults() != null) {
                fact.results.putAll(item.getResults());
            }
            // merge resultsGroupByScene
            if (item.getResultsGroupByScene() != null) {
                fact.resultsGroupByScene.putAll(item.getResultsGroupByScene());
            }
        }
    }
}

From source file:org.datacleaner.user.QuickAnalysisStrategy.java

/**
 * Loads {@link QuickAnalysisStrategy} from a {@link UserPreferences}
 * object./*from w w w  .j ava 2 s.co m*/
 * 
 * @param userPreferences
 * @return
 */
public static QuickAnalysisStrategy loadFromUserPreferences(UserPreferences userPreferences) {
    final Map<String, String> properties = userPreferences.getAdditionalProperties();

    final int columnsPerAnalyzer = MapUtils.getIntValue(properties,
            USER_PREFERENCES_NAMESPACE + ".columnsPerAnalyzer", 5);
    final boolean includeValueDistribution = MapUtils.getBooleanValue(properties,
            USER_PREFERENCES_NAMESPACE + ".includeValueDistribution", false);
    final boolean includePatternFinder = MapUtils.getBooleanValue(properties,
            USER_PREFERENCES_NAMESPACE + ".includePatternFinder", false);

    return new QuickAnalysisStrategy(columnsPerAnalyzer, includeValueDistribution, includePatternFinder);
}