diff -r 000000000000 -r 2e8eeb919028 configurationengine/source/cone/storage/filestorage.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/configurationengine/source/cone/storage/filestorage.py Thu Mar 11 17:04:37 2010 +0200 @@ -0,0 +1,350 @@ +# +# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +# All rights reserved. +# This component and the accompanying materials are made available +# under the terms of "Eclipse Public License v1.0" +# which accompanies this distribution, and is available +# at the URL "http://www.eclipse.org/legal/epl-v10.html". +# +# Initial Contributors: +# Nokia Corporation - initial contribution. +# +# Contributors: +# +# Description: +# + +import os +import re +import logging +import xml.parsers.expat +try: + from cElementTree import ElementTree +except ImportError: + try: + from elementtree import ElementTree + except ImportError: + try: + from xml.etree import cElementTree as ElementTree + except ImpotError: + from xml.etree import ElementTree + +from cone.public import exceptions +from cone.public import api, utils +#from cone.storage.configurationpersistence import ConfigurationReader, ConfigurationWriter +from cone.storage import metadata, common +from cone.confml import persistentconfml +debug = 0 + +class FileStorage(common.StorageBase): + """ + A file system based implementation for Storage. + @param path : path to the storage folder + @param mode: the mode for the folder. Default is a=append that expects the folder to exist. + """ + + def __init__(self,path,mode="r", **kwargs): + super(FileStorage, self).__init__(path) + self.logger = logging.getLogger('cone') + self.logger.debug("FileStorage path %s" % self.get_path()) + self.persistentmodule = persistentconfml + self.mode = mode + if mode.find("a")!=-1 or mode.find("r")!=-1: + # check that the given folder exists and is a folder + if not os.path.isdir(self.get_path()): + raise exceptions.StorageException("The given data folder for storage does not exist! %s" % self.get_path()) + elif mode.find("w")!=-1: + # check if the given folder exists and create it if it does not + if not os.path.exists(os.path.abspath(self.get_path())): + os.makedirs(self.get_path()) + else: + raise exceptions.StorageException("Unsupported creation mode given! %s" % mode) + + + + @classmethod + def supported_storage(cls,path): + """ + Class method for determing if the given clas supports a storage by given path. + E.g. foo.zip, foo.cpd, foo/bar, http://foo.com/ + @param path: + @return: Boolean value. True if the storage of the path is supported. False if not. + """ + if path.startswith('http://'): + return False + path = os.path.abspath(path) + (name,ext) = os.path.splitext(path) + if path != "" and ext == "": + return True + elif os.path.isdir(path): + return True + else: + return False + + def open_resource(self,path,mode="r"): + # make sure that path exists if we are creating a file + path = utils.resourceref.remove_end_slash(path) + path = utils.resourceref.remove_begin_slash(path) + path = utils.resourceref.join_refs([self.get_current_path(), path]) + fullpath = utils.resourceref.join_refs([self.get_path(),path]) + if mode.find("w") != -1: + dirpath = os.path.dirname(fullpath) + if not os.path.exists(dirpath): + os.makedirs(dirpath) + try: + res = FileResource(self,path,mode,open(fullpath,mode)) + self.__opened__(res) + return res + except IOError,e: + raise exceptions.NotResource("%s, %s" % (path,e) ) + + def delete_resource(self,path): + if self.is_resource(path): + try: + path = utils.resourceref.remove_begin_slash(path) + path = utils.resourceref.join_refs([self.get_path(),self.get_current_path(),path]) + for res in self.__get_open__(path): + res.close() + self.__closed__(res) + os.unlink(path) + except IOError: + raise exceptions.NotResource(path) + else: + raise exceptions.NotResource(path) + + def close_resource(self, res): + """ + Close the given resource instance. Normally this is called by the Resource object + in its own close. + @param res: the resource object to close. + """ + try: + self.__closed__(res) + #if not res.get_mode() == api.Storage.MODE_READ: + # self._get(utils.resourceref.to_dref(res.path)).data = res.getvalue() + except KeyError,e: + raise exceptions.StorageException("No such %s open resource! %s" % (res.path,e)) + + + def save_resource(self, res): + """ + Flush the changes of a given resource instance. Normally this is called by the Resource object + in its own save. + @param res: the resource to the resource to save. + """ + if not self.__has_resource__(res): + raise exceptions.NotResource("No such %s open resource!" % res.path) + else: + res.save() + + def is_resource(self,path): + path = utils.resourceref.remove_begin_slash(path) + path = utils.resourceref.join_refs([self.get_current_path(), path]) + path = utils.resourceref.join_refs([self.get_path(),path]) + norm_path = os.path.normpath(path) + return os.path.isfile(norm_path) + + def fix_entry(self,entry,current_root): + entry = entry.replace(current_root,'') + entry = entry.replace("\\","/") + entry = utils.resourceref.remove_begin_slash(entry) + return entry + + + def list_resources(self,path,recurse=False,empty_folders=False): + """ + Get an array of files in a folder + """ + + retarray = [] + path = utils.resourceref.remove_begin_slash(path) + fullpath = utils.resourceref.join_refs([self.get_path(),self.get_current_path(),path]) + joined = os.path.join(self.get_path(), self.get_current_path()) + current_root = os.path.normpath(os.path.abspath(joined)) + # return always unix type file paths + if recurse: + # Walk through all files in the layer + for root, dirs, files in os.walk(fullpath): + for name in files: + entry = os.path.join(root, name) + entry = os.path.normpath(os.path.abspath(entry)) + if os.path.isfile(entry): + retarray.append(self.fix_entry(entry,current_root)) + + if empty_folders: + for name in dirs: + entry = os.path.join(root, name) + entry = os.path.normpath(os.path.abspath(entry)) + if os.path.isdir(entry) and len(os.listdir(entry)) ==0: + retarray.append(self.fix_entry(entry,current_root)) + + else: + filelist = os.listdir(fullpath) + for name in filelist: + entry = os.path.join(path, name) + entry = os.path.normpath(entry) + entry = entry.replace("\\","/") + entry = utils.resourceref.remove_begin_slash(entry) + # ignore non file entries + fileentry = os.path.join(current_root,entry) + if os.path.isfile(fileentry): + if debug: print "list_resources adding %s" % entry + retarray.append(entry) + + if os.path.isdir(fileentry) and empty_folders: + if debug: print "list_resources adding %s" % entry + retarray.append(entry) + return retarray + + def import_resources(self,paths,storage): + for path in paths: + if not storage.is_resource(path): + logging.getLogger('cone').warning("The given path is not a Resource in the storage %s! Ignoring from export!" % path) + continue + wres = self.open_resource(path,'wb') + res = storage.open_resource(path,"rb") + wres.write(res.read()) + wres.close() + res.close() + + def export_resources(self,paths,storage,empty_folders=False): + """ + + + """ + for path in paths: + if not self.is_resource(path) and empty_folders==False: + logging.getLogger('cone').warning("The given path is not a Resource in this storage %s! Ignoring from export!" % path) + continue + if self.is_resource(path): + wres = storage.open_resource(path,'wb') + res = self.open_resource(path,"rb") + wres.write(res.read()) + wres.close() + res.close() + + + if self.is_folder(path) and empty_folders: + storage.create_folder(path) + + + + + def create_folder(self,path): + """ + Create a folder entry to a path + @param path : path to the folder + """ + + path = utils.resourceref.join_refs([self.get_path(), self.get_current_path(), path]) + if not os.path.exists(path): + os.makedirs(path) + + def delete_folder(self,path): + """ + Delete a folder entry from a path. The path must be empty. + @param path : path to the folder + """ + path = utils.resourceref.join_refs([self.get_path(), self.get_current_path(), path]) + if os.path.isdir(path): + os.rmdir(path) + else: + raise exceptions.StorageException("Not a folder %s" % path) + + def is_folder(self,path): + """ + Check if the given path is an existing folder in the storage + @param path : path to the folder + """ + path = utils.resourceref.join_refs([self.get_path(), self.get_current_path(), path]) + return os.path.isdir(path) + + def unload(self, path, object): + """ + Dump a given object to the storage (reference is fetched from the object) + @param object: The object to dump to the storage, which is expected to be an instance + of Base class. + """ + # Add the current path in front of the given path + path = utils.resourceref.join_refs([self.get_current_path(), path]) + if not isinstance(object, api.Configuration): + raise exceptions.StorageException("Cannot dump object type %s" % object.__class__) + # Skip the unload storing to storage if the storage is opened in read mode + if self.get_mode(self.mode) != api.Storage.MODE_READ: + res = self.open_resource(path,"wb") + data = self.persistentmodule.dumps(object) + res.write(data) + res.close() + return + + + def load(self, path): + """ + Load an from a reference. + """ + # Add the current path in front of the given path + path = utils.resourceref.join_refs([self.get_current_path(), path]) + if not utils.resourceref.get_ext(path) == "confml": + raise exceptions.StorageException("Cannot load reference type %s" % utils.resourceref.get_ext(path)) + if self.is_resource(path): + res = self.open_resource(path,"r") + # read the resource with persistentmodule + try: + obj = self.persistentmodule.loads(res.read()) + #obj.set_path(path) + res.close() + return obj + except exceptions.ParseError,e: + logging.getLogger('cone').error("Resource %s parsing failed with exception: %s" % (path,e)) + # returning an empty config in case of xml parsing failure. + return api.Configuration(path) + else: + raise exceptions.NotResource("No such %s resource!" % path) + + +class FileResource(api.Resource): + def __init__(self,storage,path,mode,handle): + api.Resource.__init__(self,storage,path,mode) + self.handle = handle + + def read(self,bytes=0): + if bytes == 0: + return self.handle.read() + else: + return self.handle.read(bytes) + + def write(self,string): + if self.get_mode() == api.Storage.MODE_READ: + raise exceptions.StorageException("Writing attempted to %s in read-only mode." % self.path) + else: + self.handle.write(string) + + def truncate(self, size=0): + self.handle.truncate(0) + self.handle.seek(size, 0) + + def save(self): + if not self.handle.closed: + self.handle.save() + + def close(self): + self.storage.close_resource(self) + self.handle.close() + + def get_size(self): + if self.get_mode() == api.Storage.MODE_WRITE: + raise exceptions.StorageException("Reading size attempted to %s in write-only mode." % self.path) + orig_pos = self.handle.tell() + self.handle.seek(0, os.SEEK_END) + try: return self.handle.tell() + finally: self.handle.seek(orig_pos, os.SEEK_SET) + + def get_content_info(self): + orig_pos = self.handle.tell() + self.handle.seek(0, os.SEEK_SET) + data = self.handle.read() + self.handle.seek(orig_pos, os.SEEK_SET) + if self.content_info == None: + self.content_info = utils.make_content_info(self, data) + + return self.content_info