Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.camel.component.digitalocean.producer.DigitalOceanDropletsProducer Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.camel.component.digitalocean.producer;
import java.util.ArrayList;
import java.util.List;
import com.myjeeva.digitalocean.common.ResourceType;
import com.myjeeva.digitalocean.exception.DigitalOceanException;
import com.myjeeva.digitalocean.exception.RequestUnsuccessfulException;
import com.myjeeva.digitalocean.pojo.Action;
import com.myjeeva.digitalocean.pojo.Actions;
import com.myjeeva.digitalocean.pojo.Backups;
import com.myjeeva.digitalocean.pojo.Delete;
import com.myjeeva.digitalocean.pojo.Droplet;
import com.myjeeva.digitalocean.pojo.Droplets;
import com.myjeeva.digitalocean.pojo.Image;
import com.myjeeva.digitalocean.pojo.Kernels;
import com.myjeeva.digitalocean.pojo.Key;
import com.myjeeva.digitalocean.pojo.Neighbors;
import com.myjeeva.digitalocean.pojo.Region;
import com.myjeeva.digitalocean.pojo.Resource;
import com.myjeeva.digitalocean.pojo.Response;
import com.myjeeva.digitalocean.pojo.Snapshots;
import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.component.digitalocean.DigitalOceanConfiguration;
import org.apache.camel.component.digitalocean.DigitalOceanEndpoint;
import org.apache.camel.component.digitalocean.constants.DigitalOceanHeaders;
import org.apache.camel.component.digitalocean.constants.DigitalOceanOperations;
import org.apache.camel.util.ObjectHelper;
/**
* The DigitalOcean producer for Droplets API.
*/
public class DigitalOceanDropletsProducer extends DigitalOceanProducer {
private Integer dropletId;
public DigitalOceanDropletsProducer(DigitalOceanEndpoint endpoint, DigitalOceanConfiguration configuration) {
super(endpoint, configuration);
}
@Override
public void process(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
DigitalOceanOperations op = determineOperation(exchange);
if (op != DigitalOceanOperations.create && op != DigitalOceanOperations.list
&& op != DigitalOceanOperations.listAllNeighbors) {
dropletId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, Integer.class);
if (ObjectHelper.isEmpty(dropletId)) {
throw new IllegalArgumentException(DigitalOceanHeaders.ID + " must be specified");
}
}
switch (op) {
case create:
createDroplet(exchange);
break;
case list:
getDroplets(exchange);
break;
case delete:
deleteDroplet(exchange);
break;
case get:
getDroplet(exchange);
break;
case listActions:
getDropletActions(exchange);
break;
case listSnapshots:
getDropletSnapshots(exchange);
break;
case listKernels:
getDropletKernels(exchange);
break;
case listBackups:
getDropletBackups(exchange);
break;
case listNeighbors:
getDropletNeighbors(exchange);
break;
case listAllNeighbors:
getAllDropletNeighbors(exchange);
break;
case enableBackups:
enableDropletBackups(exchange);
break;
case disableBackups:
disableDropletBackups(exchange);
break;
case reboot:
rebootDroplet(exchange);
break;
case powerCycle:
powerCycleDroplet(exchange);
break;
case shutdown:
shutdownDroplet(exchange);
break;
case powerOn:
powerOnDroplet(exchange);
break;
case powerOff:
powerOffDroplet(exchange);
break;
case restore:
restoreDroplet(exchange);
break;
case resetPassword:
resetDropletPassword(exchange);
break;
case resize:
resizeDroplet(exchange);
break;
case rebuild:
rebuildDroplet(exchange);
break;
case rename:
renameDroplet(exchange);
break;
case changeKernel:
changeDropletKernel(exchange);
break;
case enableIpv6:
enableDropletIpv6(exchange);
break;
case enablePrivateNetworking:
enableDropletPrivateNetworking(exchange);
break;
case takeSnapshot:
takeDropletSnapshot(exchange);
break;
case tag:
tagDroplet(exchange);
break;
case untag:
untagDroplet(exchange);
break;
default:
throw new IllegalArgumentException("Unsupported operation");
}
}
private void getDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Droplet droplet = getEndpoint().getDigitalOceanClient().getDropletInfo(dropletId);
LOG.trace("Droplet {}", droplet);
exchange.getMessage().setBody(droplet);
}
private void getDroplets(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Droplets droplets = getEndpoint().getDigitalOceanClient().getAvailableDroplets(configuration.getPage(),
configuration.getPerPage());
LOG.trace("All Droplets : page {} / {} per page [{}] ", configuration.getPage(), configuration.getPerPage(),
droplets.getDroplets());
exchange.getMessage().setBody(droplets.getDroplets());
}
private void getDropletActions(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Actions actions = getEndpoint().getDigitalOceanClient().getAvailableDropletActions(dropletId, configuration.getPage(),
configuration.getPerPage());
LOG.trace("Actions for Droplet {} : page {} / {} per page [{}] ", dropletId, configuration.getPage(),
configuration.getPerPage(), actions.getActions());
exchange.getMessage().setBody(actions.getActions());
}
private void getDropletKernels(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Kernels kernels = getEndpoint().getDigitalOceanClient().getDropletKernels(dropletId, configuration.getPage(),
configuration.getPerPage());
LOG.trace("Kernels for Droplet {} : page {} / {} per page [{}] ", dropletId, configuration.getPage(),
configuration.getPerPage(), kernels.getKernels());
exchange.getMessage().setBody(kernels.getKernels());
}
private void getDropletBackups(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Backups backups = getEndpoint().getDigitalOceanClient().getDropletBackups(dropletId, configuration.getPage(),
configuration.getPerPage());
LOG.trace("Backups for Droplet {} : page {} / {} per page [{}] ", dropletId, configuration.getPage(),
configuration.getPerPage(), backups.getBackups());
exchange.getMessage().setBody(backups.getBackups());
}
private void getDropletSnapshots(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Snapshots snapshots = getEndpoint().getDigitalOceanClient().getDropletSnapshots(dropletId, configuration.getPage(),
configuration.getPerPage());
LOG.trace("Snapshots for Droplet {} : page {} / {} per page [{}] ", dropletId, configuration.getPage(),
configuration.getPerPage(), snapshots.getSnapshots());
exchange.getMessage().setBody(snapshots.getSnapshots());
}
private void getDropletNeighbors(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Droplets droplets = getEndpoint().getDigitalOceanClient().getDropletNeighbors(dropletId, configuration.getPage());
LOG.trace("Neighbors for Droplet {} : page {} [{}] ", dropletId, configuration.getPage(), droplets.getDroplets());
exchange.getMessage().setBody(droplets.getDroplets());
}
private void getAllDropletNeighbors(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Neighbors neighbors = getEndpoint().getDigitalOceanClient().getAllDropletNeighbors(configuration.getPage());
LOG.trace("All Neighbors : page {} [{}] ", configuration.getPage(), neighbors.getNeighbors());
exchange.getMessage().setBody(neighbors.getNeighbors());
}
private void deleteDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Delete delete = getEndpoint().getDigitalOceanClient().deleteDroplet(dropletId);
LOG.trace("Delete Droplet {}", delete);
exchange.getMessage().setBody(delete);
}
@SuppressWarnings("unchecked")
private void createDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Message in = exchange.getIn();
Droplet droplet = new Droplet();
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.REGION))) {
droplet.setRegion(new Region(in.getHeader(DigitalOceanHeaders.REGION, String.class)));
} else {
throw new IllegalArgumentException(DigitalOceanHeaders.REGION + " must be specified");
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_SIZE))) {
droplet.setSize(in.getHeader(DigitalOceanHeaders.DROPLET_SIZE, String.class));
} else {
throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_SIZE + " must be specified");
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_IMAGE))) {
droplet.setImage(new Image(in.getHeader(DigitalOceanHeaders.DROPLET_IMAGE, String.class)));
} else {
throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_IMAGE + " must be specified");
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_KEYS))) {
List keys = (List) exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_KEYS);
droplet.setKeys(keys.stream().map(Key::new).toList());
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ENABLE_BACKUPS))) {
droplet.setEnableBackup(in.getHeader(DigitalOceanHeaders.DROPLET_ENABLE_BACKUPS, Boolean.class));
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ENABLE_IPV6))) {
droplet.setEnableIpv6(in.getHeader(DigitalOceanHeaders.DROPLET_ENABLE_IPV6, Boolean.class));
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ENABLE_PRIVATE_NETWORKING))) {
droplet.setEnablePrivateNetworking(
in.getHeader(DigitalOceanHeaders.DROPLET_ENABLE_PRIVATE_NETWORKING, Boolean.class));
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_USER_DATA))) {
droplet.setUserData(in.getHeader(DigitalOceanHeaders.DROPLET_USER_DATA, String.class));
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_VOLUMES))) {
droplet.setVolumeIds((List) exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_VOLUMES));
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_TAGS))) {
droplet.setTags((List) exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_TAGS));
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAMES))) {
droplet.setNames((List) in.getHeader(DigitalOceanHeaders.NAMES));
Droplets droplets = getEndpoint().getDigitalOceanClient().createDroplets(droplet);
LOG.trace("Droplets created {}", droplets);
exchange.getMessage().setBody(droplets.getDroplets());
} else if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
droplet.setName(in.getHeader(DigitalOceanHeaders.NAME, String.class));
droplet = getEndpoint().getDigitalOceanClient().createDroplet(droplet);
LOG.trace("Droplet created {}", droplet);
exchange.getMessage().setBody(droplet);
} else {
throw new IllegalArgumentException(
DigitalOceanHeaders.NAMES + " or " + DigitalOceanHeaders.NAME + " must be specified");
}
}
private void restoreDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.IMAGE_ID))) {
throw new IllegalArgumentException(DigitalOceanHeaders.IMAGE_ID + " must be specified");
}
Action action = getEndpoint().getDigitalOceanClient().restoreDroplet(dropletId,
exchange.getIn().getHeader(DigitalOceanHeaders.IMAGE_ID, Integer.class));
LOG.trace("DropletAction Restore [{}] ", action);
exchange.getMessage().setBody(action);
}
private void resizeDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_SIZE))) {
throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_SIZE + " must be specified");
}
Action action = getEndpoint().getDigitalOceanClient().resizeDroplet(dropletId,
exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_SIZE, String.class));
LOG.trace("DropletAction Resize [{}] ", action);
exchange.getMessage().setBody(action);
}
private void rebuildDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.IMAGE_ID))) {
throw new IllegalArgumentException(DigitalOceanHeaders.IMAGE_ID + " must be specified");
}
Action action = getEndpoint().getDigitalOceanClient().rebuildDroplet(dropletId,
exchange.getIn().getHeader(DigitalOceanHeaders.IMAGE_ID, Integer.class));
LOG.trace("Rebuild Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void renameDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
throw new IllegalArgumentException(DigitalOceanHeaders.NAME + " must be specified");
}
Action action = getEndpoint().getDigitalOceanClient().renameDroplet(dropletId,
exchange.getIn().getHeader(DigitalOceanHeaders.NAME, String.class));
LOG.trace("Rename Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void changeDropletKernel(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.KERNEL_ID))) {
throw new IllegalArgumentException(DigitalOceanHeaders.KERNEL_ID + " must be specified");
}
Action action = getEndpoint().getDigitalOceanClient().changeDropletKernel(dropletId,
exchange.getIn().getHeader(DigitalOceanHeaders.KERNEL_ID, Integer.class));
LOG.trace("Change Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void resetDropletPassword(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().resetDropletPassword(dropletId);
LOG.trace("Reset password Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void powerOnDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().powerOnDroplet(dropletId);
LOG.trace("Power on Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void powerOffDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().powerOffDroplet(dropletId);
LOG.trace("Power off Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void shutdownDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().shutdownDroplet(dropletId);
LOG.trace("Shutdown Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void powerCycleDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().powerCycleDroplet(dropletId);
LOG.trace("Power cycle Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void enableDropletBackups(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().enableDropletBackups(dropletId);
LOG.trace("Enable backups Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void disableDropletBackups(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().disableDropletBackups(dropletId);
LOG.trace("Disable backups for Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void enableDropletIpv6(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().enableDropletIpv6(dropletId);
LOG.trace("Enable IP v6 for Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void enableDropletPrivateNetworking(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().enableDropletPrivateNetworking(dropletId);
LOG.trace("Enable private networking for Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void rebootDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action = getEndpoint().getDigitalOceanClient().rebootDroplet(dropletId);
LOG.trace("Reboot Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void takeDropletSnapshot(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
Action action;
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
action = getEndpoint().getDigitalOceanClient().takeDropletSnapshot(dropletId,
exchange.getIn().getHeader(DigitalOceanHeaders.NAME, String.class));
} else {
action = getEndpoint().getDigitalOceanClient().takeDropletSnapshot(dropletId);
}
LOG.trace("Take Snapshot for Droplet {} : [{}] ", dropletId, action);
exchange.getMessage().setBody(action);
}
private void tagDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
throw new IllegalArgumentException(DigitalOceanHeaders.NAME + " must be specified");
}
ArrayList resources = new ArrayList<>(1);
resources.add(new Resource(dropletId.toString(), ResourceType.DROPLET));
Response response = getEndpoint().getDigitalOceanClient().tagResources(dropletId.toString(), resources);
LOG.trace("Tag Droplet {} : [{}] ", dropletId, response);
exchange.getMessage().setBody(response);
}
private void untagDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
throw new IllegalArgumentException(DigitalOceanHeaders.NAME + " must be specified");
}
ArrayList resources = new ArrayList<>(1);
resources.add(new Resource(dropletId.toString(), ResourceType.DROPLET));
Response response = getEndpoint().getDigitalOceanClient().untagResources(dropletId.toString(), resources);
LOG.trace("Untag Droplet {} : [{}] ", dropletId, response);
exchange.getMessage().setBody(response);
}
}
