def configureLoggers(self, configParser, defaultLevel='error'):
rootLogLevel = 'error'
levelRegEx = '^.*$=%s' % (defaultLevel)
if configParser is not None and configParser.has_section('LoggerLevels'):
rootLogLevel = ConfigurationManager.getOptionFromConfigParser(configParser, 'LoggerLevels', 'root', rootLogLevel)
levelRegEx = ConfigurationManager.getOptionFromConfigParser(configParser, 'LoggerLevels', 'levelregex', levelRegEx)
rootLevelInt = logging.getLevelName(rootLogLevel.upper())
logging.getLogger('').root.setLevel(rootLevelInt)
logging.getLogger('').debug('Set root logger to %s' % rootLevelInt)
if not levelRegEx:
return
# Parse expressions of the form <regex>=<log-level>. """
lines = levelRegEx.split('\n')
for line in lines:
try:
# Use the right split so we can have '='s in the regex
(regex, level) = line.rsplit('=', 1)
pattern = re.compile(regex)
tuple = (pattern, logging.getLevelName(level.upper()))
self.levelRegExList.append(tuple)
except Exception, ex:
# Do not fail
self.logger.error('Parser error in log configuration file: %s' % line)
self.logger.exception(ex)
def __init__(self, routeMapper):
self.configurationManager = ConfigurationManager.getInstance()
self.routeMapper = routeMapper
self.options = None
self.args = None
self.logger = None
self.backgroundTaskManager = None
def getInstance(cls):
""" Get configuration manager singleton instance. """
from cdb.common.utility.configurationManager import ConfigurationManager
try:
cm = ConfigurationManager()
except ConfigurationManager, ex:
cm = ex
def getRoutes(cls):
contextRoot = ConfigurationManager.getInstance().getContextRoot()
# Static instances shared between different routes
itemController = ItemController()
itemElementController = ItemElementController()
# Define routes.
routes = [
# Get item by id
{
'name': 'getItemById',
'path': '%s/items/:(itemId)' % contextRoot,
'controller': itemController,
'action': 'getItemById',
'method': ['GET']
},
# Get item element by id
{
'name': 'getItemElementById',
'path': '%s/itemElements/:(itemElementId)' % contextRoot,
'controller': itemElementController,
'action': 'getItemElementById',
'method': ['GET']
}
]
return routes
def parseArgs(self, usage=None):
CdbCli.parseArgs(self, usage)
configManager = ConfigurationManager.getInstance()
self.serviceUrl = self.options.serviceUrl
configManager.setServiceUrl(self.serviceUrl)
self.serviceHost = configManager.getServiceHost()
self.servicePort = configManager.getServicePort()
self.serviceProtocol = configManager.getServiceProtocol()
def getRoutes(cls):
contextRoot = ConfigurationManager.getInstance().getContextRoot()
# Static instances shared between different routes
userInfoController = UserInfoController()
userGroupController = UserGroupController()
# Define routes.
routes = [
# Get user group list
{
'name': 'getUserGroups',
'path': '%s/userGroups' % contextRoot,
'controller': userGroupController,
'action': 'getUserGroups',
'method': ['GET']
},
# Get user group by name
{
'name': 'getUserGroupByName',
'path': '%s/userGroupsByName/:(groupName)' % contextRoot,
'controller': userGroupController,
'action': 'getUserGroupByName',
'method': ['GET']
},
# Get user info list
{
'name': 'getUsers',
'path': '%s/users' % contextRoot,
'controller': userInfoController,
'action': 'getUsers',
'method': ['GET']
},
# Get user by id
{
'name': 'getUserById',
'path': '%s/users/:(id)' % contextRoot,
'controller': userInfoController,
'action': 'getUserById',
'method': ['GET']
},
# Get user by username
{
'name': 'getUserByUsername',
'path': '%s/usersByUsername/:(username)' % contextRoot,
'controller': userInfoController,
'action': 'getUserByUsername',
'method': ['GET']
},
]
return routes
def parseArgs(self, usage=None):
if usage:
self.parser.usage = usage
try:
(self.options, self.args) = self.parser.parse_args()
self.processArgs()
except SystemExit as rc:
sys.stdout.flush()
sys.stderr.flush()
sys.exit(int(str(rc)))
if self.validArgCount < len(self.args):
# Positional args are not enabled and we have some
msg = 'Invalid positional argument(s):'
for arg in self.args[self.validArgCount:]:
msg += ' ' + arg
msg += ' (This command allows %s positional arguments.)' % self.validArgCount
raise InvalidArgument(msg)
optDict = self.options.__dict__
if optDict.get('version'):
print('CDB Software Version: %s' % (cdb.__version__))
sys.exit(0)
# Logging level. First try from command line, then from env variable.
consoleLogLevel = optDict.get('consoleLogLevel', None)
if consoleLogLevel:
LoggingManager.getInstance().setConsoleLogLevel(consoleLogLevel)
else:
consoleLogLevel = ConfigurationManager.getInstance(
).getConsoleLogLevelFromEnvVar()
if consoleLogLevel:
LoggingManager.getInstance().setConsoleLogLevel(
consoleLogLevel)
# Check session cache.
configManager = ConfigurationManager.getInstance()
try:
self.checkSessionCache()
except Exception as ex:
self.logger.warn('Disabling session cache: %s' % ex)
configManager.setSessionCacheFile(None)
return (self.options, self.args)
def __init__(self):
if CdbPortalUrlUtility.__instance:
raise CdbPortalUrlUtility.__instance
CdbPortalUrlUtility.__instance = self
self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
cm = ConfigurationManager.getInstance()
cm.setOptionsFromConfigFile(CdbPortalUrlUtility.CONFIG_SECTION_NAME, CdbPortalUrlUtility.CONFIG_OPTION_NAME_LIST)
self.portalWebAddress = cm.getPortalWebAddress()
def __init__(self):
self.sessionCookie = None
self.host = None
self.logger = LoggingManager.getInstance().getLogger(self.__class__.__name__)
self.username = ''
self.password = ''
self.urlOpener = None
cm = ConfigurationManager.getInstance()
self.sessionCacheFile = cm.getSessionCacheFile()
self.requireSessionCredentials = cm.getRequireSessionCredentials()
def checkSessionCache(self):
configManager = ConfigurationManager.getInstance()
sessionCacheFile = configManager.getSessionCacheFile()
if sessionCacheFile is None:
sessionCacheFile = CdbCli.DEFAULT_SESSION_CACHE_FILE
sessionCacheFile = sessionCacheFile.strip()
if len(sessionCacheFile):
sessionCacheDir = os.path.dirname(sessionCacheFile)
OsUtility.createDir(sessionCacheDir, stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR)
configManager.setSessionCacheFile(sessionCacheFile)
configManager.setRequireSessionCredentials(True)
def getRoutes(cls):
contextRoot = ConfigurationManager.getInstance().getContextRoot()
# Static instances shared between different routes
propertyController = PropertyController()
propertySessionController = PropertySessionController()
routes = [
# Get property types
{
'name': 'getPropertyTypes',
'path': '%s/property/types' % contextRoot,
'controller': propertyController,
'action': 'getPropertyTypes',
'method': ['GET']
},
{
'name': 'getPropertyType',
'path': '%s/property/types/:(propertyTypeId)' % contextRoot,
'controller': propertyController,
'action': 'getPropertyType',
'method': ['GET']
},
{
'name': 'getAllowedPropertyValuesForPropertyType',
'path': '%s/property/types/:(propertyTypeId)/allowedPropertyValues' % contextRoot,
'controller': propertyController,
'action': 'getAllowedPropertyValuesForPropertyType',
'method': ['GET']
},
{
'name': 'getPropertyMetadataForPropertyValue',
'path': '%s/property/values/:(propertyValueId)/metadata' % contextRoot,
'controller': propertyController,
'action': 'getPropertyMetadataForPropertyValueId',
'method': ['GET']
},
{
'name': 'addPropertyMetadataForPropertyValue',
'path': '%s/property/values/:(propertyValueId)/addMetadata/:(metadataKey)' % contextRoot,
'controller': propertySessionController,
'action': 'addPropertyValueMetadata',
'method': ['POST']
},
{
'name': 'addPropertyMetadataForPropertyValueUsingDict',
'path': '%s/property/values/:(propertyValueId)/addMetadata' % contextRoot,
'controller': propertySessionController,
'action': 'addPropertyValueMetadataFromDict',
'method': ['POST']
},
]
return routes
def __init__(self):
if StorageUtility.__instance:
raise StorageUtility.__instance
StorageUtility.__instance = self
self.logger = LoggingManager.getInstance().getLogger(
self.__class__.__name__)
cm = ConfigurationManager.getInstance()
cm.setOptionsFromConfigFile(self.CONFIG_SECTION_NAME,
self.CONFIG_OPTION_NAME_LIST)
self.logAttachmentStoragePath = cm.getLogAttachmentPath()
self.storageDirectory = cm.getStorageDirectory()
def __init__(self):
if AuthorizationManager.__instance:
raise AuthorizationManager.__instance
AuthorizationManager.__instance = self
CdbObjectManager.__init__(self)
self.configurationManager = ConfigurationManager.getInstance()
self.principalRetriever = None
self.principalAuthenticatorList = []
self.objectCache = ObjectCache(
AuthorizationManager.DEFAULT_CACHE_SIZE,
AuthorizationManager.DEFAULT_CACHE_OBJECT_LIFETIME)
self.adminGroupName = None
self.configure()
def configureHandlers(self):
""" Configure log handlers from the config file. """
cm = ConfigurationManager.getInstance()
configFile = cm.getConfigFile()
configParser = cm.getConfigParserFromConfigFile(configFile)
configSections = cm.getConfigSectionsFromConfigParser(configParser)
# Console handler.
defaults = {
'level' : cm.getConsoleLogLevel(),
'format' : cm.getLogRecordFormat(),
'dateFormat' : cm.getLogDateFormat(),
'handler' : 'ConsoleLoggingHandler(sys.stdout,)'
}
consoleHandler = self.__configureHandler(configParser, 'ConsoleLogging', defaults)
if consoleHandler != None:
self.consoleHandler = consoleHandler
# File logging.
# Do not configure if log directory does not exist.
defaults['handler'] = None
defaults['level'] = cm.getFileLogLevel()
if not os.path.exists(configFile):
# No config file, we'll configure default.
defaultLogFile = cm.getLogFile()
defaultLogDir = os.path.dirname(defaultLogFile)
if os.path.exists(defaultLogDir):
handler = 'TimedRotatingFileLoggingHandler("%s")' % defaultLogFile
defaults['handler'] = handler
fileHandler = self.__configureHandler(configParser, 'FileLogging', defaults)
if fileHandler != None:
self.fileHandlerList.append(fileHandler)
else:
# Parse all file loggers present in the config file
for configSection in configSections:
if configSection.startswith('FileLogging'):
fileHandler = self.__configureHandler(configParser, configSection, defaults)
if fileHandler != None:
self.fileHandlerList.append(fileHandler)
# Add handlers to the root logger. Use logging class here
# to make sure we can have a logger when we parse the
# logger expressions
rootLogger = logging.getLogger('')
for handler in [self.consoleHandler] + self.fileHandlerList:
rootLogger.addHandler(handler)
# Get a logger factory based on our current config
self.configureLoggers(configParser, defaultLevel='debug')
def getUrlOpener(self, protocol):
if not self.urlOpener:
if protocol == cdbServiceConstants.CDB_SERVICE_PROTOCOL_HTTPS:
# HTTPS, use custom https handler, which
# should work even if any of cert/key/cacert files is None
cm = ConfigurationManager.getInstance()
keyFile = cm.getSslKeyFile()
certFile = cm.getSslCertFile()
self.urlOpener = urllib2.build_opener(CdbHttpsHandler)
#self.logger.debug('Using Cdb HTTPS Handler')
else:
# HTTP, use standard http handler
self.urlOpener = urllib2.build_opener(urllib2.HTTPHandler)
# Install opener before returning it.
urllib2.install_opener(self.urlOpener)
return self.urlOpener
def __init__(self):
if StorageUtility.__instance:
raise StorageUtility.__instance
StorageUtility.__instance = self
self.logger = LoggingManager.getInstance().getLogger(
self.__class__.__name__)
cm = ConfigurationManager.getInstance()
cm.setOptionsFromConfigFile(self.CONFIG_SECTION_NAME,
self.CONFIG_OPTION_NAME_LIST)
self.logAttachmentStoragePath = cm.getLogAttachmentPath()
self.propertyImageStoragePath = cm.getPropertyImagePath()
self.storageDirectory = cm.getStorageDirectory()
self.installDirectory = cm.getCdbInstallationDirectory()
self.galleryUpdateScript = '%s/%s' % (self.installDirectory,
self.GALLERY_UPDATE_SCRIPT_PATH)
def __init__(self):
DbManager.__lock.acquire()
try:
if DbManager.__instance is not None:
raise DbManager.__instance
DbManager.__instance = self
self.lock = threading.RLock()
self.logger = LoggingManager.getInstance().getLogger(
self.__class__.__name__)
cm = ConfigurationManager.getInstance()
cm.setOptionsFromConfigFile(DbManager.CONFIG_SECTION_NAME,
DbManager.CONFIG_OPTION_NAME_LIST)
dbUser = cm.getDbUser()
self.logger.debug('Using DB user: %s' % dbUser)
dbSchema = cm.getDbSchema()
dbPasswordFile = cm.getDbPasswordFile()
self.logger.debug('Using DB password file: %s' % dbPasswordFile)
dbPassword = open(dbPasswordFile, 'r').readline().strip()
dbPort = cm.getDbPort()
dbHost = cm.getDbHost()
db = cm.getDb()
self.logger.debug('DB schema: %s' % dbSchema)
self.logger.debug('DB password file: %s' % dbPasswordFile)
engineUrl = '%s://%s:%s@%s:%s/%s' % (db, dbUser, dbPassword,
dbHost, dbPort, dbSchema)
#self.logger.debug('Using engine URL: %s' % engineUrl)
self.engine = sqlalchemy.create_engine(
engineUrl,
pool_size=DbManager.DB_CONNECTION_POOL_SIZE,
max_overflow=DbManager.DB_CONNECTION_POOL_MAX_OVERFLOW,
pool_recycle=DbManager.DB_CONNECTION_POOL_RECYCYLE_TIME,
echo=DbManager.DB_CONNECTION_LOGGING_FLAG,
pool_timeout=DbManager.DB_CONNECTION_POOL_TIMEOUT)
self.metadata = sqlalchemy.MetaData(engineUrl)
self.logger.debug('Mapping DB tables')
for (dbTableName,
(dbEntityClass,
dbRelationDict)) in cdbDbEntityMap.CDB_DB_ENTITY_MAP.items():
self.mapTable(dbEntityClass, dbTableName, dbRelationDict)
self.logger.debug('Initialized SQLalchemy engines')
finally:
DbManager.__lock.release()
def __init__(self, username=None, password=None, host=None, port=None, protocol=None):
CdbApi.__init__(self)
self.configurationManager = ConfigurationManager.getInstance()
if username == None and password == None:
username = self.configurationManager.getServiceUsername()
password = self.configurationManager.getServicePassword()
if host == None:
host = self.configurationManager.getServiceHost()
if port == None:
port = self.configurationManager.getServicePort()
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
def __init__(self):
if CdbEmailUtility.__instance:
raise CdbEmailUtility.__instance
CdbEmailUtility.__instance = self
self.logger = LoggingManager.getInstance().getLogger(
self.__class__.__name__)
cm = ConfigurationManager.getInstance()
cm.setOptionsFromConfigFile(CdbEmailUtility.CONFIG_SECTION_NAME,
CdbEmailUtility.CONFIG_OPTION_NAME_LIST)
self.mode = cm.getEmailMode()
self.__verifyValidMode(self.mode)
self.logger.debug("Running in '%s' mode." % self.mode)
self.senderEmail = cm.getEmailSenderEmail()
self.adminNotificationEmail = cm.getEmailAdminNotificationEmail()
self.cdbSubjectStart = cm.getEmailSubject()
self.smtpServer = cm.getEmailSmtpServer()
def __init__(self, hostPort, timeout):
cm = ConfigurationManager.getInstance()
args = hostPort.split(':')
host = args[0]
if len(args) > 1:
port = int(args[1])
else:
port = cm.getServicePort()
keyFile = cm.getSslKeyFile()
certFile = cm.getSslCertFile()
caCertFile = cm.getSslCaCertFile()
certChain = None
strict = True
httplib.HTTPSConnection.__init__(self, host, port, keyFile, certFile,
strict, timeout)
context = self.getContext(keyFile, certFile, caCertFile, certChain)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock = context.wrap_socket(sock)
self.connect()
def getRoutes(cls):
contextRoot = ConfigurationManager.getInstance().getContextRoot()
# Static instances shared between different routes
loginController = LoginController()
# Define routes.
# Make sure to have leading '/' for consistency.
routes = [
# Authorization
{
'name' : 'login',
'path' : '%s/login' % contextRoot,
'controller' : loginController,
'action' : 'login',
'method' : ['GET', 'PUT', 'POST', 'DELETE']
},
]
return routes
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(
) + UserRouteDescriptor.getRoutes()
routes += CdbPluginRouteMapper.getPluginRoutes()
routes += ItemRouteDescriptor.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
def getRoutes(cls):
contextRoot = ConfigurationManager.getInstance().getContextRoot()
# Static instances shared between different routes
logSessionController = LogSessionController()
# Define routes.
routes = [
# Add log Attachment
{
'name': 'addAttachmentToLogEntry',
'path': '%s/logs/:(logId)/addAttachment' % contextRoot,
'controller': logSessionController,
'action': 'addLogAttachment',
'method': ['POST']
},
{
'name': 'updateLogEntry',
'path': '%s/logs/:(logId)/update' % contextRoot,
'controller': logSessionController,
'action': 'updateLogEntry',
'method': ['PUT']
},
{
'name': 'deleteLogEntry',
'path': '%s/logs/:(logId)/delete' % contextRoot,
'controller': logSessionController,
'action': 'deleteLogEntry',
'method': ['DELETE']
}
]
return routes
"""
if '?' in url:
return '%s&%s=%s' % (url, paramName, paramValue)
else:
return '%s?%s=%s' % (url, paramName, paramValue)
#######################################################################
# Testing.
if __name__ == '__main__':
api = CdbRestApi('sveseli', 'sveseli')
#api.sendRequest('https://zagreb.svdev.net:10232/cdb/directory/list', 'GET', data='')
import urllib.request, urllib.parse, urllib.error
from cdb.common.utility.configurationManager import ConfigurationManager
cm = ConfigurationManager.getInstance()
cm.setSessionCacheFile('/tmp/session')
#print 'Non-session request'
#print api.sendRequest('https://zagreb.svdev.net:10232/cdb/directory/list?path=/tmp', 'GET')
print('Session request')
data = {'path': '/tmp/xyz'}
#print api.sendSessionRequest('https://zagreb.svdev.net:10232/cdb/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/cdb/file/write', 'POST', data=data)
postdata = 'path=/tmp/xyz'
postdata += '&content=%s' % urllib.parse.quote_plus('Hey there')
print(
api.sendSessionRequest('https://zagreb.svdev.net:10232/cdb/file/write',
'POST',
contentType='application/x-www-form-urlencoded',
data=postdata))
def getRoutes(cls):
contextRoot = ConfigurationManager.getInstance().getContextRoot()
# Static instances shared between different routes
itemController = ItemController()
itemElementController = ItemElementController()
itemSessionController = ItemSessionController()
# Define routes.
routes = [
# Get item by id
{
'name': 'getItemById',
'path': '%s/items/:(itemId)' % contextRoot,
'controller': itemController,
'action': 'getItemById',
'method': ['GET']
},
# Get item element by id
{
'name': 'getItemElementById',
'path': '%s/itemElements/:(itemElementId)' % contextRoot,
'controller': itemElementController,
'action': 'getItemElementById',
'method': ['GET']
},
# Add a log entry for an item
{
'name': 'addLogEntryForItemByQrId',
'path': '%s/items/:(qrId)/addLogEntry' % contextRoot,
'controller': itemSessionController,
'action': 'addLogToItemByQrId',
'method': ['POST']
},
# Get log entries for a particular item
{
'name': 'getLogEntriesForItemByQrId',
'path': '%s/items/:(qrId)/logs' % contextRoot,
'controller': itemController,
'action': 'getItemLogsByQrId',
'method': ['GET']
},
# Get properties for a particular item
{
'name': 'getPropertiesForItemByItemId',
'path': '%s/items/:(itemId)/propertiesByItemId' % contextRoot,
'controller': itemController,
'action': 'getPropertiesForItemByItemId',
'method': ['GET']
},
# Get log entries for a particular item
{
'name': 'getLogEntriesForItemById',
'path': '%s/items/:(itemId)/logsByItemId' % contextRoot,
'controller': itemController,
'action': 'getItemLogsById',
'method': ['GET']
},
# Get items derived from item
{
'name': 'getItemsDerivedFromItem',
'path':
'%s/items/derivedFromItem/:(derivedFromItemId)' % contextRoot,
'controller': itemController,
'action': 'getItemsDerivedFromItem',
'method': ['GET']
},
# Get catalog items
{
'name': 'getCatalogItems',
'path': '%s/items/domain/catalog' % contextRoot,
'controller': itemController,
'action': 'getCatalogItems',
'method': ['GET']
}
]
return routes
def getDefaultServerPort(self):
return ConfigurationManager.getInstance().getServicePort()
try:
session.close()
finally:
self.lock.release()
def acquireConnection(self):
""" Get db connection. """
self.lock.acquire()
try:
return self.engine.connect()
finally:
self.lock.release()
def releaseConnection(self, connection):
""" Release db connection. """
self.lock.acquire()
try:
if connection:
connection.close()
finally:
self.lock.release()
#######################################################################
# Testing.
if __name__ == '__main__':
ConfigurationManager.getInstance().setConsoleLogLevel('debug')
mgr = DbManager.getInstance()
mgr.acquireConnection()
print 'Got connection'
def getDefaultServiceProtocol(self):
return ConfigurationManager.getInstance().getServiceProtocol()
def getServiceProtocol(self):
#return self.serviceProtocol
return ConfigurationManager.getInstance().getServiceProtocol()
def getServicePort(self):
#return self.servicePort
return ConfigurationManager.getInstance().getServicePort()