Java ComputeService类代码示例

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@BeforeClass
public static void setUpClass() throws RunNodesException {
    Assume.assumeTrue(HekateTestProps.is("AWS_TEST_ENABLED"));

    Properties props = new Properties();

    props.setProperty(LocationConstants.PROPERTY_REGIONS, REGION);

    ContextBuilder builder = newBuilder("aws-ec2").credentials(
        ACCESS_KEY,
        SECRET_KEY
    ).overrides(props);

    ComputeService compute = builder.modules(ImmutableSet.<Module>of(new SLF4JLoggingModule()))
        .buildView(ComputeServiceContext.class)
        .getComputeService();

    for (int i = 0; i < 4; i++) {
        ensureNodeExists(i, compute);
    }
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Test
public void test() {
    CloudProperties.getInstance().reset().load(this.getClass());
    try (DockerCloudProvider cloudProvider = (DockerCloudProvider) CloudProvider.create("provider0")) {
        final ComputeService computeService = cloudProvider.getComputeServiceContext().getComputeService();
        assertTrue("No node-group should be 'node-leak-test' before test", computeService.listNodes().stream()
                .noneMatch(cm -> "node-leak-test".equals(((NodeMetadata) cm).getGroup())));
        try {
            cloudProvider.createNode("node0").close();
            Assert.fail("Port 2468 was unexpectedly opened");
        } catch (PortOpeningException e) {
            assertTrue("No node-group should be 'node-leak-test' after test", computeService.listNodes().stream()
                    .noneMatch(cm -> "node-leak-test".equals(((NodeMetadata) cm).getGroup())));
        }
    }
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Override
protected void configure() {
    super.configure();
    bind(new TypeLiteral<ComputeServiceAdapter<ServerWithExternalIp, OsImage, OsImage, Datacenter>>() {
    }).to(DimensionDataCloudControllerComputeServiceAdapter.class);
    bind(ComputeService.class).to(DimensionDataCloudControllerComputeService.class);

    bind(new TypeLiteral<Function<ServerWithExternalIp, NodeMetadata>>() {
    }).to(ServerWithNatRuleToNodeMetadata.class);
    bind(new TypeLiteral<Function<OsImage, Image>>() {
    }).to(OsImageToImage.class);
    bind(new TypeLiteral<Function<OsImage, Hardware>>() {
    }).to(OsImageToHardware.class);
    bind(new TypeLiteral<Function<Datacenter, Location>>() {
    }).to(DatacenterToLocation.class);
    bind(TemplateOptions.class).to(DimensionDataCloudControllerTemplateOptions.class);
    bind(CreateNodesInGroupThenAddToSet.class).to(GetOrCreateNetworkDomainThenCreateNodes.class);
    bind(PrioritizeCredentialsFromTemplate.class).to(UseNodeCredentialsButOverrideFromTemplate.class);

    // to have the compute service adapter override default locations
    install(new LocationsFromComputeServiceAdapterModule<ServerWithExternalIp, OsImage, OsImage, Datacenter>() {
    });
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
public void listNodesWhereImageDoesntExist() throws Exception {
   enqueueRegions(DEFAULT_REGION);
   enqueueXml(DEFAULT_REGION, "/describe_instances_running-1.xml");
   enqueueXml(DEFAULT_REGION, "/availabilityZones.xml");
   enqueue(DEFAULT_REGION, new MockResponse().setBody("<DescribeImagesResponse><imagesSet></imagesSet></DescribeImagesResponse>"));
   enqueue(DEFAULT_REGION, new MockResponse().setBody("<DescribeSpotInstanceRequestsResponse><spotInstanceRequestSet></spotInstanceRequestSet></DescribeSpotInstanceRequestsResponse>"));

   ComputeService computeService = computeService();

   NodeMetadata node = Iterables.getOnlyElement(computeService.listNodesDetailsMatching(NodePredicates.all()));
   assertEquals(node.getId(), "us-east-1/i-2baa5550");

   assertPosted(DEFAULT_REGION, "Action=DescribeRegions");
   assertPosted(DEFAULT_REGION, "Action=DescribeInstances");
   assertPosted(DEFAULT_REGION, "Action=DescribeAvailabilityZones");
   assertPosted(DEFAULT_REGION, "Action=DescribeImages&ImageId.1=ami-aecd60c7");
   assertPosted(DEFAULT_REGION, "Action=DescribeSpotInstanceRequests");
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
public static ComputeService buildDefaultComputeService(IaasProvider iaasProvider) {

        Properties properties = new Properties();

        // load properties
        for (Map.Entry<String, String> entry : iaasProvider.getProperties().entrySet()) {
            properties.put(entry.getKey(), entry.getValue());
        }

        // set modules
        Iterable<Module> modules =
                ImmutableSet.<Module>of(new SshjSshClientModule(), new SLF4JLoggingModule(),
                        new EnterpriseConfigurationModule());

        // build context
        ContextBuilder builder =
                ContextBuilder.newBuilder(iaasProvider.getProvider())
                        .credentials(iaasProvider.getIdentity(), iaasProvider.getCredential()).modules(modules)
                        .overrides(properties);

        return builder.buildView(ComputeServiceContext.class).getComputeService();
    }
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
private static void runScriptOnGroup(final ComputeService compute,
                                     final LoginCredentials login, final String groupName, final Statement command)
        throws RunScriptOnNodesException {
    // when you run commands, you can pass options to decide whether
    // to run it as root, supply or own credentials vs from cache,
    // and wrap in an init script vs directly invoke
    Map<? extends NodeMetadata, ExecResponse> execResponses =
            compute.runScriptOnNodesMatching(//
                    inGroup(groupName), // predicate used to select nodes
                    command, // what you actually intend to run
                    overrideLoginCredentials(login)); // use the local user & ssh key

    for (Entry<? extends NodeMetadata, ExecResponse> response : execResponses.entrySet()) {
        System.out.printf(
                "<< node %s: %s%n",
                response.getKey().getId(),
                concat(response.getKey().getPrivateAddresses(), response.getKey()
                        .getPublicAddresses())
        );
        System.out.printf("<<     %s%n", response.getValue());
    }
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
private static ComputeService initComputeService(final String provider, final String identity,
                                                 final String credential) {
    // example of specific properties, in this case optimizing image list to
    // only amazon supplied
    Properties properties = new Properties();
    long scriptTimeout = TimeUnit.MILLISECONDS.convert(20, TimeUnit.MINUTES);
    properties.setProperty(TIMEOUT_SCRIPT_COMPLETE, scriptTimeout + "");

    // example of injecting a ssh implementation
    Iterable<Module> modules =
            ImmutableSet.<Module>of(new SshjSshClientModule(), new SLF4JLoggingModule(),
                    new EnterpriseConfigurationModule());

    ContextBuilder builder =
            ContextBuilder.newBuilder(provider).credentials(identity, credential).modules(modules)
                    .overrides(properties);

    System.out.printf(">> initializing %s%n", builder.getApiMetadata());

    return builder.buildView(ComputeServiceContext.class).getComputeService();
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Inject
public ECSComputeServiceContextImpl(
      @Provider Context backend,
      @Provider TypeToken<? extends Context> backendType,
      ComputeService computeService,
      Utils utils) {
   super(backend, backendType, computeService, utils);
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Override
protected void configure() {
   super.configure();
   bind(ECSApi.class).to(ECSApiImpl.class);
   bind(ComputeService.class).to(ECSComputeService.class);
   install(new LocationsFromComputeServiceAdapterModule<NodeMetadata, Hardware, Image, Location>() {});
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
private static void destroyNodes(final ComputeServiceContext ctx, final String groupname) {
	// Destroy all workers identified by the given group
	final ComputeService computeService = ctx.getComputeService();
	if (computeService != null) {
		Set<? extends NodeMetadata> destroyed = computeService
				.destroyNodesMatching(
						Predicates.<NodeMetadata> and(not(TERMINATED),
								inGroup(groupname)));
		System.out.printf("<< destroyed nodes %s%n", destroyed);
	}
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
/**
 * Build compute service.
 *
 * @return the compute service
 */
ComputeService build() {
    final String cloudProvider = getOrNull(JCloudsProperties.PROVIDER);
    final String endpoint = getOrNull(JCloudsProperties.ENDPOINT);
    final String identity = getOrNull(JCloudsProperties.IDENTITY);
    String credential = getOrNull(JCloudsProperties.CREDENTIAL);
    final String credentialPath = getOrNull(JCloudsProperties.CREDENTIAL_PATH);
    isNotNull(cloudProvider, "Cloud Provider");

    if (credential != null && credentialPath != null) {
        throw new UnsupportedOperationException("Both credential and credentialPath are set. Use only one method.");
    }
    if (credentialPath != null) {
        credential = getCredentialFromFile(cloudProvider, credentialPath);
    }

    if (LOGGER.isFinestEnabled()) {
        LOGGER.finest("Using CLOUD_PROVIDER: " + cloudProvider);
    }

    final String roleName = getOrNull(JCloudsProperties.ROLE_NAME);
    ContextBuilder contextBuilder = newContextBuilder(cloudProvider, identity, credential, roleName);
    if (endpoint != null) {
        if (LOGGER.isFinestEnabled()) {
            LOGGER.finest("Using custom endpoint: " + endpoint);
        }
        contextBuilder.endpoint(endpoint);
    }

    Properties jcloudsProperties = buildRegionZonesConfig();
    buildTagConfig();
    buildNodeFilter();

    computeService = contextBuilder.overrides(jcloudsProperties)
            .modules(ImmutableSet.of(new HazelcastLoggingModule()))
            .buildView(ComputeServiceContext.class)
            .getComputeService();

    return computeService;
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
public ComputeService initComputeService(String provider, String identity, String credential) {
    Properties properties = new Properties();
    ContextBuilder builder = ContextBuilder.newBuilder(provider)
            .credentials(identity, credential)
            .overrides(properties);
    LOGGER.info(MessageFormat.format(">> initializing Compute Service {0}", builder.getApiMetadata()));
    return builder.buildView(ComputeServiceContext.class).getComputeService();
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Test
public void test_getFilteredNodes_with_group_configured() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    String groupUnderTest = "group3";
    properties.put("group", groupUnderTest);
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    ComputeService mockComputeService = mock(ComputeService.class);
    builder.setComputeService(mockComputeService);

    Set<NodeMetadata> nodes = new HashSet<NodeMetadata>();
    for (int i = 0; i < 5; i++) {
        nodes.add(new NodeMetadataBuilder()
                .id(newSecureUuidString())
                .group("group" + i)
                .status(NodeMetadata.Status.RUNNING)
                .build());
    }
    nodes.add(new NodeMetadataBuilder()
            .id(newSecureUuidString())
            .group(groupUnderTest)
            .status(NodeMetadata.Status.RUNNING)
            .build());
    doReturn(nodes).when(mockComputeService).listNodesDetailsMatching(null);

    Set<NodeMetadata> result = (Set<NodeMetadata>) builder.getFilteredNodes();

    assertEquals(2, result.size());
    for (NodeMetadata node : result) {
        assertEquals(groupUnderTest, node.getGroup());
    }
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Test
public void test_destroy_calls_computeService_destroy() {
    ComputeServiceBuilder builder = new ComputeServiceBuilder(new HashMap<String, Comparable>());
    ComputeService mockComputeService = mock(ComputeService.class);
    ComputeServiceContext mockComputeServiceContext = mock(ComputeServiceContext.class);
    builder.setComputeService(mockComputeService);
    doReturn(mockComputeServiceContext).when(mockComputeService).getContext();
    builder.destroy();

    verify(mockComputeServiceContext).close();
}
 

import org.jclouds.compute.ComputeService; //导入依赖的package包/类
@Test
public void test_compute_service_builder_return_correct_api_class() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    properties.put("provider", "aws-ec2");
    properties.put("identity", "id");
    properties.put("credential", "credential");
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    ComputeService service = builder.build();

    assertEquals(AWSEC2ComputeService.class, service.getClass());
}