src/python/dm/ds_web_service/service/authSessionController.py

+#authenticateUser!/usr/bin/env python
+
+import cherrypy
+from dm.common.service.dmSessionController import DmSessionController
+from dm.ds_web_service.service.impl.authSessionControllerImpl import AuthSessionControllerImpl
+
+class AuthSessionController(DmSessionController):
+
+    def __init__(self):
+        DmSessionController.__init__(self)
+        self.authSessionControllerImpl = AuthSessionControllerImpl()
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getAuthorizationPrincipal(self, username, **kwargs):
+        if not len(username):
+            raise InvalidRequest('Invalid username provided.')
+        response = self.authSessionControllerImpl.getAuthorizationPrincipal(username).getFullJsonRep()
+        self.logger.debug('Returning authorization principal for %s' % (username))
+        return response
+

src/python/dm/ds_web_service/service/dsWebService.py

+#!/usr/bin/env python
+
+#
+# DM DS Web Service
+#
+
+####################################################################
+
+from dm.common.service.dmRestWebServiceBase import DmRestWebServiceBase
+from dm.common.utility.dmModuleManager import DmModuleManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from dm.common.processing.fileProcessingManager import FileProcessingManager
+from dm.ds_web_service.service.impl.experimentManager import ExperimentManager
+from dsWebServiceRouteMapper import DsWebServiceRouteMapper
+
+####################################################################
+
+class DsWebService(DmRestWebServiceBase):
+ 
+    def __init__(self):
+        DmRestWebServiceBase.__init__(self, DsWebServiceRouteMapper)
+
+    def initDmModules(self):
+        self.logger.debug('Initializing dm modules')
+
+        # Add modules that will be started.
+        moduleManager = DmModuleManager.getInstance()
+        moduleManager.addModule(ExperimentManager.getInstance())
+        moduleManager.addModule(FileProcessingManager.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('ds-web-service')
+    service = DsWebService();
+    service.run()

src/python/dm/ds_web_service/service/dsWebServiceRouteMapper.py

+#!/usr/bin/env python
+
+#
+# Route mapper for DM DS 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 userRouteDescriptor import UserRouteDescriptor
+from experimentRouteDescriptor import ExperimentRouteDescriptor
+from fileRouteDescriptor import FileRouteDescriptor
+from authRouteDescriptor import AuthRouteDescriptor
+
+class DsWebServiceRouteMapper:
+
+    @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 += AuthRouteDescriptor.getRoutes()
+        routes += UserRouteDescriptor.getRoutes()
+        routes += ExperimentRouteDescriptor.getRoutes()
+        routes += FileRouteDescriptor.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/ds_web_service/service/experimentRouteDescriptor.py

+#!/usr/bin/env python
+
+#
+# Experiment route descriptor.
+#
+
+from dm.common.utility.configurationManager import ConfigurationManager
+from experimentSessionController import ExperimentSessionController
+
+class ExperimentRouteDescriptor:
+
+    @classmethod
+    def getRoutes(cls):
+        contextRoot = ConfigurationManager.getInstance().getContextRoot()
+
+        # Static instances shared between different routes
+        experimentSessionController = ExperimentSessionController()
+
+        # Define routes.
+        routes = [
+
+            # Get experiment types
+            {
+                'name' : 'getExperimentTypes',
+                'path' : '%s/experimentTypes' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'getExperimentTypes',
+                'method' : ['GET']
+            },
+
+            # Get experiments
+            {
+                'name' : 'getExperiments',
+                'path' : '%s/experiments' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'getExperiments',
+                'method' : ['GET']
+            },
+
+            # Get experiment
+            {
+                'name' : 'getExperimentById',
+                'path' : '%s/experiments/:(id)' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'getExperimentById',
+                'method' : ['GET']
+            },
+
+            # Get experiment
+            {
+                'name' : 'getExperimentByName',
+                'path' : '%s/experimentsByName/:(name)' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'getExperimentByName',
+                'method' : ['GET']
+            },
+
+            # Add experiment
+            {
+                'name' : 'addExperiment',
+                'path' : '%s/experiments' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'addExperiment',
+                'method' : ['POST']
+            },
+
+            # Start experiment
+            {
+                'name' : 'startExperiment',
+                'path' : '%s/experiments/start' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'startExperiment',
+                'method' : ['PUT']
+            },
+
+            # Stop experiment
+            {
+                'name' : 'stopExperiment',
+                'path' : '%s/experiments/stop' % contextRoot,
+                'controller' : experimentSessionController,
+                'action' : 'stopExperiment',
+                'method' : ['PUT']
+            },
+
+        ]
+       
+        return routes
+
+

src/python/dm/ds_web_service/service/experimentSessionController.py

+#!/usr/bin/env python
+
+import cherrypy
+
+from dm.common.service.dmSessionController import DmSessionController
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.utility.encoder import Encoder
+
+from dm.ds_web_service.service.impl.experimentSessionControllerImpl import ExperimentSessionControllerImpl
+
+
+class ExperimentSessionController(DmSessionController):
+
+    def __init__(self):
+        DmSessionController.__init__(self)
+        self.experimentSessionControllerImpl = ExperimentSessionControllerImpl()
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isLoggedIn())
+    @DmSessionController.execute
+    def getExperimentTypes(self, **kwargs):
+        return self.listToJson(self.experimentSessionControllerImpl.getExperimentTypes())
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getExperiments(self, **kwargs):
+        return self.listToJson(self.experimentSessionControllerImpl.getExperiments())
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getExperimentByName(self, name, **kwargs):
+        response = self.experimentSessionControllerImpl.getExperimentByName(name).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getExperimentById(self, id, **kwargs):
+        response = self.experimentSessionControllerImpl.getExperimentByid(id).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def addExperiment(self, **kwargs):
+        name = kwargs.get('name')
+        if name is None or not len(name):
+            raise InvalidRequest('Missing experiment name.')
+        name = Encoder.decode(name)
+        experimentTypeId = kwargs.get('experimentTypeId')
+        if experimentTypeId is None:
+            raise InvalidRequest('Missing experiment type id.')
+        description = kwargs.get('description')
+        if description is not None:
+            description = Encoder.decode(description)
+        response = self.experimentSessionControllerImpl.addExperiment(name, experimentTypeId, description).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def startExperiment(self, **kwargs):
+        name = kwargs.get('name')
+        if name is None or not len(name):
+            raise InvalidRequest('Missing experiment name.')
+        name = Encoder.decode(name)
+        response = self.experimentSessionControllerImpl.startExperiment(name).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def stopExperiment(self, **kwargs):
+        name = kwargs.get('name')
+        if name is None or not len(name):
+            raise InvalidRequest('Missing experiment name.')
+        name = Encoder.decode(name)
+        response = self.experimentSessionControllerImpl.stopExperiment(name).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+

src/python/dm/ds_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 = [
+
+            # Process file
+            {
+                'name' : 'processFile',
+                'path' : '%s/files/processFile' % contextRoot,
+                'controller' : fileSessionController,
+                'action' : 'processFile',
+                'method' : ['POST']
+            },
+
+        ]
+       
+        return routes
+
+

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

+#!/usr/bin/env python
+
+import cherrypy
+
+from dm.common.service.dmSessionController import DmSessionController
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.utility.encoder import Encoder
+
+from dm.ds_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 processFile(self, **kwargs):
+        fileName = kwargs.get('fileName')
+        if not fileName: 
+            raise InvalidRequest('Missing file name.')
+        fileName = Encoder.decode(fileName)
+        filePath = kwargs.get('filePath')
+        if not filePath:
+            raise InvalidRequest('Missing file path.')
+        filePath = Encoder.decode(filePath)
+        experimentName = kwargs.get('experimentName')
+        if not experimentName:
+            raise InvalidRequest('Missing experiment name.')
+        experimentName = Encoder.decode(experimentName)
+
+        response = self.fileSessionControllerImpl.processFile(fileName, filePath, experimentName).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+

src/python/dm/ds_web_service/service/impl/authSessionControllerImpl.py

+#!/usr/bin/env python
+
+#
+# Implementation for user info controller.
+#
+
+from dm.common.constants import dmRole
+from dm.common.objects.authorizationPrincipal import AuthorizationPrincipal 
+from dm.common.objects.dmObjectManager import DmObjectManager
+from dm.common.db.api.userDbApi import UserDbApi
+
+class AuthSessionControllerImpl(DmObjectManager):
+    """ User info controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.userDbApi = UserDbApi()
+
+    def getAuthorizationPrincipal(self, username):
+        user = self.userDbApi.getUserWithPasswordByUsername(username)
+        principal = AuthorizationPrincipal(name=username, token=user.get('password'))
+        principal.setRole(dmRole.DM_USER_ROLE)
+        principal.setUserInfo(user)
+        for userSystemRoleName in user.get('userSystemRoleNameList', []):
+            if userSystemRoleName == dmRole.DM_ADMIN_ROLE:
+                principal.setRole(dmRole.DM_ADMIN_ROLE)
+        return principal
+
+

src/python/dm/ds_web_service/service/impl/experimentManager.py

+#!/usr/bin/env python
+
+import threading
+import time
+import os
+
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from dm.common.utility.singleton import Singleton
+from dm.common.utility.osUtility import OsUtility
+from dm.common.utility.valueUtility import ValueUtility
+from dm.common.utility.objectUtility import ObjectUtility
+from dm.common.utility.threadingUtility import ThreadingUtility
+from dm.common.db.api.experimentDbApi import ExperimentDbApi
+
+class ExperimentManager(Singleton):
+
+    CONFIG_SECTION_NAME = 'ExperimentManager'
+    STORAGE_DIRECTORY_KEY = 'storagedirectory'
+    MANAGE_STORAGE_PERMISSIONS_KEY = 'managestoragepermissions'
+    PLATFORM_UTILITY_KEY = 'platformutility'
+
+    FILE_PERMISSIONS_MODE = 0640
+    DIR_PERMISSIONS_MODE = 0750
+
+    # Singleton.
+    __instanceLock = threading.RLock()
+    __instance = None
+
+    def __init__(self):
+        ExperimentManager.__instanceLock.acquire()
+        try:
+            if ExperimentManager.__instance:
+                return
+            ExperimentManager.__instance = self
+            self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+
+            self.logger.debug('Initializing')
+            self.lock = threading.RLock()
+            self.experimentDbApi = ExperimentDbApi()
+            self.platformUtility = None
+            self.__configure()
+            self.logger.debug('Initialization complete')
+        finally:
+            ExperimentManager.__instanceLock.release()
+
+    def __configure(self):
+        cm = ConfigurationManager.getInstance()
+        configItems = cm.getConfigItems(ExperimentManager.CONFIG_SECTION_NAME)
+        self.logger.debug('Got config items: %s' % configItems)
+        self.storageDirectory =cm.getConfigOption(ExperimentManager.CONFIG_SECTION_NAME, ExperimentManager.STORAGE_DIRECTORY_KEY) 
+        self.manageStoragePermissions = ValueUtility.toBoolean(cm.getConfigOption(ExperimentManager.CONFIG_SECTION_NAME, ExperimentManager.MANAGE_STORAGE_PERMISSIONS_KEY))
+        platformUtility = cm.getConfigOption(ExperimentManager.CONFIG_SECTION_NAME, ExperimentManager.PLATFORM_UTILITY_KEY)
+        if platformUtility:
+            (moduleName,className,constructor) = cm.getModuleClassConstructorTuple(platformUtility)
+            self.logger.debug('Creating platform utility class %s' % className)
+            self.platformUtility = ObjectUtility.createObjectInstance(moduleName, className, constructor)
+                                                                            
+        self.logger.debug('Manage storage permissions: %s' % self.manageStoragePermissions)
+
+    def __getExperimentStorageDataDirectory(self, experiment):
+        experimentTypeName = experiment.get('experimentType').get('rootDataPath')
+        experimentName = experiment.get('name')
+        storageDirectory = '%s/%s/%s' % (self.storageDirectory, experimentTypeName, experimentName)
+        storageDirectory = os.path.normpath(storageDirectory)
+        return storageDirectory
+
+    @ThreadingUtility.synchronize
+    def updateExperimentWithStorageDataDirectory(self, experiment):
+        storageDirectory = self.__getExperimentStorageDataDirectory(experiment)
+        if os.path.exists(storageDirectory):
+            experiment['storageDirectory'] = storageDirectory
+            experiment['storageHost'] = ConfigurationManager.getInstance().getHost()
+        return storageDirectory
+
+    @ThreadingUtility.synchronize
+    def createExperimentDataDirectory(self, experiment):
+        experimentName = experiment.get('name')
+        storageDirectory = self.__getExperimentStorageDataDirectory(experiment)
+        if os.path.exists(storageDirectory):
+            self.logger.debug('Data directory %s for experiment %s already exists' % (storageDirectory, experimentName))
+        else:
+            self.logger.debug('Creating data directory for experiment %s: %s' % (experimentName, storageDirectory))
+            OsUtility.createDir(storageDirectory)
+        experiment['storageDirectory'] = storageDirectory
+        experiment['storageHost'] = ConfigurationManager.getInstance().getHost()
+        if self.manageStoragePermissions:
+            # Create experiment group
+            self.platformUtility.createGroup(experimentName)
+            self.logger.debug('Setting permissions for %s to %s' % (storageDirectory, self.DIR_PERMISSIONS_MODE))
+            OsUtility.chmodPath(storageDirectory, dirMode=self.DIR_PERMISSIONS_MODE)
+            experimentUsers = experiment.get('experimentUsernameList', [])
+            for username in experimentUsers:
+                self.platformUtility.addUserToGroup(username, experimentName)
+      
+    @ThreadingUtility.synchronize
+    def processExperimentFile(self, fileName, filePath, experiment):
+        experimentName = experiment.get('name')
+        if os.path.exists(filePath):
+            self.logger.debug('Processing file %s' % filePath)
+            if self.manageStoragePermissions:
+                self.logger.debug('Modifying permissions for %s' % filePath)
+                OsUtility.chmodPath(filePath, fileMode=self.FILE_PERMISSIONS_MODE)
+        else:
+            self.logger.debug('File path %s does not exist' % filePath)
+
+    @ThreadingUtility.synchronize
+    def start(self):
+        self.logger.debug('Started experiment manager')
+
+    @ThreadingUtility.synchronize
+    def stop(self):
+        self.logger.debug('Stopped experiment manager')
+
+####################################################################
+# Testing
+
+if __name__ == '__main__':
+    em = ExperimentManager.getInstance()
+    print em
+

src/python/dm/ds_web_service/service/impl/experimentSessionControllerImpl.py

+#!/usr/bin/env python
+
+#
+# Implementation for experiment session controller.
+#
+
+import time
+
+from dm.common.objects.experiment import Experiment
+from dm.common.objects.dmObjectManager import DmObjectManager
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.db.api.experimentDbApi import ExperimentDbApi
+from dm.ds_web_service.service.impl.experimentManager import ExperimentManager
+
+class ExperimentSessionControllerImpl(DmObjectManager):
+    """ Experiment session controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.experimentDbApi = ExperimentDbApi()
+
+    def getExperimentTypes(self):
+        experimentTypeList = self.experimentDbApi.getExperimentTypes()
+        return experimentTypeList
+
+    def getExperiments(self):
+        experimentList = self.experimentDbApi.getExperiments()
+        return experimentList
+
+    def getExperimentByName(self, name):
+        experiment = self.experimentDbApi.getExperimentByName(name)
+        ExperimentManager.getInstance().updateExperimentWithStorageDataDirectory(experiment)
+        return experiment
+
+    def getExperimentById(self, id):
+        experiment = self.experimentDbApi.getExperimentById(id)
+        ExperimentManager.getInstance().updateExperimentWithStorageDataDirectory(experiment)
+        return experiment
+
+    def addExperiment(self, name, experimentTypeId, description):
+        experiment = self.experimentDbApi.addExperiment(name, experimentTypeId, description)
+        return experiment
+
+    def startExperiment(self, name):
+        experiment = self.experimentDbApi.getExperimentWithUsers(name)
+        if experiment.get('startDate') is None:
+            experiment = self.experimentDbApi.setExperimentStartDateToNow(name)
+        ExperimentManager.getInstance().createExperimentDataDirectory(experiment)
+        return experiment
+
+    def stopExperiment(self, name):
+        experiment = self.experimentDbApi.getExperimentByName(name)
+        if experiment.get('endDate') is None:
+            experiment = self.experimentDbApi.setExperimentEndDateToNow(name)
+        ExperimentManager.getInstance().updateExperimentWithStorageDataDirectory(experiment)
+        return experiment
+

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

+#!/usr/bin/env python
+
+#
+# Implementation for file session controller.
+#
+
+import time
+
+from dm.common.objects.dmObjectManager import DmObjectManager
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.objects.fileMetadata import FileMetadata
+from dm.common.db.api.experimentDbApi import ExperimentDbApi
+from dm.ds_web_service.service.impl.experimentManager import ExperimentManager
+
+class FileSessionControllerImpl(DmObjectManager):
+    """ File session controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.experimentDbApi = ExperimentDbApi()
+
+    def processFile(self, fileName, filePath, experimentName, **kwargs):
+        experiment = self.experimentDbApi.getExperimentByName(experimentName)
+        ExperimentManager.getInstance().processExperimentFile(fileName, filePath, experiment)
+        return FileMetadata({'fileName' : fileName})

src/python/dm/ds_web_service/service/impl/mongoDbFileCatalogPlugin.py

+#!/usr/bin/env python
+
+import os
+import time
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.timeUtility import TimeUtility
+from dm.common.processing.plugins.fileProcessor import FileProcessor
+from dm.common.mongodb.api.fileMongoDbApi import FileMongoDbApi
+
+class MongoDbFileCatalogPlugin(FileProcessor):
+
+    def __init__(self):
+        FileProcessor.__init__(self)
+        self.fileMongoDbApi = FileMongoDbApi()
+        self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+
+    def processFile(self, fileInfo):
+        experimentFilePath = fileInfo.get('experimentFilePath')
+        experiment = fileInfo.get('experiment')
+        experimentName = experiment.get('name')
+        self.logger.debug('Processing file %s for experiment %s' % (fileInfo, experimentName))
+
+        experimentStorageDirectory = experiment.get('storageDirectory')
+        storageHost = experiment.get('storageHost')
+        storageFilePath = os.path.join(experimentStorageDirectory, experimentFilePath)
+        fileProcessingTime = time.time()
+        fileProcessingTimeStamp = TimeUtility.formatLocalTimeStamp(fileProcessingTime)
+
+        # Prepare catalogging entry
+        fileInfo2 = {}
+        fileInfo2['name'] = os.path.basename(experimentFilePath)
+        fileInfo2['experimentStorageDirectory'] = experimentStorageDirectory
+        fileInfo2['storageHost'] = storageHost
+        fileInfo2['storageFilePath'] = storageFilePath
+        fileInfo2['experimentFilePath'] = experimentFilePath
+        fileInfo2['experimentName'] = experimentName
+        fileInfo2['fileProcessingTime'] = fileProcessingTime
+        fileInfo2['fileProcessingTimeStamp'] = fileProcessingTimeStamp
+        fileInfo2.update(fileInfo.get('daqInfo', {}))
+        self.fileMongoDbApi.updateOrAddExperimentFile(fileInfo2)
+
+
+#######################################################################
+# Testing.
+if __name__ == '__main__':
+    pass

src/python/dm/ds_web_service/service/impl/userInfoSessionControllerImpl.py

+#!/usr/bin/env python
+
+#
+# Implementation for user info controller.
+#
+
+from dm.common.objects.dmObject import DmObject
+from dm.common.objects.dmObjectManager import DmObjectManager
+from dm.common.db.api.userDbApi import UserDbApi
+
+class UserInfoSessionControllerImpl(DmObjectManager):
+    """ User info controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.userDbApi = UserDbApi()
+
+    def getUsers(self):
+        return self.userDbApi.getUsers()
+
+    def getUserById(self, id):
+        return self.userDbApi.getUserById(id)
+
+    def getUserByUsername(self, username):
+        return self.userDbApi.getUserByUsername(username)
+

src/python/dm/ds_web_service/service/userInfoSessionController.py

+#!/usr/bin/env python
+
+import cherrypy
+from dm.common.service.dmSessionController import DmSessionController
+from dm.ds_web_service.service.impl.userInfoSessionControllerImpl import UserInfoSessionControllerImpl
+
+class UserInfoSessionController(DmSessionController):
+
+    def __init__(self):
+        DmSessionController.__init__(self)
+        self.userInfoSessionControllerImpl = UserInfoSessionControllerImpl()
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getUsers(self, **kwargs):
+        return self.listToJson(self.userInfoSessionControllerImpl.getUsers())
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getUserById(self, id, **kwargs):
+        if not id:
+            raise InvalidRequest('Invalid id provided.')
+        response = self.userInfoSessionControllerImpl.getUserById(id).getFullJsonRep()
+        self.logger.debug('Returning user info for %s: %s' % (id,response))
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isAdministrator())
+    @DmSessionController.execute
+    def getUserByUsername(self, username, **kwargs):
+        if not len(username):
+            raise InvalidRequest('Invalid username provided.')
+        response = self.userInfoSessionControllerImpl.getUserByUsername(username).getFullJsonRep()
+        self.logger.debug('Returning user info for %s: %s' % (username,response))
+        return response
+

src/python/dm/ds_web_service/service/userRouteDescriptor.py

+#!/usr/bin/env python
+
+#
+# User route descriptor.
+#
+
+from dm.common.utility.configurationManager import ConfigurationManager
+from userInfoSessionController import UserInfoSessionController
+
+class UserRouteDescriptor:
+
+    @classmethod
+    def getRoutes(cls):
+        contextRoot = ConfigurationManager.getInstance().getContextRoot()
+
+        # Static instances shared between different routes
+        userInfoSessionController = UserInfoSessionController()
+
+        # Define routes.
+        routes = [
+
+            # Get user info list
+            {
+                'name' : 'getUsers',
+                'path' : '%s/users' % contextRoot,
+                'controller' : userInfoSessionController,
+                'action' : 'getUsers', 
+                'method' : ['GET']
+            },
+
+            # Get user by id
+            {
+                'name' : 'getUserById',
+                'path' : '%s/users/:(id)' % contextRoot,
+                'controller' : userInfoSessionController,
+                'action' : 'getUserById', 
+                'method' : ['GET']
+            },
+
+            # Get user by username
+            {
+                'name' : 'getUserByUsername',
+                'path' : '%s/usersByUsername/:(username)' % contextRoot,
+                'controller' : userInfoSessionController,
+                'action' : 'getUserByUsername', 
+                'method' : ['GET']
+            },
+
+        ]
+       
+        return routes
+
+

tools/AccountSynchronizer/accountSynchronizer/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="resources"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="/home/phoebus/BFROSIK/trunk/tools/AccountSynchronizer/lib/ojdbc7.jar"/>
+	<classpathentry kind="lib" path="/home/phoebus/BFROSIK/trunk/tools/AccountSynchronizer/lib/postgresql-9.4-1201.jdbc4.jar"/>
+	<classpathentry kind="lib" path="/home/phoebus/BFROSIK/trunk/tools/AccountSynchronizer/lib/unboundid-ldapsdk-me.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

tools/AccountSynchronizer/accountSynchronizer/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>accountSynchronizer</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

tools/AccountSynchronizer/accountSynchronizer/manifest.txt

+Main-Class: gov.anl.aps.dm.sync.Synchronizer
+Class-Path: ../../lib/ojdbc7.jar ../../lib/postgresql-9.4-1201.jdbc4.jar ../../lib/unboundid-ldapsdk-me.jar ../resources

tools/AccountSynchronizer/accountSynchronizer/resources/config.properties

+### log congiguration
+log.file = accountSynchronizer%g.log
+log.limit = 6000
+log.count = 2
+
+###
+### Oracle database settings
+###
+oracle.database.connection = jdbc:oracle:thin:@ra.aps.anl.gov:1527:aps1
+oracle.database.username = glob_conn
+### oracle.database.password = 
+oracle.database.table = DCC.FL$03_BL_APV_VIEW_V2
+
+###
+### Postgresql database settings
+###
+dm.database.connection = jdbc:postgresql://127.0.0.1:11136/dm
+dm.database.username = dm
+### dm.database.password = 
+
+### Connection settings for LDAP
+###
+#
+#ldap.server.address = blacklab.xray.aps.anl.gov
+#ldap.server.port = 389
+#ldap.server.username = uid=dmadmin,ou=People,o=aps.anl.gov,dc=aps,dc=anl,dc=gov
+#ldap.server.password = 
+
+###
+### LDAP user account settings
+###
+#ldap.accounts.baseDN = ou=People, o=aps.anl.gov, dc=aps,dc=anl,dc=gov
+
+### General account settings
+###
+# The user name prefix that gets append to every badge number.
+user.userid.prefix = d
+