Exemple #1
0
  /**
   * Check for the count of EC2 slaves and determine if a new slave can be added. Takes into account
   * both what Amazon reports as well as an internal count of slaves currently being "provisioned".
   * Check for the count of EC2 slaves and determine if a new slave can be added. Takes into account
   * both what Amazon reports as well as an internal count of slaves currently being "provisioned".
   *
   * @param templateDesc
   */
  private boolean addProvisionedSlave(String ami, int amiCap, String templateDesc)
      throws AmazonClientException {
    int estimatedTotalSlaves = countCurrentEC2Slaves(null, null);
    int estimatedAmiSlaves = countCurrentEC2Slaves(ami, templateDesc);

    synchronized (provisioningAmis) {
      int currentProvisioning;

      for (int amiCount : provisioningAmis.values()) {
        estimatedTotalSlaves += amiCount;
      }
      try {
        currentProvisioning = provisioningAmis.get(ami);
      } catch (NullPointerException npe) {
        currentProvisioning = 0;
      }

      estimatedAmiSlaves += currentProvisioning;

      if (estimatedTotalSlaves >= instanceCap) {
        LOGGER.log(
            Level.INFO, "Total instance cap of " + instanceCap + " reached, not provisioning.");
        return false; // maxed out
      }

      if (estimatedAmiSlaves >= amiCap) {
        LOGGER.log(
            Level.INFO,
            "AMI Instance cap of " + amiCap + " reached for ami " + ami + ", not provisioning.");
        return false; // maxed out
      }

      LOGGER.log(
          Level.INFO,
          "Provisioning for AMI "
              + ami
              + "; "
              + "Estimated number of total slaves: "
              + String.valueOf(estimatedTotalSlaves)
              + "; "
              + "Estimated number of slaves for ami "
              + ami
              + ": "
              + String.valueOf(estimatedAmiSlaves));

      provisioningAmis.put(ami, currentProvisioning + 1);
      return true;
    }
  }
Exemple #2
0
    protected FormValidation doTestConnection(
        URL ec2endpoint,
        boolean useInstanceProfileForCredentials,
        String accessId,
        String secretKey,
        String privateKey)
        throws IOException, ServletException {
      try {
        AWSCredentialsProvider credentialsProvider =
            createCredentialsProvider(useInstanceProfileForCredentials, accessId, secretKey);
        AmazonEC2 ec2 = connect(credentialsProvider, ec2endpoint);
        ec2.describeInstances();

        if (privateKey == null)
          return FormValidation.error(
              "Private key is not specified. Click 'Generate Key' to generate one.");

        if (privateKey.trim().length() > 0) {
          // check if this key exists
          EC2PrivateKey pk = new EC2PrivateKey(privateKey);
          if (pk.find(ec2) == null)
            return FormValidation.error(
                "The EC2 key pair private key isn't registered to this EC2 region (fingerprint is "
                    + pk.getFingerprint()
                    + ")");
        }

        return FormValidation.ok(Messages.EC2Cloud_Success());
      } catch (AmazonClientException e) {
        LOGGER.log(Level.WARNING, "Failed to check EC2 credential", e);
        return FormValidation.error(e.getMessage());
      }
    }
Exemple #3
0
    public FormValidation doGenerateKey(
        StaplerResponse rsp,
        URL ec2EndpointUrl,
        boolean useInstanceProfileForCredentials,
        String accessId,
        String secretKey)
        throws IOException, ServletException {
      try {
        AWSCredentialsProvider credentialsProvider =
            createCredentialsProvider(useInstanceProfileForCredentials, accessId, secretKey);
        AmazonEC2 ec2 = connect(credentialsProvider, ec2EndpointUrl);
        List<KeyPairInfo> existingKeys = ec2.describeKeyPairs().getKeyPairs();

        int n = 0;
        while (true) {
          boolean found = false;
          for (KeyPairInfo k : existingKeys) {
            if (k.getKeyName().equals("hudson-" + n)) found = true;
          }
          if (!found) break;
          n++;
        }

        CreateKeyPairRequest request = new CreateKeyPairRequest("hudson-" + n);
        KeyPair key = ec2.createKeyPair(request).getKeyPair();

        rsp.addHeader(
            "script",
            "findPreviousFormItem(button,'privateKey').value='"
                + key.getKeyMaterial().replace("\n", "\\n")
                + "'");

        return FormValidation.ok(Messages.EC2Cloud_Success());
      } catch (AmazonClientException e) {
        LOGGER.log(Level.WARNING, "Failed to check EC2 credential", e);
        return FormValidation.error(e.getMessage());
      }
    }
Exemple #4
0
  @Override
  public Collection<PlannedNode> provision(Label label, int excessWorkload) {
    try {
      // Count number of pending executors from spot requests
      for (EC2SpotSlave n : NodeIterator.nodes(EC2SpotSlave.class)) {
        // If the slave is online then it is already counted by Jenkins
        // We only want to count potential additional Spot instance
        // slaves
        if (n.getComputer().isOffline() && label.matches(n.getAssignedLabels())) {
          DescribeSpotInstanceRequestsRequest dsir =
              new DescribeSpotInstanceRequestsRequest()
                  .withSpotInstanceRequestIds(n.getSpotInstanceRequestId());

          for (SpotInstanceRequest sir :
              connect().describeSpotInstanceRequests(dsir).getSpotInstanceRequests()) {
            // Count Spot requests that are open and still have a
            // chance to be active
            // A request can be active and not yet registered as a
            // slave. We check above
            // to ensure only unregistered slaves get counted
            if (sir.getState().equals("open") || sir.getState().equals("active")) {
              excessWorkload -= n.getNumExecutors();
            }
          }
        }
      }
      LOGGER.log(Level.INFO, "Excess workload after pending Spot instances: " + excessWorkload);

      List<PlannedNode> r = new ArrayList<PlannedNode>();

      final SlaveTemplate t = getTemplate(label);
      int amiCap = t.getInstanceCap();

      while (excessWorkload > 0) {

        if (!addProvisionedSlave(t.ami, amiCap, t.description)) {
          break;
        }

        r.add(
            new PlannedNode(
                t.getDisplayName(),
                Computer.threadPoolForRemoting.submit(
                    new Callable<Node>() {
                      public Node call() throws Exception {
                        // TODO: record the output somewhere
                        try {
                          EC2AbstractSlave s = t.provision(StreamTaskListener.fromStdout());
                          Hudson.getInstance().addNode(s);
                          // EC2 instances may have a long init script. If we
                          // declare
                          // the provisioning complete by returning without
                          // the connect
                          // operation, NodeProvisioner may decide that it
                          // still wants
                          // one more instance, because it sees that (1) all
                          // the slaves
                          // are offline (because it's still being launched)
                          // and
                          // (2) there's no capacity provisioned yet.
                          //
                          // deferring the completion of provisioning until
                          // the launch
                          // goes successful prevents this problem.
                          s.toComputer().connect(false).get();
                          return s;
                        } finally {
                          decrementAmiSlaveProvision(t.ami);
                        }
                      }
                    }),
                t.getNumExecutors()));

        excessWorkload -= t.getNumExecutors();
      }
      return r;
    } catch (AmazonClientException e) {
      LOGGER.log(Level.WARNING, "Failed to count the # of live instances on EC2", e);
      return Collections.emptyList();
    }
  }