swift: Gluster object storage plugin for Openstack Swift.

Change-Id: I5e07339064b1f3bb2aa5b04740ed870e114db4f9
BUG: 811430
Signed-off-by: Mohammed Junaid <junaid@redhat.com>
Reviewed-on: http://review.gluster.com/3118
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Vijay Bellur <vijay@gluster.com>

19 files changed, 1797 insertions, 0 deletions

diff --git a/swift/1.4.8/plugins/DiskDir.py b/swift/1.4.8/plugins/DiskDir.py
new file mode 100644
index 00000000000..4b813167196
--- /dev/null
+++ b/swift/1.4.8/plugins/DiskDir.py
@@ -0,0 +1,484 @@
+# Copyright (c) 2011 Red Hat, Inc.
+#
+# Licensed 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.
+
+import os
+
+from swift.plugins.utils import clean_metadata, dir_empty, rmdirs, mkdirs, \
+     validate_account, validate_container, check_valid_account, is_marker, \
+     get_container_details, get_account_details, create_container_metadata, \
+     create_account_metadata, DEFAULT_GID, DEFAULT_UID, get_account_details, \
+     validate_object, create_object_metadata, read_metadata, write_metadata
+
+from swift.common.constraints import CONTAINER_LISTING_LIMIT, \
+    check_mount
+
+from swift.plugins.utils import X_CONTENT_TYPE, X_CONTENT_LENGTH, X_TIMESTAMP,\
+     X_PUT_TIMESTAMP, X_TYPE, X_ETAG, X_OBJECTS_COUNT, X_BYTES_USED, \
+     X_CONTAINER_COUNT, CONTAINER
+
+from swift import plugins
+def strip_obj_storage_path(path, string='/mnt/gluster-object'):
+    """
+    strip /mnt/gluster-object
+    """
+    return path.replace(string, '').strip('/')
+
+DATADIR = 'containers'
+
+
+class DiskCommon(object):
+    def is_deleted(self):
+        return not os.path.exists(self.datadir)
+
+    def filter_prefix(self, objects, prefix):
+        """
+        Accept sorted list.
+        """
+        found = 0
+        filtered_objs = []
+        for object_name in objects:
+            if object_name.startswith(prefix):
+                filtered_objs.append(object_name)
+                found = 1
+            else:
+                if found:
+                    break
+        return filtered_objs
+
+    def filter_delimiter(self, objects, delimiter, prefix):
+        """
+        Accept sorted list.
+        Objects should start with prefix.
+        """
+        filtered_objs=[]
+        for object_name in objects:
+            tmp_obj = object_name.replace(prefix, '', 1)
+            sufix = tmp_obj.split(delimiter, 1)
+            new_obj = prefix + sufix[0]
+            if new_obj and new_obj not in filtered_objs:
+                filtered_objs.append(new_obj)
+
+        return filtered_objs
+
+    def filter_marker(self, objects, marker):
+        """
+        TODO: We can traverse in reverse order to optimize.
+        Accept sorted list.
+        """
+        filtered_objs=[]
+        found = 0
+        if objects[-1] < marker:
+            return filtered_objs
+        for object_name in objects:
+            if object_name > marker:
+                filtered_objs.append(object_name)
+
+        return filtered_objs
+
+    def filter_end_marker(self, objects, end_marker):
+        """
+        Accept sorted list.
+        """
+        filtered_objs=[]
+        for object_name in objects:
+            if object_name < end_marker:
+                filtered_objs.append(object_name)
+            else:
+                break
+
+        return filtered_objs
+
+    def filter_limit(self, objects, limit):
+        filtered_objs=[]
+        for i in range(0, limit):
+            filtered_objs.append(objects[i])
+
+        return filtered_objs
+
+    def update_account(self, metadata):
+        acc_path = self.datadir
+        write_metadata(acc_path, metadata)
+        self.metadata = metadata
+
+class DiskDir(DiskCommon):
+    """
+    Manage object files on disk.
+
+    :param path: path to devices on the node
+    :param device: device name
+    :param partition: partition on the device the object lives in
+    :param account: account name for the object
+    :param container: container name for the object
+    :param obj: object name for the object
+    :param keep_data_fp: if True, don't close the fp, otherwise close it
+    :param disk_chunk_Size: size of chunks on file reads
+    """
+
+    def __init__(self, path, device, partition, account, container, logger,
+                 uid=DEFAULT_UID, gid=DEFAULT_GID, fs_object=None):
+        self.root = path
+        device = account
+        if container:
+            self.name = container
+        else:
+            self.name = None
+        if self.name:
+            self.datadir = os.path.join(path, account, self.name)
+        else:
+            self.datadir = os.path.join(path, device)
+        self.account = account
+        self.device_path = os.path.join(path, device)
+        if not check_mount(path, device):
+            check_valid_account(account, fs_object)
+        self.logger = logger
+        self.metadata = {}
+        self.uid = int(uid)
+        self.gid = int(gid)
+        # Create a dummy db_file in /etc/swift
+        self.db_file = '/etc/swift/db_file.db'
+        if not os.path.exists(self.db_file):
+            file(self.db_file, 'w+')
+        self.dir_exists = os.path.exists(self.datadir)
+        if self.dir_exists:
+            try:
+                self.metadata = read_metadata(self.datadir)
+            except EOFError:
+                create_container_metadata(self.datadir)
+        else:
+            return
+        if container:
+            if not self.metadata:
+                create_container_metadata(self.datadir)
+                self.metadata = read_metadata(self.datadir)
+            else:
+                if not validate_container(self.metadata):
+                    create_container_metadata(self.datadir)
+                    self.metadata = read_metadata(self.datadir)
+        else:
+            if not self.metadata:
+                create_account_metadata(self.datadir)
+                self.metadata = read_metadata(self.datadir)
+            else:
+                if not validate_account(self.metadata):
+                    create_account_metadata(self.datadir)
+                    self.metadata = read_metadata(self.datadir)
+
+    def empty(self):
+        return dir_empty(self.datadir)
+
+    def delete(self):
+        if self.empty():
+            #For delete account.
+            if os.path.ismount(self.datadir):
+                clean_metadata(self.datadir)
+            else:
+                rmdirs(self.datadir)
+            self.dir_exists = False
+
+
+    def put_metadata(self, metadata):
+        """
+        Write metadata to directory/container.
+        """
+        write_metadata(self.datadir, metadata)
+        self.metadata = metadata
+
+    def put(self, metadata):
+        """
+        Create and write metatdata to directory/container.
+        :param metadata: Metadata to write.
+        """
+        if not self.dir_exists:
+            mkdirs(self.datadir)
+
+        os.chown(self.datadir, self.uid, self.gid)
+        write_metadata(self.datadir, metadata)
+        self.metadata = metadata
+        self.dir_exists = True
+
+    def put_obj(self, content_length, timestamp):
+        self.metadata[X_OBJECTS_COUNT] = int(self.metadata[X_OBJECTS_COUNT]) + 1
+        self.metadata[X_PUT_TIMESTAMP] = timestamp
+        self.metadata[X_BYTES_USED] = int(self.metadata[X_BYTES_USED]) + int(content_length)
+        #TODO: define update_metadata instad of writing whole metadata again.
+        self.put_metadata(self.metadata)
+
+    def delete_obj(self, content_length):
+        self.metadata[X_OBJECTS_COUNT] = int(self.metadata[X_OBJECTS_COUNT]) - 1
+        self.metadata[X_BYTES_USED] = int(self.metadata[X_BYTES_USED]) - int(content_length)
+        self.put_metadata(self.metadata)
+
+    def put_container(self, timestamp, object_count, bytes_used):
+        """
+        For account server.
+        """
+        self.metadata[X_OBJECTS_COUNT] = 0
+        self.metadata[X_BYTES_USED] = 0
+        self.metadata[X_CONTAINER_COUNT] = int(self.metadata[X_CONTAINER_COUNT]) + 1
+        self.metadata[X_PUT_TIMESTAMP] = timestamp
+        self.put_metadata(self.metadata)
+
+    def delete_container(self, object_count, bytes_used):
+        """
+        For account server.
+        """
+        self.metadata[X_OBJECTS_COUNT] = 0
+        self.metadata[X_BYTES_USED] = 0
+        self.metadata[X_CONTAINER_COUNT] = int(self.metadata[X_CONTAINER_COUNT]) - 1
+        self.put_metadata(self.metadata)
+
+    def unlink(self):
+        """
+        Remove directory/container if empty.
+        """
+        if dir_empty(self.datadir):
+            rmdirs(self.datadir)
+
+    def list_objects_iter(self, limit, marker, end_marker,
+                          prefix, delimiter, path):
+        """
+        Returns tuple of name, created_at, size, content_type, etag.
+        """
+        if path:
+            prefix = path = path.rstrip('/') + '/'
+            delimiter = '/'
+        if delimiter and not prefix:
+            prefix = ''
+
+        objects = []
+        object_count = 0
+        bytes_used = 0
+        container_list = []
+
+        objects, object_count, bytes_used = get_container_details(self.datadir)
+
+        if int(self.metadata[X_OBJECTS_COUNT]) != object_count or \
+           int(self.metadata[X_BYTES_USED]) != bytes_used:
+            self.metadata[X_OBJECTS_COUNT] = object_count
+            self.metadata[X_BYTES_USED] = bytes_used
+            self.update_container(self.metadata)
+
+        if objects:
+            objects.sort()
+
+        if objects and prefix:
+            objects = self.filter_prefix(objects, prefix)
+
+        if objects and delimiter:
+            objects = self.filter_delimiter(objects, delimiter, prefix)
+
+        if objects and marker:
+            objects = self.filter_marker(objects, marker)
+
+        if objects and end_marker:
+            objects = self.filter_end_marker(objects, end_marker)
+
+        if objects and limit:
+            if len(objects) > limit:
+                objects = self.filter_limit(objects, limit)
+
+        if objects:
+            for obj in objects:
+                list_item = []
+                list_item.append(obj)
+                metadata = read_metadata(self.datadir + '/' + obj)
+                if not metadata or not validate_object(metadata):
+                    metadata = create_object_metadata(self.datadir + '/' + obj)
+                if metadata:
+                    list_item.append(metadata[X_TIMESTAMP])
+                    list_item.append(int(metadata[X_CONTENT_LENGTH]))
+                    list_item.append(metadata[X_CONTENT_TYPE])
+                    list_item.append(metadata[X_ETAG])
+                container_list.append(list_item)
+
+        return container_list
+
+    def update_container(self, metadata):
+        cont_path = self.datadir
+        write_metadata(cont_path, metadata)
+        self.metadata = metadata
+
+    def update_object_count(self):
+        objects = []
+        object_count = 0
+        bytes_used = 0
+        objects, object_count, bytes_used = get_container_details(self.datadir)
+
+
+        if int(self.metadata[X_OBJECTS_COUNT]) != object_count or \
+           int(self.metadata[X_BYTES_USED]) != bytes_used:
+            self.metadata[X_OBJECTS_COUNT] = object_count
+            self.metadata[X_BYTES_USED] = bytes_used
+            self.update_container(self.metadata)
+
+    def update_container_count(self):
+        containers = []
+        container_count = 0
+
+        containers, container_count = get_account_details(self.datadir)
+
+        if int(self.metadata[X_CONTAINER_COUNT]) != container_count:
+            self.metadata[X_CONTAINER_COUNT] = container_count
+            self.update_account(self.metadata)
+
+    def get_info(self, include_metadata=False):
+        """
+        Get global data for the container.
+        :returns: dict with keys: account, container, created_at,
+                  put_timestamp, delete_timestamp, object_count, bytes_used,
+                  reported_put_timestamp, reported_delete_timestamp,
+                  reported_object_count, reported_bytes_used, hash, id,
+                  x_container_sync_point1, and x_container_sync_point2.
+                  If include_metadata is set, metadata is included as a key
+                  pointing to a dict of tuples of the metadata
+        """
+        # TODO: delete_timestamp, reported_put_timestamp
+        #       reported_delete_timestamp, reported_object_count,
+        #       reported_bytes_used, created_at
+
+        metadata = {}
+        if os.path.exists(self.datadir):
+            metadata = read_metadata(self.datadir)
+
+        data = {'account' : self.account, 'container' : self.name,
+                'object_count' : metadata.get(X_OBJECTS_COUNT, '0'),
+                'bytes_used' : metadata.get(X_BYTES_USED, '0'),
+                'hash': '', 'id' : '', 'created_at' : '1',
+                'put_timestamp' : metadata.get(X_PUT_TIMESTAMP, '0'),
+                'delete_timestamp' : '1',
+                'reported_put_timestamp' : '1', 'reported_delete_timestamp' : '1',
+                'reported_object_count' : '1', 'reported_bytes_used' : '1'}
+        if include_metadata:
+            data['metadata'] = metadata
+        return data
+
+    def put_object(self, name, timestamp, size, content_type,
+                    etag, deleted=0):
+        # TODO: Implement the specifics of this func.
+        pass
+
+    def initialize(self, timestamp):
+        pass
+
+    def update_put_timestamp(self, timestamp):
+        """
+        Create the container if it doesn't exist and update the timestamp
+        """
+        if not os.path.exists(self.datadir):
+            self.put(self.metadata)
+
+    def delete_object(self, name, timestamp):
+        # TODO: Implement the delete object
+        pass
+
+    def delete_db(self, timestamp):
+        """
+        Delete the container
+        """
+        self.unlink()
+
+    def update_metadata(self, metadata):
+        self.metadata.update(metadata)
+        write_metadata(self.datadir, self.metadata)
+
+
+class DiskAccount(DiskDir):
+    def __init__(self, root, account, fs_object = None):
+        self.root = root
+        self.account = account
+        self.datadir = os.path.join(self.root, self.account)
+        if not check_mount(root, account):
+            check_valid_account(account, fs_object)
+        self.metadata = read_metadata(self.datadir)
+        if not self.metadata or not validate_account(self.metadata):
+            self.metadata = create_account_metadata(self.datadir)
+
+    def list_containers_iter(self, limit, marker, end_marker,
+                             prefix, delimiter):
+        """
+        Return tuple of name, object_count, bytes_used, 0(is_subdir).
+        Used by account server.
+        """
+        if delimiter and not prefix:
+            prefix = ''
+        containers = []
+        container_count = 0
+        account_list = []
+
+        containers, container_count = get_account_details(self.datadir)
+
+        if int(self.metadata[X_CONTAINER_COUNT]) != container_count:
+            self.metadata[X_CONTAINER_COUNT] = container_count
+            self.update_account(self.metadata)
+
+        if containers:
+            containers.sort()
+
+        if containers and prefix:
+            containers = self.filter_prefix(containers, prefix)
+
+        if containers and delimiter:
+            containers = self.filter_delimiter(containers, delimiter, prefix)
+
+        if containers and marker:
+            containers = self.filter_marker(containers, marker)
+
+        if containers and end_marker:
+            containers = self.filter_end_marker(containers, end_marker)
+
+        if containers and limit:
+            if len(containers) > limit:
+                containers = self.filter_limit(containers, limit)
+
+        if containers:
+            for cont in containers:
+                list_item = []
+                metadata = None
+                list_item.append(cont)
+                metadata = read_metadata(self.datadir + '/' + cont)
+                if not metadata or not validate_container(metadata):
+                    metadata = create_container_metadata(self.datadir + '/' + cont)
+
+                if metadata:
+                    list_item.append(metadata[X_OBJECTS_COUNT])
+                    list_item.append(metadata[X_BYTES_USED])
+                    list_item.append(0)
+                account_list.append(list_item)
+
+        return account_list
+
+    def get_info(self, include_metadata=False):
+        """
+        Get global data for the account.
+        :returns: dict with keys: account, created_at, put_timestamp,
+                  delete_timestamp, container_count, object_count,
+                  bytes_used, hash, id
+        """
+        metadata = {}
+        if (os.path.exists(self.datadir)):
+            metadata = read_metadata(self.datadir)
+            if not metadata:
+                metadata = create_account_metadata(self.datadir)
+
+        data = {'account' : self.account, 'created_at' : '1',
+                'put_timestamp' : '1', 'delete_timestamp' : '1',
+                'container_count' : metadata.get(X_CONTAINER_COUNT, 0),
+                'object_count' : metadata.get(X_OBJECTS_COUNT, 0),
+                'bytes_used' : metadata.get(X_BYTES_USED, 0),
+                'hash' : '', 'id' : ''}
+
+        if include_metadata:
+            data['metadata'] = metadata
+        return data
diff --git a/swift/1.4.8/plugins/DiskFile.py b/swift/1.4.8/plugins/DiskFile.py
new file mode 100644
index 00000000000..815e1c3ab54
--- /dev/null
+++ b/swift/1.4.8/plugins/DiskFile.py
@@ -0,0 +1,296 @@
+# Copyright (c) 2011 Red Hat, Inc.
+#
+# Licensed 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.
+
+import os
+from eventlet import tpool
+from swift.common.utils import normalize_timestamp, renamer
+from swift.plugins.utils import mkdirs, rmdirs, validate_object, \
+    check_valid_account, create_object_metadata,  do_open, \
+    do_close, do_unlink, do_chown, do_stat, do_listdir, read_metadata,\
+    write_metadata
+from swift.common.constraints import  check_mount
+from swift.plugins.utils import X_CONTENT_TYPE, X_CONTENT_LENGTH, X_TIMESTAMP,\
+     X_PUT_TIMESTAMP, X_TYPE, X_ETAG, X_OBJECTS_COUNT, X_BYTES_USED, \
+     X_OBJECT_TYPE, FILE, DIR, MARKER_DIR, OBJECT, \
+     DIR_TYPE, FILE_TYPE, DEFAULT_UID, DEFAULT_GID
+
+import logging
+from swift.obj.server import DiskFile
+
+
+DATADIR = 'objects'
+ASYNCDIR = 'async_pending'
+KEEP_CACHE_SIZE = (5 * 1024 * 1024)
+# keep these lower-case
+DISALLOWED_HEADERS = set('content-length content-type deleted etag'.split())
+
+
+class Gluster_DiskFile(DiskFile):
+    """
+    Manage object files on disk.
+
+    :param path: path to devices on the node/mount path for UFO.
+    :param device: device name/account_name for UFO.
+    :param partition: partition on the device the object lives in
+    :param account: account name for the object
+    :param container: container name for the object
+    :param obj: object name for the object
+    :param keep_data_fp: if True, don't close the fp, otherwise close it
+    :param disk_chunk_Size: size of chunks on file reads
+    """
+
+    def __init__(self, path, device, partition, account, container, obj,
+                 logger, keep_data_fp=False, disk_chunk_size=65536,
+                 uid=DEFAULT_UID, gid=DEFAULT_GID, fs_object = None):
+        self.disk_chunk_size = disk_chunk_size
+        device = account
+        #Don't support obj_name ending/begining with '/', like /a, a/, /a/b/ etc
+        obj = obj.strip('/')
+        if '/' in obj:
+            self.obj_path, self.obj = obj.rsplit('/', 1)
+        else:
+            self.obj_path = ''
+            self.obj = obj
+
+        if self.obj_path:
+            self.name = '/'.join((container, self.obj_path))
+        else:
+            self.name = container
+        #Absolute path for obj directory.
+        self.datadir = os.path.join(path, device, self.name)
+
+        self.device_path = os.path.join(path, device)
+        if not check_mount(path, device):
+            check_valid_account(account, fs_object)
+
+        self.container_path = os.path.join(path, device, container)
+        self.tmpdir = os.path.join(path, device, 'tmp')
+        self.logger = logger
+        self.metadata = {}
+        self.meta_file = None
+        self.data_file = None
+        self.fp = None
+        self.iter_etag = None
+        self.started_at_0 = False
+        self.read_to_eof = False
+        self.quarantined_dir = None
+        self.keep_cache = False
+        self.is_dir = False
+        self.is_valid = True
+        self.uid = int(uid)
+        self.gid = int(gid)
+        if not os.path.exists(self.datadir + '/' + self.obj):
+            return
+
+        self.data_file = os.path.join(self.datadir, self.obj)
+        self.metadata = read_metadata(self.datadir + '/' + self.obj)
+        if not self.metadata:
+            create_object_metadata(self.datadir + '/' + self.obj)
+            self.metadata = read_metadata(self.datadir + '/' + self.obj)
+
+        if not validate_object(self.metadata):
+            create_object_metadata(self.datadir + '/' + self.obj)
+            self.metadata = read_metadata(self.datadir + '/' +
+                                        self.obj)
+
+        self.filter_metadata()
+
+        if os.path.isdir(self.datadir + '/' + self.obj):
+            self.is_dir = True
+        else:
+            self.fp = do_open(self.data_file, 'rb')
+            if not keep_data_fp:
+                self.close(verify_file=False)
+
+    def close(self, verify_file=True):
+        """
+        Close the file. Will handle quarantining file if necessary.
+
+        :param verify_file: Defaults to True. If false, will not check
+                            file to see if it needs quarantining.
+        """
+        #Marker directory
+        if self.is_dir:
+            return
+        if self.fp:
+            do_close(self.fp)
+            self.fp = None
+
+    def is_deleted(self):
+        """
+        Check if the file is deleted.
+
+        :returns: True if the file doesn't exist or has been flagged as
+                  deleted.
+        """
+        return not self.data_file
+
+    def create_dir_object(self, dir_path):
+        #TODO: if object already exists???
+        if os.path.exists(dir_path) and not os.path.isdir(dir_path):
+            self.logger.error("Deleting file %s", dir_path)
+            do_unlink(dir_path)
+        #If dir aleady exist just override metadata.
+        mkdirs(dir_path)
+        do_chown(dir_path, self.uid, self.gid)
+        create_object_metadata(dir_path)
+        return True
+
+
+
+    def put_metadata(self, metadata):
+        obj_path = self.datadir + '/' + self.obj
+        write_metadata(obj_path, metadata)
+        self.metadata = metadata
+
+
+    def put(self, fd, tmppath, metadata, extension=''):
+        """
+        Finalize writing the file on disk, and renames it from the temp file to
+        the real location.  This should be called after the data has been
+        written to the temp file.
+
+        :params fd: file descriptor of the temp file
+        :param tmppath: path to the temporary file being used
+        :param metadata: dictionary of metadata to be written
+        :param extention: extension to be used when making the file
+        """
+        #Marker dir.
+        if extension == '.ts':
+            return True
+        if extension == '.meta':
+            self.put_metadata(metadata)
+            return True
+        else:
+            extension = ''
+        if metadata[X_OBJECT_TYPE] == MARKER_DIR:
+            self.create_dir_object(os.path.join(self.datadir, self.obj))
+            self.put_metadata(metadata)
+            self.data_file = self.datadir + '/' + self.obj
+            return True
+        #Check if directory already exists.
+        if self.is_dir:
+            self.logger.error('Directory already exists %s/%s' % \
+                          (self.datadir , self.obj))
+            return False
+        #metadata['name'] = self.name
+        timestamp = normalize_timestamp(metadata[X_TIMESTAMP])
+        write_metadata(tmppath, metadata)
+        if X_CONTENT_LENGTH in metadata:
+            self.drop_cache(fd, 0, int(metadata[X_CONTENT_LENGTH]))
+        tpool.execute(os.fsync, fd)
+        if self.obj_path:
+            dir_objs = self.obj_path.split('/')
+            tmp_path = ''
+            if len(dir_objs):
+                for dir_name in dir_objs:
+                    if tmp_path:
+                        tmp_path = tmp_path + '/' + dir_name
+                    else:
+                        tmp_path = dir_name
+                    if not self.create_dir_object(os.path.join(self.container_path,
+                            tmp_path)):
+                        self.logger.error("Failed in subdir %s",\
+                                        os.path.join(self.container_path,tmp_path))
+                        return False
+
+        renamer(tmppath, os.path.join(self.datadir,
+                                      self.obj + extension))
+        do_chown(os.path.join(self.datadir, self.obj + extension), \
+              self.uid, self.gid)
+        self.metadata = metadata
+        #self.logger.error("Meta %s", self.metadata)
+        self.data_file = self.datadir + '/' + self.obj + extension
+        return True
+
+
+    def unlinkold(self, timestamp):
+        """
+        Remove any older versions of the object file.  Any file that has an
+        older timestamp than timestamp will be deleted.
+
+        :param timestamp: timestamp to compare with each file
+        """
+        if self.metadata and self.metadata['X-Timestamp'] != timestamp:
+            self.unlink()
+
+    def unlink(self):
+        """
+        Remove the file.
+        """
+        #Marker dir.
+        if self.is_dir:
+            rmdirs(os.path.join(self.datadir, self.obj))
+            if not os.path.isdir(os.path.join(self.datadir, self.obj)):
+                self.metadata = {}
+                self.data_file = None
+            else:
+                logging.error('Unable to delete dir %s' % os.path.join(self.datadir, self.obj))
+            return
+
+        for fname in do_listdir(self.datadir):
+            if fname == self.obj:
+                try:
+                    do_unlink(os.path.join(self.datadir, fname))
+                except OSError, err:
+                    if err.errno != errno.ENOENT:
+                        raise
+
+        #Remove entire path for object.
+        #remove_dir_path(self.obj_path, self.container_path)
+
+        self.metadata = {}
+        self.data_file = None
+
+    def get_data_file_size(self):
+        """
+        Returns the os.path.getsize for the file.  Raises an exception if this
+        file does not match the Content-Length stored in the metadata. Or if
+        self.data_file does not exist.
+
+        :returns: file size as an int
+        :raises DiskFileError: on file size mismatch.
+        :raises DiskFileNotExist: on file not existing (including deleted)
+        """
+        #Marker directory.
+        if self.is_dir:
+            return 0
+        try:
+            file_size = 0
+            if self.data_file:
+                file_size = os.path.getsize(self.data_file)
+                if  X_CONTENT_LENGTH in self.metadata:
+                    metadata_size = int(self.metadata[X_CONTENT_LENGTH])
+                    if file_size != metadata_size:
+                        self.metadata[X_CONTENT_LENGTH] = file_size
+                        self.update_object(self.metadata)
+
+                return file_size
+        except OSError, err:
+            if err.errno != errno.ENOENT:
+                raise
+        raise DiskFileNotExist('Data File does not exist.')
+
+    def update_object(self, metadata):
+        obj_path = self.datadir + '/' + self.obj
+        write_metadata(obj_path, metadata)
+        self.metadata = metadata
+
+    def filter_metadata(self):
+        if X_TYPE in self.metadata:
+            self.metadata.pop(X_TYPE)
+        if X_OBJECT_TYPE in self.metadata:
+            self.metadata.pop(X_OBJECT_TYPE)
+
diff --git a/swift/1.4.8/plugins/Glusterfs.py b/swift/1.4.8/plugins/Glusterfs.py
new file mode 100644
index 00000000000..d5e847a8239
--- /dev/null
+++ b/swift/1.4.8/plugins/Glusterfs.py
@@ -0,0 +1,104 @@
+# Copyright (c) 2011 Red Hat, Inc.
+#
+# Licensed 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.
+import logging
+import os
+from ConfigParser import ConfigParser
+from swift.common.utils import TRUE_VALUES
+from hashlib import md5
+
+class Glusterfs(object):
+    def __init__(self):
+        self.name = 'glusterfs'
+        self.fs_conf = ConfigParser()
+        self.fs_conf.read(os.path.join('/etc/swift', 'fs.conf'))
+        self.mount_path = self.fs_conf.get('DEFAULT', 'mount_path', '/mnt/gluster-object')
+        self.auth_account = self.fs_conf.get('DEFAULT', 'auth_account', 'auth')
+        self.mount_ip = self.fs_conf.get('DEFAULT', 'mount_ip', 'localhost')
+        self.remote_cluster = self.fs_conf.get('DEFAULT', 'remote_cluster', False) in TRUE_VALUES
+
+    def mount(self, account):
+        export = self.get_export_from_account_id(account)
+        mount_path = os.path.join(self.mount_path, account)
+        mnt_cmd = 'mount -t glusterfs %s:%s %s' % (self.mount_ip, export, \
+                                                   mount_path)
+        if os.system(mnt_cmd) or \
+        not os.path.exists(os.path.join(mount_path)):
+            raise Exception('Mount failed %s: %s' % (self.name, mnt_cmd))
+            return False
+        return True
+
+    def unmount(self, mount_path):
+        umnt_cmd = 'umount %s 2>> /dev/null' % mount_path
+        if os.system(umnt_cmd):
+            logging.error('Unable to unmount %s %s' % (mount_path, self.name))
+
+    def get_export_list_local(self):
+        export_list = []
+        cmnd = 'gluster volume info'
+
+        if os.system(cmnd + ' >> /dev/null'):
+            raise Exception('Getting volume failed %s', self.name)
+            return export_list
+
+        fp = os.popen(cmnd)
+        while True:
+            item = fp.readline()
+            if not item:
+                break
+            item = item.strip('\n').strip(' ')
+            if item.lower().startswith('volume name:'):
+                export_list.append(item.split(':')[1].strip(' '))
+
+        return export_list
+
+
+    def get_export_list_remote(self):
+        export_list = []
+        cmnd = 'ssh %s gluster volume info' % self.mount_ip
+        print 'Remote'
+
+        if os.system(cmnd + ' >> /dev/null'):
+            raise Exception('Getting volume info failed %s, make sure to have \
+                            passwordless ssh on %s', self.name, self.mount_ip)
+            return export_list
+
+        fp = os.popen(cmnd)
+        while True:
+            item = fp.readline()
+            if not item:
+                break
+            item = item.strip('\n').strip(' ')
+            if item.lower().startswith('volume name:'):
+                export_list.append(item.split(':')[1].strip(' '))
+
+        return export_list
+
+    def get_export_list(self):
+        if self.remote_cluster:
+            return self.get_export_list_remote()
+        else:
+            return self.get_export_list_local()
+
+    def get_export_from_account_id(self, account):
+        if not account:
+            print 'account is none, returning'
+            raise AttributeError
+
+        for export in self.get_export_list():
+            if account == 'AUTH_' + export:
+                return export
+
+        raise Exception('No export found %s %s' % (account, self.name))
+        return None
diff --git a/swift/1.4.8/plugins/__init__.py b/swift/1.4.8/plugins/__init__.py
new file mode 100644
index 00000000000..3d98c960c14
--- /dev/null
+++ b/swift/1.4.8/plugins/__init__.py
@@ -0,0 +1,16 @@
+# Copyright (c) 2011 Red Hat, Inc.
+#
+# Licensed 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.
+
+from Glusterfs import Glusterfs
diff --git a/swift/1.4.8/plugins/conf/account-server/1.conf b/swift/1.4.8/plugins/conf/account-server/1.conf
new file mode 100644
index 00000000000..54cbf654003
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/account-server/1.conf
@@ -0,0 +1,22 @@
+[DEFAULT]
+devices = /srv/1/node
+mount_check = false
+bind_port = 6012
+user = root
+log_facility = LOG_LOCAL2
+
+[pipeline:main]
+pipeline = gluster account-server
+
+[app:account-server]
+use = egg:swift#account
+
+[filter:gluster]
+use = egg:swift#gluster
+
+[account-replicator]
+vm_test_mode = yes
+
+[account-auditor]
+
+[account-reaper]
diff --git a/swift/1.4.8/plugins/conf/account.builder b/swift/1.4.8/plugins/conf/account.builder
new file mode 100644
index 00000000000..2943b9cfb49
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/account.builder
diff --git a/swift/1.4.8/plugins/conf/account.ring.gz b/swift/1.4.8/plugins/conf/account.ring.gz
new file mode 100644
index 00000000000..e1a5e6ae25e
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/account.ring.gz
diff --git a/swift/1.4.8/plugins/conf/container-server/1.conf b/swift/1.4.8/plugins/conf/container-server/1.conf
new file mode 100644
index 00000000000..9e776838f58
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/container-server/1.conf
@@ -0,0 +1,24 @@
+[DEFAULT]
+devices = /srv/1/node
+mount_check = false
+bind_port = 6011
+user = root
+log_facility = LOG_LOCAL2
+
+[pipeline:main]
+pipeline = gluster container-server
+
+[app:container-server]
+use = egg:swift#container
+
+[filter:gluster]
+use = egg:swift#gluster
+
+[container-replicator]
+vm_test_mode = yes
+
+[container-updater]
+
+[container-auditor]
+
+[container-sync]
diff --git a/swift/1.4.8/plugins/conf/container.builder b/swift/1.4.8/plugins/conf/container.builder
new file mode 100644
index 00000000000..6031d79df60
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/container.builder
diff --git a/swift/1.4.8/plugins/conf/container.ring.gz b/swift/1.4.8/plugins/conf/container.ring.gz
new file mode 100644
index 00000000000..fdbcb18b2bf
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/container.ring.gz
diff --git a/swift/1.4.8/plugins/conf/db_file.db b/swift/1.4.8/plugins/conf/db_file.db
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/db_file.db
diff --git a/swift/1.4.8/plugins/conf/fs.conf b/swift/1.4.8/plugins/conf/fs.conf
new file mode 100644
index 00000000000..3cc0b732e93
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/fs.conf
@@ -0,0 +1,8 @@
+[DEFAULT]
+mount_path = /mnt/gluster-object
+auth_account = auth
+#ip of the fs server.
+mount_ip = localhost
+#fs server need not be local, remote server can also be used,
+#set remote_cluster=yes for using remote server.
+remote_cluster = no
diff --git a/swift/1.4.8/plugins/conf/object-server/1.conf b/swift/1.4.8/plugins/conf/object-server/1.conf
new file mode 100644
index 00000000000..f191cefcf01
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/object-server/1.conf
@@ -0,0 +1,22 @@
+[DEFAULT]
+devices = /srv/1/node
+mount_check = false
+bind_port = 6010
+user = root
+log_facility = LOG_LOCAL2
+
+[pipeline:main]
+pipeline = gluster object-server
+
+[app:object-server]
+use = egg:swift#object
+
+[filter:gluster]
+use = egg:swift#gluster
+
+[object-replicator]
+vm_test_mode = yes
+
+[object-updater]
+
+[object-auditor]
diff --git a/swift/1.4.8/plugins/conf/object.builder b/swift/1.4.8/plugins/conf/object.builder
new file mode 100644
index 00000000000..ce45350595d
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/object.builder
diff --git a/swift/1.4.8/plugins/conf/object.ring.gz b/swift/1.4.8/plugins/conf/object.ring.gz
new file mode 100644
index 00000000000..73e88d58918
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/object.ring.gz
diff --git a/swift/1.4.8/plugins/conf/proxy-server.conf b/swift/1.4.8/plugins/conf/proxy-server.conf
new file mode 100644
index 00000000000..7f23d85ccd9
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/proxy-server.conf
@@ -0,0 +1,25 @@
+[DEFAULT]
+bind_port = 8080
+user = root
+log_facility = LOG_LOCAL1
+
+[pipeline:main]
+pipeline = healthcheck cache tempauth proxy-server
+
+[app:proxy-server]
+use = egg:swift#proxy
+allow_account_management = true
+account_autocreate = true
+
+[filter:tempauth]
+use = egg:swift#tempauth
+user_admin_admin = admin .admin .reseller_admin
+user_test_tester = testing .admin
+user_test2_tester2 = testing2 .admin
+user_test_tester3 = testing3
+
+[filter:healthcheck]
+use = egg:swift#healthcheck
+
+[filter:cache]
+use = egg:swift#memcache
diff --git a/swift/1.4.8/plugins/conf/swift.conf b/swift/1.4.8/plugins/conf/swift.conf
new file mode 100644
index 00000000000..f9864e35231
--- /dev/null
+++ b/swift/1.4.8/plugins/conf/swift.conf
@@ -0,0 +1,7 @@
+[DEFAULT]
+Enable_plugin = yes
+
+[swift-hash]
+# random unique string that can never change (DO NOT LOSE)
+swift_hash_path_suffix = gluster
+
diff --git a/swift/1.4.8/plugins/constraints.py b/swift/1.4.8/plugins/constraints.py
new file mode 100644
index 00000000000..6be853629fb
--- /dev/null
+++ b/swift/1.4.8/plugins/constraints.py
@@ -0,0 +1,97 @@
+# Copyright (c) 2011 Red Hat, Inc.
+#
+# Licensed 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.
+
+import os
+import logging
+from swift.common.constraints import check_utf8, check_metadata
+
+from webob.exc import HTTPBadRequest, HTTPLengthRequired, \
+    HTTPRequestEntityTooLarge
+
+
+#: Max file size allowed for objects
+MAX_FILE_SIZE = 0xffffffffffffffff
+#: Max length of the name of a key for metadata
+MAX_META_NAME_LENGTH = 128
+#: Max length of the value of a key for metadata
+MAX_META_VALUE_LENGTH = 256
+#: Max number of metadata items
+MAX_META_COUNT = 90
+#: Max overall size of metadata
+MAX_META_OVERALL_SIZE = 4096
+#: Max object name length
+MAX_OBJECT_NAME_LENGTH = 255
+#: Max object list length of a get request for a container
+CONTAINER_LISTING_LIMIT = 10000
+#: Max container list length of a get request for an account
+ACCOUNT_LISTING_LIMIT = 10000
+MAX_ACCOUNT_NAME_LENGTH = 255
+MAX_CONTAINER_NAME_LENGTH = 255
+
+def validate_obj_name(obj):
+    if len(obj) > MAX_OBJECT_NAME_LENGTH:
+        logging.error('Object name too long %s' % obj)
+        return False
+    if obj == '.' or obj == '..':
+        logging.error('Object name cannot be . or .. %s' % obj)
+        return False
+
+    return True
+
+def check_object_creation(req, object_name):
+    """
+    Check to ensure that everything is alright about an object to be created.
+
+    :param req: HTTP request object
+    :param object_name: name of object to be created
+    :raises HTTPRequestEntityTooLarge: the object is too large
+    :raises HTTPLengthRequered: missing content-length header and not
+                                a chunked request
+    :raises HTTPBadRequest: missing or bad content-type header, or
+                            bad metadata
+    """
+    if req.content_length and req.content_length > MAX_FILE_SIZE:
+        return HTTPRequestEntityTooLarge(body='Your request is too large.',
+                request=req, content_type='text/plain')
+    if req.content_length is None and \
+            req.headers.get('transfer-encoding') != 'chunked':
+        return HTTPLengthRequired(request=req)
+    if 'X-Copy-From' in req.headers and req.content_length:
+        return HTTPBadRequest(body='Copy requests require a zero byte body',
+                              request=req, content_type='text/plain')
+    for obj in object_name.split('/'):
+        if not validate_obj_name(obj):
+            return HTTPBadRequest(body='Invalid object name %s' %
+                    (obj), request=req,
+                    content_type='text/plain')
+    if 'Content-Type' not in req.headers:
+        return HTTPBadRequest(request=req, content_type='text/plain',
+                    body='No content type')
+    if not check_utf8(req.headers['Content-Type']):
+        return HTTPBadRequest(request=req, body='Invalid Content-Type',
+                    content_type='text/plain')
+    if 'x-object-manifest' in req.headers:
+        value = req.headers['x-object-manifest']
+        container = prefix = None
+        try:
+            container, prefix = value.split('/', 1)
+        except ValueError:
+            pass
+        if not container or not prefix or '?' in value or '&' in value or \
+                prefix[0] == '/':
+            return HTTPBadRequest(request=req,
+                body='X-Object-Manifest must in the format container/prefix')
+    return check_metadata(req, 'object')
+
diff --git a/swift/1.4.8/plugins/utils.py b/swift/1.4.8/plugins/utils.py
new file mode 100644
index 00000000000..57c6180fdd1
--- /dev/null
+++ b/swift/1.4.8/plugins/utils.py
@@ -0,0 +1,692 @@
+# Copyright (c) 2011 Red Hat, Inc.
+#
+# Licensed 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.
+
+import logging
+import os
+import errno
+from hashlib import md5
+from swift.common.utils import normalize_timestamp
+from xattr import setxattr, removexattr, getxattr, removexattr
+import cPickle as pickle
+
+X_CONTENT_TYPE = 'Content-Type'
+X_CONTENT_LENGTH = 'Content-Length'
+X_TIMESTAMP = 'X-Timestamp'
+X_PUT_TIMESTAMP = 'X-PUT-Timestamp'
+X_TYPE = 'X-Type'
+X_ETAG = 'ETag'
+X_OBJECTS_COUNT = 'X-Object-Count'
+X_BYTES_USED = 'X-Bytes-Used'
+X_CONTAINER_COUNT = 'X-Container-Count'
+X_OBJECT_TYPE = 'X-Object-Type'
+DIR_TYPE = 'application/directory'
+ACCOUNT = 'Account'
+MOUNT_PATH = '/mnt/gluster-object'
+METADATA_KEY = 'user.swift.metadata'
+CONTAINER = 'container'
+DIR = 'dir'
+MARKER_DIR = 'marker_dir'
+FILE = 'file'
+DIR_TYPE = 'application/directory'
+FILE_TYPE = 'application/octet-stream'
+OBJECT = 'Object'
+OBJECT_TYPE = 'application/octet-stream'
+DEFAULT_UID = -1
+DEFAULT_GID = -1
+PICKLE_PROTOCOL = 2
+CHUNK_SIZE = 65536
+
+
+def mkdirs(path):
+    """
+    Ensures the path is a directory or makes it if not. Errors if the path
+    exists but is a file or on permissions failure.
+
+    :param path: path to create
+    """
+    if not os.path.isdir(path):
+        try:
+            do_makedirs(path)
+        except OSError, err:
+            #TODO: check, isdir will fail if mounted and volume stopped.
+            #if err.errno != errno.EEXIST or not os.path.isdir(path)
+            if err.errno != errno.EEXIST:
+                raise
+
+def rmdirs(path):
+    if os.path.isdir(path) and dir_empty(path):
+        do_rmdir(path)
+    else:
+        logging.error("rmdirs failed dir may not be empty or not valid dir")
+        return False
+
+def strip_obj_storage_path(path, string='/mnt/gluster-object'):
+    """
+    strip /mnt/gluster-object
+    """
+    return path.replace(string, '').strip('/')
+
+def do_mkdir(path):
+    try:
+        os.mkdir(path)
+    except Exception, err:
+        logging.exception("Mkdir failed on %s err: %s", path, str(err))
+        if err.errno != errno.EEXIST:
+            raise
+    return True
+
+def do_makedirs(path):
+    try:
+        os.makedirs(path)
+    except Exception, err:
+        logging.exception("Makedirs failed on %s err: %s", path, str(err))
+        if err.errno != errno.EEXIST:
+            raise
+    return True
+
+
+def do_listdir(path):
+    try:
+        buf = os.listdir(path)
+    except Exception, err:
+        logging.exception("Listdir failed on %s err: %s", path, str(err))
+        raise
+    return buf
+
+def do_chown(path, uid, gid):
+    try:
+        os.chown(path, uid, gid)
+    except Exception, err:
+        logging.exception("Chown failed on %s err: %s", path, str(err))
+        raise
+    return True
+
+def do_stat(path):
+    try:
+        #Check for fd.
+        if isinstance(path, int):
+            buf = os.fstat(path)
+        else:
+            buf = os.stat(path)
+    except Exception, err:
+        logging.exception("Stat failed on %s err: %s", path, str(err))
+        raise
+
+    return buf
+
+def do_open(path, mode):
+    try:
+        fd = open(path, mode)
+    except Exception, err:
+        logging.exception("Open failed on %s err: %s", path, str(err))
+        raise
+    return fd
+
+def do_close(fd):
+    #fd could be file or int type.
+    try:
+        if isinstance(fd, int):
+            os.close(fd)
+        else:
+            fd.close()
+    except Exception, err:
+        logging.exception("Close failed on %s err: %s", fd, str(err))
+        raise
+    return True
+
+def do_unlink(path, log = True):
+    try:
+        os.unlink(path)
+    except Exception, err:
+        if log:
+            logging.exception("Unlink failed on %s err: %s", path, str(err))
+        if err.errno != errno.ENOENT:
+            raise
+    return True
+
+def do_rmdir(path):
+    try:
+        os.rmdir(path)
+    except Exception, err:
+        logging.exception("Rmdir failed on %s err: %s", path, str(err))
+        if err.errno != errno.ENOENT:
+            raise
+    return True
+
+def do_rename(old_path, new_path):
+    try:
+        os.rename(old_path, new_path)
+    except Exception, err:
+        logging.exception("Rename failed on %s to %s  err: %s", old_path, new_path, \
+                          str(err))
+        raise
+    return True
+
+def do_setxattr(path, key, value):
+    fd = None
+    if not os.path.isdir(path):
+        fd = do_open(path, 'rb')
+    else:
+        fd = path
+    if fd or os.path.isdir(path):
+        try:
+            setxattr(fd, key, value)
+        except Exception, err:
+            logging.exception("setxattr failed on %s key %s err: %s", path, key, str(err))
+            raise
+        finally:
+            if fd and not os.path.isdir(path):
+                do_close(fd)
+    else:
+        logging.error("Open failed path %s", path)
+        return False
+    return True
+
+
+
+def do_getxattr(path, key, log = True):
+    fd = None
+    if not os.path.isdir(path):
+        fd = do_open(path, 'rb')
+    else:
+        fd = path
+    if fd or os.path.isdir(path):
+        try:
+            value = getxattr(fd, key)
+        except Exception, err:
+            if log:
+                logging.exception("getxattr failed on %s key %s err: %s", path, key, str(err))
+            raise
+        finally:
+            if fd and not os.path.isdir(path):
+                do_close(fd)
+    else:
+        logging.error("Open failed path %s", path)
+        return False
+    return value
+
+def do_removexattr(path, key):
+    fd = None
+    if not os.path.isdir(path):
+        fd = do_open(path, 'rb')
+    else:
+        fd = path
+    if fd or os.path.isdir(path):
+        try:
+            removexattr(fd, key)
+        except Exception, err:
+            logging.exception("removexattr failed on %s key %s err: %s", path, key, str(err))
+            raise
+        finally:
+            if fd and not os.path.isdir(path):
+                do_close(fd)
+    else:
+        logging.error("Open failed path %s", path)
+        return False
+    return True
+
+def read_metadata(path):
+    """
+    Helper function to read the pickled metadata from a File/Directory .
+
+    :param path: File/Directory to read metadata from.
+
+    :returns: dictionary of metadata
+    """
+    metadata = ''
+    key = 0
+    while True:
+        try:
+            metadata += do_getxattr(path, '%s%s' % (METADATA_KEY, (key or '')),
+                            log = False)
+        except Exception:
+            break
+        key += 1
+    if metadata:
+        return pickle.loads(metadata)
+    else:
+        return {}
+
+
+def write_metadata(path, metadata):
+    """
+    Helper function to write pickled metadata for a File/Directory.
+
+    :param path: File/Directory path to write the metadata
+    :param metadata: metadata to write
+    """
+    metastr = pickle.dumps(metadata, PICKLE_PROTOCOL)
+    key = 0
+    while metastr:
+        do_setxattr(path, '%s%s' % (METADATA_KEY, key or ''), metastr[:254])
+        metastr = metastr[254:]
+        key += 1
+
+def clean_metadata(path):
+    key = 0
+    while True:
+        value = do_getxattr(path, '%s%s' % (METADATA_KEY, (key or '')))
+        do_removexattr(path, '%s%s' % (METADATA_KEY, (key or '')))
+        key += 1
+
+
+def dir_empty(path):
+    """
+    Return true if directory/container is empty.
+    :param path: Directory path.
+    :returns: True/False.
+    """
+    if os.path.isdir(path):
+        try:
+            files = do_listdir(path)
+        except Exception, err:
+            logging.exception("listdir failed on %s err: %s", path, str(err))
+            raise
+        if not files:
+            return True
+        else:
+            return False
+    else:
+        if not os.path.exists(path):
+            return True
+
+
+def get_device_from_account(account):
+    if account.startswith(RESELLER_PREFIX):
+        device = account.replace(RESELLER_PREFIX, '', 1)
+        return device
+
+def check_user_xattr(path):
+    if not os.path.exists(path):
+        return False
+    do_setxattr(path, 'user.test.key1', 'value1')
+    try:
+        removexattr(path, 'user.test.key1')
+    except Exception, err:
+        logging.exception("removexattr failed on %s err: %s", path, str(err))
+        #Remove xattr may fail in case of concurrent remove.
+    return True
+
+
+def _check_valid_account(account, fs_object):
+    mount_path = getattr(fs_object, 'mount_path', MOUNT_PATH)
+
+    if not check_account_exists(fs_object.get_export_from_account_id(account), \
+                                fs_object):
+        logging.error('Account not present %s', account)
+        return False
+
+    if not os.path.ismount(os.path.join(mount_path, account)):
+        if not os.path.isdir(os.path.join(mount_path, account)):
+            mkdirs(os.path.join(mount_path, account))
+
+        fs_object.unmount(os.path.join(mount_path, account))
+
+    if fs_object:
+        if not fs_object.mount(account):
+            return False
+
+    if not check_user_xattr(os.path.join(mount_path, account)):
+        logging.error('Error: No support for user.xattr on backend %s' % account)
+        return False
+
+    chmod_cmd = ['chmod 777 %s' % (mount_path), \
+                 'chmod 777 %s/%s' % (mount_path, account)]
+
+    for cmd in chmod_cmd:
+        if os.system(cmd):
+            logging.error('Chmod failed: %s' % (cmd))
+            return False
+
+    return True
+
+def check_valid_account(account, fs_object):
+    return _check_valid_account(account, fs_object)
+
+def validate_container(metadata):
+    if not metadata:
+        logging.error('No metadata')
+        return False
+
+    if X_TYPE not in metadata.keys() or \
+       X_TIMESTAMP not in metadata.keys() or \
+       X_PUT_TIMESTAMP not in metadata.keys() or \
+       X_OBJECTS_COUNT not in metadata.keys() or \
+       X_BYTES_USED not in metadata.keys():
+        #logging.error('Container error %s' % metadata)
+        return False
+
+    if metadata[X_TYPE] == CONTAINER:
+        return True
+
+    logging.error('Container error %s' % metadata)
+    return False
+
+def validate_account(metadata):
+    if not metadata:
+        logging.error('No metadata')
+        return False
+
+    if X_TYPE not in metadata.keys() or \
+       X_TIMESTAMP not in metadata.keys() or \
+       X_PUT_TIMESTAMP not in metadata.keys() or \
+       X_OBJECTS_COUNT not in metadata.keys() or \
+       X_BYTES_USED not in metadata.keys() or \
+       X_CONTAINER_COUNT not in metadata.keys():
+        #logging.error('Account error %s' % metadata)
+        return False
+
+    if metadata[X_TYPE] == ACCOUNT:
+        return True
+
+    logging.error('Account error %s' % metadata)
+    return False
+
+def validate_object(metadata):
+    if not metadata:
+        logging.error('No metadata')
+        return False
+
+    if X_TIMESTAMP not in metadata.keys() or \
+       X_CONTENT_TYPE not in metadata.keys() or \
+       X_ETAG not in metadata.keys() or \
+       X_CONTENT_LENGTH not in metadata.keys() or \
+       X_TYPE not in metadata.keys() or \
+       X_OBJECT_TYPE not in metadata.keys():
+        #logging.error('Object error %s' % metadata)
+        return False
+
+    if metadata[X_TYPE] == OBJECT:
+        return True
+
+    logging.error('Object error %s' % metadata)
+    return False
+
+def is_marker(metadata):
+    if not metadata:
+        logging.error('No metadata')
+        return False
+
+    if X_OBJECT_TYPE not in metadata.keys():
+        logging.error('X_OBJECT_TYPE missing %s' % metadata)
+        return False
+
+    if metadata[X_OBJECT_TYPE] == MARKER_DIR:
+        return True
+    else:
+        return False
+
+def _update_list(path, const_path, src_list, reg_file=True, object_count=0,
+                 bytes_used=0, obj_list=[]):
+    obj_path = strip_obj_storage_path(path, const_path)
+
+    for i in src_list:
+        if obj_path:
+            obj_list.append(os.path.join(obj_path, i))
+        else:
+            obj_list.append(i)
+
+        object_count += 1
+
+        if reg_file:
+            bytes_used += os.path.getsize(path + '/' + i)
+
+    return object_count, bytes_used
+
+def update_list(path, const_path, dirs=[], files=[], object_count=0,
+                bytes_used=0, obj_list=[]):
+    object_count, bytes_used = _update_list (path, const_path, files, True,
+                                             object_count, bytes_used,
+                                             obj_list)
+    object_count, bytes_used = _update_list (path, const_path, dirs, False,
+                                             object_count, bytes_used,
+                                             obj_list)
+    return object_count, bytes_used
+
+def get_container_details_from_fs(cont_path, const_path,
+                                  memcache=None):
+    """
+    get container details by traversing the filesystem
+    """
+    bytes_used = 0
+    object_count = 0
+    obj_list=[]
+    dir_list = []
+
+    if os.path.isdir(cont_path):
+        for (path, dirs, files) in os.walk(cont_path):
+            object_count, bytes_used = update_list(path, const_path, dirs, files,
+                                                   object_count, bytes_used,
+                                                   obj_list)
+
+            dir_list.append(path + ':' + str(do_stat(path).st_mtime))
+
+    if memcache:
+        memcache.set(strip_obj_storage_path(cont_path), obj_list)
+        memcache.set(strip_obj_storage_path(cont_path) + '-dir_list',
+                     ','.join(dir_list))
+        memcache.set(strip_obj_storage_path(cont_path) + '-cont_meta',
+                     [object_count, bytes_used])
+
+    return obj_list, object_count, bytes_used
+
+def get_container_details_from_memcache(cont_path, const_path,
+                                        memcache):
+    """
+    get container details stored in memcache
+    """
+
+    bytes_used = 0
+    object_count = 0
+    obj_list=[]
+
+    dir_contents = memcache.get(strip_obj_storage_path(cont_path) + '-dir_list')
+    if not dir_contents:
+        return get_container_details_from_fs(cont_path, const_path,
+                                             memcache=memcache)
+
+    for i in dir_contents.split(','):
+        path, mtime = i.split(':')
+        if mtime != str(do_stat(path).st_mtime):
+            return get_container_details_from_fs(cont_path, const_path,
+                                                 memcache=memcache)
+
+    obj_list = memcache.get(strip_obj_storage_path(cont_path))
+
+    object_count, bytes_used = memcache.get(strip_obj_storage_path(cont_path) + '-cont_meta')
+
+    return obj_list, object_count, bytes_used
+
+def get_container_details(cont_path, memcache=None):
+    """
+    Return object_list, object_count and bytes_used.
+    """
+    if memcache:
+        object_list, object_count, bytes_used = get_container_details_from_memcache(cont_path, cont_path,
+                                                                                    memcache=memcache)
+    else:
+        object_list, object_count, bytes_used = get_container_details_from_fs(cont_path, cont_path)
+
+    return object_list, object_count, bytes_used
+
+def get_account_details_from_fs(acc_path, memcache=None):
+    container_list = []
+    container_count = 0
+
+    if os.path.isdir(acc_path):
+        for name in do_listdir(acc_path):
+            if not os.path.isdir(acc_path + '/' + name) or \
+               name.lower() == 'tmp':
+                continue
+            container_count += 1
+            container_list.append(name)
+
+    if memcache:
+        memcache.set(strip_obj_storage_path(acc_path) + '_container_list', container_list)
+        memcache.set(strip_obj_storage_path(acc_path)+'_mtime', str(do_stat(acc_path).st_mtime))
+        memcache.set(strip_obj_storage_path(acc_path)+'_container_count', container_count)
+
+    return container_list, container_count
+
+def get_account_details_from_memcache(acc_path, memcache=None):
+    if memcache:
+        mtime = memcache.get(strip_obj_storage_path(acc_path)+'_mtime')
+        if not mtime or mtime != str(do_stat(acc_path).st_mtime):
+            return get_account_details_from_fs(acc_path, memcache)
+        container_list = memcache.get(strip_obj_storage_path(acc_path) + '_container_list')
+        container_count = memcache.get(strip_obj_storage_path(acc_path)+'_container_count')
+        return container_list, container_count
+
+
+def get_account_details(acc_path, memcache=None):
+    """
+    Return container_list and container_count.
+    """
+    if memcache:
+        return get_account_details_from_memcache(acc_path, memcache)
+    else:
+        return get_account_details_from_fs(acc_path, memcache)
+
+
+
+def get_etag(path):
+    etag = None
+    if os.path.exists(path):
+        etag = md5()
+        if not os.path.isdir(path):
+            fp = open(path, 'rb')
+            if fp:
+                while True:
+                    chunk = fp.read(CHUNK_SIZE)
+                    if chunk:
+                        etag.update(chunk)
+                    else:
+                        break
+                fp.close()
+
+        etag = etag.hexdigest()
+
+    return etag
+
+
+def get_object_metadata(obj_path):
+    """
+    Return metadata of object.
+    """
+    metadata = {}
+    if os.path.exists(obj_path):
+        if not os.path.isdir(obj_path):
+            metadata = {
+                    X_TIMESTAMP: normalize_timestamp(os.path.getctime(obj_path)),
+                    X_CONTENT_TYPE: FILE_TYPE,
+                    X_ETAG: get_etag(obj_path),
+                    X_CONTENT_LENGTH: os.path.getsize(obj_path),
+                    X_TYPE: OBJECT,
+                    X_OBJECT_TYPE: FILE,
+                }
+        else:
+            metadata = {
+                    X_TIMESTAMP: normalize_timestamp(os.path.getctime(obj_path)),
+                    X_CONTENT_TYPE: DIR_TYPE,
+                    X_ETAG: get_etag(obj_path),
+                    X_CONTENT_LENGTH: 0,
+                    X_TYPE: OBJECT,
+                    X_OBJECT_TYPE: DIR,
+                }
+
+    return metadata
+
+def get_container_metadata(cont_path, memcache=None):
+    objects = []
+    object_count = 0
+    bytes_used = 0
+    objects, object_count, bytes_used = get_container_details(cont_path,
+                                                              memcache=memcache)
+    metadata = {X_TYPE: CONTAINER,
+                X_TIMESTAMP: normalize_timestamp(os.path.getctime(cont_path)),
+                X_PUT_TIMESTAMP: normalize_timestamp(os.path.getmtime(cont_path)),
+                X_OBJECTS_COUNT: object_count,
+                X_BYTES_USED: bytes_used}
+    return metadata
+
+def get_account_metadata(acc_path, memcache=None):
+    containers = []
+    container_count = 0
+    containers, container_count = get_account_details(acc_path, memcache)
+    metadata = {X_TYPE: ACCOUNT,
+                X_TIMESTAMP: normalize_timestamp(os.path.getctime(acc_path)),
+                X_PUT_TIMESTAMP: normalize_timestamp(os.path.getmtime(acc_path)),
+                X_OBJECTS_COUNT: 0,
+                X_BYTES_USED: 0,
+                X_CONTAINER_COUNT: container_count}
+    return metadata
+
+def restore_object(obj_path, metadata):
+    meta = read_metadata(obj_path)
+    if meta:
+        meta.update(metadata)
+        write_metadata(obj_path, meta)
+    else:
+        write_metadata(obj_path, metadata)
+
+def restore_container(cont_path, metadata):
+    meta = read_metadata(cont_path)
+    if meta:
+        meta.update(metadata)
+        write_metadata(cont_path, meta)
+    else:
+        write_metadata(cont_path, metadata)
+
+def restore_account(acc_path, metadata):
+    meta = read_metadata(acc_path)
+    if meta:
+        meta.update(metadata)
+        write_metadata(acc_path, meta)
+    else:
+        write_metadata(acc_path, metadata)
+
+def create_object_metadata(obj_path):
+    meta = get_object_metadata(obj_path)
+    restore_object(obj_path, meta)
+    return meta
+
+def create_container_metadata(cont_path, memcache=None):
+    meta = get_container_metadata(cont_path, memcache)
+    restore_container(cont_path, meta)
+    return meta
+
+def create_account_metadata(acc_path, memcache=None):
+    meta = get_account_metadata(acc_path, memcache)
+    restore_account(acc_path, meta)
+    return meta
+
+
+def check_account_exists(account, fs_object):
+    if account not in get_account_list(fs_object):
+        logging.error('Account not exists %s' % account)
+        return False
+    else:
+        return True
+
+def get_account_list(fs_object):
+    account_list = []
+    if fs_object:
+        account_list = fs_object.get_export_list()
+    return account_list
+
+
+def get_account_id(account):
+    return RESELLER_PREFIX + md5(account + HASH_PATH_SUFFIX).hexdigest()
+