コード例 #1
0
  @Override
  public List<CloudVmInstanceStatus> check(AuthenticatedContext ac, List<CloudInstance> vms) {
    List<CloudVmInstanceStatus> statuses = new ArrayList<>();
    AzureRMClient azureRMClient = armClient.getClient(ac.getCloudCredential());
    String stackName = armTemplateUtils.getStackName(ac.getCloudContext());

    for (CloudInstance vm : vms) {
      try {
        Map<String, Object> virtualMachine =
            azureRMClient.getVirtualMachineInstanceView(stackName, vm.getInstanceId());
        List<Map<String, Object>> vmStatuses = (List) virtualMachine.get("statuses");
        for (Map<String, Object> vmStatuse : vmStatuses) {
          String statusCode = vmStatuse.get("code").toString();
          if (statusCode.startsWith("PowerState")) {
            statusCode = statusCode.replace("PowerState/", "");
            statuses.add(new CloudVmInstanceStatus(vm, ArmInstanceStatus.get(statusCode)));
            break;
          }
        }
      } catch (Exception e) {
        statuses.add(new CloudVmInstanceStatus(vm, InstanceStatus.TERMINATED));
      }
    }
    return statuses;
  }
コード例 #2
0
  @SuppressWarnings("unchecked")
  @Override
  public List<CloudResourceStatus> launch(
      AuthenticatedContext authenticatedContext,
      CloudStack stack,
      PersistenceNotifier notifier,
      AdjustmentType adjustmentType,
      Long threshold) {
    String stackName = authenticatedContext.getCloudContext().getName();
    boolean existingNetwork = isExistingNetwork(stack);
    boolean assignFloatingIp = assignFloatingIp(stack);
    String existingSubnetCidr = getExistingSubnetCidr(authenticatedContext, stack);
    String heatTemplate =
        heatTemplateBuilder.build(
            stackName,
            stack.getGroups(),
            stack.getSecurity(),
            stack.getImage(),
            existingNetwork,
            existingSubnetCidr != null,
            assignFloatingIp);
    Map<String, String> parameters =
        heatTemplateBuilder.buildParameters(
            authenticatedContext,
            stack.getNetwork(),
            stack.getImage(),
            existingNetwork,
            existingSubnetCidr);

    OSClient client = openStackClient.createOSClient(authenticatedContext);

    Stack heatStack =
        client
            .heat()
            .stacks()
            .create(
                Builders.stack()
                    .name(stackName)
                    .template(heatTemplate)
                    .disableRollback(false)
                    .parameters(parameters)
                    .timeoutMins(OPERATION_TIMEOUT)
                    .build());

    CloudResource cloudResource =
        new CloudResource.Builder().type(ResourceType.HEAT_STACK).name(heatStack.getId()).build();
    try {
      notifier.notifyAllocation(cloudResource, authenticatedContext.getCloudContext());
    } catch (Exception e) {
      // Rollback
      terminate(authenticatedContext, stack, Lists.newArrayList(cloudResource));
    }
    List<CloudResourceStatus> resources =
        check(authenticatedContext, Lists.newArrayList(cloudResource));
    LOGGER.debug("Launched resources: {}", resources);
    return resources;
  }
コード例 #3
0
 @Override
 public List<CloudResourceStatus> update(
     AuthenticatedContext authenticatedContext, CloudStack stack, List<CloudResource> resources) {
   String stackName = authenticatedContext.getCloudContext().getName();
   boolean existingNetwork = isExistingNetwork(stack);
   boolean assignFloatingIp = assignFloatingIp(stack);
   String existingSubnetCidr = getExistingSubnetCidr(authenticatedContext, stack);
   String heatTemplate =
       heatTemplateBuilder.build(
           stackName,
           stack.getGroups(),
           stack.getSecurity(),
           stack.getImage(),
           existingNetwork,
           existingSubnetCidr != null,
           assignFloatingIp);
   Map<String, String> parameters =
       heatTemplateBuilder.buildParameters(
           authenticatedContext,
           stack.getNetwork(),
           stack.getImage(),
           existingNetwork,
           existingSubnetCidr);
   return updateHeatStack(authenticatedContext, resources, heatTemplate, parameters);
 }
コード例 #4
0
  @Override
  public List<CloudVmInstanceStatus> stop(
      AuthenticatedContext ac, List<CloudResource> resources, List<CloudInstance> vms) {
    AzureRMClient azureRMClient = armClient.getClient(ac.getCloudCredential());
    String stackName = armTemplateUtils.getStackName(ac.getCloudContext());
    List<CloudVmInstanceStatus> statuses = new ArrayList<>();

    for (CloudInstance vm : vms) {
      try {
        azureRMClient.stopVirtualMachine(stackName, vm.getInstanceId());
        statuses.add(new CloudVmInstanceStatus(vm, InstanceStatus.IN_PROGRESS));
      } catch (HttpResponseException e) {
        statuses.add(
            new CloudVmInstanceStatus(
                vm, InstanceStatus.FAILED, e.getResponse().getData().toString()));
      } catch (Exception e) {
        statuses.add(new CloudVmInstanceStatus(vm, InstanceStatus.FAILED, e.getMessage()));
      }
    }
    return statuses;
  }
コード例 #5
0
 private void doRollbackAndDecreaseNodeCount(
     AuthenticatedContext auth,
     List<CloudResourceStatus> statuses,
     Set<Long> ids,
     Group group,
     ResourceBuilderContext ctx,
     ResourceBuilders resourceBuilders,
     Boolean upscale) {
   List<ComputeResourceBuilder> compute =
       resourceBuilders.compute(auth.getCloudContext().getPlatform());
   List<Future<ResourceRequestResult<List<CloudResourceStatus>>>> futures = new ArrayList<>();
   LOGGER.info(
       String.format(
           "InstanceGroup %s node count decreased with one so the new node size is: %s",
           group.getName(), group.getInstances().size()));
   if (getRemovableInstanceTemplates(group, ids).size() <= 0 && !upscale) {
     LOGGER.info("InstanceGroup node count lower than 1 which is incorrect so error will throw");
     throwError(statuses);
   } else {
     for (int i = compute.size() - 1; i >= 0; i--) {
       for (CloudResourceStatus cloudResourceStatus : statuses) {
         try {
           if (compute
               .get(i)
               .resourceType()
               .equals(cloudResourceStatus.getCloudResource().getType())) {
             ResourceDeleteThread thread =
                 createThread(
                     ResourceDeleteThread.NAME,
                     ctx,
                     auth,
                     cloudResourceStatus.getCloudResource(),
                     compute.get(i),
                     false);
             Future<ResourceRequestResult<List<CloudResourceStatus>>> future =
                 resourceBuilderExecutor.submit(thread);
             futures.add(future);
             for (Future<ResourceRequestResult<List<CloudResourceStatus>>> future1 : futures) {
               future1.get();
             }
             futures.clear();
           }
         } catch (Exception e) {
           LOGGER.info("Resource can not be deleted. Reason: {} ", e.getMessage());
         }
       }
     }
   }
 }
コード例 #6
0
 private void doRollback(
     AuthenticatedContext auth,
     List<CloudResourceStatus> failuresList,
     Group group,
     Integer fullNodeCount,
     ResourceBuilderContext ctx,
     ResourceBuilders resourceBuilders,
     ScaleContext stx) {
   CloudContext localStack = auth.getCloudContext();
   Set<Long> failures = failureCount(failuresList);
   if (stx.getAdjustmentType() == null && failures.size() > 0) {
     LOGGER.info("Failure policy is null so error will throw");
     throwError(failuresList);
   }
   switch (stx.getAdjustmentType()) {
     case EXACT:
       if (stx.getThreshold() > fullNodeCount - failures.size()) {
         LOGGER.info("Number of failures is more than the threshold so error will throw");
         throwError(failuresList);
       } else if (failures.size() != 0) {
         LOGGER.info("Decrease node counts because threshold was higher");
         handleExceptions(
             auth, failuresList, group, ctx, resourceBuilders, failures, stx.getUpscale());
       }
       break;
     case PERCENTAGE:
       if (Double.valueOf(stx.getThreshold())
           > calculatePercentage(failures.size(), fullNodeCount)) {
         LOGGER.info("Number of failures is more than the threshold so error will throw");
         throwError(failuresList);
       } else if (failures.size() != 0) {
         LOGGER.info("Decrease node counts because threshold was higher");
         handleExceptions(
             auth, failuresList, group, ctx, resourceBuilders, failures, stx.getUpscale());
       }
       break;
     case BEST_EFFORT:
       LOGGER.info("Decrease node counts because threshold was higher");
       handleExceptions(
           auth, failuresList, group, ctx, resourceBuilders, failures, stx.getUpscale());
       break;
     default:
       LOGGER.info("Unsupported adjustment type so error will throw");
       throwError(failuresList);
       break;
   }
 }
コード例 #7
0
  private List<CloudResourceStatus> updateHeatStack(
      AuthenticatedContext authenticatedContext,
      List<CloudResource> resources,
      String heatTemplate,
      Map<String, String> parameters) {
    CloudResource resource = utils.getHeatResource(resources);
    String stackName = authenticatedContext.getCloudContext().getName();
    String heatStackId = resource.getName();

    OSClient client = openStackClient.createOSClient(authenticatedContext);
    StackUpdate updateRequest =
        Builders.stackUpdate()
            .template(heatTemplate)
            .parameters(parameters)
            .timeoutMins(OPERATION_TIMEOUT)
            .build();
    client.heat().stacks().update(stackName, heatStackId, updateRequest);
    LOGGER.info(
        "Heat stack update request sent with stack name: '{}' for Heat stack: '{}'",
        stackName,
        heatStackId);
    return check(authenticatedContext, resources);
  }
コード例 #8
0
  @Override
  public List<CloudResourceStatus> terminate(
      AuthenticatedContext authenticatedContext,
      CloudStack cloudStack,
      List<CloudResource> resources) {

    for (CloudResource resource : resources) {
      switch (resource.getType()) {
        case HEAT_STACK:
          String heatStackId = resource.getName();
          String stackName = authenticatedContext.getCloudContext().getName();
          LOGGER.info("Terminate stack: {}", stackName);
          OSClient client = openStackClient.createOSClient(authenticatedContext);
          client.heat().stacks().delete(stackName, heatStackId);
          break;
        default:
          throw new CloudConnectorException(
              String.format("Invalid resource type: %s", resource.getType()));
      }
    }

    return check(authenticatedContext, resources);
  }
コード例 #9
0
  @Override
  public List<CloudResourceStatus> check(
      AuthenticatedContext authenticatedContext, List<CloudResource> resources) {
    List<CloudResourceStatus> result = new ArrayList<>();
    OSClient client = openStackClient.createOSClient(authenticatedContext);

    for (CloudResource resource : resources) {
      switch (resource.getType()) {
        case HEAT_STACK:
          String heatStackId = resource.getName();
          String stackName = authenticatedContext.getCloudContext().getName();
          LOGGER.info("Checking OpenStack Heat stack status of: {}", stackName);
          Stack heatStack = client.heat().stacks().getDetails(stackName, heatStackId);
          CloudResourceStatus heatResourceStatus = utils.heatStatus(resource, heatStack);
          result.add(heatResourceStatus);
          break;
        default:
          throw new CloudConnectorException(
              String.format("Invalid resource type: %s", resource.getType()));
      }
    }

    return result;
  }