use of com.google.api.services.compute.model.Operation in project cloudbreak by hortonworks.
the class GcpDeleteVpcTest method deleteNetwork.
@AfterSuite
@Parameters("vpcName")
public void deleteNetwork(@Optional("it-vpc") String vpcName) throws Exception {
springTestContextPrepareTestInstance();
String serviceAccountPrivateKey = ResourceUtil.readBase64EncodedContentFromResource(applicationContext, defaultP12File);
HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
PrivateKey privateKey = SecurityUtils.loadPrivateKeyFromKeyStore(SecurityUtils.getPkcs12KeyStore(), new ByteArrayInputStream(Base64.decodeBase64(serviceAccountPrivateKey)), "notasecret", "privatekey", "notasecret");
JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();
GoogleCredential googleCredential = new GoogleCredential.Builder().setTransport(httpTransport).setJsonFactory(jsonFactory).setServiceAccountId(defaultServiceAccountId).setServiceAccountScopes(Collections.singletonList(ComputeScopes.COMPUTE)).setServiceAccountPrivateKey(privateKey).build();
Compute compute = new Builder(httpTransport, jsonFactory, null).setApplicationName(defaultName).setHttpRequestInitializer(googleCredential).build();
Delete delete = compute.networks().delete(defaultProjectId, vpcName);
Operation operation = delete.execute();
if (operation.getHttpErrorStatusCode() != null) {
throw new IllegalStateException("gcp operation failed: " + operation.getHttpErrorMessage());
}
}
use of com.google.api.services.compute.model.Operation in project platformlayer by platformlayer.
the class CloudInstanceMapper method doOperation.
@Handler
public void doOperation() throws OpsException, IOException {
Tags instanceTags = instance.getTags();
GoogleCloud cloud = findCloud();
if (cloud == null) {
throw new OpsException("Could not find cloud");
}
GoogleComputeClient computeClient = googleComputeClientFactory.getComputeClient(cloud);
getRecursionState().pushChildScope(cloud);
List<String> assignedInstanceIds = instanceTags.findAll(Tag.ASSIGNED);
if (assignedInstanceIds.isEmpty()) {
if (createInstance && !OpsContext.isDelete()) {
MachineCreationRequest request = buildMachineCreationRequest();
PlatformLayerKey instanceKey = instance.getKey();
request.tags.add(Tag.buildParentTag(instanceKey));
PublicKey servicePublicKey = service.getSshKey().getKeyPair().getPublic();
Instance created = computeClient.createInstance(cloud, request, servicePublicKey);
{
Tag instanceTag = Tag.build(Tag.ASSIGNED, created.getName());
platformLayer.addTag(instance.getKey(), instanceTag);
}
assignedInstanceIds.add(created.getName());
}
}
if (assignedInstanceIds.isEmpty() && !OpsContext.isDelete()) {
throw new OpsException("Instance not yet assigned");
}
GoogleComputeMachine machine = null;
OpsTarget target = null;
if (!assignedInstanceIds.isEmpty()) {
if (assignedInstanceIds.size() != 1) {
log.warn("Multiple instance ids found: " + assignedInstanceIds);
}
// We just take the first instance id
String assignedInstanceId = Iterables.getFirst(assignedInstanceIds, null);
Instance server = computeClient.findInstanceByName(assignedInstanceId);
if (server == null) {
if (OpsContext.isConfigure()) {
throw new OpsException("Unable to find assigned server: " + assignedInstanceId);
}
} else {
server = computeClient.ensureHasPublicIp(server);
machine = new GoogleComputeMachine(computeClient, cloud, server);
SshKey sshKey = service.getSshKey();
target = machine.getTarget(GoogleComputeClient.USER_NAME, sshKey.getKeyPair());
// We need to use sudo while we set up root access
((SshOpsTarget) target).setEnsureRunningAsRoot(true);
}
}
if (!assignedInstanceIds.isEmpty() && OpsContext.isDelete()) {
for (String instanceId : assignedInstanceIds) {
Instance server = computeClient.findInstanceByName(instanceId);
if (server == null) {
log.warn("Could not find assigned server: " + instanceId + ", ignoring");
continue;
}
// TODO: Remove associated firewall rules
log.warn("Deleting firewall rules not yet implemented");
// SecurityGroup securityGroup = null;
// if (supportsSecurityGroups) {
// securityGroup = openstackHelpers.getMachineSecurityGroup(computeClient, server);
// }
Operation terminateOperation = computeClient.terminateInstance(instanceId);
try {
computeClient.waitComplete(terminateOperation, 5, TimeUnit.MINUTES);
} catch (TimeoutException e) {
throw new OpsException("Timeout while waiting for instance termination", e);
}
// if (securityGroup != null) {
// // We need to terminate the instance before we delete the security group it uses
// if (terminateOperation != null) {
// waitOperation(terminateOperation);
// }
//
// try {
// log.info("Deleting security group: " + securityGroup.getId());
// computeClient.root().securityGroups().securityGroup(securityGroup.getId()).delete();
// } catch (OpenstackNotFoundException e) {
// log.info("Ignoring not-found error while deleting security group: " + securityGroup.getId());
// }
// }
}
if (machine != null) {
machine.refreshState();
}
}
RecursionState recursion = getRecursionState();
if (OpsContext.isDelete() && machine == null) {
recursion.setPreventRecursion(true);
} else {
recursion.pushChildScope(machine);
recursion.pushChildScope(target);
}
}
use of com.google.api.services.compute.model.Operation in project platformlayer by platformlayer.
the class GoogleComputeClient method terminateInstance.
public Operation terminateInstance(String instanceId) throws OpsException {
try {
log.debug("Terminating instance: " + instanceId);
Operation operation = compute.instances().delete(projectId, instanceId).execute();
return operation;
} catch (IOException e) {
throw new OpsException("Error deleting instance", e);
}
}
use of com.google.api.services.compute.model.Operation in project platformlayer by platformlayer.
the class GoogleComputeClient method createInstance.
public Instance createInstance(GoogleCloud cloud, MachineCreationRequest request, PublicKey sshPublicKey) throws OpsException {
try {
Image foundImage = null;
{
DiskImageRecipe recipe = null;
if (request.recipeId != null) {
recipe = platformLayerClient.getItem(request.recipeId, DiskImageRecipe.class);
}
OperatingSystemRecipe operatingSystem = null;
if (recipe != null) {
operatingSystem = recipe.getOperatingSystem();
}
log.info("Listing images to pick best image");
Iterable<Image> images = listImages(PROJECTID_GOOGLE);
// TODO: We need a better solution here!!
log.warn("Hard coding image names");
Set<String> imageNames = Sets.newHashSet("ubuntu-12-04-v20120621");
for (Image image : images) {
if (imageNames.contains(image.getName())) {
foundImage = image;
break;
}
}
if (foundImage == null) {
throw new IllegalArgumentException("Could not find image");
}
}
// GCE requires that the name comply with RFC1035, which I think means a valid DNS
// For now, just use a UUID, with a pl- prefix so it doesn't start with a number
// TODO: Fix this!
String instanceName = "pl-" + UUID.randomUUID().toString();
Operation createServerOperation;
{
Instance create = new Instance();
create.setName(instanceName);
create.setZone(buildZoneUrl(projectId, ZONE_US_CENTRAL1_A));
{
NetworkInterface networkInterface = new NetworkInterface();
networkInterface.setNetwork(buildNetworkUrl(projectId, "default"));
AccessConfig networkAccessConfig = new AccessConfig();
networkAccessConfig.setType("ONE_TO_ONE_NAT");
networkInterface.setAccessConfigs(Lists.newArrayList(networkAccessConfig));
create.setNetworkInterfaces(Lists.newArrayList(networkInterface));
}
Metadata metadata = new Metadata();
metadata.setItems(Lists.<Items>newArrayList());
create.setMetadata(metadata);
if (request.tags != null) {
for (Tag tag : request.tags) {
Metadata.Items meta = new Metadata.Items();
meta.setKey(tag.getKey());
meta.setValue(tag.getValue());
metadata.getItems().add(meta);
}
}
if (request.sshPublicKey != null) {
Metadata.Items meta = new Metadata.Items();
meta.setKey("sshKeys");
meta.setValue(USER_NAME + ":" + OpenSshUtils.serialize(sshPublicKey));
metadata.getItems().add(meta);
}
create.setImage(foundImage.getSelfLink());
MachineType flavor = getClosestInstanceType(request);
if (flavor == null) {
throw new OpsException("Cannot determine machine type for request");
}
create.setMachineType(flavor.getSelfLink());
if (request.securityGroups != null) {
// TODO: Reimplement if needed
throw new UnsupportedOperationException();
}
// if (createdSecurityGroup != null) {
// ServerForCreate.SecurityGroup serverSecurityGroup = new ServerForCreate.SecurityGroup();
// serverSecurityGroup.setName(createdSecurityGroup.getName());
// create.getSecurityGroups().add(serverSecurityGroup);
// }
// create.setConfigDrive(cloudBehaviours.useConfigDrive());
log.info("Launching new server: " + instanceName);
try {
createServerOperation = compute.instances().insert(projectId, create).execute();
} catch (IOException e) {
throw new OpsException("Error launching new instance", e);
}
}
log.info("Waiting for server to be ready");
createServerOperation = waitComplete(createServerOperation, 10, TimeUnit.MINUTES);
Instance created;
InstanceState state = null;
while (true) {
created = findInstanceByName(instanceName);
state = InstanceState.get(created);
log.info("Instance state: " + state);
if (state.isRunning()) {
break;
}
Thread.sleep(1000);
}
return created;
} catch (InterruptedException e) {
ExceptionUtils.handleInterrupted(e);
throw new OpsException("Error building server", e);
} catch (TimeoutException e) {
throw new OpsException("Timeout waiting for server build", e);
}
}
use of com.google.api.services.compute.model.Operation in project platformlayer by platformlayer.
the class GoogleComputeClient method createFirewallRule.
public void createFirewallRule(Firewall rule) throws OpsException {
try {
log.debug("Inserting firewall rule: " + rule);
Operation operation = compute.firewalls().insert(projectId, rule).execute();
waitComplete(operation, 5, TimeUnit.MINUTES);
// TODO: Check success of operation?
} catch (IOException e) {
throw new OpsException("Error creating firewall", e);
} catch (TimeoutException e) {
throw new OpsException("Timeout while waiting for firewall creation", e);
}
}
Aggregations