src/python/dm/daq_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.daq_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 startDaq(self, **kwargs):
+        name = kwargs.get('name')
+        if name is None or not len(name):
+            raise InvalidRequest('Missing experiment name.')
+        name = Encoder.decode(name)
+        dataDirectory = kwargs.get('dataDirectory')
+        if dataDirectory is None or not len(dataDirectory):
+            raise InvalidRequest('Missing experiment data directory.')
+        dataDirectory = Encoder.decode(dataDirectory)
+        response = self.experimentSessionControllerImpl.startDaq(name, dataDirectory).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+
+    @cherrypy.expose
+    @DmSessionController.require(DmSessionController.isLoggedIn())
+    @DmSessionController.execute
+    def stopDaq(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.stopDaq(name).getFullJsonRep()
+        self.logger.debug('Returning: %s' % response)
+        return response
+

src/python/dm/daq_web_service/service/impl/dmFileSystemEventHandler.py

+#!/usr/bin/env python
+
+import os
+
+from watchdog.events import FileSystemEventHandler
+
+from dm.common.utility.loggingManager import LoggingManager
+
+class DmFileSystemEventHandler(FileSystemEventHandler):
+
+    def __init__(self, fileSystemObserver):
+        FileSystemEventHandler.__init__(self)
+        self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+        self.fileSystemObserver = fileSystemObserver
+
+    def dispatch(self, event):
+        FileSystemEventHandler.dispatch(self, event)
+
+    def on_any_event(self, event):
+        FileSystemEventHandler.on_any_event(self, event)
+
+    def on_created(self, event):
+        FileSystemEventHandler.on_created(self, event)
+
+    def on_deleted(self, event):
+        FileSystemEventHandler.on_deleted(self, event)
+
+    def on_modified(self, event):
+        FileSystemEventHandler.on_modified(self, event)
+        path = event.src_path
+        self.logger.debug('File system modified event: %s' % (event.__dict__))
+        if not event.is_directory:
+            self.fileSystemObserver.observedFileUpdated(path)
+        
+    def on_moved(self, event):
+        FileSystemEventHandler.on_moved(self, event)
+
+####################################################################
+# Testing
+
+if __name__ == '__main__':
+    import sys
+    import time
+    import logging
+    from watchdog.observers import Observer
+    from watchdog.observers.polling import PollingObserver
+    from watchdog.observers.api import ObservedWatch
+    from watchdog.observers.api import EventQueue
+    from watchdog.observers.api import EventEmitter
+    from watchdog.events import LoggingEventHandler
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s - %(message)s',
+                        datefmt='%Y-%m-%d %H:%M:%S')
+    path = sys.argv[1] if len(sys.argv) > 1 else '.'
+    eventHandler = DmFileSystemEventHandler()
+
+    observer = PollingObserver()
+    observedWatch = observer.schedule(eventHandler, path, recursive=True)
+    print 'OBSERVED WATCH: ', observedWatch
+
+    #observer.add_handler_for_watch(eventHandler2, observedWatch)
+    #observer._clear_emitters()
+    print observer.emitters
+
+    observer.start()
+    try:
+        while True:
+            time.sleep(1)
+            print time.time()
+    except KeyboardInterrupt:
+        observer.stop()
+    observer.join()

src/python/dm/daq_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.ds_web_service.api.dsRestApiFactory import DsRestApiFactory
+from fileSystemObserver import FileSystemObserver
+
+class ExperimentSessionControllerImpl(DmObjectManager):
+    """ Experiment session controller implementation class. """
+
+    def __init__(self):
+        DmObjectManager.__init__(self)
+        self.experimentDict = {}
+
+    def startDaq(self, name, dataDirectory):
+        FileSystemObserver.getInstance().startObservingPath(dataDirectory)
+        startTime = time.time()
+        experiment = Experiment({'name' : name, 'dataDirectory' : dataDirectory, 'daqStartTime' : startTime})
+        self.experimentDict[name] = experiment
+        return experiment
+
+    def stopDaq(self, name):
+        experiment = self.experimentDict.get(name)
+        if experiment is None or experiment.get('daqEndTime') is not None:
+            raise InvalidRequest('Experiment %s is not active.' % name)
+        dataDirectory = experiment.get('dataDirectory')
+        FileSystemObserver.getInstance().stopObservingPath(dataDirectory)
+        experiment['daqEndTime'] = time.time()
+        return experiment

src/python/dm/daq_web_service/service/impl/fileProcessingManager.py

+#!/usr/bin/env python
+
+import threading
+import time
+
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from dm.common.utility.objectUtility import ObjectUtility
+from dm.common.utility.threadSafeQueue import ThreadSafeQueue 
+from dm.common.utility.singleton import Singleton
+from dm.daq_web_service.service.impl.fileProcessingThread import FileProcessingThread
+
+class FileProcessingManager(threading.Thread,Singleton):
+
+    CONFIG_SECTION_NAME = 'FileProcessingManager'
+    N_PROCESSING_THREADS_KEY = 'nprocessingthreads'
+    FILE_PROCESSOR_KEY = 'fileprocessor'
+
+    # Singleton.
+    __instanceLock = threading.RLock()
+    __instance = None
+
+    def __init__(self):
+        FileProcessingManager.__instanceLock.acquire()
+        try:
+            if FileProcessingManager.__instance:
+                return
+            FileProcessingManager.__instance = self
+            self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+
+            self.logger.debug('Initializing')
+            self.lock = threading.RLock()
+            self.fileProcessingThreadDict = {}
+            self.eventFlag = threading.Event()
+            self.fileProcessorDict = {}
+            self.fileProcessorKeyList = []
+            self.fileProcessingQueue = ThreadSafeQueue()
+            self.processedFileDict = {}
+            self.unprocessedFileDict = {}
+            self.__configure()
+            self.logger.debug('Initialization complete')
+        finally:
+            FileProcessingManager.__instanceLock.release()
+
+    def __configure(self):
+        cm = ConfigurationManager.getInstance()
+        configItems = cm.getConfigItems(FileProcessingManager.CONFIG_SECTION_NAME)
+        self.logger.debug('Got config items: %s' % configItems)
+        self.nProcessingThreads = int(cm.getConfigOption(FileProcessingManager.CONFIG_SECTION_NAME, FileProcessingManager.N_PROCESSING_THREADS_KEY))
+
+        # Create processors  
+        for (key,value) in configItems:
+            if key.startswith(FileProcessingManager.FILE_PROCESSOR_KEY):
+                (moduleName,className,constructor) = cm.getModuleClassConstructorTuple(value)
+                self.logger.debug('Creating file processor instance of class %s' % className)
+                fileProcessor = ObjectUtility.createObjectInstance(moduleName, className, constructor)
+                self.fileProcessorDict[key] = fileProcessor
+        self.fileProcessorKeyList = self.fileProcessorDict.keys()
+        self.fileProcessorKeyList.sort()
+        self.logger.debug('File processor keys: %s' % self.fileProcessorKeyList)
+
+    def processObservedFile(self, observedFile):
+        self.fileProcessingQueue.push(observedFile)
+        self.eventFlag.set()
+
+    def start(self):
+        self.lock.acquire()
+        try:
+            self.logger.debug('Starting file processing threads')
+            for i in range(0, self.nProcessingThreads):
+                tName = 'FileProcessingThread-%s' % i
+                t = FileProcessingThread(tName, self.eventFlag, self.fileProcessorDict, self.fileProcessorKeyList, self.fileProcessingQueue, self.processedFileDict, self.unprocessedFileDict)
+                t.start()
+                self.fileProcessingThreadDict[tName] = t
+        finally:
+            self.lock.release()
+
+    def stop(self):
+        self.lock.acquire()
+        try:
+            self.logger.debug('Stopping file processing threads')
+            for (tName, t) in self.fileProcessingThreadDict.items():
+                t.stop()
+            self.eventFlag.set()
+            for (tName, t) in self.fileProcessingThreadDict.items():
+                t.join()
+        finally:
+             self.lock.release()
+
+
+    def setEvent(self):
+        self.lock.acquire()
+        try:
+             self.eventFlag.set()
+        finally:
+            self.lock.release()
+
+    def clearEvent(self):
+        self.lock.acquire()
+        try:
+            self.eventFlag.clear()
+        finally:
+            self.lock.release()
+
+####################################################################
+# Testing
+
+if __name__ == '__main__':
+    fp = FileProcessingManager.getInstance()
+    print fp
+    #fp.start()
+    #time.sleep(30)
+    #fp.stop()
+
+

src/python/dm/daq_web_service/service/impl/fileProcessingThread.py

+#!/usr/bin/env python
+
+import threading
+
+from dm.common.utility.loggingManager import LoggingManager
+
+class FileProcessingThread(threading.Thread):
+
+    def __init__ (self, name, eventFlag, fileProcessorDict, fileProcessorKeyList, fileProcessingQueue, processedFileDict, unprocessedFileDict):
+    
+        threading.Thread.__init__(self)
+        self.setName(name)
+        self.exitFlag = False
+        self.eventFlag = eventFlag
+        self.fileProcessorDict = fileProcessorDict
+        self.fileProcessorKeyList = fileProcessorKeyList
+        self.fileProcessingQueue = fileProcessingQueue
+        self.processedFileDict = processedFileDict 
+        self.unprocessedFileDict = unprocessedFileDict 
+        self.logger = LoggingManager.getInstance().getLogger(name)
+
+    def run(self):
+        self.logger.debug('Starting thread: %s' % self.getName())
+        while True:
+            if self.exitFlag:
+                self.logger.debug('Exit flag set, %s done' % self.getName())
+                break
+
+            while True:
+                file = self.fileProcessingQueue.pop()
+                if file is None:
+                    break
+                path = file.getPath()
+                try:
+                    for processorKey in self.fileProcessorKeyList: 
+                        processor = self.fileProcessorDict.get(processorKey)
+                        processorName = processor.__class__.__name__
+                        self.logger.debug('%s is about to process file %s ' % (processorName, file))
+                        try:
+                            processor.processFile(path)
+                            self.logger.debug('%s processed file %s ' % (processorName, file))
+                        except Exception, ex:
+                            self.logger.exception(ex)
+                            self.logger.debug('%s processing failed for file %s ' % (processorName, file))
+                            file[processorName] = {'error' : ex}
+                            self.unprocessedFileDict[path] = file
+
+                except Exception, ex:
+                    self.logger.exception(ex)
+
+            self.eventFlag.wait()
+
+    def stop(self):
+        self.exitFlag = True
+
+####################################################################
+# Testing
+
+if __name__ == '__main__':
+    pass
+
+

src/python/dm/daq_web_service/service/impl/fileSystemObserver.py

+#!/usr/bin/env python
+
+import threading
+import time
+
+from watchdog.observers.polling import PollingObserver
+
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.configurationManager import ConfigurationManager
+from dm.common.objects.observedFile import ObservedFile
+from dm.common.utility.singleton import Singleton
+
+from dmFileSystemEventHandler import DmFileSystemEventHandler
+from fileProcessingManager import FileProcessingManager
+
+class FileSystemObserver(threading.Thread,Singleton):
+
+    CONFIG_SECTION_NAME = 'FileSystemObserver'
+    MIN_FILE_PROCESSING_DELAY_IN_SECONDS_KEY = 'minfileprocessingdelayinseconds'
+    FILE_SYSTEM_EVENT_TIMEOUT_IN_SECONDS_KEY = 'filesystemeventtimeoutinseconds'
+
+    # Singleton.
+    __instanceLock = threading.RLock()
+    __instance = None
+
+    def __init__(self):
+        FileSystemObserver.__instanceLock.acquire()
+        try:
+            if FileSystemObserver.__instance:
+                return
+            FileSystemObserver.__instance = self
+            threading.Thread.__init__(self)
+            self.setName('FileSystemObserverThread')
+            self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
+
+            self.logger.debug('Initializing')
+            self.lock = threading.RLock()
+            self.eventFlag = threading.Event()
+            self.exitFlag = False
+
+            self.observedFileMap = {}
+            self.observer = PollingObserver()
+            self.eventHandler = DmFileSystemEventHandler(self)
+            self.observedWatchDict = {}
+            self.__configure()
+            self.fileProcessingManager = FileProcessingManager.getInstance()
+            self.logger.debug('Initialization complete')
+        finally:
+            FileSystemObserver.__instanceLock.release()
+
+    def __configure(self):
+        cm = ConfigurationManager.getInstance()
+        configItems = cm.getConfigItems(FileSystemObserver.CONFIG_SECTION_NAME)
+        self.logger.debug('Got config items: %s' % configItems)
+        self.minFileProcessingDelayInSeconds = int(cm.getConfigOption(FileSystemObserver.CONFIG_SECTION_NAME, FileSystemObserver.MIN_FILE_PROCESSING_DELAY_IN_SECONDS_KEY))
+        self.fileSystemTimeoutInSeconds = int(cm.getConfigOption(FileSystemObserver.CONFIG_SECTION_NAME, FileSystemObserver.FILE_SYSTEM_EVENT_TIMEOUT_IN_SECONDS_KEY))
+
+    def startObservingPath(self, path):
+        self.lock.acquire()
+        try:
+            self.logger.debug('Starting observer for %s' % path)
+            observedWatch = self.observer.schedule(self.eventHandler, path, recursive=True)
+            self.observedWatchDict[path] = observedWatch
+        finally:
+            self.lock.release()
+
+    def stopObservingPath(self, path):
+        self.lock.acquire()
+        try:
+            observedWatch = self.observedWatchDict.get(path)
+            if observedWatch:
+                self.logger.debug('Stopping observer for %s' % path)
+                self.observer.unschedule(observedWatch)
+            else:
+                self.logger.debug('Observer for %s is not active' % path)
+        finally:
+            self.lock.release()
+        
+    def observedFileUpdated(self, path):
+        self.lock.acquire()
+        try:
+            observedFile = self.observedFileMap.get(path, ObservedFile(path=path))
+            observedFile.setLastUpdatedTimestampToNow()
+            self.observedFileMap[path] = observedFile
+            self.logger.debug('Observed file updated: %s', observedFile)
+        finally:
+            self.lock.release()
+       
+    def checkObservedFilesForProcessing(self):
+        self.lock.acquire()
+        try:
+            now = time.time()
+            pathsForProcessing = []
+            for (path,observedFile) in self.observedFileMap.items():
+                timestamp = observedFile.get('lastUpdateTimestamp')
+                deltaT = now - timestamp
+                if deltaT > self.minFileProcessingDelayInSeconds:
+                    self.logger.debug('File %s was last modified %s seconds ago, will process it.' % (path, deltaT))
+                    pathsForProcessing.append(path)
+            return pathsForProcessing
+        finally:
+            self.lock.release()
+    
+    def processObservedFile(self, path):
+        self.lock.acquire()
+        try:
+            self.logger.debug('Processing file %s' % path)
+            observedFile = self.observedFileMap.get(path)
+            if observedFile is not None:
+                del self.observedFileMap[path]
+                self.fileProcessingManager.processObservedFile(observedFile)
+        finally:
+            self.lock.release()
+     
+    def start(self):
+        self.lock.acquire()
+        try:
+            self.logger.debug('Starting file observer thread')
+            threading.Thread.start(self)
+
+            self.logger.debug('Starting watchdog observer')
+            self.observer.start()
+        finally:
+             self.lock.release()
+
+    def run(self):
+        self.logger.debug('Starting thread: %s' % self.getName())
+        while True:
+            if self.exitFlag:
+                self.logger.debug('Exit flag set, %s done' % self.getName())
+                break
+            try:
+                self.logger.debug('Checking observed files')
+
+                pathsForProcessing = self.checkObservedFilesForProcessing()
+                for path in pathsForProcessing:
+                    self.processObservedFile(path)
+            except Exception, ex:
+                self.logger.exception(ex)
+            self.eventFlag.wait(timeout=self.fileSystemTimeoutInSeconds)
+
+    def stop(self):
+        self.lock.acquire()
+        try:
+            self.logger.debug('Stopping watchdog observer')
+            self.observer.stop()
+            self.observer.join()
+
+            self.logger.debug('Stopping file observer thread')
+            self.exitFlag = True
+            self.eventFlag.set()
+            self.logger.debug('Event is set, joining thread')
+            threading.Thread.join(self)
+            self.logger.debug('Module stopped')
+        finally:
+             self.lock.release()
+
+
+    def setEvent(self):
+        self.lock.acquire()
+        try:
+             self.eventFlag.set()
+        finally:
+            self.lock.release()
+
+    def clearEvent(self):
+        self.lock.acquire()
+        try:
+            self.eventFlag.clear()
+        finally:
+            self.lock.release()
+
+####################################################################
+# Testing
+
+if __name__ == '__main__':
+    fp = FileSystemObserver.getInstance()
+    fp.start()
+    time.sleep(30)
+    fp.stop()
+
+

src/python/dm/daq_web_service/service/impl/userInfoControllerImpl.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 UserInfoControllerImpl(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/api/authRestApi.py

+#!/usr/bin/env python
+
+import os
+import urllib
+
+from dm.common.utility.encoder import Encoder
+from dm.common.exceptions.dmException import DmException
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.objects.authorizationPrincipal import AuthorizationPrincipal
+from dsRestApi import DsRestApi
+
+class AuthRestApi(DsRestApi):
+   
+    def __init__(self, username=None, password=None, host=None, port=None, protocol=None):
+        DsRestApi.__init__(self, username, password, host, port, protocol)
+
+    @DsRestApi.execute
+    def getAuthorizationPrincipal(self, username):
+        if username is None:
+            raise InvalidRequest('Username must be provided.')
+        url = '%s/authorizationPrincipals/%s' % (self.getContextRoot(), username)
+        self.logger.debug('Retrieving principal for user %s' % (username))
+        responseData = self.sendSessionRequest(url=url, method='GET')
+        return AuthorizationPrincipal(responseData)
+
+#######################################################################
+# Testing.
+
+if __name__ == '__main__':
+    api = AuthRestApi('dm', 'dm', 'zagreb.svdev.net', 22236, 'http')
+    print api.authenticateUser('sveseli', 'sv')
+        
+
+
+

src/python/dm/ds_web_service/api/dsRestApi.py

+#!/usr/bin/env python
+
+from dm.common.api.dmRestApi import DmRestApi
+
+class DsRestApi(DmRestApi):
+    """ Base DS DM REST api class. """
+
+    def __init__(self, username=None, password=None, host=None, port=None, protocol=None):
+        if host == None:
+            host = self.configurationManager.getDsWebServiceHost()
+        if port == None:
+            port = self.configurationManager.getDsWebServicePort()
+        DmRestApi.__init__(self, username, password, host, port, protocol)
+
+#######################################################################
+# Testing.
+
+if __name__ == '__main__':
+    pass
+
+

src/python/dm/ds_web_service/api/dsRestApiFactory.py

+#!/usr/bin/env python
+
+from dm.common.utility.loggingManager import LoggingManager
+from dm.common.utility.configurationManager import ConfigurationManager
+
+class DsRestApiFactory:
+
+    CONFIG_SECTION_NAME = 'DsRestApiFactory'
+    USERNAME_KEY = 'username'
+    PASSWORD_FILE_KEY = 'passwordfile'
+    HOST_KEY = 'host'
+    PORT_KEY = 'port'
+    PROTOCOL_KEY = 'protocol'
+
+    __logger = None
+    __username = None
+    __password = None
+    __host = None
+    __port = None
+    __protocol = None
+
+    @classmethod
+    def getLogger(cls):
+        if cls.__logger is None:
+            cls.__logger = LoggingManager.getInstance().getLogger(cls.__name__)
+        return cls.__logger
+
+    @classmethod
+    def __getConfiguration(cls):
+        if cls.__username is None:
+            cls.__username = ConfigurationManager.getInstance().getConfigOption(cls.CONFIG_SECTION_NAME, cls.USERNAME_KEY)
+            cls.__password = open(ConfigurationManager.getInstance().getConfigOption(cls.CONFIG_SECTION_NAME, cls.PASSWORD_FILE_KEY)).read().strip()
+            cls.__host = ConfigurationManager.getInstance().getConfigOption(cls.CONFIG_SECTION_NAME, cls.HOST_KEY)
+            cls.__port = ConfigurationManager.getInstance().getConfigOption(cls.CONFIG_SECTION_NAME, cls.PORT_KEY)
+            cls.__protocol = ConfigurationManager.getInstance().getConfigOption(cls.CONFIG_SECTION_NAME, cls.PROTOCOL_KEY)
+        return (cls.__username, cls.__password, cls.__host, cls.__port, cls.__protocol)
+
+    @classmethod
+    def getUserRestApi(cls):
+        from userRestApi import UserRestApi
+        (username, password, host, port, protocol) = cls.__getConfiguration()
+        api = UserRestApi(username, password, host, port, protocol)
+        return api
+
+    @classmethod
+    def getAuthRestApi(cls):
+        from authRestApi import AuthRestApi
+        (username, password, host, port, protocol) = cls.__getConfiguration()
+        api = AuthRestApi(username, password, host, port, protocol)
+        return api
+
+####################################################################
+# Testing
+
+if __name__ == '__main__':
+    pass
+

src/python/dm/ds_web_service/api/experimentRestApi.py

+#!/usr/bin/env python
+
+import os
+import urllib
+
+from dm.common.utility.encoder import Encoder
+from dm.common.exceptions.dmException import DmException
+from dm.common.objects.experiment import Experiment
+from dm.common.objects.experimentType import ExperimentType
+from dsRestApi import DsRestApi
+
+class ExperimentRestApi(DsRestApi):
+    
+    def __init__(self, username=None, password=None, host=None, port=None, protocol=None):
+        DsRestApi.__init__(self, username, password, host, port, protocol)
+
+    @DsRestApi.execute
+    def getExperimentTypes(self):
+        url = '%s/experimentTypes' % (self.getContextRoot())
+        responseData = self.sendSessionRequest(url=url, method='GET')
+        return self.toDmObjectList(responseData, ExperimentType)
+
+    @DsRestApi.execute
+    def getExperiments(self):
+        url = '%s/experiments' % (self.getContextRoot())
+        responseData = self.sendSessionRequest(url=url, method='GET')
+        return self.toDmObjectList(responseData, Experiment)
+
+    @DsRestApi.execute
+    def getExperimentByName(self, name):
+        url = '%s/experimentsByName/%s' % (self.getContextRoot(), name)
+        if name is None or not len(name):
+            raise InvalidRequest('Experiment name must be provided.')
+        responseDict = self.sendSessionRequest(url=url, method='GET')
+        return Experiment(responseDict)
+
+    @DsRestApi.execute
+    def getExperimentById(self, id):
+        url = '%s/experiments/%s' % (self.getContextRoot(), id)
+        if id is None:
+            raise InvalidRequest('Experiment id must be provided.')
+        responseDict = self.sendSessionRequest(url=url, method='GET')
+        return Experiment(responseDict)
+
+    @DsRestApi.execute
+    def startExperiment(self, name):
+        url = '%s/experiments/start' % (self.getContextRoot())
+        if name is None or not len(name):
+            raise InvalidRequest('Experiment name must be provided.')
+        url += '?name=%s' % Encoder.encode(name)
+        responseDict = self.sendSessionRequest(url=url, method='PUT')
+        return Experiment(responseDict)
+
+    @DsRestApi.execute
+    def stopExperiment(self, name):
+        url = '%s/experiments/stop' % (self.getContextRoot())
+        if name is None or not len(name):
+            raise InvalidRequest('Experiment name must be provided.')
+        url += '?name=%s' % Encoder.encode(name)
+        responseDict = self.sendSessionRequest(url=url, method='PUT')
+        return Experiment(responseDict)
+
+    @DsRestApi.execute
+    def addExperiment(self, name, experimentTypeId, description):
+        url = '%s/experiments' % (self.getContextRoot())
+        if name is None or not len(name):
+            raise InvalidRequest('Experiment name must be provided.')
+        url += '?name=%s' % Encoder.encode(name)
+        if experimentTypeId is None:
+            raise InvalidRequest('Experiment type id must be provided.')
+        url += '&experimentTypeId=%s' % experimentTypeId
+        if description is not None:
+            url += '&description=%s' % Encoder.encode(description)
+        responseDict = self.sendSessionRequest(url=url, method='POST')
+        return Experiment(responseDict)
+
+#######################################################################
+# Testing.
+
+if __name__ == '__main__':
+    api = ExperimentRestApi('sveseli', 'sveseli', 'zagreb.svdev.net', 33336, 'http')
+    print api.startExperiment('experiment1')
+

src/python/dm/ds_web_service/api/userRestApi.py

+#!/usr/bin/env python
+
+import os
+import urllib
+
+from dm.common.utility.encoder import Encoder
+from dm.common.exceptions.dmException import DmException
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.common.objects.userInfo import UserInfo
+from dsRestApi import DsRestApi
+
+class UserRestApi(DsRestApi):
+    
+    def __init__(self, username=None, password=None, host=None, port=None, protocol=None):
+        DsRestApi.__init__(self, username, password, host, port, protocol)
+
+    @DsRestApi.execute
+    def getUsers(self):
+        url = '%s/users' % (self.getContextRoot())
+        responseData = self.sendSessionRequest(url=url, method='GET')
+        return self.toDmObjectList(responseData, UserInfo)
+
+    @DsRestApi.execute
+    def getUserById(self, id):
+        if id is None:
+            raise InvalidRequest('User id must be provided.')
+        url = '%s/users/%s' % (self.getContextRoot(), id)
+        responseData = self.sendSessionRequest(url=url, method='GET')
+        return UserInfo(responseData)
+
+    @DsRestApi.execute
+    def getUserByUsername(self, username):
+        if username is None:
+            raise InvalidRequest('Username must be provided.')
+        url = '%s/usersByUsername/%s' % (self.getContextRoot(), username)
+        responseData = self.sendSessionRequest(url=url, method='GET')
+        return UserInfo(responseData)
+
+#######################################################################
+# Testing.
+
+if __name__ == '__main__':
+    pass
+
+
+

src/python/dm/ds_web_service/cli/addExperimentCli.py

+#!/usr/bin/env python
+
+from dm.ds_web_service.api.experimentRestApi import ExperimentRestApi
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dsWebServiceSessionCli import DsWebServiceSessionCli
+
+class AddExperimentCli(DsWebServiceSessionCli):
+    def __init__(self):
+        DsWebServiceSessionCli.__init__(self)
+        self.addOption('', '--name', dest='name', help='Experiment name.')
+        self.addOption('', '--type-id', dest='typeId', help='Experiment type id.')
+        self.addOption('', '--description', dest='description', help='Experiment description.')
+
+    def checkArgs(self):
+        if self.options.name is None:
+            raise InvalidRequest('Experiment name must be provided.')
+        if self.options.typeId is None:
+            raise InvalidRequest('Experiment type id must be provided.')
+
+
+    def getName(self):
+        return self.options.name
+
+    def getTypeId(self):
+        return self.options.typeId
+
+    def getDescription(self):
+        return self.options.description
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-get-experiment --name=NAME --type-id=TYPEID
+        [--description=DESCRIPTION]
+
+Description:
+    Add new experiment to the DM database. 
+        """)
+        self.checkArgs()
+        api = ExperimentRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        experiment = api.addExperiment(self.getName(), self.getTypeId(), self.getDescription())
+        print experiment.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = AddExperimentCli()
+    cli.run()
+

src/python/dm/ds_web_service/cli/dsWebServiceCli.py

+#!/usr/bin/env python
+
+from dm.common.cli.dmRestCli import DmRestCli
+from dm.common.utility.configurationManager import ConfigurationManager
+
+class DsWebServiceCli(DmRestCli):
+    """ DM DS web service cli class. """
+
+    def __init__(self, validArgCount=0):
+        DmRestCli.__init__(self, validArgCount)
+
+    def getDefaultServiceHost(self):
+        return ConfigurationManager.getInstance().getDsWebServiceHost()
+
+    def getDefaultServicePort(self):
+        return ConfigurationManager.getInstance().getDsWebServicePort()
+                        `

src/python/dm/ds_web_service/cli/dsWebServiceSessionCli.py

+#!/usr/bin/env python
+
+from dm.common.cli.dmRestSessionCli import DmRestSessionCli
+from dm.common.utility.osUtility import OsUtility
+from dm.common.utility.configurationManager import ConfigurationManager
+
+class DsWebServiceSessionCli(DmRestSessionCli):
+    """ DM DS web service session cli class. """
+
+    DEFAULT_SESSION_CACHE_FILE = OsUtility.getUserHomeDir() + '/.dm/.ds.session.cache'
+
+    def __init__(self, validArgCount=0):
+        DmRestSessionCli.__init__(self, validArgCount)
+        ConfigurationManager.getInstance().setSessionCacheFile(DsWebServiceSessionCli.DEFAULT_SESSION_CACHE_FILE)
+
+    def getDefaultServiceHost(self):
+        return ConfigurationManager.getInstance().getDsWebServiceHost()
+
+    def getDefaultServicePort(self):
+        return ConfigurationManager.getInstance().getDsWebServicePort()
+

src/python/dm/ds_web_service/cli/getExperimentCli.py

+#!/usr/bin/env python
+
+from dm.common.exceptions.invalidRequest import InvalidRequest
+from dm.ds_web_service.api.userRestApi import ExperimentRestApi
+from dsWebServiceSessionCli import DsWebServiceSessionCli
+
+class GetExperimentCli(DsWebServiceSessionCli):
+    def __init__(self):
+        DsWebServiceSessionCli.__init__(self)
+        self.addOption('', '--id', dest='id', help='Experiment id. Either id or name must be provided. If both are provided, id takes precedence.')
+        self.addOption('', '--name', dest='name', help='Experiment name. Either id or name must be provided. If both are provided, id takes precedence.')
+
+    def checkArgs(self):
+        if self.options.id is None and self.options.username is None:
+            raise InvalidRequest('Either user id or username must be provided.')
+
+    def getId(self):
+        return self.options.id
+
+    def getName(self):
+        return self.options.name
+
+    def runCommand(self):
+        self.parseArgs(usage="""
+    dm-get-user --id=ID|--name=NAME
+
+Description:
+    Retrieves experiment information.
+        """)
+        self.checkArgs()
+        api = ExperimentRestApi(self.getLoginUsername(), self.getLoginPassword(), self.getServiceHost(), self.getServicePort(), self.getServiceProtocol())
+        if self.getId() is not None:
+            experiment = api.getExperimentById(self.getId())
+        else:
+            experiment = api.getExperimentByName(self.getName())
+        print experiment.getDisplayString(self.getDisplayKeys(), self.getDisplayFormat())
+
+#######################################################################
+# Run command.
+if __name__ == '__main__':
+    cli = GetExperimentCli()
+    cli.run()
+