예제 #1
0
  /** Choose which datapoint to use. */
  public enum TimeScale {
    SEC10(TimeUnit2.SECONDS.toMillis(10)),
    MIN(TimeUnit2.MINUTES.toMillis(1)),
    HOUR(TimeUnit2.HOURS.toMillis(1));

    /** Number of milliseconds (10 secs, 1 min, and 1 hour) that this constant represents. */
    public final long tick;

    TimeScale(long tick) {
      this.tick = tick;
    }

    /** Creates a new {@link DateFormat} suitable for processing this {@link TimeScale}. */
    public DateFormat createDateFormat() {
      switch (this) {
        case HOUR:
          return new SimpleDateFormat("MMM/dd HH");
        case MIN:
          return new SimpleDateFormat("HH:mm");
        case SEC10:
          return new SimpleDateFormat("HH:mm:ss");
        default:
          throw new AssertionError();
      }
    }

    /** Parses the {@link TimeScale} from the query parameter. */
    public static TimeScale parse(String type) {
      if (type == null) return TimeScale.MIN;
      return Enum.valueOf(TimeScale.class, type.toUpperCase(Locale.ENGLISH));
    }
  }
 /**
  * Turns an interval into milliseconds./
  *
  * @param interval the interval.
  * @return the milliseconds.
  */
 private static long toIntervalMillis(String interval) {
   TimeUnit2 units = TimeUnit2.MINUTES;
   interval = interval.toLowerCase();
   if (interval.endsWith("h")) {
     units = TimeUnit2.HOURS;
     interval = StringUtils.removeEnd(interval, "h");
   }
   if (interval.endsWith("m")) {
     interval = StringUtils.removeEnd(interval, "m");
   } else if (interval.endsWith("d")) {
     units = TimeUnit2.DAYS;
     interval = StringUtils.removeEnd(interval, "d");
   } else if (interval.endsWith("ms")) {
     units = TimeUnit2.SECONDS;
     interval = StringUtils.removeEnd(interval, "ms");
   } else if (interval.endsWith("s")) {
     units = TimeUnit2.SECONDS;
     interval = StringUtils.removeEnd(interval, "s");
   }
   long value = 0;
   try {
     value = Long.parseLong(interval);
   } catch (NumberFormatException e) {
     value = 1;
   }
   return Math.min(
       TimeUnit2.DAYS.toMillis(30),
       Math.max(TimeUnit2.MINUTES.toMillis(1), units.toMillis(value)));
 }
 /**
  * Turns an interval into a suitable crontab.
  *
  * @param interval the interval.
  * @return the crontab.
  */
 private static String toCrontab(String interval) {
   long millis = toIntervalMillis(interval);
   if (millis < TimeUnit2.MINUTES.toMillis(5)) {
     return "* * * * *";
   }
   if (millis < TimeUnit2.MINUTES.toMillis(10)) {
     return "*/12 * * * *";
   }
   if (millis < TimeUnit2.MINUTES.toMillis(30)) {
     return "*/6 * * * *";
   }
   if (millis < TimeUnit2.HOURS.toMillis(1)) {
     return "*/2 * * * *";
   }
   if (millis < TimeUnit2.HOURS.toMillis(8)) {
     return "H * * * *";
   }
   return "H H * * *";
 }
 @Override
 public synchronized long check(VMLabMgrComputer computer) {
   if (computer.isIdle()) {
     final long idleTime = System.currentTimeMillis() - computer.getIdleStartMilliseconds();
     if (idleTime > TimeUnit2.MINUTES.toMillis(1)) {
       LOGGER.info(MessageFormat.format("Disconnecting from {0}", computer.getName()));
       computer.getNode().terminate();
     }
   }
   return 1l;
 }
/**
 * Default convenience implementation of {@link RetentionStrategy} for slaves provisioned from
 * {@link Cloud}.
 *
 * <p>If a slave is idle for 10 mins, this retention strategy will remove the slave. This can be
 * used as-is for a {@link Node} provisioned by cloud to implement the auto-scaling semantics, it
 * can be subtyped to tweak the behavior, or it can be used as an example.
 *
 * <p>TODO {@link CloudRetentionStrategy} seems to be a better implementation.
 *
 * @author Kohsuke Kawaguchi
 * @since 1.510
 */
public class CloudSlaveRetentionStrategy<T extends Computer> extends RetentionStrategy<T> {

  @Override
  @GuardedBy("hudson.model.Queue.lock")
  public long check(T c) {
    if (!c.isConnecting() && c.isAcceptingTasks()) {
      if (isIdleForTooLong(c)) {
        try {
          Node n = c.getNode();
          if (n
              != null) // rare, but n==null if the node is deleted and being checked roughly at the
            // same time
            kill(n);
        } catch (IOException e) {
          LOGGER.log(Level.WARNING, "Failed to remove " + c.getDisplayName(), e);
        }
      }
    }
    return checkCycle();
  }

  /**
   * Remove the node.
   *
   * <p>To actually deallocate the resource tied to this {@link Node}, implement {@link
   * Computer#onRemoved()}.
   */
  protected void kill(Node n) throws IOException {
    Jenkins.getInstance().removeNode(n);
  }

  /** When do we check again next time? */
  protected long checkCycle() {
    return getIdleMaxTime() / 10;
  }

  /** Has this computer been idle for too long? */
  protected boolean isIdleForTooLong(T c) {
    return System.currentTimeMillis() - c.getIdleStartMilliseconds() > getIdleMaxTime();
  }

  /** If the computer has been idle longer than this time, we'll kill the slave. */
  protected long getIdleMaxTime() {
    return TIMEOUT;
  }

  // for debugging, it's convenient to be able to reduce this time
  public static long TIMEOUT =
      Long.getLong(
          CloudSlaveRetentionStrategy.class.getName() + ".timeout", TimeUnit2.MINUTES.toMillis(10));

  private static final Logger LOGGER =
      Logger.getLogger(CloudSlaveRetentionStrategy.class.getName());
}
  private Connection connectToSsh(Computer computer, PrintStream logger)
      throws RequestUnsuccessfulException, DigitalOceanException {

    final long timeout = TimeUnit2.MINUTES.toMillis(computer.getCloud().getTimeoutMinutes());
    final long startTime = System.currentTimeMillis();
    final int sleepTime = 10;

    long waitTime;

    while ((waitTime = System.currentTimeMillis() - startTime) < timeout) {

      // Hack to fetch this each time through the loop to get the latest information.
      final Droplet droplet =
          DigitalOcean.getDroplet(
              computer.getCloud().getAuthToken(), computer.getNode().getDropletId());

      if (isDropletStarting(droplet)) {
        logger.println(
            "Waiting for droplet to enter ACTIVE state. Sleeping " + sleepTime + " seconds.");
      } else {
        try {
          final String host = getIpAddress(computer);

          if (Strings.isNullOrEmpty(host) || "0.0.0.0".equals(host)) {
            logger.println(
                "No ip address yet, your host is most likely waiting for an ip address.");
          } else {
            int port = computer.getSshPort();

            Connection conn = getDropletConnection(host, port, logger);
            if (conn != null) {
              return conn;
            }
          }
        } catch (IOException e) {
          // Ignore, we'll retry.
        }
        logger.println("Waiting for SSH to come up. Sleeping " + sleepTime + " seconds.");
      }

      sleep(sleepTime);
    }

    throw new RuntimeException(
        format(
            "Timed out after %d seconds of waiting for ssh to become available (max timeout configured is %s)",
            waitTime / 1000, timeout / 1000));
  }
 /**
  * Returns the interval between indexing.
  *
  * @return the interval between indexing.
  */
 @SuppressWarnings("unused") // used by Jelly EL
 public String getInterval() {
   if (interval < TimeUnit2.SECONDS.toMillis(1)) {
     return Long.toString(interval) + "ms";
   }
   if (interval < TimeUnit2.MINUTES.toMillis(1)) {
     return Long.toString(TimeUnit2.MILLISECONDS.toSeconds(interval)) + "s";
   }
   if (interval < TimeUnit2.HOURS.toMillis(1)) {
     return Long.toString(TimeUnit2.MILLISECONDS.toMinutes(interval)) + "m";
   }
   if (interval < TimeUnit2.DAYS.toMillis(1)) {
     return Long.toString(TimeUnit2.MILLISECONDS.toHours(interval)) + "h";
   }
   return Long.toString(TimeUnit2.MILLISECONDS.toDays(interval)) + "d";
 }
 @Override
 public synchronized long check(JCloudsComputer c) {
   if (c.isIdle() && !c.getNode().isPendingDelete() && !disabled) {
     // Get the retention time, in minutes, from the JCloudsCloud this JCloudsComputer belongs to.
     final int retentionTime = JCloudsCloud.getByName(c.getCloudName()).getRetentionTime();
     if (retentionTime > -1) {
       final long idleMilliseconds = System.currentTimeMillis() - c.getIdleStartMilliseconds();
       if (idleMilliseconds > TimeUnit2.MINUTES.toMillis(retentionTime)) {
         LOGGER.info("Setting " + c.getName() + " to be deleted.");
         if (!c.isOffline()) {
           c.setTemporarilyOffline(true, OfflineCause.create(Messages._DeletedCause()));
         }
         c.getNode().setPendingDelete(true);
       }
     }
   }
   return 1;
 }