Java Server类代码示例

import org.openstack4j.model.compute.Server; //导入依赖的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.Server; //导入依赖的package包/类
private static void waitUntilServerDeleted(OSClient os, String serverId) throws Exception{
    while(true){
        Server server=os.compute().servers().get(serverId);
        Server.Status status=Status.DELETED;
        if(server!=null)
            status=server.getStatus();
        System.out.println("current status: "+status.toString());
        if(status.equals(Status.DELETED)){
            break; 
        }else{
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
        }
    }
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
public static Set<String> getVolumesAttachedToServer(String serverId, OSClient os) throws Exception {
    ServerService serverService = os.compute().servers();
    serverId=CommonAPI.takeFromMemory(NovaKey.NOVA_SERVERID, serverId);
    Server server = serverService.get(serverId);
    List<String> volumeList = server.getOsExtendedVolumesAttached();
    Set<String> volSet = new TreeSet<String>();
    for (String volumeId : volumeList) {
        VolumeAttachment attachment = getAttachmentOnVolume(volumeId, os);
        if (!attachment.getDevice().contains("vda")) {
            printVolumeDetails(os.blockStorage().volumes().get(volumeId));
            volSet.add(volumeId);
        }
    }
    System.out.println("Total Attached Volumes: "+volSet.size());
    return volSet;
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Override
public void refreshAll(PluginRequest pluginRequest) throws Exception{
    if (!refreshed) {
        String agentID;
        PluginSettings pluginSettings = pluginRequest.getPluginSettings();
        Agents agents = pluginRequest.listAgents();
        Map<String, String> op_instance_prefix = new HashMap<String, String>();
        op_instance_prefix.put("name",pluginSettings.getOpenstackVmPrefix());
        List<Server> allInstances = (List<Server>) os_client(pluginSettings).compute().servers().list(op_instance_prefix);
        for (Server server : allInstances) {
            if (agents.containsAgentWithId(server.getId())) {
                register(new OpenStackInstance(server.getId(),
                        server.getCreated(),
                        server.getMetadata().get(Constants.GOSERVER_PROPERTIES_PREFIX + Constants.ENVIRONMENT_KEY),
                        os_client(pluginSettings)));
            }else{
                os_client(pluginSettings).compute().servers().delete(server.getId());
            }
        }
        refreshed = true;
    }
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
private OpenStackInstances unregisteredAfterTimeout(PluginSettings settings, Agents knownAgents) throws Exception {

        String agentID;
        Map<String, String> op_instance_prefix = new HashMap<String, String>();
        op_instance_prefix.put("name",settings.getOpenstackVmPrefix());

        Period period = settings.getAutoRegisterPeriod();
        OpenStackInstances unregisteredInstances = new OpenStackInstances();
        OpenstackClientWrapper client = new OpenstackClientWrapper(settings);
        List<Server> allInstances = (List<Server>) client.getClient().compute().servers().list(op_instance_prefix);

        for (Server server : allInstances) {
            if (knownAgents.containsAgentWithId(server.getId())) {
                continue;
            }
            if (DateUtils.addMinutes(server.getCreated(), period.getMinutes()).before(new Date())) {
                unregisteredInstances.register(new OpenStackInstance(server.getId(),
                        server.getCreated(),
                        server.getMetadata().get(Constants.GOSERVER_PROPERTIES_PREFIX + Constants.ENVIRONMENT_KEY),
                        client.getClient()));
            }
        }
        return unregisteredInstances;
    }
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Override
public List<Machine> startMachines(int count) throws StartMachinesException, CloudPoolDriverException {
    checkState(isConfigured(), "attempt to use unconfigured driver");

    List<Machine> startedMachines = new ArrayList<>();
    try {
        for (int i = 0; i < count; i++) {
            // tag new server with cloud pool membership
            Map<String, String> tags = ImmutableMap.of(Constants.CLOUD_POOL_TAG, getPoolName());
            Server newServer = this.client.launchServer(uniqueServerName(), provisioningTemplate(), tags);
            Machine machine = serverToMachine().apply(newServer);
            startedMachines.add(machine);

            if (provisioningTemplate().isAssignFloatingIp()) {
                String serverId = newServer.getId();
                String floatingIp = this.client.assignFloatingIp(serverId);
                machine.getPublicIps().add(floatingIp);
            }
        }
    } catch (Exception e) {
        throw new StartMachinesException(count, startedMachines, e);
    }
    return startedMachines;
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Override
public Void doRequest(OSClient api) throws NotFoundException, ResponseException {
    // look for victim server in all regions
    ServerService serverApi = api.compute().servers();
    Server victimServer = serverApi.get(this.victimId);
    if (victimServer == null) {
        throw new NotFoundException(format("delete failed: server with id '%s' could not be found in region %s",
                this.victimId, getApiAccessConfig().getRegion()));
    }

    releaseFloatingIps(api, victimServer);
    ActionResponse response = serverApi.delete(this.victimId);
    if (!response.isSuccess()) {
        throw new ResponseException(
                String.format("delete failed: server %s: %s", this.victimId, response.getFault()),
                response.getCode());
    }

    awaitTermination(victimServer.getId());
    return null;
}
 

import org.openstack4j.model.compute.Server; //导入依赖的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.Server; //导入依赖的package包/类
@Test
public void testWithStateIn() {
    Server server = server(Status.STOPPED);

    // empty set
    assertFalse(ServerPredicates.withStateIn().test(server));
    // non-empty set, missing a matching state
    assertFalse(ServerPredicates.withStateIn(Status.ACTIVE).test(server));
    assertFalse(ServerPredicates.withStateIn(Status.ACTIVE, Status.BUILD).test(server));
    // set contains matching state only
    assertTrue(ServerPredicates.withStateIn(Status.STOPPED).test(server));
    // set contains matching state and other states
    assertTrue(ServerPredicates.withStateIn(Status.ACTIVE, Status.STOPPED).test(server));

    // test with another server state
    server = server(Status.ACTIVE);
    assertFalse(ServerPredicates.withStateIn(Status.STOPPED, Status.BUILD).test(server));
    assertTrue(ServerPredicates.withStateIn(Status.ACTIVE, Status.STOPPED).test(server));
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Test
public void convertServerWithPublicAndPrivateIpAddresses() {
    DateTime now = UtcTime.now();

    NovaAddresses addresses = new NovaAddresses();
    addresses.add("Default network", novaAddress("10.11.12.2", "fixed"));
    addresses.add("Default network", novaAddress("130.239.48.193", "floating"));
    Server server = server(Status.ACTIVE, now, addresses, "1C-1G");

    Machine machine = new ServerToMachine("RackSpace", "LON").apply(server);
    assertThat(machine.getId(), is(server.getId()));
    assertThat(machine.getMachineState(), is(MachineState.RUNNING));
    assertThat(machine.getCloudProvider(), is("RackSpace"));
    assertThat(machine.getRegion(), is("LON"));
    assertThat(machine.getMachineSize(), is("1C-1G"));
    assertThat(machine.getMembershipStatus(), is(MembershipStatus.defaultStatus()));
    assertThat(machine.getServiceState(), is(ServiceState.UNKNOWN));
    assertThat(machine.getRequestTime().toDate(), is(server.getCreated()));
    assertThat(machine.getPublicIps(), is(asList("130.239.48.193")));
    assertThat(machine.getPrivateIps(), is(asList("10.11.12.2")));
    assertThat(machine.getMetadata(), is(JsonUtils.toJson(server)));
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Test
public void convertServerWithoutPublicIpAddress() {
    DateTime now = UtcTime.now();

    NovaAddresses addresses = new NovaAddresses();
    addresses.add("private", novaAddress("10.11.12.2", "fixed"));
    Server server = server(Status.ACTIVE, now, addresses, "1C-1G");

    Machine machine = new ServerToMachine("CityCloud", "Kna1").apply(server);
    assertThat(machine.getId(), is(server.getId()));
    assertThat(machine.getMachineState(), is(MachineState.RUNNING));
    assertThat(machine.getRegion(), is("Kna1"));
    assertThat(machine.getCloudProvider(), is("CityCloud"));
    assertThat(machine.getMachineSize(), is("1C-1G"));
    assertThat(machine.getMembershipStatus(), is(MembershipStatus.defaultStatus()));
    assertThat(machine.getServiceState(), is(ServiceState.UNKNOWN));
    assertThat(machine.getRequestTime().toDate(), is(server.getCreated()));
    List<String> empty = asList();
    assertThat(machine.getPublicIps(), is(empty));
    assertThat(machine.getPrivateIps(), is(asList("10.11.12.2")));
    assertThat(machine.getMetadata(), is(JsonUtils.toJson(server)));
}
 

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

		Server server = os.compute().servers().get(serverId);

		logger.info("Server retrieved successfully for ID: " + serverId);

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

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Override
public List<CloudResource> build(OpenStackContext context, long privateId, AuthenticatedContext auth, Group group, Image image,
        List<CloudResource> buildableResource, Map<String, String> tags) throws Exception {
    CloudResource resource = buildableResource.get(0);
    try {
        String publicNetId = context.getStringParameter(OpenStackConstants.PUBLIC_NET_ID);
        if (publicNetId != null) {
            OSClient osClient = createOSClient(auth);
            List<CloudResource> computeResources = context.getComputeResources(privateId);
            CloudResource instance = getInstance(computeResources);
            FloatingIP unusedIp = osClient.compute().floatingIps().allocateIP(publicNetId);
            ActionResponse response = osClient.compute().floatingIps().addFloatingIP(instance.getParameter(OpenStackConstants.SERVER, Server.class),
                    unusedIp.getFloatingIpAddress());
            if (!response.isSuccess()) {
                throw new OpenStackResourceException("Add floating-ip to server failed", resourceType(), resource.getName(),
                        auth.getCloudContext().getId(), response.getFault());
            }
            return Collections.singletonList(createPersistedResource(resource, group.getName(), unusedIp.getId()));
        }
        return Collections.emptyList();
    } catch (OS4JException ex) {
        throw new OpenStackResourceException("Add floating-ip to server failed", resourceType(), resource.getName(), ex);
    }
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
/**
 * @param em     Hibernate session object
 * @param region Region this entity belongs to
 * @param sg     Security Group in context
 * @param osPort Open stack port
 * @param vmPort VM port
 * @throws IOException
 */
public static void discoverVmForPort(EntityManager em, String region, SecurityGroup sg, Port osPort, VMPort vmPort)
        throws IOException, EncryptionException {

    try (Openstack4JNova nova = new Openstack4JNova(new Endpoint(sg.getVirtualizationConnector(), sg.getProjectName()))) {
        Server osVm = nova.getServer(region, osPort.getDeviceId());
        if (null == osVm) {
            OSCEntityManager.delete(em, vmPort, StaticRegistry.transactionalBroadcastUtil());
            //TODO sridhar handle stale VM delete ?
            return;

        }
        VM vm = VMEntityManager.findByOpenstackId(em, osPort.getDeviceId());
        if (vm == null) {
            vm = new VM(region, osPort.getDeviceId(), osVm.getName());
            OSCEntityManager.create(em, vm, StaticRegistry.transactionalBroadcastUtil());
        }
        vmPort.setVm(vm);
        // Update vm host if needed
        String hypervisorHostname = osVm.getHypervisorHostname();
        if (hypervisorHostname != null && !hypervisorHostname.equals(vm.getHost())) {
            vm.setHost(hypervisorHostname);
            OSCEntityManager.update(em, vm, StaticRegistry.transactionalBroadcastUtil());
        }
    }
    OSCEntityManager.update(em, vmPort, StaticRegistry.transactionalBroadcastUtil());
}
 

import org.openstack4j.model.compute.Server; //导入依赖的package包/类
@Override
public void executeTransaction(EntityManager em) throws Exception {
    this.dai = DistributedApplianceInstanceEntityMgr.findById(em, this.dai.getId());
    DeploymentSpec ds = this.dai.getDeploymentSpec();

    Endpoint endPoint = new Endpoint(ds);
    try (Openstack4JNova nova = new Openstack4JNova(endPoint)) {
        Server serverDAI = nova.getServer(ds.getRegion(), this.dai.getExternalId());
        // Check is SVA is Shut off
        if (serverDAI.getStatus().equals(Server.Status.SHUTOFF)) {
            boolean isStarted = nova.startServer(ds.getRegion(), this.dai.getExternalId());
            this.log.info("SVA found in SHUTOFF state we will try to start it ... Is SVA started successfully: " + isStarted);
        }
    }
}