import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
public Predicate<ComputeMetadata> buildNodeFilter() {
    nodesFilter = new Predicate<ComputeMetadata>() {
        @Override
        public boolean apply(ComputeMetadata nodeMetadata) {
            if (nodeMetadata == null) {
                return false;
            }
            if (tagPairs.size() > nodeMetadata.getUserMetadata().size()) {
                return false;
            }
            for (AbstractMap.SimpleImmutableEntry entry : tagPairs) {
                String value = nodeMetadata.getUserMetadata().get(entry.getKey());
                if (value == null || !value.equals(entry.getValue())) {
                    return false;
                }
            }
            return true;
        }
    };
    return nodesFilter;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Test
public void test_buildNodeFilter_with_NodeMetadata_with_multiple_tags() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    properties.put("tag-keys", "tag1,tag2");
    properties.put("tag-values", "value1,value2");
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    builder.buildTagConfig();
    Predicate<ComputeMetadata> nodeFilter = builder.buildNodeFilter();

    Map<String, String> userMetaData = new HashMap<String, String>();
    userMetaData.put("tag1", "value1");

    NodeMetadata metadata = new NodeMetadataBuilder()
            .userMetadata(userMetaData)
            .id(newSecureUuidString())
            .status(NodeMetadata.Status.RUNNING)
            .build();

    assertFalse(nodeFilter.apply(metadata));
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Test
public void test_buildNodeFilter_with_NodeMetadata_with_single_tag() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    properties.put("tag-keys", "tag1");
    properties.put("tag-values", "value1");
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    builder.buildTagConfig();
    Predicate<ComputeMetadata> nodeFilter = builder.buildNodeFilter();

    Map<String, String> userMetaData = new HashMap<String, String>();
    userMetaData.put("tag1", "value2");

    NodeMetadata metadata = new NodeMetadataBuilder()
            .userMetadata(userMetaData)
            .id(newSecureUuidString())
            .status(NodeMetadata.Status.RUNNING)
            .build();

    assertFalse(nodeFilter.apply(metadata));
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Test
public void test_buildNodeFilter_with_NodeMetadata_with_multiple_tags_with_and_relation() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    properties.put("tag-keys", "Owner,Stack");
    properties.put("tag-values", "DbAdmin,Production");
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    builder.buildTagConfig();
    Predicate<ComputeMetadata> nodeFilter = builder.buildNodeFilter();

    Map<String, String> userMetaData = new HashMap<String, String>();
    userMetaData.put("Owner", "DbAdmin");
    userMetaData.put("Stack", "Production");

    NodeMetadata metadata = new NodeMetadataBuilder()
            .userMetadata(userMetaData)
            .id(newSecureUuidString())
            .status(NodeMetadata.Status.RUNNING)
            .build();

    assertTrue(nodeFilter.apply(metadata));
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Test
public void test_buildNodeFilter_with_NodeMetadata_with_multiple_tags_with_and_relation_where_user_metadata_has_more_elements() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    properties.put("tag-keys", "Owner,Stack");
    properties.put("tag-values", "DbAdmin,Production");
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    builder.buildTagConfig();
    Predicate<ComputeMetadata> nodeFilter = builder.buildNodeFilter();

    Map<String, String> userMetaData = new HashMap<String, String>();
    userMetaData.put("Owner", "DbAdmin");
    userMetaData.put("Stack", "Production");
    userMetaData.put("Number", "1");

    NodeMetadata metadata = new NodeMetadataBuilder()
            .userMetadata(userMetaData)
            .id(newSecureUuidString())
            .status(NodeMetadata.Status.RUNNING)
            .build();

    assertTrue(nodeFilter.apply(metadata));
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Test
public void test_buildNodeFilter_with_NodeMetadata_with_single_value() {
    Map<String, Comparable> properties = new HashMap<String, Comparable>();
    properties.put("tag-keys", "tag1");
    properties.put("tag-values", "value1");
    ComputeServiceBuilder builder = new ComputeServiceBuilder(properties);
    builder.buildTagConfig();
    Predicate<ComputeMetadata> nodeFilter = builder.buildNodeFilter();

    Map<String, String> userMetaData = new HashMap<String, String>();
    userMetaData.put("tag1", "value1");

    NodeMetadata metadata = new NodeMetadataBuilder()
            .userMetadata(userMetaData)
            .id(newSecureUuidString())
            .status(NodeMetadata.Status.RUNNING)
            .build();

    assertTrue(nodeFilter.apply(metadata));
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
/**
 * Returns the required {@ComputeMetadata} {@link Predicate} for the Exhcnage.
 * The predicate can be used for filtering.
 */
public Predicate<ComputeMetadata> getComputePredicate(final Exchange exchange) {
    final String nodeId = getNodeId(exchange);

    Predicate<ComputeMetadata> predicate = new Predicate<ComputeMetadata>() {
        public boolean apply(ComputeMetadata metadata) {
            if (nodeId != null && !nodeId.equals(metadata.getId())) {
                return false;
            }

            //If NodeMetadata also delegate to Node predicate.
            if (metadata instanceof NodeMetadataImpl) {
                Predicate<NodeMetadata> nodeMetadataPredicate = getNodePredicate(exchange);
                if (!nodeMetadataPredicate.apply((NodeMetadataImpl) metadata)) {
                    return false;
                }
            }
            return true;
        }
    };

    return predicate;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Inject
public JCloudsCreateVirtualMachineStrategy(JCloudsComputeClient jCloudsComputeClient,
    OneWayConverter<ComputeMetadata, VirtualMachine> computeMetadataVirtualMachineConverter,
    OneWayConverter<TemplateOptions, org.jclouds.compute.options.TemplateOptions> templateOptionsConverter,
    NamingStrategy namingStrategy) {

  checkNotNull(jCloudsComputeClient);
  checkNotNull(computeMetadataVirtualMachineConverter);
  checkNotNull(templateOptionsConverter);
  checkNotNull(namingStrategy);

  this.jCloudsComputeClient = jCloudsComputeClient;
  this.computeMetadataVirtualMachineConverter = computeMetadataVirtualMachineConverter;
  this.templateOptionsConverter = templateOptionsConverter;
  this.namingStrategy = namingStrategy;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Override
public void handle(Upload command) {
    if (isDeploymentLoaded()) {
        ExternalComponentInstance ownerVM = null;
        for (ExternalComponentInstance ni: deploy.getComponentInstances().onlyExternals()) {
            if (ni.getName().equals(command.getArtifactId())) {
                ownerVM = ni;
            }
        }
        if (ownerVM != null && ownerVM instanceof VMInstance) {
            Provider p = ((VMInstance) ownerVM).getType().getProvider();
            JCloudsConnector jc = new JCloudsConnector(p.getName(), p.getCredentials().getLogin(), p.getCredentials().getPassword());
            ComputeMetadata c = jc.getVMByName(command.getArtifactId());
            jc.uploadFile(command.getLocalPath(), command.getRemotePath(), c.getId(), "ubuntu",
                    ((VM) ownerVM.getType()).getPrivateKey());
        } else {
            final String text = "There is no VM with this ID!";
            final Message message = new Message(command, Category.ERROR, text);
            dispatch(message);
        }

    } else {
        reportNoDeploymentLoaded(command);

    }
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Test
public void test_buildNodeFilter_with_null_NodeMetadata() {
    ComputeServiceBuilder builder = new ComputeServiceBuilder(new HashMap<String, Comparable>());
    Predicate<ComputeMetadata> nodeFilter = builder.buildNodeFilter();

    assertFalse(nodeFilter.apply(null));
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Inject
public VirtualMachineSupplier(JCloudsComputeClient jCloudsComputeClient,
    OneWayConverter<ComputeMetadata, VirtualMachine> jCloudsComputeMetadataToVirtualMachine,
    NamingStrategy namingStrategy) {

  checkNotNull(jCloudsComputeClient, "jCloudsComputeClient is null.");
  checkNotNull(jCloudsComputeMetadataToVirtualMachine,
      "jCloudsComputeMetadataToVirtualMachine is null.");
  checkNotNull(namingStrategy, "namingStrategy is null.");

  this.jCloudsComputeClient = jCloudsComputeClient;
  this.jCloudsComputeMetadataToVirtualMachine = jCloudsComputeMetadataToVirtualMachine;
  this.namingStrategy = namingStrategy;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Override
public VirtualMachine apply(final ComputeMetadata computeMetadata) {

  checkArgument(computeMetadata instanceof NodeMetadata);

  VirtualMachineBuilder virtualMachineBuilder = VirtualMachineBuilder.newBuilder();
  virtualMachineBuilder.id(computeMetadata.getId())
      .providerId(computeMetadata.getProviderId()).name(forceName(computeMetadata));

  ((NodeMetadata) computeMetadata).getPrivateAddresses()
      .forEach(virtualMachineBuilder::addIpString);
  ((NodeMetadata) computeMetadata).getPublicAddresses()
      .forEach(virtualMachineBuilder::addIpString);
  if (((NodeMetadata) computeMetadata).getCredentials() != null) {
    virtualMachineBuilder.loginCredential(this.loginCredentialConverter
        .apply(((NodeMetadata) computeMetadata).getCredentials()));
  }

  virtualMachineBuilder
      .hardware(hardwareConverter.apply(((NodeMetadata) computeMetadata).getHardware()));

  String imageId = ((NodeMetadata) computeMetadata).getImageId();
  if (imageId != null) {
    virtualMachineBuilder.image(imageGetStrategy.get(imageId));
  }

  return virtualMachineBuilder.build();
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Inject
public OpenstackCreateVirtualMachineStrategy(JCloudsComputeClient jCloudsComputeClient,
    OneWayConverter<ComputeMetadata, VirtualMachine> computeMetadataVirtualMachineConverter,
    OneWayConverter<TemplateOptions, org.jclouds.compute.options.TemplateOptions> templateOptionsConverter,
    GetStrategy<String, Location> locationGetStrategy, NamingStrategy namingStrategy) {
  super(jCloudsComputeClient, computeMetadataVirtualMachineConverter,
      templateOptionsConverter, namingStrategy);
  this.locationGetStrategy = locationGetStrategy;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
public static Predicate<ComputeMetadata> nameStartsWith(final String prefix) {
   Preconditions.checkNotNull(prefix, "prefix must be defined");

   return new Predicate<ComputeMetadata>() {
      @Override
      public boolean apply(ComputeMetadata computeMetadata) {
         return computeMetadata.getName().startsWith(prefix);
      }

      @Override
      public String toString() {
         return "nameStartsWith(" + prefix + ")";
      }
   };
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
public ComputeMetadata findVMByName(String name, Provider p) {//TODO: use the connector factory
    JCloudsConnector jc = new JCloudsConnector(p.getName(), p.getCredentials().getLogin(),
            p.getCredentials().getPassword());
    ComputeMetadata cm = jc.getVMByName(name);
    jc.closeConnection();
    return cm;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
public Set<? extends ComputeMetadata> listOfVMs(Provider p) {//TODO: use the connector factory
    JCloudsConnector jc = new JCloudsConnector(p.getName(), p.getCredentials().getLogin(),
            p.getCredentials().getPassword());
    Set<? extends ComputeMetadata> list = jc.listOfVMs();
    jc.closeConnection();
    return list;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
/**
 * Sets the metadata of the available nodes to the out message.
 */
protected void listNodes(Exchange exchange) {
    Predicate<ComputeMetadata> predicate = getComputePredicate(exchange);
    Set<? extends ComputeMetadata> computeMetadatas = computeService.listNodesDetailsMatching(predicate);
    exchange.getOut().setBody(computeMetadatas);
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Override
public List<DiscoveryNode> buildDynamicNodes() {
    List<DiscoveryNode> discoveryNodes = Lists.newArrayList();
    String addressContains = componentSettings.get("address_contains", null);
    @SuppressWarnings("unchecked")
    Set<? extends ComputeMetadata> nodes = context.getComputeService().listNodesDetailsMatching(buildFilter());

    for(ComputeMetadata metadata : nodes){
        if(metadata instanceof NodeMetadata){
            if(tags.size() > 0){
                // filtering by tags
                boolean hasTag = false;
                for(String tag : metadata.getTags()){
                    if(tags.contains(tag)){
                        hasTag = true;
                        break;
                    }
                }
                if(!hasTag){
                    // this node does not have any of the tags we are looking for
                    continue;
                }
            }

            Set<String> nodeAddresses;
            if(privateIp){
                nodeAddresses = ((NodeMetadata) metadata).getPrivateAddresses();
            }
            else{
                nodeAddresses = ((NodeMetadata) metadata).getPublicAddresses();
            }
            String address = null;
            for(String ip : nodeAddresses){
                if(addressContains != null && ip.contains(addressContains)){
                    address = ip;
                    break;
                }
                else if(addressContains == null){
                    address = ip;
                    break;
                }
            }
            if(address != null){
                try {
                    TransportAddress[] addresses = transportService.addressesFromString(address);
                    for(int i = 0; (i < addresses.length && i < UnicastZenPing.LIMIT_PORTS_COUNT); i++){
                        logger.trace("adding {}, address {}, transport_address {}", ((NodeMetadata) metadata).getHostname(), address, addresses[i]);
                        discoveryNodes.add(new DiscoveryNode("#cloud-" + ((NodeMetadata) metadata).getHostname() + "-" + i, addresses[i], Version.CURRENT));
                    }
                } catch (Exception e) {
                    logger.warn("failed to add {}, address {}", e, ((NodeMetadata) metadata).getHostname(), address);
                }
            }
            else{
                logger.trace("not adding {}, address is null, host_type {}", ((NodeMetadata) metadata).getHostname());
            }
        }
    }

    logger.debug("using dynamic discovery nodes {}", discoveryNodes);

    return discoveryNodes;
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Override
public Set<? extends ComputeMetadata> listNodes() {
  return this.computeServiceContext.getComputeService()
      .listNodesDetailsMatching(input -> true);
}
 

import org.jclouds.compute.domain.ComputeMetadata; //导入依赖的package包/类
@Override
protected void configure() {
  super.configure();

  //bind the compute context provider
  bind(ComputeServiceContext.class).toProvider(ComputeServiceContextProvider.class)
      .in(Singleton.class);

  //bind the image converter
  bind(new TypeLiteral<OneWayConverter<org.jclouds.compute.domain.Image, Image>>() {
  }).to(JCloudsImageToImage.class);

  //bind the operating system converter
  bind(
      new TypeLiteral<OneWayConverter<OperatingSystem, de.uniulm.omi.cloudiator.domain.OperatingSystem>>() {
      }).to(JCloudsOperatingSystemConverter.class);

  //bind the operating system family converter
  bind(new TypeLiteral<OneWayConverter<OsFamily, OperatingSystemFamily>>() {
  }).to(JCloudsOperatingSystemFamilyConverter.class);

  //bind the location converter
  bind(new TypeLiteral<OneWayConverter<org.jclouds.domain.Location, Location>>() {
  }).to(JCloudsLocationToLocation.class);

  //bind the reverse location converter
  bind(new TypeLiteral<OneWayConverter<Location, org.jclouds.domain.Location>>() {
  }).to(LocationToJCloudsLocation.class);

  //bind the hardware converter
  bind(new TypeLiteral<OneWayConverter<Hardware, HardwareFlavor>>() {
  }).to(JCloudsHardwareToHardwareFlavor.class);

  //bind the virtual machine converter
  bind(new TypeLiteral<OneWayConverter<ComputeMetadata, VirtualMachine>>() {
  }).to(virtualMachineConverter());

  //bind the login credential converter
  bind(new TypeLiteral<OneWayConverter<LoginCredentials, LoginCredential>>() {
  }).to(JCloudsLoginCredentialsToLoginCredential.class);

  //bind the security group converter
  bind(
      new TypeLiteral<OneWayConverter<org.jclouds.compute.domain.SecurityGroup, SecurityGroup>>() {
      }).to(JCloudsSecurityGroupToSecurityGroup.class);

  //bind the security group rule converter
  bind(new TypeLiteral<OneWayConverter<IpPermission, SecurityGroupRule>>() {
  }).to(JCloudsIpPermissionToSecurityGroupRule.class);

  //bind the template options converter
  bind(
      new TypeLiteral<OneWayConverter<TemplateOptions, org.jclouds.compute.options.TemplateOptions>>() {
      }).to(templateOptionsConverter());
}