elastic-grid

/**

 * Elastic Grid

 * Copyright (C) 2008-2010 Elastic Grid, LLC.

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero General Public License as

 * published by the Free Software Foundation, either version 3 of the

 * License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

package com.elasticgrid.storage.rackspace;

import com.elasticgrid.storage.Container;

import com.elasticgrid.storage.Storable;

import com.elasticgrid.storage.StorableNotFoundException;

import com.elasticgrid.storage.StorageException;

import com.mosso.client.cloudfiles.FilesClient;

import com.mosso.client.cloudfiles.FilesContainer;

import com.mosso.client.cloudfiles.FilesObject;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import javax.activation.MimetypesFileTypeMap;

import java.io.File;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.lang.reflect.Field;

/**

 * {@link Container} providing support for Rackspace Cloud Files.

 *

 * @author Jerome Bernard

 */

public class CloudFilesContainer implements Container {

    private final FilesClient rackspace;

    private final FilesContainer rackspaceContainer;

    private final MimetypesFileTypeMap mimes;

    private Field mimeTypeField;

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

    public CloudFilesContainer(final FilesClient rackspace, final FilesContainer rackspaceContainer) throws NoSuchFieldException {

        this.rackspace = rackspace;

        this.rackspaceContainer = rackspaceContainer;

        this.mimes = new MimetypesFileTypeMap();

        mimeTypeField = FilesObject.class.getDeclaredField("mimeType");

        mimeTypeField.setAccessible(true);

    }

    public String getName() {

        return rackspaceContainer.getName();

    }

    public List<Storable> listStorables() throws StorageException {

        try {

            rackspace.login();

            List<FilesObject> objects = rackspace.listObjects(getName());

            List<Storable> storables = new ArrayList<Storable>(objects.size());

            for (FilesObject object : objects) {

                // small hack in order to fetch the mime type of the underlying object

                String mimeType = (String) mimeTypeField.get(object);

                if (!"application/directory".equals(mimeType))      // skip directories

                    storables.add(new CloudFilesStorable(rackspace, object));

            }

            return storables;

        } catch (Exception e) {

            throw new StorageException("Can't list storables", e);

        }

    }

    public Storable findStorableByName(String name) throws StorableNotFoundException, StorageException {

        try {

            rackspace.login();

            int hasPath = name.lastIndexOf('/');

            List<FilesObject> objects = null;

            if (hasPath == -1) {

                objects = rackspace.listObjects(getName());

            } else {

                String path = name.substring(0, hasPath);

                objects = rackspace.listObjects(getName(), path);

            }

            if (objects.isEmpty())

                throw new StorableNotFoundException(name);

            FilesObject found = null;

            for (FilesObject object : objects) {

                if (object.getName().equals(name)) {

                    found = object;

                    break;

                }

            }

            if (found == null)

                throw new StorableNotFoundException(name);

            else

                return new CloudFilesStorable(rackspace, found);

        } catch (StorableNotFoundException snfe) {

            throw snfe;

        } catch (Exception e) {

            throw new StorageException("Can't find storage", e);

        }

    }

    public Storable uploadStorable(File file) throws StorageException {

        return uploadStorable(file.getName(), file);

    }

    public Storable uploadStorable(String name, File file) throws StorageException {

        try {

            rackspace.login();

            // create directories if needed

            String path = name.substring(0, name.lastIndexOf('/'));

            logger.log(Level.FINE, "Creating full path \"{0}\"", path);

            rackspace.createFullPath(getName(), path);

            // upload the file

            logger.log(Level.FINE, "Uploading \"{0}\"", name);

            InputStream stream = null;

            try {

                stream = FileUtils.openInputStream(file);

                rackspace.storeStreamedObject(getName(), stream, mimes.getContentType(file), name,

                        Collections.<String, String>emptyMap());

            } finally {

                IOUtils.closeQuietly(stream);

            }

            // retrieve rackspace object

            return findStorableByName(name);

        } catch (Exception e) {

            throw new StorageException("Can't upload storable from file", e);

        }

    }

    public Storable uploadStorable(String name, InputStream stream, String mimeType) throws StorageException {

        try {

            rackspace.login();

            // create directories if needed

            String path = name.substring(0, name.lastIndexOf('/'));

            logger.log(Level.FINE, "Creating full path \"{0}\"", path);

            rackspace.createFullPath(getName(), path);

            // upload the file

            logger.log(Level.FINE, "Uploading \"{0}\"", name);

            try {

                rackspace.storeStreamedObject(getName(), stream, mimeType, name,

                        Collections.<String, String>emptyMap());

            } finally {

                IOUtils.closeQuietly(stream);

            }

            // retrieve rackspace object

            return findStorableByName(name);

        } catch (Exception e) {

            throw new StorageException("Can't upload storable from stream", e);

        }

    }

    public void deleteStorable(String name) throws StorageException {

        try {

            rackspace.deleteObject(getName(), name);

        } catch (Exception e) {

            throw new StorageException("Can't delete storable", e);

        }

    }

}