Adding EPL version of configurationengine.
#
# 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