src/python/dm/cat_web_service/service/catWebServiceRouteMapper.py

+#!/usr/bin/env python
+
+#
+# Route mapper for DM CAT web service.
+#
+
+import sys
+import os
+
+import cherrypy
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from dm.common.service.loginRouteDescriptor import LoginRouteDescriptor
+from fileRouteDescriptor import FileRouteDescriptor
+from datasetRouteDescriptor import DatasetRouteDescriptor
+
+class CatWebServiceRouteMapper:
+
+    @classmethod
+    def setupRoutes(cls):
+        """ Setup RESTFul routes. """
+        logger = LoggingManager.getInstance().getLogger(cls.__name__)
+        contextRoot = ConfigurationManager.getInstance().getContextRoot()
+        logger.debug('Using context root: %s' % contextRoot)
+
+        # Get routes.
+        routes = LoginRouteDescriptor.getRoutes() 
+        routes += FileRouteDescriptor.getRoutes()
+        routes += DatasetRouteDescriptor.getRoutes()
+
+        # Add routes to dispatcher. 
+        d = cherrypy.dispatch.RoutesDispatcher()
+        for route in routes:
+            logger.debug('Connecting route: %s' % route)
+            d.connect(route['name'], route['path'], action=route['action'], controller=route['controller'], conditions=dict(method=route['method']))
+        return d
+
+

src/python/dm/cat_web_service/service/datasetRouteDescriptor.py

+#!/usr/bin/env python
+
+#
+# Dataset route descriptor.
+#
+
+from dm.common.utility.configurationManager import ConfigurationManager
+from datasetSessionController import DatasetSessionController
+
+class DatasetRouteDescriptor:
+
+    @classmethod
+    def getRoutes(cls):
+        contextRoot = ConfigurationManager.getInstance().getContextRoot()
+
+        # Static instances shared between different routes
+        datasetSessionController = DatasetSessionController()
+
+        # Define routes.
+        routes = [
+
+            # Add experiment dataset
+            {
+                'name' : 'addExperimentDataset',
+                'path' : '%s/datasetsByExperiment/:(experimentName)/:(datasetName)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'addExperimentDataset',
+                'method' : ['POST']
+            },
+
+            # Update dataset by id
+            {
+                'name' : 'updateDatasetById',
+                'path' : '%s/datasets/:(id)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'updateDatasetById',
+                'method' : ['PUT']
+            },
+
+            # Update experiment dataset by name
+            {
+                'name' : 'updateExperimentDataset',
+                'path' : '%s/datasetsByExperiment/:(experimentName)/:(datasetName)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'updateExperimentDataset',
+                'method' : ['PUT']
+            },
+
+            # Get dataset info list
+            {
+                'name' : 'getDatasets',
+                'path' : '%s/datasets' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'getDatasets',
+                'method' : ['GET']
+            },
+
+            # Get experiment dataset info list 
+            {
+                'name' : 'getExperimentDatasets',
+                'path' : '%s/datasetsByExperiment/:(experimentName)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'getExperimentDatasets',
+                'method' : ['GET']
+            },
+
+            # Get dataset by id
+            {
+                'name' : 'getDatasetById',
+                'path' : '%s/datasets/:(id)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'getDatasetById',
+                'method' : ['GET']
+            },
+
+            # Get experiment dataset by name
+            {
+                'name' : 'getExperimentDataset',
+                'path' : '%s/datasetsByExperiment/:(experimentName)/:(datasetName)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'getExperimentDataset',
+                'method' : ['GET']
+            },
+
+            # Get experiment dataset files
+            {
+                'name' : 'getExperimentDatasetFiles',
+                'path' : '%s/filesByExperimentDataset/:(experimentName)/:(datasetName)' % contextRoot,
+                'controller' : datasetSessionController,
+                'action' : 'getExperimentDatasetFiles',
+                'method' : ['GET']
+            },
+
+
+        ]
+       
+        return routes
+
+

src/python/dm/cat_web_service/service/datasetSessionController.py

+#!/usr/bin/env python
+
+import cherrypy
+import json
+from dm.common.utility.encoder import Encoder
+from dm.common.service.dmSessionController import DmSessionController
+from dm.cat_web_service.service.impl.datasetSessionControllerImpl import DatasetSessionControllerImpl
+
+class DatasetSessionController(DmSessionController):
+
+    def __init__(self):
+        DmSessionController.__init__(self)
+        self.datasetSessionControllerImpl = DatasetSessionControllerImpl()
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def addExperimentDataset(self, experimentName, datasetName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not datasetName:
+            raise InvalidRequest('Invalid dataset name provided.')
+        encodedDatasetInfo = kwargs.get('datasetInfo')
+        if not encodedDatasetInfo:
+            raise InvalidRequest('Invalid dataset info provided.')
+        datasetInfo = json.loads(Encoder.decode(encodedDatasetInfo))
+        datasetInfo['datasetName'] = datasetName
+        datasetInfo['experimentName'] = experimentName
+        response = self.datasetSessionControllerImpl.addExperimentDataset(datasetInfo).getFullJsonRep()
+        self.logger.debug('Added dataset %s: %s' % (datasetName,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def updateExperimentDataset(self, experimentName, datasetName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not datasetName:
+            raise InvalidRequest('Invalid dataset name provided.')
+        encodedDatasetInfo = kwargs.get('datasetInfo')
+        if not encodedDatasetInfo:
+            raise InvalidRequest('Invalid dataset info provided.')
+        datasetInfo = json.loads(Encoder.decode(encodedDatasetInfo))
+        datasetInfo['datasetName'] = datasetName
+        datasetInfo['experimentName'] = experimentName
+        response = self.datasetSessionControllerImpl.updateExperimentDataset(datasetInfo).getFullJsonRep()
+        self.logger.debug('Updated dataset %s: %s' % (datasetName,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def updateDatasetById(self, id, **kwargs):
+        if not id:
+            raise InvalidRequest('Invalid dataset id provided.')
+        encodedDatasetInfo = kwargs.get('datasetInfo')
+        if not encodedDatasetInfo:
+            raise InvalidRequest('Invalid dataset info provided.')
+        datasetInfo = json.loads(Encoder.decode(encodedDatasetInfo))
+        response = self.datasetSessionControllerImpl.updateDatasetById(datasetInfo).getFullJsonRep()
+        self.logger.debug('Updated dataset id %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getDatasets(self, **kwargs):
+        encodedQueryDict = kwargs.get('queryDict')
+        queryDict = {}
+        if encodedQueryDict:
+            queryDict = json.loads(Encoder.decode(encodedQueryDict))
+        return self.listToJson(self.datasetSessionControllerImpl.getDatasets(queryDict=queryDict))
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getExperimentDatasets(self, experimentName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        encodedQueryDict = kwargs.get('queryDict')
+        queryDict = {}
+        if encodedQueryDict:
+            queryDict = json.loads(Encoder.decode(encodedQueryDict))
+        return self.listToJson(self.datasetSessionControllerImpl.getExperimentDatasets(experimentName, queryDict=queryDict))
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getDatasetById(self, id, **kwargs):
+        if not id:
+            raise InvalidRequest('Invalid id provided.')
+        response = self.datasetSessionControllerImpl.getDatasetById(id).getFullJsonRep()
+        self.logger.debug('Returning dataset id %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getExperimentDataset(self, experimentName, datasetName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not datasetName:
+            raise InvalidRequest('Invalid dataset name provided.')
+        response = self.datasetSessionControllerImpl.getExperimentDataset(experimentName, datasetName).getFullJsonRep()
+        self.logger.debug('Returning dataset %s: %s' % (datasetName,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getExperimentDatasetFiles(self, experimentName, datasetName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not datasetName:
+            raise InvalidRequest('Invalid dataset name provided.')
+        response = self.listToJson(self.datasetSessionControllerImpl.getExperimentDatasetFiles(experimentName, datasetName))
+        return response
+

src/python/dm/cat_web_service/service/fileRouteDescriptor.py

+#!/usr/bin/env python
+
+#
+# File route descriptor.
+#
+
+from dm.common.utility.configurationManager import ConfigurationManager
+from fileSessionController import FileSessionController
+
+class FileRouteDescriptor:
+
+    @classmethod
+    def getRoutes(cls):
+        contextRoot = ConfigurationManager.getInstance().getContextRoot()
+
+        # Static instances shared between different routes
+        fileSessionController = FileSessionController()
+
+        # Define routes.
+        routes = [
+
+            # Add experiment file
+            {
+                'name' : 'addExperimentFile',
+                'path' : '%s/filesByExperimentAndPath/:(experimentName)/:(encodedExperimentFilePath)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'addExperimentFile',
+                'method' : ['POST']
+            },
+
+            # Update experiment file by id
+            {
+                'name' : 'updateExperimentFileById',
+                'path' : '%s/filesByExperimentAndId/:(experimentName)/:(id)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'updateExperimentFileById',
+                'method' : ['PUT']
+            },
+
+            # Update experiment file by name
+            {
+                'name' : 'updateExperimentFile',
+                'path' : '%s/filesByExperimentAndPath/:(experimentName)/:(encodedExperimentFilePath)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'updateExperimentFile',
+                'method' : ['PUT']
+            },
+
+            # Get experiment file info list 
+            {
+                'name' : 'getExperimentFiles',
+                'path' : '%s/filesByExperiment/:(experimentName)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'getExperimentFiles',
+                'method' : ['GET']
+            },
+
+            # Get experiment file by id
+            {
+                'name' : 'getExperimentFileById',
+                'path' : '%s/filesByExperimentAndId/:(experimentName)/:(id)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'getExperimentFileById',
+                'method' : ['GET']
+            },
+
+            # Get experiment file by path
+            {
+                'name' : 'getExperimentFile',
+                'path' : '%s/filesByExperimentAndPath/:(experimentName)/:(encodedExperimentFilePath)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'getExperimentFile',
+                'method' : ['GET']
+            },
+
+        ]
+       
+        return routes
+
+

src/python/dm/cat_web_service/service/fileSessionController.py

+#!/usr/bin/env python
+
+import cherrypy
+import json
+from dm.common.utility.encoder import Encoder
+from dm.common.service.dmSessionController import DmSessionController
+from dm.cat_web_service.service.impl.fileSessionControllerImpl import FileSessionControllerImpl
+
+class FileSessionController(DmSessionController):
+
+    def __init__(self):
+        DmSessionController.__init__(self)
+        self.fileSessionControllerImpl = FileSessionControllerImpl()
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def addExperimentFile(self, experimentName, encodedExperimentFilePath, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        experimentFilePath = Encoder.decode(encodedExperimentFilePath)
+        if not experimentFilePath:
+            raise InvalidRequest('Invalid experiment file path provided.')
+        encodedFileInfo = kwargs.get('fileInfo')
+        if not encodedFileInfo:
+            raise InvalidRequest('Invalid file info provided.')
+        fileInfo = json.loads(Encoder.decode(encodedFileInfo))
+        fileInfo['experimentFilePath'] = experimentFilePath
+        fileInfo['experimentName'] = experimentName
+        response = self.fileSessionControllerImpl.addExperimentFile(fileInfo).getFullJsonRep()
+        self.logger.debug('Added file %s: %s' % (experimentFilePath,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def updateExperimentFile(self, experimentName, encodedExperimentFilePath, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        experimentFilePath = Encoder.decode(encodedExperimentFilePath)
+        if not experimentFilePath:
+            raise InvalidRequest('Invalid experiment file path provided.')
+        encodedFileInfo = kwargs.get('fileInfo')
+        if not encodedFileInfo:
+            raise InvalidRequest('Invalid file info provided.')
+        fileInfo = json.loads(Encoder.decode(encodedFileInfo))
+        fileInfo['experimentFilePath'] = experimentFilePath
+        fileInfo['experimentName'] = experimentName
+        response = self.fileSessionControllerImpl.updateExperimentFile(fileInfo).getFullJsonRep()
+        self.logger.debug('Updated file %s: %s' % (experimentFilePath,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def updateExperimentFileById(self, expermentName, id, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not id:
+            raise InvalidRequest('Invalid file id provided.')
+        encodedFileInfo = kwargs.get('fileInfo')
+        if not encodedFileInfo:
+            raise InvalidRequest('Invalid file info provided.')
+        fileInfo = json.loads(Encoder.decode(encodedFileInfo))
+        fileInfo['experimentName'] = experimentName
+        response = self.fileSessionControllerImpl.updateExperimentFileById(fileInfo).getFullJsonRep()
+        self.logger.debug('Updated file id %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getExperimentFiles(self, experimentName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        encodedQueryDict = kwargs.get('queryDict')
+        queryDict = {}
+        if encodedQueryDict:
+            queryDict = json.loads(Encoder.decode(encodedQueryDict))
+        return self.listToJson(self.fileSessionControllerImpl.getExperimentFiles(experimentName, queryDict=queryDict))
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getExperimentFileById(self, experimentName, id, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not id:
+            raise InvalidRequest('Invalid id provided.')
+        response = self.fileSessionControllerImpl.getExperimentFileById(experimentName, id).getFullJsonRep()
+        self.logger.debug('Returning file id %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.canManageStation())
+    @DmSessionController.execute
+    def getExperimentFile(self, experimentName, encodedExperimentFilePath, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        experimentFilePath = Encoder.decode(encodedExperimentFilePath)
+        if not experimentFilePath:
+            raise InvalidRequest('Invalid experiment file path provided.')
+        response = self.fileSessionControllerImpl.getExperimentFile(experimentName, experimentFilePath).getFullJsonRep()
+        self.logger.debug('Returning file %s: %s' % (experimentFilePath,response))
+        return response
+

src/python/dm/cat_web_service/service/impl/__init__.py

+__version__ = "Development Snapshot"

src/python/dm/cat_web_service/service/impl/datasetSessionControllerImpl.py

+#!/usr/bin/env python
+
+#
+# Implementation for dataset controller.
+#
+
+from dm.common.objects.dmObject import DmObject
+from dm.common.objects.dmObjectManager import DmObjectManager
+from dm.common.mongodb.api.datasetMongoDbApi import DatasetMongoDbApi
+
+class DatasetSessionControllerImpl(DmObjectManager):
+    """ Dataset controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.datasetMongoDbApi = DatasetMongoDbApi()
+
+    def addExperimentDataset(self, datasetInfo):
+        return self.datasetMongoDbApi.addExperimentDataset(datasetInfo)
+
+    def updateExperimentDataset(self, datasetInfo):
+        return self.datasetMongoDbApi.updateExperimentDataset(datasetInfo)
+
+    def updateDatasetById(self, datasetInfo):
+        return self.datasetMongoDbApi.updateDatasetById(datasetInfo)
+
+    def getDatasets(self, queryDict):
+        return self.datasetMongoDbApi.getDatasets(queryDict=queryDict)
+
+    def getExperimentDatasets(self, experimentName, queryDict):
+        return self.datasetMongoDbApi.getExperimentDatasets(experimentName, queryDict=queryDict)
+
+    def getDatasetById(self, id):
+        return self.datasetMongoDbApi.getDatasetById(id)
+
+    def getExperimentDataset(self, experimentName, datasetName):
+        return self.datasetMongoDbApi.getExperimentDataset(experimentName, datasetName)
+
+    def getExperimentDatasetFiles(self, experimentName, datasetName):
+        return self.datasetMongoDbApi.getExperimentDatasetFiles(experimentName, datasetName)
+

src/python/dm/cat_web_service/service/impl/fileSessionControllerImpl.py

+#!/usr/bin/env python
+
+#
+# Implementation for file controller.
+#
+
+from dm.common.objects.dmObject import DmObject
+from dm.common.objects.dmObjectManager import DmObjectManager
+from dm.common.mongodb.api.fileMongoDbApi import FileMongoDbApi
+
+class FileSessionControllerImpl(DmObjectManager):
+    """ File controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.fileMongoDbApi = FileMongoDbApi()
+
+    def addExperimentFile(self, fileInfo):
+        return self.fileMongoDbApi.addExperimentFile(fileInfo)
+
+    def updateExperimentFile(self, fileInfo):
+        return self.fileMongoDbApi.updateExperimentFile(fileInfo)
+
+    def updateExperimentFileById(self, fileInfo):
+        return self.fileMongoDbApi.updateExperimentFileById(fileInfo)
+
+    def getExperimentFiles(self, experimentName, queryDict):
+        return self.fileMongoDbApi.getExperimentFiles(experimentName, queryDict=queryDict)
+
+    def getExperimentFileById(self, experimentName, id):
+        return self.fileMongoDbApi.getExperimentFileById(experimentName, id)
+
+    def getExperimentFile(self, experimentName, fileName):
+        return self.fileMongoDbApi.getExperimentFile(experimentName, fileName)
+

src/python/dm/common/api/dmApi.py

+#!/usr/bin/env python
+
+import json
+from dm.common.exceptions.dmException import DmException
+from dm.common.utility.loggingManager import LoggingManager
+
+class DmApi(object):
+    """ Base dm api class. """
+    def __init__(self, username = None, password = None):
+        self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+
+    @classmethod
+    def getLogger(cls):
+        logger = LoggingManager.getInstance().getLogger(cls.__name__)
+        return logger
+
+    @classmethod
+    def toDmObjectList(cls, dictList, dmObjectClass):
+        dmObjectList = []
+        for dict in dictList:
+            dmObjectList.append(dmObjectClass(dict))
+        return dmObjectList 
+
+    # Exception decorator for all api calls
+    @classmethod
+    def execute(cls, func):
+        def decorate(*args, **kwargs):
+            try:
+                response = func(*args, **kwargs)
+                return response
+            except DmException, ex:
+                raise
+            except Exception, ex:
+                cls.getLogger().exception('%s' % ex)
+                raise DmException(exception=ex)
+        return decorate

src/python/dm/common/api/dmRestApi.py

+#!/usr/bin/env python
+
+import socket
+import json
+
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.client.sessionManager import SessionManager
+from dm.common.utility.configurationManager import ConfigurationManager 
+from dm.common.exceptions.authorizationError import AuthorizationError
+from dm.common.api.dmApi import DmApi
+
+class DmRestApi(DmApi):
+    """ Base dm REST api class. """
+
+    def __init__(self, username=None, password=None, host=None, port=None, protocol=None):
+        DmApi.__init__(self)
+        self.configurationManager = ConfigurationManager.getInstance()
+        if protocol == None:
+            protocol = self.configurationManager.getServiceProtocol()
+        self.username = username
+        self.password = password
+        self.host = host
+        self.port = port
+        self.protocol = protocol
+        self.sessionManager = None
+
+    @classmethod
+    def toJson(cls, o):
+        return json.dumps(o)
+
+    @classmethod
+    def fromJson(cls, s):
+        return json.loads(s)
+
+    def __getWebServiceUrl(self, url):
+        if url.find('://') < 0:
+            return '%s://%s:%s' % (self.protocol, socket.gethostbyname(self.host), self.port)
+
+        # Break the URL down into component pieces
+        from urlparse import urlparse
+        o = urlparse(url)
+        wsUrl = '%s://%s' % (o[0], o[1])
+        return wsUrl
+
+    def getContextRoot(self):
+        return self.configurationManager.getContextRoot()
+
+    def setUsername(self, username):
+        self.username = username
+
+    def getUsername(self):
+        return self.username
+
+    def setPassword(self, password):
+        self.password = password
+
+    def getPassword(self):
+        return self.password
+
+    def setHost(self, host):
+        self.host = host
+
+    def getHost(self):
+        return self.host
+
+    def setPort(self, port):
+        self.port = port
+
+    def getPort(self):
+        return self.port
+
+    def setProtocol(self, protocol):
+        self.protocol = protocol
+
+    def getProtocol(self):
+        return self.protocol
+
+    def getSessionManager(self):
+        if not self.sessionManager:
+            self.sessionManager = SessionManager()
+        return self.sessionManager
+
+    def getConfigManager(self):
+        return self.configurationManager
+
+    def sendSessionRequest(self, url, method, contentType='html', data={}):
+        """ Send authorized session request. """
+        sm = self.getSessionManager()
+        if not sm.hasSession():
+            #if self.username == None:
+            #    raise AuthorizationError('Username not supplied.')
+            #if self.password == None:
+            #    raise AuthorizationError('Password not supplied.')
+            wsUrl = self.__getWebServiceUrl(url)
+            # establishSession() sets the 'wsUrl' so the explicit call
+            # to setHost() is not required
+            sm.establishSession(wsUrl, self.username, self.password)
+        (response, responseData) = sm.sendSessionRequest(url, method, contentType, data)
+        return json.loads(responseData)
+
+    def sendRequest(self, url, method, contentType='html', data={}):
+        """ Send non-authorized request. """
+        sm = self.getSessionManager()
+        # Because there's no call to establishSession(), explicitly call
+        # setHost()
+        sm.setHost(self.__getWebServiceUrl(url))
+        (response, responseData) = self.getSessionManager().sendRequest(url, method, contentType, data)
+        return json.loads(responseData)
+
+#######################################################################
+# Testing.
+
+if __name__ == '__main__':
+    api = DmRestApi('sveseli', 'sveseli')
+    #api.sendRequest('https://zagreb.svdev.net:10232/dm/directory/list', 'GET', data='')
+    import urllib
+    from dm.common.utility.configurationManager import ConfigurationManager
+    cm = ConfigurationManager.getInstance()
+    cm.setSessionCacheFile('/tmp/session')
+    #print 'Non-session request'
+    #print api.sendRequest('https://zagreb.svdev.net:10232/dm/directory/list?path=/tmp', 'GET')
+    print 'Session request'
+    data = { 'path' : '/tmp/xyz' }
+    #print api.sendSessionRequest('https://zagreb.svdev.net:10232/dm/file/write?path=/tmp/xyz&content=xyz', 'POST', contentType='application/x-www-form-urlencoded', data=urllib.urlencode(data))
+    #print api.sendSessionRequest('https://zagreb.svdev.net:10232/dm/file/write', 'POST', data=data)
+    postdata='path=/tmp/xyz'
+    postdata+='&content=%s' % urllib.quote_plus('Hey there')
+    print api.sendSessionRequest('https://zagreb.svdev.net:10232/dm/file/write', 'POST', contentType='application/x-www-form-urlencoded', data=postdata)
+
+
+

src/python/dm/common/cli/dmCli.py

+#!/usr/bin/env python
+
+import sys
+import os
+import os.path
+import stat
+from optparse import OptionGroup
+
+import dm
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from dm.common.utility.osUtility import OsUtility
+from dm.common.objects.dmObject import DmObject
+from dm.common.exceptions.dmException import DmException
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.exceptions.invalidArgument import InvalidArgument
+from dm.common.exceptions.internalError import InternalError
+from dm.common.cli.dmOptionParser import DmOptionParser
+from dm.common.constants import dmStatus
+
+class DmCli(object):
+    """ Base dm command line interface class. """
+    DEFAULT_SESSION_CACHE_FILE = OsUtility.getUserHomeDir() + '/.dm/.session.cache'
+    ANY_NUMBER_OF_POSITIONAL_ARGS = 10000000
+
+    def __init__(self, validArgCount=0):
+        self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+        # Do not log into a file for CLIs
+        LoggingManager.getInstance().setFileLogLevel('CRITICAL') 
+        LoggingManager.getInstance().setConsoleLogLevel('CRITICAL') 
+        self.parser = DmOptionParser()
+        self.options = {}
+        self.args = []
+        self.validArgCount = validArgCount
+        self.optionGroupDict = {}
+
+        commonGroup = 'Common Options'
+        self.addOptionGroup(commonGroup, None)
+        self.addOptionToGroup(commonGroup, '-h', '--help', action='help', help='Show this help message and exit.')
+        self.addOptionToGroup(commonGroup, '-?', '',       action='help', help='Show this help message and exit.')
+        self.addOptionToGroup(commonGroup, '-v', '--version', action='store_true', dest='version', default=False, help='Print version and exit.')
+        self.addOptionToGroup(commonGroup, '-d', '--debug', dest='consoleLogLevel', help='Set debug level (valid values: CRITICAL, ERROR, WARNING, INFO, DEBUG). Console log level can also be set via DM_CONSOLE_LOG_LEVEL environment variable,')
+        self.addOptionToGroup(commonGroup, '', '--display-format', dest='displayFormat', default=DmObject.TEXT_DISPLAY_FORMAT, help='Display format for output objects. Possible options are: %s, %s, and %s (default: %s).' % (DmObject.TEXT_DISPLAY_FORMAT, DmObject.DICT_DISPLAY_FORMAT, DmObject.JSON_DISPLAY_FORMAT, DmObject.TEXT_DISPLAY_FORMAT)) 
+        self.addOptionToGroup(commonGroup, '', '--display-keys', dest='displayKeys', default=DmObject.DEFAULT_KEYS, help='List of output object keys to display. Possible options are: %s, %s, and string containing comma-separated keys (default: %s, represents class default keys).' % (DmObject.DEFAULT_KEYS, DmObject.ALL_KEYS, DmObject.DEFAULT_KEYS)) 
+
+    def getDefaultServiceHost(self):
+        return ConfigurationManager.getInstance().getServiceHost()
+
+    def getDefaultServicePort(self):
+        return ConfigurationManager.getInstance().getServicePort()
+
+    def getDefaultServiceProtocol(self):
+        return ConfigurationManager.getInstance().getServiceProtocol()
+
+    def getUsername(self):
+        return None
+
+    def getPassword(self):
+        return None
+
+    def getDisplayFormat(self):
+        return self.options.displayFormat
+
+    def getDisplayKeys(self):
+        return self.options.displayKeys
+
+    def getLogger(self):
+        return self.logger
+
+    def getParser(self):
+        return self.parser
+
+    def addOption(self, *args, **kwargs):
+        self.parser.add_option(*args, **kwargs)
+
+    def addOptionToGroup(self, groupName, *args, **kwargs):
+        """ Add group option. Group must be created using addOptionGroup(). """
+        group = self.optionGroupDict.get(groupName)
+        group.add_option(*args, **kwargs)
+
+    def addOptionGroup(self, groupName, desc):
+        group = OptionGroup(self.parser, groupName, desc)
+        self.parser.add_option_group(group)
+        self.optionGroupDict[groupName] = group
+
+    def processArgs(self):
+        pass
+
+    def parseArgs(self, usage=None):
+        if usage:
+            self.parser.usage = usage
+        try:
+            (self.options, self.args) = self.parser.parse_args()
+            self.processArgs()
+        except SystemExit, rc:
+            sys.stdout.flush()
+            sys.stderr.flush()
+            sys.exit(int(str(rc)))
+
+        if self.validArgCount < len(self.args):
+            # Positional args are not enabled and we have some
+            msg = 'Invalid positional argument(s):'
+            for arg in self.args[self.validArgCount:]:
+                msg += ' ' + arg
+            msg += ' (This command allows %s positional arguments.)' % self.validArgCount
+            raise InvalidArgument(msg)
+
+        optDict = self.options.__dict__
+        if optDict.get('version'):
+            print 'DM Software Version: %s' % (dm.__version__)
+            sys.exit(0)
+
+        # Logging level. First try from command line, then from env variable.
+        consoleLogLevel = optDict.get('consoleLogLevel', None)
+        if consoleLogLevel:
+            LoggingManager.getInstance().setConsoleLogLevel(consoleLogLevel)
+        else:
+            consoleLogLevel = ConfigurationManager.getInstance().getConsoleLogLevelFromEnvVar()
+            if consoleLogLevel:
+                LoggingManager.getInstance().setConsoleLogLevel(consoleLogLevel)
+
+
+        # Check session cache.
+        configManager = ConfigurationManager.getInstance()
+        try:
+            self.checkSessionCache()
+        except Exception, ex:
+            self.logger.warn('Disabling session cache: %s' % ex)
+            configManager.setSessionCacheFile(None)
+
+        return (self.options, self.args)
+
+    def checkSessionCache(self):
+        configManager = ConfigurationManager.getInstance()
+        sessionCacheFile = configManager.getSessionCacheFile()
+        if sessionCacheFile is None:
+            sessionCacheFile = DmCli.DEFAULT_SESSION_CACHE_FILE 
+        sessionCacheFile = sessionCacheFile.strip()
+        if len(sessionCacheFile):
+            sessionCacheDir = os.path.dirname(sessionCacheFile)
+            OsUtility.createDir(sessionCacheDir, stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR)
+            configManager.setSessionCacheFile(sessionCacheFile)
+            configManager.setRequireSessionCredentials(True)
+
+    def usage(self, s=None):
+        """ Print help provided by optparse. """
+        if s:
+            print >>sys.stderr, 'Error: ', s, '\n'
+        self.parser.print_help()
+        sys.exit(dmStatus.DM_ERROR)
+
+    def getOptions(self):
+        return self.options
+
+    def getNArgs(self):
+        """ Returns the number of command line arguments. """
+        return len(self.args)
+
+    def getArgs(self):
+        """ Returns the command line argument list. """
+        return self.args
+
+    def splitArgsIntoDict(self, keyValueDelimiter=':'):
+        """ Returns the command line argument list as dictionary of key/value
+        pairs. Each argument is split using specified delimiter. """
+        argDict = {}
+        for a in self.args:
+            sList = a.split(keyValueDelimiter)
+            key = sList[0]
+            value = ''
+            if len(sList) > 1:
+                value = keyValueDelimiter.join(sList[1:])
+            argDict[key] = value
+        return argDict
+
+    def getArg(self, i):
+        """ Returns the i-th command line argument. """
+        return self.args[i]
+
+    def getServiceHost(self):
+        #return self.serviceHost
+        return ConfigurationManager.getInstance().getServiceHost()
+
+    def getServicePort(self):
+        #return self.servicePort
+        return ConfigurationManager.getInstance().getServicePort()
+
+    def getServiceProtocol(self):
+        #return self.serviceProtocol
+        return ConfigurationManager.getInstance().getServiceProtocol()
+
+    def getSslCaCertFile(self):
+        return self.sslCaCertFile
+
+    def getSslCertFile(self):
+        return self.sslCertFile
+
+    def getSslKeyFile(self):
+        return self.sslKeyFile
+
+    def displayDmObject(self, dmObject):
+        if isinstance(dmObject, dmObject):
+            return '%s' % dmObject.getJsonRep()
+        else:
+            return '%s' % dmObject
+
+    def runCommand(self):
+        """ This method must be implemented by the derived class. """
+        raise InternalError('Method runCommand() must be overriden in the derived class.')
+
+    def run(self):
+        """ This method invokes runCommand() and handles any exceptions. """
+        try:
+            self.runCommand()
+        except DmException, ex:
+            self.logger.exception('%s' % ex)
+            print '%s' % ex.getErrorMessage()
+            raise SystemExit(ex.getErrorCode())
+        except SystemExit, ex:
+            raise
+        except Exception, ex:
+            self.logger.exception('%s' % ex)
+            print >>sys.stderr, '%s' % ex
+            raise SystemExit(dmStatus.DM_ERROR)
+
+    def getId(self):
+        id = self.options.id
+        if id == None:
+            raise InvalidRequest('Missing id.')
+        return id
+
+    def displayDmObject(self, dmObject):
+        optDict = self._options.__dict__
+        if isinstance(dmObject, DmObject):
+            if optDict.get('dict'):
+                 return '%s' % dmObject
+            else:
+                 return dmObject.display()
+        else:
+            return '%s' % dmObject
+
+#######################################################################
+# Testing
+
+if __name__ == '__main__':
+    cli = DmCli(3)
+    cli.addOption("-f", "--file", dest="filename", help="write report to FILE", metavar="FILE")
+    cli.addOption("-q", "--quiet", action="store_false", dest="verbose", default=True, help="don't print log messages to stdout")
+    (options, args) = cli.parseArgs()
+    print 'After parse:'
+    print 'OPTIONS: ', options
+    print 'ARGS: ', args
+    print 'From CLI'
+    print 'OPTIONS: ', cli.getOptions()
+    print 'ARGS: ', cli.getArgs()
+    print
+    print 'FILENAME'
+    print 'options.filename', options.filename
+    print 'cli.getOptions().filename', cli.getOptions().filename
+    o = cli.getOptions()
+    print 'o.filename', o.filename
+    print 'cli.getArgs()', cli.getArgs()
+    print 'len(cli.getArgs())', len(cli.getArgs())
+
+    for a in cli.getArgs():
+        print 'arg', a
+
+    first_arg = cli.getArg(0)
+    print 'first_arg', first_arg
+
+    second_arg = cli.getArg(1)
+    print 'second_arg', second_arg
+
+    try:
+        third_arg = cli.getArg(2)
+        print 'third_arg', third_arg
+    except:
+        print 'no third arg'

src/python/dm/common/cli/dmDbCli.py

+#!/usr/bin/env python
+
+from dm.common.cli.dmCli import DmCli
+from dm.common.utility.configurationManager import ConfigurationManager
+
+class DmDbCli(DmCli):
+    """ Base dm DB cli class. """
+
+    def __init__(self, validArgCount=0):
+        DmCli.__init__(self, validArgCount)
+
+

src/python/dm/common/cli/dmOptionParser.py

+#!/usr/bin/env python
+
+import sys
+from optparse import OptionParser
+from cStringIO import StringIO
+
+class DmOptionParser(OptionParser):
+    def __init__(self):
+        OptionParser.__init__(self, add_help_option=False)
+
+    def replaceKeys(self, output):
+        replacementMap = {
+            'usage:' : 'Usage:',
+            'options:' : 'Options:',
+        }
+        result = output
+        for (key, value) in replacementMap.items():
+            result = result.replace(key, value)
+        return result
+
+    def printUsage(self, file=None):
+        self.print_usage(file)
+
+    # Replaces base class method
+    def print_usage(self, file=None):
+        sysStdout = sys.stdout
+        cliStdout = StringIO()
+        sys.stdout = cliStdout
+        OptionParser.print_usage(self, file)
+        sys.stdout = sysStdout
+        print self.replaceKeys(cliStdout.getvalue())
+
+    def printHelp(self, file=None):
+        self.printHelp(file)
+
+    # Replaces base class method
+    def print_help(self, file=None):
+        sysStdout = sys.stdout
+        cliStdout = StringIO()
+        sys.stdout = cliStdout
+        OptionParser.print_help(self, file)
+        sys.stdout = sysStdout
+        print self.replaceKeys(cliStdout.getvalue())
+
+#######################################################################
+# Testing
+
+if __name__ == '__main__':
+    p = DmOptionParser()
+    p.add_option('-f', '--file', dest='filename',
+        help='write report to FILE', metavar='FILE')
+    p.add_option('-q', '--quiet',
+        action='store_false', dest='verbose', default=True,
+        help='do not print log messages to standard output')
+    p.parse_args()
+    p.print_usage()
+    p.print_help()

src/python/dm/common/cli/dmRestCli.py

+#!/usr/bin/env python
+
+from dm.common.cli.dmCli import DmCli
+from dm.common.utility.configurationManager import ConfigurationManager
+
+class DmRestCli(DmCli):
+    """ Base dm REST cli class. """
+
+    def __init__(self, validArgCount=0):
+        DmCli.__init__(self, validArgCount)
+        self.serviceHost = None
+        self.servicePort = None
+
+        serviceGroup = 'Service Options'
+        self.addOptionGroup(serviceGroup, None)
+        # These will be set via env variables
+        self.addOptionToGroup(serviceGroup, '', '--service-host', dest='serviceHost', default=self.getDefaultServiceHost(), help='Service host (default: %s, can be set via DM_SERVICE_HOST environment variable).' % self.getDefaultServiceHost())
+        self.addOptionToGroup(serviceGroup, '', '--service-port', dest='servicePort', default=self.getDefaultServicePort(), help='Service port (default: %s, can be set via DM_SERVICE_PORT environment variable).' % self.getDefaultServicePort())
+        self.addOptionToGroup(serviceGroup, '', '--service-protocol', dest='serviceProtocol', default=self.getDefaultServiceProtocol(), help='Service protocol (default: %s, can be set via DM_SERVICE_PROTOCOL environment variable).' % self.getDefaultServiceProtocol())
+
+        # SSL options, disabled for now.
+        #self.addOptionToGroup(commonGroup, '', '--ssl-key', dest='sslKeyFile', help='SSL key file (needed if service requires peer verification, can be set via DM_SSL_KEY_FILE environment variable).')
+        #self.addOptionToGroup(commonGroup, '', '--ssl-cert', dest='sslCertFile', help='SSL certificate file (needed if service requires peer verification, can be set via DM_SSL_CERT_FILE environment variable).')
+        #self.addOptionToGroup(commonGroup, '', '--ssl-ca-cert', dest='sslCaCertFile', help='SSL CA certificate file (needed if client requires peer verification, can be set via DM_SSL_CA_CERT_FILE environment variable).')
+        
+    def getDefaultServiceHost(self):
+        return ConfigurationManager.getInstance().getServiceHost()
+
+    def getDefaultServicePort(self):
+        return ConfigurationManager.getInstance().getServicePort()
+
+    def getDefaultServiceProtocol(self):
+        return ConfigurationManager.getInstance().getWebServiceProtocol()
+
+    def parseArgs(self, usage=None):
+        DmCli.parseArgs(self, usage)
+        configManager = ConfigurationManager.getInstance()
+        self.serviceHost = self.options.serviceHost
+        configManager.setServiceHost(self.serviceHost)
+        self.servicePort = self.options.servicePort
+        configManager.setServicePort(self.servicePort)
+        self.serviceProtocol = self.options.serviceProtocol
+        configManager.setServiceProtocol(self.serviceProtocol)
+
+        # SSL options, comment out for now
+        #self.sslCaCertFile = self.options.sslCaCertFile
+        #if self.sslCaCertFile:
+        #    configManager.setSslCaCertFile(self.sslCaCertFile)
+        #self.sslCertFile = self.options.sslCertFile
+        #if self.sslCertFile:
+        #    configManager.setSslCertFile(self.sslCertFile)
+        #self.sslKeyFile = self.options.sslKeyFile
+        #if self.sslKeyFile:
+        #    configManager.setSslKeyFile(self._sslKeyFile)
+

src/python/dm/common/cli/dmRestSessionCli.py

+#!/usr/bin/env python
+
+from dm.common.cli.dmRestCli import DmRestCli
+from dm.common.utility.configurationManager import ConfigurationManager
+
+class DmRestSessionCli(DmRestCli):
+    """ Base dm session cli class. """
+
+    def __init__(self, validArgCount=0):
+        DmRestCli.__init__(self, validArgCount)
+        self.username = None
+        self.password = None
+
+        loginGroup = 'Login Options'
+        self.addOptionGroup(loginGroup, None)
+        self.addOptionToGroup(loginGroup, '', '--login-username', dest='loginUsername', help='Login username.')
+        self.addOptionToGroup(loginGroup, '', '--login-password', dest='loginPassword', help='Login password.')
+        self.addOptionToGroup(loginGroup, '', '--login-file', dest='loginFile', help='Login file, contains "<login username>|<login password>" pair. It can be specified using DM_LOGIN_FILE environment variable. This option cannot be used with --login-username and --login-password options.')
+
+    def parseArgs(self, usage=None):
+        DmRestCli.parseArgs(self, usage)
+        self.loginUsername = self.options.loginUsername
+        self.loginPassword = self.options.loginPassword
+        self.loginFile = self.options.loginFile
+        self.parseLoginFile()
+        return (self.options, self.args)
+
+    def getLoginUsername(self):
+        return self.loginUsername
+
+    def getLoginPassword(self):
+        return self.loginPassword
+
+    def getLoginFile(self):
+        if not self.loginFile:
+            configManager = ConfigurationManager.getInstance()
+            self.loginFile = configManager.getLoginFile()
+        return self.loginFile
+
+    def parseLoginFile(self):
+        if self.getLoginFile() and not self.getLoginUsername() and not self.getLoginPassword():
+            try:
+                # Assume form <username>|<password>
+                tokenList = open(self.loginFile).readline().split('|')
+                if len(tokenList) == 2:
+                    self.loginUsername = tokenList[0].strip()
+                    self.loginPassword = tokenList[1].strip()
+            except:
+                # Ignore invalid login file
+                pass
+
+    def hasCredentials(self):
+        return (self.getLoginUsername() != None and self.getLoginPassword() != None)
+
+#######################################################################
+# Testing
+
+if __name__ == '__main__':
+        pass

src/python/dm/common/client/dmExceptionMapper.py

+#!/usr/bin/env python
+
+from dm.common.constants import dmStatus
+from dm.common.exceptions import dmExceptionMap
+from dm.common.exceptions.dmException import DmException
+
+class DmExceptionMapper:
+
+    @classmethod
+    def checkStatus(cls, httpHeaders):
+        """ Map dm status code into appropriate exception. """
+        code = httpHeaders.get('Dm-Status-Code', None)
+        msg = httpHeaders.get('Dm-Status-Message', 'Internal Error')
+        if code is None or code == str(dmStatus.DM_OK):
+            return
+        elif dmExceptionMap.DM_EXCEPTION_MAP.has_key(int(code)):
+            # Exception string is value of the form 'x.y.z'
+            # where 'x.y' is dm module, and 'z' class in that module
+            exStr = dmExceptionMap.DM_EXCEPTION_MAP.get(int(code))
+            exClass = exStr.split('.')[-1] # 'z' in 'x.y.z'
+            exModule = '.'.join(exStr.split('.')[:-1]) # 'x.y' in 'x.y.z'
+            exec 'from dm.common.exceptions.%s import %s' % (exModule, exClass)
+            exec 'ex = %s(msg)' % (exClass)
+            raise ex
+        else:
+            raise DmException(msg)
+
+# Testing.
+if __name__ == '__main__':
+    pass