コード例 #1
0
  public Operation waitComplete(Operation operation, int duration, TimeUnit unit)
      throws TimeoutException, OpsException {
    long timeoutAt = System.currentTimeMillis() + unit.toMillis(duration);

    // TODO: Timeout?
    while (operation.getStatus().equals("RUNNING")) {
      if (timeoutAt < System.currentTimeMillis()) {
        throw new TimeoutException("Timeout while waiting for operation to complete");
      }
      log.debug("Polling for operation completion: " + operation);
      try {
        operation = compute.operations().get(projectId, operation.getName()).execute();
      } catch (IOException e) {
        throw new OpsException("Error waiting for operation to complete", e);
      }

      try {
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new OpsException("Interrupted while waiting for operation to complete", e);
      }
    }

    return operation;
  }
コード例 #2
0
 protected Compute.RegionOperations.Get createRegionOperations(
     Compute compute, GcpCredential gcpCredential, Operation operation, CloudRegion region)
     throws IOException {
   return compute
       .regionOperations()
       .get(gcpCredential.getProjectId(), region.region(), operation.getName());
 }
コード例 #3
0
  public Operation terminateInstance(String instanceId) throws OpsException {
    try {
      log.debug("Terminating instance: " + instanceId);

      Operation operation = compute.instances().delete(projectId, instanceId).execute();
      return operation;
    } catch (IOException e) {
      throw new OpsException("Error deleting instance", e);
    }
  }
コード例 #4
0
 public void createFirewallRule(Firewall rule) throws OpsException {
   try {
     log.debug("Inserting firewall rule: " + rule);
     Operation operation = compute.firewalls().insert(projectId, rule).execute();
     waitComplete(operation, 5, TimeUnit.MINUTES);
     // TODO: Check success of operation?
   } catch (IOException e) {
     throw new OpsException("Error creating firewall", e);
   } catch (TimeoutException e) {
     throw new OpsException("Timeout while waiting for firewall creation", e);
   }
 }
コード例 #5
0
 @Override
 public Boolean call() {
   LOGGER.info("Checking status of Gcp image '{}' copy", name);
   try {
     Compute.Images.Get getImages = compute.images().get(projectId, name);
     String status = getImages.execute().getStatus();
     LOGGER.info("Status of image {} copy: {}", name, status);
     return READY.equals(status);
   } catch (IOException e) {
     LOGGER.warn("Failed to retrieve image copy status", e);
     return false;
   }
 }
コード例 #6
0
 public Instance findInstanceByName(String name) throws OpsException {
   try {
     log.debug("Retrieving instance by name: " + name);
     Instance instance = compute.instances().get(projectId, name).execute();
     return instance;
   } catch (GoogleJsonResponseException e) {
     if (e.getStatusCode() == 404) {
       return null;
     }
     throw new OpsException("Error getting instance", e);
   } catch (IOException e) {
     throw new OpsException("Error getting instance", e);
   }
 }
コード例 #7
0
  private Iterable<MachineType> listMachineTypes(String projectId) throws OpsException {
    List<MachineType> ret = Lists.newArrayList();

    MachineTypeList machineTypeList;
    try {
      log.debug("Listing machine types in project " + projectId);
      machineTypeList = compute.machineTypes().list(projectId).execute();
    } catch (IOException e) {
      throw new OpsException("Error listing machine types", e);
    }
    if (machineTypeList.getItems() != null) {
      ret.addAll(machineTypeList.getItems());
    }

    return ret;
  }
コード例 #8
0
  private Iterable<Image> listImages(String projectId) throws OpsException {
    List<Image> ret = Lists.newArrayList();

    ImageList imageList;
    try {
      log.debug("Listing images in project " + projectId);
      imageList = compute.images().list(projectId).execute();
    } catch (IOException e) {
      throw new OpsException("Error listing images", e);
    }
    if (imageList.getItems() != null) {
      ret.addAll(imageList.getItems());
    }

    return ret;
  }
コード例 #9
0
  public List<Firewall> getInstanceFirewallRules(String instanceUrl) throws OpsException {
    List<Firewall> ret = Lists.newArrayList();

    FirewallList firewalls;
    try {
      log.debug("Listing firewall rules");
      firewalls = compute.firewalls().list(projectId).execute();
    } catch (IOException e) {
      throw new OpsException("Error listing firewalls", e);
    }

    // TODO: Use filter

    if (firewalls.getItems() != null) {
      for (Firewall firewall : firewalls.getItems()) {
        if (firewall.getTargetTags() != null && firewall.getTargetTags().contains(instanceUrl)) {
          ret.add(firewall);
        }
      }
    }

    return ret;
  }
コード例 #10
0
 public static Compute.RegionOperations.Get regionOperations(
     Compute compute, String projectId, String operationName, Region region) throws IOException {
   return compute.regionOperations().get(projectId, region.value(), operationName);
 }
コード例 #11
0
 public static Compute.ZoneOperations.Get zoneOperations(
     Compute compute, String projectId, String operationName, AvailabilityZone region)
     throws IOException {
   return compute.zoneOperations().get(projectId, region.value(), operationName);
 }
コード例 #12
0
 public static Compute.GlobalOperations.Get globalOperations(
     Compute compute, String projectId, String operationName) throws IOException {
   return compute.globalOperations().get(projectId, operationName);
 }
コード例 #13
0
  public Instance createInstance(
      GoogleCloud cloud, MachineCreationRequest request, PublicKey sshPublicKey)
      throws OpsException {
    // GoogleComputeClient computeClient = getComputeClient(cloud);

    try {
      Image foundImage = null;

      {
        DiskImageRecipe recipe = null;
        if (request.recipeId != null) {
          recipe = platformLayerClient.getItem(request.recipeId, DiskImageRecipe.class);
        }

        OperatingSystemRecipe operatingSystem = null;
        if (recipe != null) {
          operatingSystem = recipe.getOperatingSystem();
        }

        log.info("Listing images to pick best image");
        Iterable<Image> images = listImages(PROJECTID_GOOGLE);

        // TODO: We need a better solution here!!
        log.warn("Hard coding image names");
        Set<String> imageNames = Sets.newHashSet("ubuntu-12-04-v20120621");
        // Set<String> imageNames = Sets.newHashSet("centos-6-2-v20120621");

        for (Image image : images) {
          if (imageNames.contains(image.getName())) {
            foundImage = image;
            break;
          }
        }

        if (foundImage == null) {
          throw new IllegalArgumentException("Could not find image");
        }
      }

      // GCE requires that the name comply with RFC1035, which I think means a valid DNS
      // For now, just use a UUID, with a pl- prefix so it doesn't start with a number
      // TODO: Fix this!
      String instanceName = "pl-" + UUID.randomUUID().toString();

      Operation createServerOperation;
      {
        Instance create = new Instance();

        create.setName(instanceName);

        create.setZone(buildZoneUrl(projectId, ZONE_US_CENTRAL1_A));

        {
          NetworkInterface networkInterface = new NetworkInterface();
          networkInterface.setNetwork(buildNetworkUrl(projectId, "default"));

          AccessConfig networkAccessConfig = new AccessConfig();
          networkAccessConfig.setType("ONE_TO_ONE_NAT");

          networkInterface.setAccessConfigs(Lists.newArrayList(networkAccessConfig));

          create.setNetworkInterfaces(Lists.newArrayList(networkInterface));
        }

        Metadata metadata = new Metadata();
        metadata.setItems(Lists.<Items>newArrayList());
        create.setMetadata(metadata);

        if (request.tags != null) {
          for (Tag tag : request.tags) {
            Metadata.Items meta = new Metadata.Items();
            meta.setKey(tag.getKey());
            meta.setValue(tag.getValue());
            metadata.getItems().add(meta);
          }
        }

        if (request.sshPublicKey != null) {
          Metadata.Items meta = new Metadata.Items();
          meta.setKey("sshKeys");
          meta.setValue(USER_NAME + ":" + OpenSshUtils.serialize(sshPublicKey));

          metadata.getItems().add(meta);
        }

        create.setImage(foundImage.getSelfLink());

        MachineType flavor = getClosestInstanceType(request);
        if (flavor == null) {
          throw new OpsException("Cannot determine machine type for request");
        }
        create.setMachineType(flavor.getSelfLink());

        if (request.securityGroups != null) {
          // TODO: Reimplement if needed
          throw new UnsupportedOperationException();
        }

        // if (createdSecurityGroup != null) {
        // ServerForCreate.SecurityGroup serverSecurityGroup = new ServerForCreate.SecurityGroup();
        // serverSecurityGroup.setName(createdSecurityGroup.getName());
        // create.getSecurityGroups().add(serverSecurityGroup);
        // }

        // create.setConfigDrive(cloudBehaviours.useConfigDrive());

        log.info("Launching new server: " + instanceName);
        try {
          createServerOperation = compute.instances().insert(projectId, create).execute();
        } catch (IOException e) {
          throw new OpsException("Error launching new instance", e);
        }
      }

      log.info("Waiting for server to be ready");
      createServerOperation = waitComplete(createServerOperation, 10, TimeUnit.MINUTES);

      Instance created;

      InstanceState state = null;
      while (true) {
        created = findInstanceByName(instanceName);

        state = InstanceState.get(created);
        log.info("Instance state: " + state);

        if (state.isRunning()) {
          break;
        }

        Thread.sleep(1000);
      }

      return created;
    } catch (InterruptedException e) {
      ExceptionUtils.handleInterrupted(e);
      throw new OpsException("Error building server", e);
    } catch (TimeoutException e) {
      throw new OpsException("Timeout waiting for server build", e);
    }
  }
コード例 #14
0
 protected Compute.GlobalOperations.Get createGlobalOperations(
     Compute compute, GcpCredential gcpCredential, Operation operation) throws IOException {
   return compute.globalOperations().get(gcpCredential.getProjectId(), operation.getName());
 }