Synnefo » Pithos Android Client

/**

 * 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 net.elasticgrid.rackspace.cloudservers;

import net.elasticgrid.rackspace.cloudservers.Server.Status;

import net.elasticgrid.rackspace.cloudservers.internal.ConfirmResize;

import net.elasticgrid.rackspace.cloudservers.internal.Flavors;

import net.elasticgrid.rackspace.cloudservers.internal.Images;

import net.elasticgrid.rackspace.cloudservers.internal.Metadata;

import net.elasticgrid.rackspace.cloudservers.internal.MetadataItem;

import net.elasticgrid.rackspace.cloudservers.internal.Private;

import net.elasticgrid.rackspace.cloudservers.internal.Public;

import net.elasticgrid.rackspace.cloudservers.internal.Reboot;

import net.elasticgrid.rackspace.cloudservers.internal.Rebuild;

import net.elasticgrid.rackspace.cloudservers.internal.Resize;

import net.elasticgrid.rackspace.cloudservers.internal.RevertResize;

import net.elasticgrid.rackspace.cloudservers.internal.ServerID;

import net.elasticgrid.rackspace.cloudservers.internal.Servers;

import net.elasticgrid.rackspace.cloudservers.internal.SharedIpGroup;

import net.elasticgrid.rackspace.cloudservers.internal.SharedIpGroups;

import net.elasticgrid.rackspace.cloudservers.internal.ShareIp;

import net.elasticgrid.rackspace.common.RackspaceConnection;

import net.elasticgrid.rackspace.common.RackspaceException;

import org.apache.http.HttpException;

import org.apache.http.client.methods.HttpDelete;

import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.client.methods.HttpPut;

import org.apache.http.client.methods.HttpRequestBase;

import org.apache.http.entity.ContentProducer;

import org.apache.http.entity.EntityTemplate;

import org.jibx.runtime.BindingDirectory;

import org.jibx.runtime.IBindingFactory;

import org.jibx.runtime.IMarshallingContext;

import org.jibx.runtime.JiBXException;

import java.io.IOException;

import java.io.OutputStream;

import java.net.InetAddress;

import java.net.MalformedURLException;

import java.net.UnknownHostException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Collections;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

 * Implementation based on the XML documents.

 *

 * @author Jerome Bernard

 */

public class XMLCloudServers extends RackspaceConnection implements CloudServers {

    private static final Logger logger = Logger.getLogger(XMLCloudServers.class.getName());

    /**

     * Initializes the Rackspace Cloud Servers connection with the Rackspace login information.

     *

     * @param username the Rackspace username

     * @param apiKey   the Rackspace API key

     * @throws RackspaceException if the credentials are invalid

     * @throws IOException        if there is a network issue

     * @see #authenticate()

     */

    public XMLCloudServers(String username, String apiKey) throws RackspaceException, IOException {

        super(username, apiKey);

    }

    public List<Server> getServers() throws CloudServersException {

        logger.info("Retrieving servers information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers");

        return buildListOfServers(request);

    }

    public List<Server> getServersWithDetails() throws CloudServersException {

        logger.info("Retrieving detailed servers information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers/detail");

        return buildListOfServers(request);

    }

    private List<Server> buildListOfServers(HttpGet request) throws CloudServersException {

        Servers response = makeRequestInt(request, Servers.class);

        List<Server> servers = new ArrayList<Server>(response.getServers().size());

        for (net.elasticgrid.rackspace.cloudservers.internal.Server server : response.getServers())

            servers.add(buildServer(server));

        return servers;

    }

    public Server getServerDetails(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving detailed information for server {0}...", serverID);

        validateServerID(serverID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers/" + serverID);

        return buildServer(makeRequestInt(request, net.elasticgrid.rackspace.cloudservers.internal.Server.class));

    }

    private Server buildServer(net.elasticgrid.rackspace.cloudservers.internal.Server response) throws CloudServersException {

        try {

            return new Server(

                    response.getId(), response.getName(), response.getAdminPass(),

                    response.getImageId(), response.getFlavorId(),

                    response.getStatus() == null ? null : Status.valueOf(response.getStatus().name()),

                    metadataAsMap(response.getMetadata()),

                    new Addresses(response.getAddresses()),

                    new Personality(response.getPersonality())

            );

        } catch (UnknownHostException e) {

            throw new CloudServersException("Can't build server", e);

        }

    }

    private static Map<String, String> metadataAsMap(Metadata metadata) {

        if (metadata == null)

            return Collections.emptyMap();

        Map<String, String> meta = new HashMap<String, String>();

        for (MetadataItem item : metadata.getMetadatas()) {

            meta.put(item.getKey(), item.getString());

        }

        return meta;

    }

    public Addresses getServerAddresses(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving all IP addresses of server {0}...", serverID);

        validateServerID(serverID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers/" + serverID + "/ips");

        net.elasticgrid.rackspace.cloudservers.internal.Addresses response = makeRequestInt(request, net.elasticgrid.rackspace.cloudservers.internal.Addresses.class);

        try {

            return new Addresses(response);

        } catch (UnknownHostException e) {

            throw new CloudServersException("Can't validate server addresses", e);

        }

    }

    public List<InetAddress> getServerPublicAddresses(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving all public IP addresses of server {0}...", serverID);

        validateServerID(serverID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers/" + serverID + "/ips/public");

        Public response = makeRequestInt(request, Public.class);

        try {

            List<InetAddress> addresses = new ArrayList<InetAddress>(response.getAddressLists().size());

            for (net.elasticgrid.rackspace.cloudservers.internal.Address address : response.getAddressLists()) {

                addresses.add(InetAddress.getByName(address.getAddr()));

            }

            return addresses;

        } catch (UnknownHostException e) {

            throw new CloudServersException("Can't validate server addresses", e);

        }

    }

    public List<InetAddress> getServerPrivateAddresses(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving all private IP addresses of server {0}...", serverID);

        validateServerID(serverID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers/" + serverID + "/ips/private");

        Private response = makeRequestInt(request, Private.class);

        try {

            List<InetAddress> addresses = new ArrayList<InetAddress>(response.getAddressLists().size());

            for (net.elasticgrid.rackspace.cloudservers.internal.Address address : response.getAddressLists()) {

                addresses.add(InetAddress.getByName(address.getAddr()));

            }

            return addresses;

        } catch (UnknownHostException e) {

            throw new CloudServersException("Can't validate server addresses", e);

        }

    }

    public void shareAddress(int groupID, int serverID, InetAddress address) throws CloudServersException {

        shareAddress(groupID, serverID, address, false);

    }

    public void shareAddress(int groupID, int serverID, InetAddress address, boolean configureServer) throws CloudServersException {

        logger.log(Level.INFO, "Sharing IP in group {0} for address {1} with server {2}...", new Object[]{groupID, address, serverID});

        validateServerID(serverID);

        if (address == null)

            throw new IllegalArgumentException("Invalid IP address");

        ShareIp shareIp = new ShareIp();

        shareIp.setSharedIpGroupId(groupID);

        shareIp.setConfigureServer(configureServer);

        HttpPut request = new HttpPut(getServerManagementURL() + "/servers/" + serverID

                + "/ips/public/" + address.getHostAddress());

        makeRequestInt(request);

    }

    public void unshareAddress(int serverID, InetAddress address) throws CloudServersException {

        logger.log(Level.INFO, "Unsharing IP address {0} with server {1}...", new Object[]{address, serverID});

        validateServerID(serverID);

        if (address == null)

            throw new IllegalArgumentException("Invalid IP address");

        HttpDelete request = new HttpDelete(getServerManagementURL() + "/servers/" + serverID

                + "/ips/public/" + address.getHostAddress());

        makeRequestInt(request);

    }

    public Server createServer(String name, int imageID, int flavorID) throws CloudServersException {

        return createServer(name, imageID, flavorID, null);

    }

    public Server createServer(String name, int imageID, int flavorID, Map<String, String> metadata) throws CloudServersException {

        logger.log(Level.INFO, "Creating server {0} from image {1} running on flavor {2}...",

                new Object[]{name, imageID, flavorID});

        if (name == null)

            throw new IllegalArgumentException("Server name has to be specified!");

        if (imageID == 0)

            throw new IllegalArgumentException("Image ID has to be specified!");

        if (flavorID == 0)

            throw new IllegalArgumentException("Flavor ID has to be specified!");

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers");

        net.elasticgrid.rackspace.cloudservers.internal.Server server = new net.elasticgrid.rackspace.cloudservers.internal.Server();

        server.setName(name);

        server.setImageId(imageID);

        server.setFlavorId(flavorID);

        if (metadata != null && !metadata.isEmpty()) {

            Metadata rawMetadata = new Metadata();

            List<MetadataItem> metadataItems = rawMetadata.getMetadatas();

            for (Map.Entry<String, String> entry : metadata.entrySet()) {

                MetadataItem item = new MetadataItem();

                item.setKey(entry.getKey());

                item.setString(entry.getValue());

                metadataItems.add(item);

            }

            server.setMetadata(rawMetadata);

        }

        return buildServer(makeEntityRequestInt(request, server, net.elasticgrid.rackspace.cloudservers.internal.Server.class));

    }

    public void rebootServer(int serverID) throws CloudServersException {

        rebootServer(serverID, RebootType.SOFT);

    }

    public void rebootServer(int serverID, RebootType type) throws CloudServersException {

        logger.log(Level.INFO, "Rebooting server {0} via {1} reboot...", new Object[]{serverID, type.name()});

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/action");

        Reboot reboot = new Reboot();

        reboot.setType(net.elasticgrid.rackspace.cloudservers.internal.RebootType.valueOf(type.name()));

        makeEntityRequestInt(request, reboot);

    }

    public void rebuildServer(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Rebuilding server {0}...", serverID);

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/action");

        makeEntityRequestInt(request, new Rebuild());

    }

    public void rebuildServer(int serverID, int imageID) throws CloudServersException {

        logger.log(Level.INFO, "Rebuilding server {0} from image {1}...", new Object[]{serverID, imageID});

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/action");

        Rebuild rebuild = new Rebuild();

        rebuild.setImageId(imageID);

        makeEntityRequestInt(request, rebuild);

    }

    public void resizeServer(int serverID, int flavorID) throws CloudServersException {

        logger.log(Level.INFO, "Resizing server {0} to run on flavor {1}...", new Object[]{serverID, flavorID});

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/action");

        Resize resize = new Resize();

        resize.setFlavorId(flavorID);

        makeEntityRequestInt(request, resize);

    }

    public void confirmResize(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Confirming resize of server {0}...", serverID);

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/action");

        makeEntityRequestInt(request, new ConfirmResize());

    }

    public void revertResize(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Cancelling resize of server {0}...", serverID);

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/action");

        makeEntityRequestInt(request, new RevertResize());

    }

    public void updateServerName(int serverID, String name) throws CloudServersException {

        updateServerNameAndPassword(serverID, name, null);

    }

    public void updateServerPassword(int serverID, String password) throws CloudServersException {

        updateServerNameAndPassword(serverID, null, password);

    }

    public void updateServerNameAndPassword(final int serverID, final String name, final String password) throws CloudServersException {

        validateServerID(serverID);

        HttpPut request = new HttpPut(getServerManagementURL() + "/servers/" + serverID);

        net.elasticgrid.rackspace.cloudservers.internal.Server server = new net.elasticgrid.rackspace.cloudservers.internal.Server();

        server.setId(serverID);

        if (name != null)

            server.setName(name);

        if (password != null)

            server.setAdminPass(password);

        makeEntityRequestInt(request, server);

    }

    public void deleteServer(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Deleting server {0}...", serverID);

        validateServerID(serverID);

        HttpDelete request = new HttpDelete(getServerManagementURL() + "/servers/" + serverID);

        makeRequestInt(request);

    }

    public Limits getLimits() throws CloudServersException {

        HttpGet request = new HttpGet(getServerManagementURL() + "/limits");

        net.elasticgrid.rackspace.cloudservers.internal.Limits response = makeRequestInt(request, net.elasticgrid.rackspace.cloudservers.internal.Limits.class);

        List<RateLimit> rateLimits = new ArrayList<RateLimit>(response.getRate().getRateLimits().size());

        for (net.elasticgrid.rackspace.cloudservers.internal.RateLimit limit : response.getRate().getRateLimits())

            rateLimits.add(new RateLimit(

                    HTTPVerb.valueOf(limit.getVerb().name()),

                    limit.getURI(),

                    limit.getRegex(),

                    limit.getValue(),

                    limit.getRemaining(),

                    RateLimit.Unit.valueOf(limit.getUnit().name()),

                    limit.getResetTime()

            ));

        List<AbsoluteLimit> absoluteLimits = new ArrayList<AbsoluteLimit>(response.getAbsolute().getAbsoluteLimits().size());

        for (net.elasticgrid.rackspace.cloudservers.internal.AbsoluteLimit limit : response.getAbsolute().getAbsoluteLimits())

            absoluteLimits.add(new AbsoluteLimit(limit.getName(), limit.getValue()));

        return new Limits(rateLimits, absoluteLimits);

    }

    public List<Flavor> getFlavors() throws CloudServersException {

        logger.info("Retrieving flavors information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/flavors");

        return buildListOfFlavors(request);

    }

    public List<Flavor> getFlavorsWithDetails() throws CloudServersException {

        logger.info("Retrieving detailed flavors information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/flavors/detail");

        return buildListOfFlavors(request);

    }

    public Flavor getFlavorDetails(int flavorID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving detailed information for flavor {0}...", flavorID);

        validateFlavorID(flavorID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/flavors/" + flavorID);

        return buildFlavor(makeRequestInt(request, net.elasticgrid.rackspace.cloudservers.internal.Flavor.class));

    }

    private List<Flavor> buildListOfFlavors(HttpGet request) throws CloudServersException {

        Flavors response = makeRequestInt(request, Flavors.class);

        List<Flavor> flavors = new ArrayList<Flavor>(response.getFlavors().size());

        for (net.elasticgrid.rackspace.cloudservers.internal.Flavor flavor : response.getFlavors())

            flavors.add(buildFlavor(flavor));

        return flavors;

    }

    private Flavor buildFlavor(net.elasticgrid.rackspace.cloudservers.internal.Flavor response) {

        return new Flavor(response.getId(), response.getName(), response.getRam(), response.getDisk());

    }

    public List<Image> getImages() throws CloudServersException {

        logger.info("Retrieving images information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/images");

        return buildListOfImages(makeRequestInt(request, Images.class));

    }

    public List<Image> getImagesWithDetails() throws CloudServersException {

        logger.info("Retrieving detailed images information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/images/detail");

        return buildListOfImages(makeRequestInt(request, Images.class));

    }

    public Image getImageDetails(int imageID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving detailed information for image {0}...", imageID);

        validateImageID(imageID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/images/" + imageID);

        return buildImage(makeRequestInt(request, net.elasticgrid.rackspace.cloudservers.internal.Image.class));

    }

    public Image createImage(String name, int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Creating image named ''{0}'' from server {1}...", new Object[]{name, serverID});

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/images");

        net.elasticgrid.rackspace.cloudservers.internal.Image image = new net.elasticgrid.rackspace.cloudservers.internal.Image();

        image.setName(name);

        image.setServerId(serverID);

        return buildImage(makeEntityRequestInt(request, image, net.elasticgrid.rackspace.cloudservers.internal.Image.class));

    }

    private List<Image> buildListOfImages(Images response) {

        List<Image> images = new ArrayList<Image>(response.getImages().size());

        for (net.elasticgrid.rackspace.cloudservers.internal.Image image : response.getImages())

            images.add(buildImage(image));

        return images;

    }

    private Image buildImage(net.elasticgrid.rackspace.cloudservers.internal.Image created) {

        return new Image(

                created.getId(), created.getName(), created.getServerId(),

                created.getUpdated(), created.getCreated(), created.getProgress(),

                created.getStatus() == null ? null : Image.Status.valueOf(created.getStatus().name())

        );

    }

    public BackupSchedule getBackupSchedule(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving backup schedule for server {0}...", serverID);

        validateServerID(serverID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/servers/" + serverID + "/backup_schedule");

        net.elasticgrid.rackspace.cloudservers.internal.BackupSchedule response = makeRequestInt(request, net.elasticgrid.rackspace.cloudservers.internal.BackupSchedule.class);

        return new BackupSchedule(

                response.getEnabled(),

                BackupSchedule.WeeklyBackup.valueOf(response.getWeekly().name()),

                BackupSchedule.DailyBackup.valueOf(response.getDaily().name())

        );

    }

    public void scheduleBackup(int serverID, BackupSchedule schedule) throws CloudServersException {

        logger.log(Level.INFO, "Updating backup schedule for server {0} to {1}...",

                new Object[]{serverID, schedule});

        validateServerID(serverID);

        HttpPost request = new HttpPost(getServerManagementURL() + "/servers/" + serverID + "/backup_schedule");

        net.elasticgrid.rackspace.cloudservers.internal.BackupSchedule s = new net.elasticgrid.rackspace.cloudservers.internal.BackupSchedule();

        s.setEnabled(schedule.isEnabled());

        s.setWeekly(net.elasticgrid.rackspace.cloudservers.internal.WeeklyBackup.valueOf(schedule.getWeekly().name()));

        s.setDaily(net.elasticgrid.rackspace.cloudservers.internal.DailyBackup.valueOf(schedule.getDaily().name()));

        makeEntityRequestInt(request, s);

    }

    public void deleteBackupSchedule(int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Deleting backup schedule for server {0}...", serverID);

        validateServerID(serverID);

        HttpDelete request = new HttpDelete(getServerManagementURL() + "/servers/" + serverID + "/backup_schedule");

        makeRequestInt(request);

    }

    public List<SharedIPGroup> getSharedIPGroups() throws CloudServersException {

        logger.info("Retrieving shared IP groups information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/shared_ip_groups");

        return buildListOfSharedIPGroups(request);

    }

    public List<SharedIPGroup> getSharedIPGroupsWithDetails() throws CloudServersException {

        logger.info("Retrieving detailed shared IP groups information...");

        HttpGet request = new HttpGet(getServerManagementURL() + "/shared_ip_groups/detail");

        return buildListOfSharedIPGroups(request);

    }

    public SharedIPGroup getSharedIPGroup(int groupID) throws CloudServersException {

        logger.log(Level.INFO, "Retrieving detailed shared IP group information for {0}...", groupID);

        HttpGet request = new HttpGet(getServerManagementURL() + "/shared_ip_groups/" + groupID);

        return buildSharedIPGroup(makeRequestInt(request, SharedIpGroup.class));

    }

    public SharedIPGroup createSharedIPGroup(String name) throws CloudServersException {

        return createSharedIPGroup(name, 0);

    }

    public SharedIPGroup createSharedIPGroup(String name, int serverID) throws CloudServersException {

        logger.log(Level.INFO, "Creating shared IP group named {0} for server {1}...", new Object[]{name, serverID});

        HttpPost request = new HttpPost(getServerManagementURL() + "/shared_ip_groups");

        SharedIpGroup group = new SharedIpGroup();

        group.setName(name);

        if (serverID != 0) {

            ServerID server = new ServerID();

            server.setId(serverID);

            group.setServer(server);

        }

        return buildSharedIPGroup(makeEntityRequestInt(request, group, SharedIpGroup.class));

    }

    public void deleteSharedIPGroup(int groupID) throws CloudServersException {

        logger.log(Level.INFO, "Deleting shared IP group {0}...", groupID);

        validateSharedIPGroupID(groupID);

        HttpDelete request = new HttpDelete(getServerManagementURL() + "/shared_ip_groups/" + groupID);

        makeRequestInt(request);

    }

    private List<SharedIPGroup> buildListOfSharedIPGroups(HttpGet request) throws CloudServersException {

        SharedIpGroups response = makeRequestInt(request, SharedIpGroups.class);

        List<SharedIPGroup> groups = new ArrayList<SharedIPGroup>(response.getSharedIpGroups().size());

        for (SharedIpGroup group : response.getSharedIpGroups())

            groups.add(buildSharedIPGroup(group));

        return groups;

    }

    private SharedIPGroup buildSharedIPGroup(SharedIpGroup group) {

        List<Integer> serverIDs = new ArrayList<Integer>(group.getServers().getServerIDLists().size());

        for (ServerID id : group.getServers().getServerIDLists())

            serverIDs.add(id.getId());

        return new SharedIPGroup(group.getId(), group.getName(), serverIDs);

    }

    protected void makeEntityRequestInt(HttpEntityEnclosingRequestBase request, final Object entity) throws CloudServersException {

        makeEntityRequestInt(request, entity, Void.class);

    }

    protected <T> T makeEntityRequestInt(HttpEntityEnclosingRequestBase request, final Object entity, Class<T> respType) throws CloudServersException {

        request.setEntity(new EntityTemplate(new ContentProducer() {

            public void writeTo(OutputStream output) throws IOException {

                try {

                    IBindingFactory bindingFactory = BindingDirectory.getFactory(entity.getClass());

                    final IMarshallingContext marshallingCxt = bindingFactory.createMarshallingContext();

                    marshallingCxt.marshalDocument(entity, "UTF-8", true, output);

                } catch (JiBXException e) {

                    IOException ioe = new IOException("Can't marshal server details");

                    ioe.initCause(e);

                    e.printStackTrace();

                    throw ioe;

                }

            }

        }));

        return makeRequestInt(request, respType);

    }

    protected void makeRequestInt(HttpRequestBase request) throws CloudServersException {

        makeRequestInt(request, Void.class);

    }

    protected <T> T makeRequestInt(HttpRequestBase request, Class<T> respType) throws CloudServersException {

        try {

            return makeRequest(request, respType);

        } catch (RackspaceException e) {

            throw new CloudServersException(e);

        } catch (JiBXException e) {

            throw new CloudServersException("Problem parsing returned message.", e);

        } catch (MalformedURLException e) {

            throw new CloudServersException(e.getMessage(), e);

        } catch (IOException e) {

            throw new CloudServersException(e.getMessage(), e);

        } catch (HttpException e) {

            throw new CloudServersException(e.getMessage(), e);

        }

    }

    private void validateServerID(int serverID) throws IllegalArgumentException {

        if (serverID == 0)

            throw new IllegalArgumentException("Invalid serverID " + serverID);

    }

    private void validateFlavorID(int flavorID) throws IllegalArgumentException {

        if (flavorID == 0)

            throw new IllegalArgumentException("Invalid flavorID " + flavorID);

    }

    private void validateImageID(int imageID) throws IllegalArgumentException {

        if (imageID == 0)

            throw new IllegalArgumentException("Invalid imageID " + imageID);

    }

    private void validateSharedIPGroupID(int groupID) throws IllegalArgumentException {

        if (groupID == 0)

            throw new IllegalArgumentException("Invalid shared IP group ID " + groupID);

    }

}