import org.openstack4j.model.compute.ServerCreate; //导入依赖的package包/类
public Server create(String name, String keypairName, String imageId, String flavorId, 
		List<String> networks, boolean powerOn) {
	Assert.notNull(client());
	
	ServerCreate serverCreate = client().compute().servers().serverBuilder()
		.name(name)
		.keypairName(keypairName)
		.image(imageId)
		.flavor(flavorId)
		.networks(networks)
		.build();
	
	Server server = null;
	if (powerOn)
		server = client().compute().servers().boot(serverCreate) ;
	
	return server;
}
 

import org.openstack4j.model.compute.ServerCreate; //导入依赖的package包/类
private static ServerCreate getServerConfig(Instance instance) {
    ServerCreateBuilder builder = Builders.server()
            .name(instance.getName())
            .flavor(instance.getFlavor().getId())
            .image(instance.getImage().getRealId());
    
    if (!instance.getKeypairs().isEmpty()) {
        builder = builder.keypairName(instance.getKeypairs().get(0).getName());
    }

    if (!instance.getNetworks().isEmpty()) {
        List<String> networks = instance.getNetworks().stream()
                .map(org.meridor.perspective.beans.Network::getId)
                .collect(Collectors.toList());
        builder = builder.networks(networks);
    }

    Optional<AvailabilityZone> availabilityZoneCandidate = Optional.ofNullable(instance.getAvailabilityZone());
    if (availabilityZoneCandidate.isPresent()) {
        builder = builder.availabilityZone(availabilityZoneCandidate.get().getName());
    }
    
    return builder.build();
}
 

import org.openstack4j.model.compute.ServerCreate; //导入依赖的package包/类
@Override
public Server doRequest(OSClient api) throws NotFoundException, ResponseException {
    ServerService serverService = api.compute().servers();

    ServerCreateBuilder serverCreateBuilder = serverService.serverBuilder().name(this.serverName)
            .flavor(getFlavorId()).image(getImageId()).keypairName(this.keyPair).addMetadata(this.metadata);

    for (String securityGroup : this.securityGroups) {
        serverCreateBuilder.addSecurityGroup(securityGroup);
    }
    if (this.networks != null && !this.networks.isEmpty()) {
        serverCreateBuilder.networks(getNetworkIds());
    }
    if (this.encodedUserData != null) {
        serverCreateBuilder.userData(this.encodedUserData);
    }

    ServerCreate serverCreate = serverCreateBuilder.build();
    Server server = serverService.boot(serverCreate);
    // first call to boot only seem to return a stripped Server object
    // (missing fields such as status). re-fetch it before returning.
    return serverService.get(server.getId());
}
 

import org.openstack4j.model.compute.ServerCreate; //导入依赖的package包/类
@Override
public VirtualMachine apply(VirtualMachineTemplate virtualMachineTemplate) {

  //todo we currently simply assume that this is a zone (hosts may follow)
  Location zone = locationGetStrategy.get(virtualMachineTemplate.locationId());
  checkNotNull(zone, "zone is null");
  checkState(LocationScope.ZONE.equals(zone.locationScope()), "zone is no zone");
  checkState(zone.parent().isPresent(), "zone has no parent region");
  Location region = zone.parent().get();

  List<String> networks = new ArrayList<>(1);
  if (networkStrategy.get() != null) {
    networks.add(networkStrategy.get());
  }

  //keypair
  String keyPairName = null;
  Keypair keypair = null;
  if (virtualMachineTemplate.templateOptions().isPresent()) {
    keyPairName = virtualMachineTemplate.templateOptions().get().keyPairName();
  }
  if (keyPairName == null) {
    keypair = osClient.compute().keypairs()
        .create(namingStrategy.generateNameBasedOnName(null), null);
  }

  List<String> secGroups = new ArrayList<>(1);
  if (virtualMachineTemplate.templateOptions().isPresent()) {
    secGroups.add(createSecurityGroupFromTemplateOption
        .create(virtualMachineTemplate.templateOptions().get(),
            virtualMachineTemplate.locationId()));
  }

  if (defaultSecurityGroup != null) {
    secGroups.add(defaultSecurityGroup);
  }

  //todo this code also assumes that location is always the availability zone
  final ServerCreateBuilder serverCreateBuilder = Builders.server()
      .name(namingStrategy.generateUniqueNameBasedOnName(virtualMachineTemplate.name()))
      .flavor(IdScopeByLocations.from(virtualMachineTemplate.hardwareFlavorId()).getId())
      .image(IdScopeByLocations.from(virtualMachineTemplate.imageId()).getId())
      .availabilityZone(IdScopeByLocations.from(virtualMachineTemplate.locationId()).getId())
      .networks(networks).keypairName(keyPairName);
  for (String secGroup : secGroups) {
    serverCreateBuilder.addSecurityGroup(secGroup);
  }
  final ServerCreate serverCreate = serverCreateBuilder.build();
  //todo make timeout configurable
  final Server createdServer = osClient.useRegion(region.id()).compute().servers()
      .bootAndWaitActive(serverCreate, 120000);
  // we retrieve the newly created server to get additional details the creation request does
  // not contain
  final Server retrievedServer = osClient.compute().servers().get(createdServer.getId());
  checkState(retrievedServer != null,
      "Could not retrieve newly created server with id " + createdServer.getId());
  return virtualMachineConverter
      .apply(new ServerInRegion(createdServer, retrievedServer, region, keypair));
}
 

import org.openstack4j.model.compute.ServerCreate; //导入依赖的package包/类
@Override
public Server createServer(String serverName, String imageId, String flavorId, String keyPairName) {
	try {

		Server newServer = null;
		String networkId = null;

		// Adhering to openstack format of subnet names 'subnet-<name>'.
		String networkName = "subnet-" + properties.getProperty(Constants.OS_NETWORK_NAME);

		for( Subnet net : os.networking().subnet().list() ) {
			if(net.getName().equals(networkName)) {
				networkId = net.getNetworkId();
				logger.info("Using network " + networkName + " with ID: " + networkId);
				break;
			}
		}

		if(networkId != null) {

			List<String> srvNet = new LinkedList<String>();
			srvNet.add(networkId);

			ServerCreate sc = Builders.server()
					.name(serverName)
					.flavor(flavorId)
					.image(imageId)
					.networks(srvNet)
					.keypairName(keyPairName)
					.build();

			//Boot the Server
			newServer = os.compute().servers().boot(sc);

			logger.info("New server created with ID: " + newServer.getId());

		}
		else {
			logger.error("Network with name " + networkName + " not found.");
		}
		return newServer;
	}
	catch( Exception ex ) {
		ex.printStackTrace();
		// TODO: Check with the team on how to handle exceptions.
		logger.error("Failed to create server.");
		return null;
	}
}