Example usage for org.joda.time Duration isLongerThan

List of usage examples for org.joda.time Duration isLongerThan

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. Duration
  6. isLongerThan

Introduction

In this page you can find the example usage for org.joda.time Duration isLongerThan.

Prototype

public boolean isLongerThan(ReadableDuration duration)

Source Link

Document

Is the length of this duration longer than the duration passed in.

Usage

From source file:io.druid.indexing.overlord.autoscaling.SimpleResourceManagementStrategy.java

License:Apache License

@Override
public boolean doProvision(RemoteTaskRunner runner) {
    Collection<RemoteTaskRunnerWorkItem> pendingTasks = runner.getPendingTasks();
    Collection<ZkWorker> zkWorkers = runner.getWorkers();
    synchronized (lock) {
        boolean didProvision = false;
        final WorkerBehaviorConfig workerConfig = workerConfigRef.get();
        if (workerConfig == null || workerConfig.getAutoScaler() == null) {
            log.warn("No workerConfig available, cannot provision new workers.");
            return false;
        }//from  w w  w.  j  a  v a2 s .  co m
        final Predicate<ZkWorker> isValidWorker = createValidWorkerPredicate(config);
        final int currValidWorkers = Collections2.filter(zkWorkers, isValidWorker).size();

        final List<String> workerNodeIds = workerConfig.getAutoScaler().ipToIdLookup(Lists.newArrayList(
                Iterables.<ZkWorker, String>transform(zkWorkers, new Function<ZkWorker, String>() {
                    @Override
                    public String apply(ZkWorker input) {
                        return input.getWorker().getIp();
                    }
                })));
        currentlyProvisioning.removeAll(workerNodeIds);

        updateTargetWorkerCount(workerConfig, pendingTasks, zkWorkers);

        int want = targetWorkerCount - (currValidWorkers + currentlyProvisioning.size());
        while (want > 0) {
            final AutoScalingData provisioned = workerConfig.getAutoScaler().provision();
            final List<String> newNodes;
            if (provisioned == null || (newNodes = provisioned.getNodeIds()).isEmpty()) {
                break;
            } else {
                currentlyProvisioning.addAll(newNodes);
                lastProvisionTime = new DateTime();
                scalingStats.addProvisionEvent(provisioned);
                want -= provisioned.getNodeIds().size();
                didProvision = true;
            }
        }

        if (!currentlyProvisioning.isEmpty()) {
            Duration durSinceLastProvision = new Duration(lastProvisionTime, new DateTime());

            log.info("%s provisioning. Current wait time: %s", currentlyProvisioning, durSinceLastProvision);

            if (durSinceLastProvision.isLongerThan(config.getMaxScalingDuration().toStandardDuration())) {
                log.makeAlert("Worker node provisioning taking too long!")
                        .addData("millisSinceLastProvision", durSinceLastProvision.getMillis())
                        .addData("provisioningCount", currentlyProvisioning.size()).emit();

                workerConfig.getAutoScaler().terminateWithIds(Lists.newArrayList(currentlyProvisioning));
                currentlyProvisioning.clear();
            }
        }

        return didProvision;
    }
}

From source file:io.druid.indexing.overlord.autoscaling.SimpleResourceManagementStrategy.java

License:Apache License

@Override
public boolean doTerminate(RemoteTaskRunner runner) {
    Collection<RemoteTaskRunnerWorkItem> pendingTasks = runner.getPendingTasks();
    synchronized (lock) {
        final WorkerBehaviorConfig workerConfig = workerConfigRef.get();
        if (workerConfig == null) {
            log.warn("No workerConfig available, cannot terminate workers.");
            return false;
        }/*w w  w  .java  2  s  .co  m*/

        boolean didTerminate = false;
        final Set<String> workerNodeIds = Sets.newHashSet(workerConfig.getAutoScaler().ipToIdLookup(Lists
                .newArrayList(Iterables.transform(runner.getLazyWorkers(), new Function<ZkWorker, String>() {
                    @Override
                    public String apply(ZkWorker input) {
                        return input.getWorker().getIp();
                    }
                }))));

        final Set<String> stillExisting = Sets.newHashSet();
        for (String s : currentlyTerminating) {
            if (workerNodeIds.contains(s)) {
                stillExisting.add(s);
            }
        }
        currentlyTerminating.clear();
        currentlyTerminating.addAll(stillExisting);

        Collection<ZkWorker> workers = runner.getWorkers();
        updateTargetWorkerCount(workerConfig, pendingTasks, workers);

        if (currentlyTerminating.isEmpty()) {

            final int excessWorkers = (workers.size() + currentlyProvisioning.size()) - targetWorkerCount;
            if (excessWorkers > 0) {
                final Predicate<ZkWorker> isLazyWorker = createLazyWorkerPredicate(config);
                final List<String> laziestWorkerIps = Lists.transform(
                        runner.markWorkersLazy(isLazyWorker, excessWorkers), new Function<ZkWorker, String>() {
                            @Override
                            public String apply(ZkWorker zkWorker) {
                                return zkWorker.getWorker().getIp();
                            }
                        });
                if (laziestWorkerIps.isEmpty()) {
                    log.info("Wanted to terminate %,d workers, but couldn't find any lazy ones!",
                            excessWorkers);
                } else {
                    log.info("Terminating %,d workers (wanted %,d): %s", laziestWorkerIps.size(), excessWorkers,
                            Joiner.on(", ").join(laziestWorkerIps));

                    final AutoScalingData terminated = workerConfig.getAutoScaler().terminate(laziestWorkerIps);
                    if (terminated != null) {
                        currentlyTerminating.addAll(terminated.getNodeIds());
                        lastTerminateTime = new DateTime();
                        scalingStats.addTerminateEvent(terminated);
                        didTerminate = true;
                    }
                }
            }
        } else {
            Duration durSinceLastTerminate = new Duration(lastTerminateTime, new DateTime());

            log.info("%s terminating. Current wait time: %s", currentlyTerminating, durSinceLastTerminate);

            if (durSinceLastTerminate.isLongerThan(config.getMaxScalingDuration().toStandardDuration())) {
                log.makeAlert("Worker node termination taking too long!")
                        .addData("millisSinceLastTerminate", durSinceLastTerminate.getMillis())
                        .addData("terminatingCount", currentlyTerminating.size()).emit();

                currentlyTerminating.clear();
            }
        }

        return didTerminate;
    }
}

From source file:io.druid.indexing.overlord.autoscaling.SimpleResourceManagementStrategy.java

License:Apache License

private boolean hasTaskPendingBeyondThreshold(Collection<RemoteTaskRunnerWorkItem> pendingTasks) {
    synchronized (lock) {
        long now = System.currentTimeMillis();
        for (TaskRunnerWorkItem pendingTask : pendingTasks) {
            final Duration durationSinceInsertion = new Duration(
                    pendingTask.getQueueInsertionTime().getMillis(), now);
            final Duration timeoutDuration = config.getPendingTaskTimeout().toStandardDuration();
            if (durationSinceInsertion.isEqual(timeoutDuration)
                    || durationSinceInsertion.isLongerThan(timeoutDuration)) {
                return true;
            }/*w w w.  j  ava2 s.  c  o  m*/
        }
        return false;
    }
}

From source file:io.druid.indexing.overlord.autoscaling.SimpleWorkerResourceManagementStrategy.java

License:Apache License

protected boolean doProvision(WorkerTaskRunner runner) {
    Collection<? extends TaskRunnerWorkItem> pendingTasks = runner.getPendingTasks();
    Collection<ImmutableWorkerInfo> workers = getWorkers(runner);
    synchronized (lock) {
        boolean didProvision = false;
        final WorkerBehaviorConfig workerConfig = workerConfigRef.get();
        if (workerConfig == null || workerConfig.getAutoScaler() == null) {
            log.warn("No workerConfig available, cannot provision new workers.");
            return false;
        }/*ww  w .jav a 2  s .c o  m*/

        final Predicate<ImmutableWorkerInfo> isValidWorker = ResourceManagementUtil
                .createValidWorkerPredicate(config);
        final int currValidWorkers = Collections2.filter(workers, isValidWorker).size();

        final List<String> workerNodeIds = workerConfig.getAutoScaler().ipToIdLookup(
                Lists.newArrayList(Iterables.transform(workers, new Function<ImmutableWorkerInfo, String>() {
                    @Override
                    public String apply(ImmutableWorkerInfo input) {
                        return input.getWorker().getIp();
                    }
                })));
        currentlyProvisioning.removeAll(workerNodeIds);

        updateTargetWorkerCount(workerConfig, pendingTasks, workers);

        int want = targetWorkerCount - (currValidWorkers + currentlyProvisioning.size());
        while (want > 0) {
            final AutoScalingData provisioned = workerConfig.getAutoScaler().provision();
            final List<String> newNodes;
            if (provisioned == null || (newNodes = provisioned.getNodeIds()).isEmpty()) {
                break;
            } else {
                currentlyProvisioning.addAll(newNodes);
                lastProvisionTime = new DateTime();
                scalingStats.addProvisionEvent(provisioned);
                want -= provisioned.getNodeIds().size();
                didProvision = true;
            }
        }

        if (!currentlyProvisioning.isEmpty()) {
            Duration durSinceLastProvision = new Duration(lastProvisionTime, new DateTime());

            log.info("%s provisioning. Current wait time: %s", currentlyProvisioning, durSinceLastProvision);

            if (durSinceLastProvision.isLongerThan(config.getMaxScalingDuration().toStandardDuration())) {
                log.makeAlert("Worker node provisioning taking too long!")
                        .addData("millisSinceLastProvision", durSinceLastProvision.getMillis())
                        .addData("provisioningCount", currentlyProvisioning.size()).emit();

                workerConfig.getAutoScaler().terminateWithIds(Lists.newArrayList(currentlyProvisioning));
                currentlyProvisioning.clear();
            }
        }

        return didProvision;
    }
}

From source file:io.druid.indexing.overlord.autoscaling.SimpleWorkerResourceManagementStrategy.java

License:Apache License

boolean doTerminate(WorkerTaskRunner runner) {
    Collection<? extends TaskRunnerWorkItem> pendingTasks = runner.getPendingTasks();
    synchronized (lock) {
        final WorkerBehaviorConfig workerConfig = workerConfigRef.get();
        if (workerConfig == null) {
            log.warn("No workerConfig available, cannot terminate workers.");
            return false;
        }//from  ww  w .j  av a  2s.c o m

        boolean didTerminate = false;
        final Set<String> workerNodeIds = Sets.newHashSet(workerConfig.getAutoScaler().ipToIdLookup(
                Lists.newArrayList(Iterables.transform(runner.getLazyWorkers(), new Function<Worker, String>() {
                    @Override
                    public String apply(Worker input) {
                        return input.getIp();
                    }
                }))));

        final Set<String> stillExisting = Sets.newHashSet();
        for (String s : currentlyTerminating) {
            if (workerNodeIds.contains(s)) {
                stillExisting.add(s);
            }
        }
        currentlyTerminating.clear();
        currentlyTerminating.addAll(stillExisting);

        Collection<ImmutableWorkerInfo> workers = getWorkers(runner);
        updateTargetWorkerCount(workerConfig, pendingTasks, workers);

        if (currentlyTerminating.isEmpty()) {

            final int excessWorkers = (workers.size() + currentlyProvisioning.size()) - targetWorkerCount;
            if (excessWorkers > 0) {
                final Predicate<ImmutableWorkerInfo> isLazyWorker = ResourceManagementUtil
                        .createLazyWorkerPredicate(config);
                final Collection<String> laziestWorkerIps = Collections2.transform(
                        runner.markWorkersLazy(isLazyWorker, excessWorkers), new Function<Worker, String>() {
                            @Override
                            public String apply(Worker worker) {
                                return worker.getIp();
                            }
                        });
                if (laziestWorkerIps.isEmpty()) {
                    log.info("Wanted to terminate %,d workers, but couldn't find any lazy ones!",
                            excessWorkers);
                } else {
                    log.info("Terminating %,d workers (wanted %,d): %s", laziestWorkerIps.size(), excessWorkers,
                            Joiner.on(", ").join(laziestWorkerIps));

                    final AutoScalingData terminated = workerConfig.getAutoScaler()
                            .terminate(ImmutableList.copyOf(laziestWorkerIps));
                    if (terminated != null) {
                        currentlyTerminating.addAll(terminated.getNodeIds());
                        lastTerminateTime = new DateTime();
                        scalingStats.addTerminateEvent(terminated);
                        didTerminate = true;
                    }
                }
            }
        } else {
            Duration durSinceLastTerminate = new Duration(lastTerminateTime, new DateTime());

            log.info("%s terminating. Current wait time: %s", currentlyTerminating, durSinceLastTerminate);

            if (durSinceLastTerminate.isLongerThan(config.getMaxScalingDuration().toStandardDuration())) {
                log.makeAlert("Worker node termination taking too long!")
                        .addData("millisSinceLastTerminate", durSinceLastTerminate.getMillis())
                        .addData("terminatingCount", currentlyTerminating.size()).emit();

                currentlyTerminating.clear();
            }
        }

        return didTerminate;
    }
}

From source file:io.druid.indexing.overlord.autoscaling.SimpleWorkerResourceManagementStrategy.java

License:Apache License

private boolean hasTaskPendingBeyondThreshold(Collection<? extends TaskRunnerWorkItem> pendingTasks) {
    synchronized (lock) {
        long now = System.currentTimeMillis();
        for (TaskRunnerWorkItem pendingTask : pendingTasks) {
            final Duration durationSinceInsertion = new Duration(
                    pendingTask.getQueueInsertionTime().getMillis(), now);
            final Duration timeoutDuration = config.getPendingTaskTimeout().toStandardDuration();
            if (durationSinceInsertion.isEqual(timeoutDuration)
                    || durationSinceInsertion.isLongerThan(timeoutDuration)) {
                return true;
            }/*w  w  w  .  j a v a  2s.  com*/
        }
        return false;
    }
}

From source file:io.druid.indexing.overlord.scaling.SimpleResourceManagementStrategy.java

License:Open Source License

@Override
public boolean doProvision(Collection<RemoteTaskRunnerWorkItem> pendingTasks, Collection<ZkWorker> zkWorkers) {
    synchronized (lock) {
        boolean didProvision = false;
        final WorkerSetupData workerSetupData = workerSetupDataRef.get();
        if (workerSetupData == null) {
            log.warn("No workerSetupData available, cannot provision new workers.");
            return false;
        }// w w w.j  av  a2  s .c  o  m
        final Predicate<ZkWorker> isValidWorker = createValidWorkerPredicate(config, workerSetupData);
        final int currValidWorkers = Collections2.filter(zkWorkers, isValidWorker).size();

        final List<String> workerNodeIds = autoScalingStrategy.ipToIdLookup(Lists.newArrayList(
                Iterables.<ZkWorker, String>transform(zkWorkers, new Function<ZkWorker, String>() {
                    @Override
                    public String apply(ZkWorker input) {
                        return input.getWorker().getIp();
                    }
                })));
        currentlyProvisioning.removeAll(workerNodeIds);

        updateTargetWorkerCount(workerSetupData, pendingTasks, zkWorkers);

        int want = targetWorkerCount - (currValidWorkers + currentlyProvisioning.size());
        while (want > 0) {
            final AutoScalingData provisioned = autoScalingStrategy.provision();
            final List<String> newNodes;
            if (provisioned == null || (newNodes = provisioned.getNodeIds()).isEmpty()) {
                break;
            } else {
                currentlyProvisioning.addAll(newNodes);
                lastProvisionTime = new DateTime();
                scalingStats.addProvisionEvent(provisioned);
                want -= provisioned.getNodeIds().size();
                didProvision = true;
            }
        }

        if (!currentlyProvisioning.isEmpty()) {
            Duration durSinceLastProvision = new Duration(lastProvisionTime, new DateTime());

            log.info("%s provisioning. Current wait time: %s", currentlyProvisioning, durSinceLastProvision);

            if (durSinceLastProvision.isLongerThan(config.getMaxScalingDuration().toStandardDuration())) {
                log.makeAlert("Worker node provisioning taking too long!")
                        .addData("millisSinceLastProvision", durSinceLastProvision.getMillis())
                        .addData("provisioningCount", currentlyProvisioning.size()).emit();

                autoScalingStrategy.terminateWithIds(Lists.newArrayList(currentlyProvisioning));
                currentlyProvisioning.clear();
            }
        }

        return didProvision;
    }
}

From source file:io.druid.indexing.overlord.scaling.SimpleResourceManagementStrategy.java

License:Open Source License

@Override
public boolean doTerminate(Collection<RemoteTaskRunnerWorkItem> pendingTasks, Collection<ZkWorker> zkWorkers) {
    synchronized (lock) {
        final WorkerSetupData workerSetupData = workerSetupDataRef.get();
        if (workerSetupData == null) {
            log.warn("No workerSetupData available, cannot terminate workers.");
            return false;
        }/*from   w  ww.j av  a2 s .c  o  m*/

        boolean didTerminate = false;
        final Set<String> workerNodeIds = Sets.newHashSet(autoScalingStrategy.ipToIdLookup(
                Lists.newArrayList(Iterables.transform(zkWorkers, new Function<ZkWorker, String>() {
                    @Override
                    public String apply(ZkWorker input) {
                        return input.getWorker().getIp();
                    }
                }))));

        final Set<String> stillExisting = Sets.newHashSet();
        for (String s : currentlyTerminating) {
            if (workerNodeIds.contains(s)) {
                stillExisting.add(s);
            }
        }
        currentlyTerminating.clear();
        currentlyTerminating.addAll(stillExisting);

        updateTargetWorkerCount(workerSetupData, pendingTasks, zkWorkers);

        final Predicate<ZkWorker> isLazyWorker = createLazyWorkerPredicate(config, workerSetupData);
        if (currentlyTerminating.isEmpty()) {
            final int excessWorkers = (zkWorkers.size() + currentlyProvisioning.size()) - targetWorkerCount;
            if (excessWorkers > 0) {
                final List<String> laziestWorkerIps = FluentIterable.from(zkWorkers).filter(isLazyWorker)
                        .limit(excessWorkers).transform(new Function<ZkWorker, String>() {
                            @Override
                            public String apply(ZkWorker zkWorker) {
                                return zkWorker.getWorker().getIp();
                            }
                        }).toList();

                if (laziestWorkerIps.isEmpty()) {
                    log.info("Wanted to terminate %,d workers, but couldn't find any lazy ones!",
                            excessWorkers);
                } else {
                    log.info("Terminating %,d workers (wanted %,d): %s", laziestWorkerIps.size(), excessWorkers,
                            Joiner.on(", ").join(laziestWorkerIps));

                    final AutoScalingData terminated = autoScalingStrategy.terminate(laziestWorkerIps);
                    if (terminated != null) {
                        currentlyTerminating.addAll(terminated.getNodeIds());
                        lastTerminateTime = new DateTime();
                        scalingStats.addTerminateEvent(terminated);
                        didTerminate = true;
                    }
                }
            }
        } else {
            Duration durSinceLastTerminate = new Duration(lastTerminateTime, new DateTime());

            log.info("%s terminating. Current wait time: %s", currentlyTerminating, durSinceLastTerminate);

            if (durSinceLastTerminate.isLongerThan(config.getMaxScalingDuration().toStandardDuration())) {
                log.makeAlert("Worker node termination taking too long!")
                        .addData("millisSinceLastTerminate", durSinceLastTerminate.getMillis())
                        .addData("terminatingCount", currentlyTerminating.size()).emit();

                currentlyTerminating.clear();
            }
        }

        return didTerminate;
    }
}

From source file:io.druid.server.coordinator.helper.SegmentCompactorUtil.java

License:Apache License

/**
 * Return an interval for looking up for timeline.
 * If {@code totalInterval} is larger than {@link #LOOKUP_PERIOD}, it returns an interval of {@link #LOOKUP_PERIOD}
 * and the end of {@code totalInterval}.
 */// w  w  w  . java2 s . c  o m
static Interval getNextLoopupInterval(Interval totalInterval) {
    final Duration givenDuration = totalInterval.toDuration();
    return givenDuration.isLongerThan(LOOKUP_DURATION) ? new Interval(LOOKUP_PERIOD, totalInterval.getEnd())
            : totalInterval;
}

From source file:is.illuminati.block.spyros.garmin.model.Lap.java

License:Open Source License

/**
 * Get a list of all pauses in the lap./*from w  w w.  j av  a  2s  .  c  o m*/
 * @return list of all pauses.
 */
public ImmutableList<Pause> getPauses() {
    ImmutableList.Builder<Pause> pausesBuilder = ImmutableList.builder();
    PeekingIterator<Track> it = Iterators.peekingIterator(tracks.iterator());
    while (it.hasNext()) {
        Track former = it.next();
        Track latter;
        if (it.hasNext()) {
            latter = it.peek();
        } else {
            break;
        }
        Duration gap = new Duration(former.getEndTime(), latter.getStartTime());
        if (gap.isLongerThan(Duration.standardSeconds(10))) {
            pausesBuilder.add(new Pause(former.getEndTime(), latter.getStartTime()));
        }
    }
    return pausesBuilder.build();
}