src/python/dm/cat_web_service/cli/getExperimentFileCli.py

+#!/usr/bin/env python
+
+from dm.cat_web_service.api.fileRestApi import FileRestApi
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from catWebServiceSessionCli import CatWebServiceSessionCli
+
+class GetExperimentFileCli(CatWebServiceSessionCli):
+    def __init__(self):
+        CatWebServiceSessionCli.__init__(self, validArgCount=self.ANY_NUMBER_OF_POSITIONAL_ARGS)
+        self.addOption('', '--file', dest='fileName', help='File name.')
+        self.addOption('', '--experiment', dest='experimentName', help='Experiment name.')
+
+    def checkArgs(self):
+        if self.options.experimentName is None:
+            raise InvalidRequest('Experiment name must be provided.')
+        if self.options.fileName is None:
+            raise InvalidRequest('File name must be provided.')
+
+    def getExperimentName(self):
+        return self.options.experimentName
+
+    def getFileName(self):
+        return self.options.fileName
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-get-experiment-file --file=FILENAME --experiment=EXPERIMENTNAME 
+
+Description:
+    Retrieve experiment file metadata from the catalog. 
+        """)
+        self.checkArgs()
+        api = FileRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        fileMetadata = api.getExperimentFile(self.getExperimentName(), self.getFileName())
+        print fileMetadata.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = GetExperimentFileCli()
+    cli.run()
+

src/python/dm/cat_web_service/cli/getExperimentFilesCli.py

+#!/usr/bin/env python
+
+from dm.cat_web_service.api.fileRestApi import FileRestApi
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from catWebServiceSessionCli import CatWebServiceSessionCli
+
+class GetExperimentFilesCli(CatWebServiceSessionCli):
+    def __init__(self):
+        CatWebServiceSessionCli.__init__(self, validArgCount=self.ANY_NUMBER_OF_POSITIONAL_ARGS)
+        self.addOption('', '--experiment', dest='experimentName', help='Experiment name.')
+
+    def checkArgs(self):
+        if self.options.experimentName is None:
+            raise InvalidRequest('Experiment name must be provided.')
+
+    def getExperimentName(self):
+        return self.options.experimentName
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-get-experiment-files --experiment=EXPERIMENTNAME 
+        [key1:value1, key2:value2, ...]
+
+Description:
+    Retrieve experiment files from the metadata catalog. Only those files that
+    match provided key/value metadata pairs will be returned. If no specific
+    metadata key/values are requested, all experiment files will be returned. 
+        """)
+        self.checkArgs()
+        api = FileRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        queryDict = self.splitArgsIntoDict()
+        fileMetadataList = api.getExperimentFiles(self.getExperimentName(), queryDict)
+        for fileMetadata in fileMetadataList:
+            print fileMetadata.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = GetExperimentFilesCli()
+    cli.run()
+

src/python/dm/cat_web_service/cli/getFilesCli.py

+#!/usr/bin/env python
+
+from dm.cat_web_service.api.fileRestApi import FileRestApi
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from catWebServiceSessionCli import CatWebServiceSessionCli
+
+class GetFilesCli(CatWebServiceSessionCli):
+    def __init__(self):
+        CatWebServiceSessionCli.__init__(self, validArgCount=self.ANY_NUMBER_OF_POSITIONAL_ARGS)
+
+    def checkArgs(self):
+        pass
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-get-files 
+        [key1:value1, key2:value2, ...]
+
+Description:
+    Retrieve files from the metadata catalog. Only those files that
+    match provided key/value metadata pairs will be returned. If no specific
+    metadata key/values are requested, all experiment files will be returned. 
+        """)
+        self.checkArgs()
+        api = FileRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        queryDict = self.splitArgsIntoDict()
+        fileMetadataList = api.getFiles(queryDict)
+        for fileMetadata in fileMetadataList:
+            print fileMetadata.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = GetFilesCli()
+    cli.run()
+

src/python/dm/cat_web_service/cli/updateExperimentDatasetCli.py

+#!/usr/bin/env python
+
+from dm.cat_web_service.api.datasetRestApi import DatasetRestApi
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from catWebServiceSessionCli import CatWebServiceSessionCli
+
+class UpdateExperimentDatasetCli(CatWebServiceSessionCli):
+    def __init__(self):
+        CatWebServiceSessionCli.__init__(self, validArgCount=self.ANY_NUMBER_OF_POSITIONAL_ARGS)
+        self.addOption('', '--dataset', dest='datasetName', help='Dataset name.')
+        self.addOption('', '--experiment', dest='experimentName', help='Experiment name.')
+
+    def checkArgs(self):
+        if self.options.experimentName is None:
+            raise InvalidRequest('Experiment name must be provided.')
+        if self.options.datasetName is None:
+            raise InvalidRequest('Dataset name must be provided.')
+
+    def getExperimentName(self):
+        return self.options.experimentName
+
+    def getDatasetName(self):
+        return self.options.datasetName
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-update-experiment-dataset --dataset=DATASETNAME 
+        --experiment=EXPERIMENTNAME 
+        [key1:value1, key2:value2, ...]
+
+Description:
+    Updates experiment dataset in the metadata catalog. All provided key/value 
+    pairs are interpreted as dataset metadata, and will be merged with existing
+    metadata, overwriting values for existing keys, and adding values for
+    new keys.
+        """)
+        self.checkArgs()
+        api = DatasetRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        datasetInfo = self.splitArgsIntoDict()
+        datasetInfo['experimentName'] = self.getExperimentName()
+        datasetInfo['datasetName'] = self.getDatasetName()
+        datasetMetadata = api.updateExperimentDataset(datasetInfo)
+        print datasetMetadata.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = UpdateExperimentDatasetCli()
+    cli.run()
+

src/python/dm/cat_web_service/cli/updateExperimentFileCli.py

+#!/usr/bin/env python
+
+from dm.cat_web_service.api.fileRestApi import FileRestApi
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from catWebServiceSessionCli import CatWebServiceSessionCli
+
+class UpdateExperimentFileCli(CatWebServiceSessionCli):
+    def __init__(self):
+        CatWebServiceSessionCli.__init__(self, validArgCount=self.ANY_NUMBER_OF_POSITIONAL_ARGS)
+        self.addOption('', '--file', dest='fileName', help='File name.')
+        self.addOption('', '--experiment', dest='experimentName', help='Experiment name.')
+
+    def checkArgs(self):
+        if self.options.experimentName is None:
+            raise InvalidRequest('Experiment name must be provided.')
+        if self.options.fileName is None:
+            raise InvalidRequest('File name must be provided.')
+
+    def getExperimentName(self):
+        return self.options.experimentName
+
+    def getFileName(self):
+        return self.options.fileName
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-update-experiment-file --file=FILENAME --experiment=EXPERIMENTNAME 
+        [key1:value1, key2:value2, ...]
+
+Description:
+    Updates experiment file in the metadata catalog. All provided key/value 
+    pairs are interpreted as file metadata, and will be merged with existing
+    metadata, overwriting values for existing keys, and adding values for
+    new keys.
+        """)
+        self.checkArgs()
+        api = FileRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        fileInfo = self.splitArgsIntoDict()
+        fileInfo['experimentName'] = self.getExperimentName()
+        fileInfo['fileName'] = self.getFileName()
+        fileMetadata = api.updateExperimentFile(fileInfo)
+        print fileMetadata.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = UpdateExperimentFileCli()
+    cli.run()
+

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

+__version__ = "Development Snapshot"

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

+#!/usr/bin/env python
+
+#
+# DM CAT Web Service
+#
+
+from dm.common.service.dmRestWebServiceBase import DmRestWebServiceBase
+from dm.common.utility.dmModuleManager import DmModuleManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from catWebServiceRouteMapper import CatWebServiceRouteMapper
+
+class CatWebService(DmRestWebServiceBase):
+ 
+    def __init__(self):
+        DmRestWebServiceBase.__init__(self, CatWebServiceRouteMapper)
+
+    def initDmModules(self):
+        self.logger.debug('Initializing dm modules')
+
+        # Add modules that will be started.
+        moduleManager = DmModuleManager.getInstance()
+        self.logger.debug('Initialized dm modules')
+
+    def getDefaultServerHost(self):
+        return ConfigurationManager.getInstance().getServiceHost()
+
+    def getDefaultServerPort(self):
+        return ConfigurationManager.getInstance().getServicePort()
+
+####################################################################
+# Run service
+
+if __name__ == '__main__':
+    ConfigurationManager.getInstance().setServiceName('cat-web-service')
+    service = CatWebService();
+    service.run()

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.isAdministrator())
+    @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.isAdministrator())
+    @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.isAdministrator())
+    @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.isAdministrator())
+    @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.isAdministrator())
+    @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.isAdministrator())
+    @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.isAdministrator())
+    @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.isAdministrator())
+    @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/filesByExperiment/:(experimentName)/:(fileName)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'addExperimentFile',
+                'method' : ['POST']
+            },
+
+            # Update file by id
+            {
+                'name' : 'updateFileById',
+                'path' : '%s/files/:(id)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'updateFileById',
+                'method' : ['PUT']
+            },
+
+            # Update experiment file by name
+            {
+                'name' : 'updateExperimentFile',
+                'path' : '%s/filesByExperiment/:(experimentName)/:(fileName)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'updateExperimentFile',
+                'method' : ['PUT']
+            },
+
+            # Get file info list
+            {
+                'name' : 'getFiles',
+                'path' : '%s/files' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'getFiles',
+                'method' : ['GET']
+            },
+
+            # Get experiment file info list 
+            {
+                'name' : 'getExperimentFiles',
+                'path' : '%s/filesByExperiment/:(experimentName)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'getExperimentFiles',
+                'method' : ['GET']
+            },
+
+            # Get file by id
+            {
+                'name' : 'getFileById',
+                'path' : '%s/files/:(id)' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'getFileById',
+                'method' : ['GET']
+            },
+
+            # Get experiment file by name
+            {
+                'name' : 'getExperimentFile',
+                'path' : '%s/filesByExperiment/:(experimentName)/:(fileName)' % 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.isAdministrator())
+    @DmSessionController.execute
+    def addExperimentFile(self, experimentName, fileName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not fileName:
+            raise InvalidRequest('Invalid file name provided.')
+        encodedFileInfo = kwargs.get('fileInfo')
+        if not encodedFileInfo:
+            raise InvalidRequest('Invalid file info provided.')
+        fileInfo = json.loads(Encoder.decode(encodedFileInfo))
+        fileInfo['fileName'] = fileName
+        fileInfo['experimentName'] = experimentName
+        response = self.fileSessionControllerImpl.addExperimentFile(fileInfo).getFullJsonRep()
+        self.logger.debug('Added file %s: %s' % (fileName,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def updateExperimentFile(self, experimentName, fileName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not fileName:
+            raise InvalidRequest('Invalid file name provided.')
+        encodedFileInfo = kwargs.get('fileInfo')
+        if not encodedFileInfo:
+            raise InvalidRequest('Invalid file info provided.')
+        fileInfo = json.loads(Encoder.decode(encodedFileInfo))
+        fileInfo['fileName'] = fileName
+        fileInfo['experimentName'] = experimentName
+        response = self.fileSessionControllerImpl.updateExperimentFile(fileInfo).getFullJsonRep()
+        self.logger.debug('Updated file %s: %s' % (fileName,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def updateFileById(self, id, **kwargs):
+        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))
+        response = self.fileSessionControllerImpl.updateFileById(fileInfo).getFullJsonRep()
+        self.logger.debug('Updated file id %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getFiles(self, **kwargs):
+        encodedQueryDict = kwargs.get('queryDict')
+        queryDict = {}
+        if encodedQueryDict:
+            queryDict = json.loads(Encoder.decode(encodedQueryDict))
+        return self.listToJson(self.fileSessionControllerImpl.getFiles(queryDict=queryDict))
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @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.isAdministrator())
+    @DmSessionController.execute
+    def getFileById(self, id, **kwargs):
+        if not id:
+            raise InvalidRequest('Invalid id provided.')
+        response = self.fileSessionControllerImpl.getFileById(id).getFullJsonRep()
+        self.logger.debug('Returning file id %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getExperimentFile(self, experimentName, fileName, **kwargs):
+        if not experimentName:
+            raise InvalidRequest('Invalid experiment name provided.')
+        if not fileName:
+            raise InvalidRequest('Invalid file name provided.')
+        response = self.fileSessionControllerImpl.getExperimentFile(experimentName, fileName).getFullJsonRep()
+        self.logger.debug('Returning file %s: %s' % (fileName,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 updateFileById(self, fileInfo):
+        return self.fileMongoDbApi.updateFileById(fileInfo)
+
+    def getFiles(self, queryDict):
+        return self.fileMongoDbApi.getFiles(queryDict=queryDict)
+
+    def getExperimentFiles(self, experimentName, queryDict):
+        return self.fileMongoDbApi.getExperimentFiles(experimentName, queryDict=queryDict)
+
+    def getFileById(self, id):
+        return self.fileMongoDbApi.getFileById(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)
+
+
+