import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
@Override
public KeyPair create(@Nullable String name, @Nullable String publicKey, String locationId) {

  checkNotNull(locationId, "location is null");
  if (name != null) {
    checkArgument(!name.isEmpty(), "name is empty");
  }
  if (publicKey != null) {
    checkArgument(!publicKey.isEmpty(), "publicKey is empty");
  }

  final Location region = getRegion(locationId);
  Keypair osKeyPair = osClient.useRegion(region.id()).compute().keypairs()
      .create(namingStrategy.generateUniqueNameBasedOnName(name), publicKey);

  checkNotNull(osKeyPair, "keyPair was not generated.");
  checkState(osKeyPair.getPrivateKey() != null && publicKey == null,
      "privateKeyPair not present in generated keyPair (when no public key is supplied)");
  return KeyPairBuilder.newBuilder()
      .id(IdScopeByLocations.from(region.id(), osKeyPair.getName()).getIdWithLocation())
      .providerId(osKeyPair.getName()).location(region).publicKey(osKeyPair.getPublicKey())
      .privateKey(osKeyPair.getPrivateKey()).name(osKeyPair.getName()).build();
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
@Override
public Keypair createKeyPair(String keyPairName, String publicKey) {
	try {

		Keypair keyp = os.compute().keypairs().create(keyPairName, publicKey);

		logger.info("Keypair created successfully: " + keyp.getName());

		return keyp;
	}
	catch( Exception ex ) {
		ex.printStackTrace();
		// TODO: Check with the team on how to handle exceptions.
		logger.error("Failed to create keypair: " + keyPairName);
		return null;
	}
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
@Override
public Keypair getKeyPair(String keyPairName) {
	try {

		Keypair keyp = os.compute().keypairs().get(keyPairName);

		if(keyp != null){
			logger.info("Keypair retrieved successfully: " + keyp.getName());				
		}

		return keyp;
	}
	catch( Exception ex ) {
		ex.printStackTrace();
		// TODO: Check with the team on how to handle exceptions.
		logger.error("Failed to retrieve keypair: " + keyPairName);
		return null;
	}
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
private void createKeyPair(AuthenticatedContext authenticatedContext, CloudStack stack, OSClient client) {
    KeystoneCredentialView keystoneCredential = openStackClient.createKeystoneCredential(authenticatedContext);

    String keyPairName = keystoneCredential.getKeyPairName();
    if (client.compute().keypairs().get(keyPairName) == null) {
        try {
            Keypair keyPair = client.compute().keypairs().create(keyPairName, stack.getInstanceAuthentication().getPublicKey());
            LOGGER.info("Keypair has been created: {}", keyPair);
        } catch (Exception e) {
            LOGGER.error("Failed to create keypair", e);
            throw new CloudConnectorException(e.getMessage(), e);
        }
    } else {
        LOGGER.info("Keypair already exists: {}", keyPairName);
    }
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
@Override
public CloudSshKeys sshKeys(CloudCredential cloudCredential, Region region, Map<String, String> filters) {
    OSClient osClient = openStackClient.createOSClient(cloudCredential);
    KeystoneCredentialView osCredential = openStackClient.createKeystoneCredential(cloudCredential);

    Set<CloudSshKey> cloudSshKeys = new HashSet<>();
    for (Keypair keypair : osClient.compute().keypairs().list()) {
        Map<String, Object> properties = new HashMap<>();
        properties.put("fingerprint", keypair.getFingerprint());
        properties.put("id", keypair.getId());
        properties.put("publicKey", keypair.getPublicKey());
        properties.put("createdAt", keypair.getCreatedAt());

        CloudSshKey cloudSshKey = new CloudSshKey();
        cloudSshKey.setName(keypair.getName());
        cloudSshKey.setProperties(properties);
        cloudSshKeys.add(cloudSshKey);
    }

    Map<String, Set<CloudSshKey>> result = new HashMap<>();
    result.put(region.value() == null ? osCredential.getTenantName() : region.value(), cloudSshKeys);
    LOGGER.info("openstack cloud ssh keys result: {}", result);
    return new CloudSshKeys(result);
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
public List<SelectItem> getListOfKeypairs() {
    // Get all Keypairs the current account making the request has access to
    List<? extends Keypair> keypairs = osClient.compute().keypairs().list();

    List<SelectItem> keypairList = new ArrayList<SelectItem>();
    for (Keypair keypair : keypairs) {
        keypairList.add(new SelectItem(keypair.getName(), keypair.getName()));
    }
    return keypairList;
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
public static String CreateKeypair(OSClient os, String keypair)
		throws InterruptedException {
	Keypair kp = os.compute().keypairs().create(keypair, null);
	String name = kp.getName();
	System.out.println("name: " + name);
	return name;
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
@Nullable
@Override
public KeyPair get(String id) {
  checkNotNull(id);
  checkArgument(!id.isEmpty());
  final IdScopedByLocation scopedId = IdScopeByLocations.from(id);
  final Keypair retrieved =
      osClient.useRegion(getRegion(scopedId.getLocationId()).id()).compute().keypairs()
          .get(scopedId.getId());
  return KeyPairBuilder.newBuilder().location(getRegion(scopedId.getLocationId()))
      .id(scopedId.getIdWithLocation()).providerId(retrieved.getName())
      .name(retrieved.getName()).build();
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
public ServerInRegion(Server createdServer, Server retrievedServer, Location region, @Nullable Keypair keypair) {
  checkNotNull(retrievedServer);
  checkNotNull(createdServer, "createdServer is null.");
  checkNotNull(region, "region is null.");
  this.createdServer = createdServer;
  this.retrievedServer = retrievedServer;
  this.region = region;
  regionScopedId =
      IdScopeByLocations.from(region.id(), createdServer.getId()).getIdWithLocation();
  this.keypair = keypair;
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    HttpLoggingFilter.toggleLogging(false);
    CloudApiSettings driverConfig = DriverConfigLoader.loadDefault();

    OSClient client = new OSClientFactory(driverConfig).authenticatedClient();
    KeypairService keyApi = client.compute().keypairs();

    String publicKeyContent = new String(Files.toByteArray(publicKeyFile));
    Keypair createdKeypair = keyApi.create(keyPairName, publicKeyContent);
    LOG.info("created keypair: {}", createdKeypair);
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
private static void listKeys(KeypairService keyApi) {
    List<? extends Keypair> keypairs = keyApi.list();
    LOG.info("found {} keypair(s)", keypairs.size());
    for (Keypair keypair : keypairs) {
        LOG.info("keypair: " + keypair);
    }
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
@Test
public void testNovaKeypair() throws Exception {
    when(osTestKeypair.getName()).thenReturn(KEYPAIR_NAME);
    when(osTestKeypair.getPublicKey()).thenReturn(dummyKeypair.getPublicKey());
    when(osTestKeypair.getFingerprint()).thenReturn("fp");
    when(osTestKeypair.getPrivateKey()).thenReturn("prk");

    CamelContext camelContext = Mockito.mock(CamelContext.class);
    when(camelContext.getHeadersMapFactory()).thenReturn(new DefaultHeadersMapFactory());

    Message msg = new DefaultMessage(camelContext);
    msg.setHeader(OpenstackConstants.OPERATION, OpenstackConstants.CREATE);
    msg.setHeader(OpenstackConstants.NAME, KEYPAIR_NAME);

    Exchange exchange = Mockito.mock(Exchange.class);
    when(exchange.getIn()).thenReturn(msg);

    NovaEndpoint endpoint = Mockito.mock(NovaEndpoint.class);
    Producer producer = new KeypairProducer(endpoint, client);
    producer.process(exchange);

    ArgumentCaptor<String> nameCaptor = ArgumentCaptor.forClass(String.class);
    ArgumentCaptor<String> keypairCaptor = ArgumentCaptor.forClass(String.class);
    verify(keypairService).create(nameCaptor.capture(), keypairCaptor.capture());

    assertEquals(KEYPAIR_NAME, nameCaptor.getValue());
    assertNull(keypairCaptor.getValue());

    Keypair result = msg.getBody(Keypair.class);
    assertEquals("fp", result.getFingerprint());
    assertEquals("prk", result.getPrivateKey());
    assertEquals(dummyKeypair.getName(), result.getName());
    assertEquals(dummyKeypair.getPublicKey(), result.getPublicKey());
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的package包/类
public List<? extends Keypair> keyPairs() {
	return client().compute().keypairs().list();
}
 

import org.openstack4j.model.compute.Keypair; //导入依赖的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.Keypair; //导入依赖的package包/类
public Optional<Keypair> keypair() {
  return Optional.ofNullable(keypair);
}