FCL/sftools/depl/swconfigmdw: comparison configurationengine/source/cone/storage/webstorage.py

equal deleted inserted replaced

-:87cfa131b535
+:e7e0ae78773e
 import urllib, urllib2
 import simplejson
 import posixpath
 from cone.public import *
-from cone.carbon import persistentjson, model
+from cone.carbon import persistentjson, model, resourcemapper
 from cone.storage import authenticate
 class WebStorage(api.Storage):
 """
 A general base class for all storage type classes
 """
 # Test the path, whether it is a featurelist or configuration
 try:
 object_type = object.meta.get('type')
 except (TypeError,AttributeError):
-logging.getLogger('cone').error('Cannot dump configuration %s to webstorage without a type.' % path)
+logging.getLogger('cone').info('Cannot dump configuration %s to webstorage without a type.' % path)
 return False
-carbonpath = persistentjson.CarbonResourceMapper().map_confml_resource(object_type, path)
+carbonpath = resourcemapper.CarbonResourceMapper().map_confml_resource(object_type, path)
 if object_type == 'featurelist':
 # Create a featurelist
 success = self.extapi.create_featurelist(carbonpath, object)
 if success:
 self.resource_cache.add_resource_link(path, carbonpath)
 solution to link Configuration project concepts to Carbon storage
 """
 if not self._resource_cache:
 self._resource_cache = ResourceCache()
-reslist = self.extapi.list_resources("/", True)
+try:
+reslist = self.extapi.list_resources("/", True)
+except urllib2.HTTPError, e:
+print e
+return []
 # Append all resources to resource cache
 for res in reslist:
 self._resource_cache.add_resource(res)
 #                    if isinstance(res, model.ConfigurationResource):
 #                        self._resource_cache.add_configuration(res)
 #                    elif isinstance(res, model.FeatureListResource):
 #                        self._resource_cache.add_featurelist(res)
 return self._resource_cache
-def list_resources(self,path, recurse=False, empty_folders=False):
+def list_resources(self,path, **kwargs):
 """
 find the resources under certain path/path
 @param path : reference to path where resources are searched
 @param recurse : defines whether to return resources directly under the path or does the listing recurse to subfolders.
 Default value is False. Set to True to enable recursion.
 @param empty_folders: parameters that defined whether empty folders are included. This parameter is ignored
 in WebStorage.
 """
-return self.resource_cache.list_resources(path,recurse)
+return self.resource_cache.list_resources(path, kwargs.get('recurse', False))
 def open_resource(self,path,mode="r"):
 path = utils.resourceref.remove_begin_slash(path)
 if self.resource_cache.get_resource_object(path):
 return res
 except KeyError:
 raise exceptions.NotResource("The given resource is not found %s" % path)
 def is_resource(self,path):
-return self.resource_cache.is_resource(path)
+ret= self.resource_cache.is_resource(path)
+if not ret:
+try:
+mapped = self.resource_cache.get_mapped_resource(path)
+ret = self.extapi.is_resource(mapped)
+except Exception:
+pass
+return ret
 #        path = path.replace(".confml", ".configuration")
 #        path = utils.resourceref.join_refs([self.get_current_path(), path])
 #        try:
 #            query = urllib.quote(self._get_action_url('is_resource', path))
 #            self.conn.request("GET", query)
 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:
 if self.resource_cache.get_resource_link(path):
 path = self.resource_cache.get_resource_link(path)
+elif self.is_resource(path):
+path = self.resource_cache.get_mapped_resource(path)
 else:
 """ otherwise create the new resource first before update"""
 if self._create_resource(path, object):
 path = self.resource_cache.get_resource_link(path)
 else:
 # Creation failed
-logging.getLogger('cone').error('Creation of %s resource failed' % path)
+logging.getLogger('cone').info('Creation of %s resource failed' % path)
 return
 data = persistentjson.dumps(object)
 self.extapi.update_resource(path, data)
 else:
 raise exceptions.StorageException("Cannot dump object to readonly storage")
 return
 def load(self, path):
 """
 Load resource from a path.
 """
 pathelems = path.split('/',1)
 self.server_path = pathelems[0]
 if len(pathelems) > 1:
 self.service_path = pathelems[1]
 self._username = kwargs.get('username', None)
 self._password = kwargs.get('password', None)
 authhandler = authenticate.CarbonAuthHandler()
-authhandler.add_password(self.username, self.password)
+authhandler.add_username_func(self.get_username)
+authhandler.add_password_func(self.get_password)
 self.conn = urllib2.build_opener(urllib2.HTTPCookieProcessor, authhandler, urllib2.ProxyHandler({}))
-@property
+def get_username(self):
-def username(self):
 if self._username == None:
 self._username = getpass.getuser()
 return self._username
-@property
+def get_password(self):
-def password(self):
 if self._password == None:
-self._password = getpass.getpass()
+self._password = getpass.getpass("Password (%s):" % self._username)
 return self._password
 def checklogin(self):
 """
 Checks that we are logged in by loading the main page.
 query = self._get_action_url('list_resources', path)
 req = urllib2.Request(query)
 resp = self.conn.open(req)
 if resp.code == httplib.OK:
 bytes = resp.read()
-reslist = simplejson.loads(bytes)
+if bytes:
-return reslist.get('resources',[])
+reslist = simplejson.loads(bytes)
+return reslist.get('resources',[])
 else:
 return []
 except exceptions.NotFound:
 return []
+def is_resource(self, path):
+try:
+query = self._get_action_url('is_resource', path)
+req = urllib2.Request(query)
+resp = self.conn.open(req)
+if resp.code == httplib.OK:
+reader = persistentjson.HasResourceReader()
+ret = resp.read()
+return reader.loads(ret)
+else:
+return False
+except exceptions.NotFound:
+return False
 def update_resource(self, path, data):
 """
 Update a resource to carbon. The resource can be a CarbonConfiguration or FeatureList object.
 @param object: The object which is dumped to dict with persistentjson and then updated to server.
 """
 respdata = simplejson.loads(bytes)
 success = respdata.get('success') == True
 if success:
 logging.getLogger('cone').info('Carbon update succeeds to path %s.' % (respdata.get('path')))
 else:
-logging.getLogger('cone').error('Carbon update %s failed %s' % (path,respdata.get('errors')))
+logging.getLogger('cone').error('Carbon update %s failed!' % (path))
+if respdata.get('errors'):
+formatted_err = ""
+for error in respdata.get('errors'):
+formatted_err += "%s: %s\n" % (error,respdata.get('errors')[error])
+logging.getLogger('cone').info('Carbon update to path %s returned %s' % (respdata.get('path'),formatted_err))
 return success
 else:
 logging.getLogger('cone').error('Carbon update %s failed %s: %s' % (path,resp.code, resp))
 return False
 except urllib2.HTTPError,e:
 def add_resource(self, resourcepath):
 """
 Add a resource
 """
-confmlpath = persistentjson.CarbonResourceMapper().map_carbon_resource(resourcepath)
+confmlpath = resourcemapper.CarbonResourceMapper().map_carbon_resource(resourcepath)
 self._cache[confmlpath] = resourcepath
 def list_resources(self, path, recurse=False):
 """
 List ConE resources under certain path
 object_type = 'featurelist'
 elif path.endswith('/root.confml'):
 object_type = 'configurationlayer'
 else:
 object_type = 'configurationroot'
-carbonpath = persistentjson.CarbonResourceMapper().map_confml_resource(object_type, path)
+carbonpath = resourcemapper.CarbonResourceMapper().map_confml_resource(object_type, path)
 return carbonpath
 def add_resource_link(self,link, path):
 """
 Add a actual Carbon resource link. The link is the key which returns path when asked from get_resource_link.

changeset 3	e7e0ae78773e
parent 0	2e8eeb919028