def main(args):
parser = _createParser()
log.debug('manager', 'Parsing arguments (%r)' % ', '.join(args))
options, args = parser.parse_args(args)
# Force options down configure's throat
for d in ['logdir', 'rundir']:
o = getattr(options, d, None)
if o:
log.debug('manager', 'Setting configure.%s to %s' % (d, o))
setattr(configure, d, o)
# parse planet config file
if len(args) <= 1:
log.warning('manager', 'Please specify a planet configuration file')
sys.stderr.write("Please specify a planet configuration file.\n")
return 1
planetFile = args[1]
try:
cfg = config.ManagerConfigParser(planetFile)
except IOError, e:
sys.stderr.write("ERROR: Could not read configuration from '%s':\n" %
planetFile)
sys.stderr.write("ERROR: %s\n" % e.strerror)
return 1
def main(args):
parser = _createParser()
log.debug("manager", "Parsing arguments (%r)" % ", ".join(args))
options, args = parser.parse_args(args)
# Force options down configure's throat
for d in ["logdir", "rundir"]:
o = getattr(options, d, None)
if o:
log.debug("manager", "Setting configure.%s to %s" % (d, o))
setattr(configure, d, o)
# parse planet config file
if len(args) <= 1:
log.warning("manager", "Please specify a planet configuration file")
sys.stderr.write("Please specify a planet configuration file.\n")
return 1
planetFile = args[1]
try:
cfg = config.ManagerConfigParser(planetFile)
except IOError, e:
sys.stderr.write("ERROR: Could not read configuration from '%s':\n" % planetFile)
sys.stderr.write("ERROR: %s\n" % e.strerror)
return 1
def getRecentConnections():
"""
Fetches a list of recently used connections
@returns: recently used connections
@rtype: list of L{RecentConnection}
"""
def _parseConnection(filename):
tree = minidom.parse(filename)
state = {}
for childNode in tree.documentElement.childNodes:
if (childNode.nodeType != Node.TEXT_NODE and
childNode.nodeType != Node.COMMENT_NODE):
state[childNode.nodeName] = childNode.childNodes[0].wholeText
state['port'] = int(state['port'])
state['use_insecure'] = (state['use_insecure'] != '0')
authenticator = Authenticator(username=state['user'],
password=state['passwd'])
return PBConnectionInfo(state['host'], state['port'],
not state['use_insecure'],
authenticator)
recentFilenames = _getRecentFilenames()
recentConnections = []
for filename in sorted(recentFilenames, reverse=True):
try:
state = _parseConnection(filename)
recentConnections.append(
RecentConnection(str(state),
filename=filename,
info=state))
except Exception, e:
log.warning('connections', 'Error parsing %s: %r', filename, e)
def _cbRequestAvatarId(self, validKey, credentials):
if not validKey:
return failure.Failure(UnauthorizedLogin())
if not credentials.signature:
return failure.Failure(error.ValidPublicKey())
else:
try:
if conch.version.major < 10:
pubKey = keys.getPublicKeyObject(data=credentials.blob)
if keys.verifySignature(pubKey, credentials.signature,
credentials.sigData):
return credentials.username
else:
pubKey = keys.Key.fromString(credentials.blob)
if pubKey.verify(credentials.signature,
credentials.sigData):
return credentials.username
except: # any error should be treated as a failed login
f = failure.Failure()
log.warning('manhole',
'error checking signature on creds %r: %r',
credentials, log.getFailureMessage(f))
return f
return failure.Failure(UnauthorizedLogin())
def _cbRequestAvatarId(self, validKey, credentials):
if not validKey:
return failure.Failure(UnauthorizedLogin())
if not credentials.signature:
return failure.Failure(error.ValidPublicKey())
else:
try:
if conch.version.major < 10:
pubKey = keys.getPublicKeyObject(data=credentials.blob)
if keys.verifySignature(pubKey, credentials.signature,
credentials.sigData):
return credentials.username
else:
pubKey = keys.Key.fromString(credentials.blob)
if pubKey.verify(credentials.signature,
credentials.sigData):
return credentials.username
except: # any error should be treated as a failed login
f = failure.Failure()
log.warning('manhole',
'error checking signature on creds %r: %r',
credentials, log.getFailureMessage(f))
return f
return failure.Failure(UnauthorizedLogin())
def read(self):
try:
tree = minidom.parse(self._filename)
node = tree.getElementsByTagName('gtk-admin-state')[0]
for elem in node.childNodes:
self._values[elem.nodeName] = elem.firstChild.data
except (IOError, IndexError, ExpatError), e:
log.warning('Cannot read gtl-admin-state %s',
log.getExceptionMessage(e))
def read(self):
try:
tree = minidom.parse(self._filename)
node = tree.getElementsByTagName('gtk-admin-state')[0]
for elem in node.childNodes:
self._values[elem.nodeName] = elem.firstChild.data
except (IOError, IndexError, ExpatError), e:
log.warning('Cannot read gtl-admin-state %s',
log.getExceptionMessage(e))
def handleGStreamerDeviceError(failure, device, mid=None):
"""
Handle common GStreamer GstErrors or other.
Return a message or None.
"""
if not mid:
log.warning('check',
'handleGStreamerDeviceError: no message id specified')
m = None
if failure.check(errors.GStreamerGstError):
source, gerror, debug = failure.value.args
log.debug('check',
'GStreamer GError: %s (domain %s, code %d, debug %s)' % (
gerror.message, gerror.domain, gerror.code, debug))
if gerror.domain == "gst-resource-error-quark":
if gerror.code == int(Gst.RESOURCE_ERROR_OPEN_READ):
m = messages.Error(T_(
N_("Could not open device '%s' for reading. "
"Check permissions on the device."), device), mid=mid)
documentation.messageAddFixBadPermissions(m)
if gerror.code == int(Gst.RESOURCE_ERROR_OPEN_WRITE):
m = messages.Error(T_(
N_("Could not open device '%s' for writing. "
"Check permissions on the device."), device), mid=mid)
documentation.messageAddFixBadPermissions(m)
elif gerror.code == int(Gst.RESOURCE_ERROR_OPEN_READ_WRITE):
m = messages.Error(T_(
N_("Could not open device '%s'. "
"Check permissions on the device."), device), mid=mid)
documentation.messageAddFixBadPermissions(m)
elif gerror.code == int(Gst.RESOURCE_ERROR_BUSY):
m = messages.Error(T_(
N_("Device '%s' is already in use."), device), mid=mid)
elif gerror.code == int(Gst.RESOURCE_ERROR_SETTINGS):
m = messages.Error(T_(
N_("Device '%s' did not accept the requested settings."),
device),
debug="%s\n%s" % (gerror.message, debug), mid=mid)
# fallback GStreamer GstError handling
if not m:
m = messages.Error(T_(N_("Internal unhandled GStreamer error.")),
debug="%s\n%s: %d\n%s" % (
gerror.message, gerror.domain, gerror.code, debug),
mid=mid)
elif failure.check(errors.GStreamerError):
m = messages.Error(T_(N_("Internal GStreamer error.")),
debug=debugFailure(failure), mid=mid)
log.debug('check', 'handleGStreamerError: returning %r' % m)
return m
def handleGStreamerDeviceError(failure, device, mid=None):
"""
Handle common GStreamer GstErrors or other.
Return a message or None.
"""
if not mid:
log.warning('check',
'handleGStreamerDeviceError: no message id specified')
m = None
if failure.check(errors.GStreamerGstError):
source, gerror, debug = failure.value.args
log.debug('check',
'GStreamer GError: %s (domain %s, code %d, debug %s)' % (
gerror.message, gerror.domain, gerror.code, debug))
if gerror.domain == "gst-resource-error-quark":
if gerror.code == int(gst.RESOURCE_ERROR_OPEN_READ):
m = messages.Error(T_(
N_("Could not open device '%s' for reading. "
"Check permissions on the device."), device), mid=mid)
documentation.messageAddFixBadPermissions(m)
if gerror.code == int(gst.RESOURCE_ERROR_OPEN_WRITE):
m = messages.Error(T_(
N_("Could not open device '%s' for writing. "
"Check permissions on the device."), device), mid=mid)
documentation.messageAddFixBadPermissions(m)
elif gerror.code == int(gst.RESOURCE_ERROR_OPEN_READ_WRITE):
m = messages.Error(T_(
N_("Could not open device '%s'. "
"Check permissions on the device."), device), mid=mid)
documentation.messageAddFixBadPermissions(m)
elif gerror.code == int(gst.RESOURCE_ERROR_BUSY):
m = messages.Error(T_(
N_("Device '%s' is already in use."), device), mid=mid)
elif gerror.code == int(gst.RESOURCE_ERROR_SETTINGS):
m = messages.Error(T_(
N_("Device '%s' did not accept the requested settings."),
device),
debug="%s\n%s" % (gerror.message, debug), mid=mid)
# fallback GStreamer GstError handling
if not m:
m = messages.Error(T_(N_("Internal unhandled GStreamer error.")),
debug="%s\n%s: %d\n%s" % (
gerror.message, gerror.domain, gerror.code, debug),
mid=mid)
elif failure.check(errors.GStreamerError):
m = messages.Error(T_(N_("Internal GStreamer error.")),
debug=debugFailure(failure), mid=mid)
log.debug('check', 'handleGStreamerError: returning %r' % m)
return m
def save(self):
try:
f = open(self._filename, 'w')
doc = minidom.Document()
root = doc.createElement('gtk-admin-state')
doc.appendChild(root)
for key, value in self._values.iteritems():
self._append(doc, root, key, value)
doc.writexml(f)
f.close()
except IOError, e:
log.warning('Cannot find gtk-admin-state: %s',
log.getExceptionMessage(e))
def _notifyListeners(self, index, *args):
# notify our local listeners; compute set of procs first, so as
# to allow the listeners set to change during the calls
self._ensureListeners()
for proc in [tup[index] for tup in self._listeners.values()]:
if proc:
try:
proc(self, *args)
except Exception, e:
# These are all programming errors
log.warning("stateremotecache",
'Exception in StateCache handler: %s',
log.getExceptionMessage(e))
def _notifyListeners(self, index, *args):
# notify our local listeners; compute set of procs first, so as
# to allow the listeners set to change during the calls
self._ensureListeners()
for proc in [tup[index] for tup in self._listeners.values()]:
if proc:
try:
proc(self, *args)
except Exception, e:
# These are all programming errors
log.warning("stateremotecache",
'Exception in StateCache handler: %s',
log.getExceptionMessage(e))
def setMood(self, moodValue):
if self._jobState and moodValue != moods.sad.value:
log.warning('componentstate', 'cannot set component mood to '
'something other than sad when we have a '
'jobState -- fix your code!')
elif moodValue == self.get('mood'):
log.log('componentstate', '%s already in mood %d',
self.get('name'), moodValue)
else:
log.debug('componentstate',
'manager sets mood of %s from %s to %d',
self.get('name'), self.get('mood'), moodValue)
self.set('mood', moodValue)
def save(self):
try:
f = open(self._filename, 'w')
doc = minidom.Document()
root = doc.createElement('gtk-admin-state')
doc.appendChild(root)
for key, value in self._values.iteritems():
self._append(doc, root, key, value)
doc.writexml(f)
f.close()
except IOError, e:
log.warning('Cannot find gtk-admin-state: %s',
log.getExceptionMessage(e))
def emit(self, signalName, *args):
self.__ensureSignals()
if signalName not in self.__signals__:
raise ValueError('Emitting unknown signal %s' % signalName)
connections = self.__signalConnections
for name, proc, pargs, pkwargs in connections.values():
if name == signalName:
try:
proc(self, *(args + pargs), **pkwargs)
except Exception, e:
log.warning("signalmixin", "Exception calling "
"signal handler %r: %s", proc,
log.getExceptionMessage(e))
def run(self):
while self._running:
sessions = self.plug._sessions.keys()
for session in sessions:
try:
session.doServe()
except Exception, e:
log.warning("Error during async file serving: %s",
log.getExceptionMessage(e))
try:
session.doCopy()
except Exception, e:
log.warning("Error during file copy: %s",
log.getExceptionMessage(e))
def run(self):
while self._running:
sessions = self.plug._sessions.keys()
for session in sessions:
try:
session.doServe()
except Exception, e:
log.warning("Error during async file serving: %s",
log.getExceptionMessage(e))
try:
session.doCopy()
except Exception, e:
log.warning("Error during file copy: %s",
log.getExceptionMessage(e))
def emit(self, signalName, *args):
self.__ensureSignals()
if signalName not in self.__signals__:
raise ValueError('Emitting unknown signal %s' % signalName)
connections = self.__signalConnections
for name, proc, pargs, pkwargs in connections.values():
if name == signalName:
try:
proc(self, *(args + pargs), **pkwargs)
except Exception, e:
log.warning("signalmixin", "Exception calling "
"signal handler %r: %s", proc,
log.getExceptionMessage(e))
def getRecentConnections():
"""
Fetches a list of recently used connections
@returns: recently used connections
@rtype: list of L{RecentConnection}
"""
recentFilenames = _getRecentFilenames()
recentConnections = []
for filename in sorted(recentFilenames, reverse=True):
try:
state = _parseSingleConnectionFile(filename)
recentConnections.append(RecentConnection(str(state), filename=filename, info=state))
except Exception, e:
log.warning("connections", "Error parsing %s: %r", filename, e)
def _cbRequestAvatarId(self, validKey, credentials):
if not validKey:
return failure.Failure(UnauthorizedLogin())
if not credentials.signature:
return failure.Failure(error.ValidPublicKey())
else:
try:
pubKey = keys.getPublicKeyObject(data=credentials.blob)
if keys.verifySignature(pubKey, credentials.signature, credentials.sigData):
return credentials.username
except: # any error should be treated as a failed login
f = failure.Failure()
log.warning("error checking signature: %r", credentials)
return f
return failure.Failure(UnauthorizedLogin())
def _cbRequestAvatarId(self, validKey, credentials):
if not validKey:
return failure.Failure(UnauthorizedLogin())
if not credentials.signature:
return failure.Failure(error.ValidPublicKey())
else:
try:
pubKey = keys.getPublicKeyObject(data = credentials.blob)
if keys.verifySignature(pubKey, credentials.signature,
credentials.sigData):
return credentials.username
except: # any error should be treated as a failed login
f = failure.Failure()
log.warning('error checking signature: %r', credentials)
return f
return failure.Failure(UnauthorizedLogin())
def getDefaultConnections():
"""
Fetches a list of default connections.
@returns: default connections
@rtype: list of L{ConnectionInfo}
"""
filename = xdg.config_read_path('connections')
if not filename:
return []
try:
return _parseMultipleConnectionsFile(filename)
except Exception, e:
log.warning('connections', 'Error parsing %s: %r', filename, e)
def getRecentConnections():
"""
Fetches a list of recently used connections
@returns: recently used connections
@rtype: list of L{RecentConnection}
"""
recentFilenames = _getRecentFilenames()
recentConnections = []
for filename in sorted(recentFilenames, reverse=True):
try:
state = _parseSingleConnectionFile(filename)
recentConnections.append(
RecentConnection(str(state), filename=filename, info=state))
except Exception, e:
log.warning('connections', 'Error parsing %s: %r', filename, e)
def getDefaultConnections():
"""
Fetches a list of default connections.
@returns: default connections
@rtype: list of L{ConnectionInfo}
"""
filename = xdg.config_read_path('connections')
if not filename:
return []
try:
return _parseMultipleConnectionsFile(filename)
except Exception, e:
log.warning('connections', 'Error parsing %s: %r', filename, e)
def reloadFlumotion():
"""Properly reload all flumotion-related modules currently loaded."""
needs_reload = lambda name: name.startswith('flumotion')
for name in filter(needs_reload, sys.modules.keys()):
if not name in sys.modules:
log.warning("reload", "hm, %s disappeared from the modules" % name)
continue
module = sys.modules[name]
if not module:
log.log("reload", "hm, module '%s' == None" % name)
continue
log.log("reload", "rebuilding %s" % module)
try:
rebuild(module, doLog=0)
except SyntaxError, msg:
from flumotion.common import errors
raise errors.ReloadSyntaxError(msg)
def reloadFlumotion():
"""Properly reload all flumotion-related modules currently loaded."""
needs_reload = lambda name: name.startswith('flumotion')
for name in filter(needs_reload, sys.modules.keys()):
if not name in sys.modules:
log.warning("reload", "hm, %s disappeared from the modules" % name)
continue
module = sys.modules[name]
if not module:
log.log("reload", "hm, module '%s' == None" % name)
continue
log.log("reload", "rebuilding %s" % module)
try:
rebuild(module, doLog=0)
except SyntaxError, msg:
from flumotion.common import errors
raise errors.ReloadSyntaxError(msg)
def get(project, attribute, default=None):
"""
Get an attribute from a project's module.
"""
log.debug('project', 'Getting attribute %s from project %s',
attribute, project)
# short-circuit flumotion, the core project
if project == 'flumotion':
return getattr(configure, attribute, default)
moduleName = "flumotion.project.%s" % project
try:
exec("import %s" % moduleName)
except ImportError, e:
log.warning('project', 'Could not load project %s: %s',
project, log.getExceptionMessage(e))
raise errors.NoProjectError(moduleName)
class SSHPublicKeyChecker(log.Loggable):
try:
credentialInterfaces = credentials.ISSHPrivateKey,
except AttributeError:
log.warning('manhole', 'ssh manhole unavailable (old twisted)')
# you won't be able to log anything in
credentialInterfaces = ()
interface.implements(ICredentialsChecker)
def __init__(self, authorizedKeysFile):
self.authorizedKeysFile = authorizedKeysFile
def requestAvatarId(self, credentials):
d = defer.maybeDeferred(self.checkKey, credentials)
d.addCallback(self._cbRequestAvatarId, credentials)
d.addErrback(self._ebRequestAvatarId)
return d
def _cbRequestAvatarId(self, validKey, credentials):
if not validKey:
return failure.Failure(UnauthorizedLogin())
if not credentials.signature:
return failure.Failure(error.ValidPublicKey())
else:
try:
pubKey = keys.getPublicKeyObject(data = credentials.blob)
if keys.verifySignature(pubKey, credentials.signature,
credentials.sigData):
return credentials.username
except: # any error should be treated as a failed login
f = failure.Failure()
log.warning('error checking signature: %r', credentials)
return f
return failure.Failure(UnauthorizedLogin())
def checkKey(self, credentials):
filename = self.authorizedKeysFile
if not os.path.exists(filename):
return 0
lines = open(filename).xreadlines()
for l in lines:
l2 = l.split()
if len(l2) < 2:
continue
try:
if base64.decodestring(l2[1]) == credentials.blob:
return 1
except binascii.Error:
continue
return 0
def _ebRequestAvatarId(self, f):
if not f.check(UnauthorizedLogin, error.ValidPublicKey):
log.warning('failed login %r', f)
return failure.Failure(UnauthorizedLogin())
return f
def get(project, attribute, default=None):
"""
Get an attribute from a project's module.
"""
log.debug('project', 'Getting attribute %s from project %s', attribute,
project)
# short-circuit flumotion, the core project
if project == 'flumotion':
return getattr(configure, attribute, default)
moduleName = "flumotion.project.%s" % project
try:
exec("import %s" % moduleName)
except ImportError, e:
msg = ('Could not load project %s: %s' %
(project, log.getExceptionMessage(e)))
log.warning('project', msg)
raise errors.NoProjectError(project, msg)
def upgradeAliases(conf):
eaters = dict(conf.get('eater', {})) # a copy
concat = lambda lists: reduce(list.__add__, lists, [])
if not reduce(lambda x, y: y and isinstance(x, tuple),
concat(eaters.values()),
True):
for eater in eaters:
aliases = []
feeders = eaters[eater]
for i in range(len(feeders)):
val = feeders[i]
if isinstance(val, tuple):
feedId, alias = val
aliases.append(val[1])
else:
feedId = val
alias = eater
while alias in aliases:
log.warning('config', "Duplicate alias %s for "
"eater %s, uniquifying", alias, eater)
alias += '-bis'
aliases.append(alias)
feeders[i] = (feedId, val)
conf['eater'] = eaters
def upgradeAliases(conf):
eaters = dict(conf.get('eater', {})) # a copy
concat = lambda lists: reduce(list.__add__, lists, [])
if not reduce(lambda x, y: y and isinstance(x, tuple),
concat(eaters.values()), True):
for eater in eaters:
aliases = []
feeders = eaters[eater]
for i in range(len(feeders)):
val = feeders[i]
if isinstance(val, tuple):
feedId, alias = val
aliases.append(val[1])
else:
feedId = val
alias = eater
while alias in aliases:
log.warning(
'config', "Duplicate alias %s for "
"eater %s, uniquifying", alias, eater)
alias += '-bis'
aliases.append(alias)
feeders[i] = (feedId, val)
conf['eater'] = eaters
if not hasattr(module, methodName):
raise err("module %s has no method named %s" %
(moduleName, methodName))
log.debug('reflectcall', 'calling method %s.%s' % (moduleName, methodName))
try:
ret = getattr(module, methodName)(*args, **kwargs)
except err:
# already nicely formatted, so fall through
log.debug('reflectcall', 'letting error fall through')
raise
except Exception, e:
msg = log.getExceptionMessage(e)
log.warning('reflectcall', msg)
log.warning('reflectcall', 'raising error')
raise err(msg)
log.debug('reflectcall', 'returning %r' % ret)
return ret
def createComponent(moduleName, methodName, config):
"""
@param moduleName: name of the module to create the component from
@type moduleName: string
@param methodName: the factory method to use to create the component
@type methodName: string
@param config: the component's config dict
def registerPackagePath(self, packagePath, key, prefix=configure.PACKAGE):
"""
Register a given path as a path that can be imported from.
Used to support partition of bundled code or import code from various
uninstalled location.
sys.path will also be changed to include this, and remove references
to older packagePath's for the same bundle.
@param packagePath: path to add under which the module namespaces live,
(ending in an md5sum, for flumotion purposes)
@type packagePath: string
@param key a unique id for the package being registered
@type key: string
@param prefix: prefix of the packages to be considered
@type prefix: string
"""
new = True
packagePath = os.path.abspath(packagePath)
if not os.path.exists(packagePath):
log.warning('bundle',
'registering a non-existing package path %s' % packagePath)
self.log('registering packagePath %s' % packagePath)
# check if a packagePath for this bundle was already registered
if key in self._paths:
oldPath = self._paths[key]
if packagePath == oldPath:
self.log('already registered %s for key %s' % (
packagePath, key))
return
new = False
# Find the packages in the path and sort them,
# the following algorithm only works if they're sorted.
# By sorting the list we can ensure that a parent package
# is always processed before one of its children
if not os.path.isdir(packagePath):
log.warning('bundle', 'package path not a dir: %s',
packagePath)
packageNames = []
else:
packageNames = _findPackageCandidates(packagePath, prefix)
if not packageNames:
log.log('bundle',
'packagePath %s does not have candidates starting with %s' %
(packagePath, prefix))
return
packageNames.sort()
self.log('package candidates %r' % packageNames)
if not new:
# it already existed, and now it's a different path
log.log('bundle',
'replacing old path %s with new path %s for key %s' % (
oldPath, packagePath, key))
if oldPath in sys.path:
log.log('bundle',
'removing old packagePath %s from sys.path' % oldPath)
sys.path.remove(oldPath)
# clear this key from our name -> key cache
for keys in self._packages.values():
if key in keys:
keys.remove(key)
self._paths[key] = packagePath
# put packagePath at the top of sys.path if not in there
if not packagePath in sys.path:
self.log('adding packagePath %s to sys.path' % packagePath)
sys.path.insert(0, packagePath)
# update our name->keys cache
for name in packageNames:
if name not in self._packages:
self._packages[name] = [key]
else:
self._packages[name].insert(0, key)
self.log('packagePath %s has packageNames %r' % (
packagePath, packageNames))
# since we want sub-modules to be fixed up before parent packages,
# we reverse the list
packageNames.reverse()
for packageName in packageNames:
if packageName not in sys.modules:
continue
self.log('fixing up %s ...' % packageName)
# the package is imported, so mess with __path__ and rebuild
package = sys.modules.get(packageName)
for path in package.__path__:
if not new and path.startswith(oldPath):
self.log('%s.__path__ before remove %r' % (
packageName, package.__path__))
self.log('removing old %s from %s.__path__' % (
path, name))
package.__path__.remove(path)
self.log('%s.__path__ after remove %r' % (
packageName, package.__path__))
# move the new path to the top
# insert at front because FLU_REGISTRY_PATH paths should override
# base components, and because subsequent reload() should prefer
# the latest registered path
newPath = os.path.join(packagePath,
packageName.replace('.', os.sep))
# if path already at position 0, everything's fine
# if it's in there at another place, it needs to move to front
# if not in there, it needs to be put in front
if len(package.__path__) == 0:
# FIXME: this seems to happen to e.g. flumotion.component.base
# even when it was just rebuilt and had the __path__ set
# can be triggered by choosing a admin_gtk depending on
# the base admin_gtk where the base admin_gtk changes
self.debug('WARN: package %s does not have __path__ values' % (
packageName))
elif package.__path__[0] == newPath:
self.log('path %s already at start of %s.__path__' % (
newPath, packageName))
continue
if newPath in package.__path__:
package.__path__.remove(newPath)
self.log('moving %s to front of %s.__path__' % (
newPath, packageName))
else:
self.log('inserting new %s into %s.__path__' % (
newPath, packageName))
package.__path__.insert(0, newPath)
# Rebuilding these packages just to get __path__ fixed in
# seems not necessary - but re-enable it if it breaks
# self.log('rebuilding package %s from paths %r' % (packageName,
# package.__path__))
# rebuild.rebuild(package)
# self.log('rebuilt package %s with paths %r' % (packageName,
# package.__path__))
self.log('fixed up %s, __path__ %s ...' % (
packageName, package.__path__))
# now rebuild all non-package modules in this packagePath if this
# is not a new package
if not new:
self.log('finding end module candidates')
if not os.path.isdir(packagePath):
log.warning('bundle', 'package path not a dir: %s',
path)
moduleNames = []
else:
moduleNames = findEndModuleCandidates(packagePath, prefix)
self.log('end module candidates to rebuild: %r' % moduleNames)
for name in moduleNames:
if name in sys.modules:
# fixme: isn't sys.modules[name] sufficient?
self.log("rebuilding non-package module %s" % name)
try:
module = reflect.namedAny(name)
except AttributeError:
log.warning('bundle',
"could not reflect non-package module %s" % name)
continue
if hasattr(module, '__path__'):
self.log('rebuilding module %s with paths %r' % (name,
module.__path__))
rebuild.rebuild(module)
#if paths:
# module.__path__ = paths
self.log('registered packagePath %s for key %s' % (packagePath, key))
def registerPackagePath(self, packagePath, key, prefix=configure.PACKAGE):
"""
Register a given path as a path that can be imported from.
Used to support partition of bundled code or import code from various
uninstalled location.
sys.path will also be changed to include this, and remove references
to older packagePath's for the same bundle.
@param packagePath: path to add under which the module namespaces live,
(ending in an md5sum, for flumotion purposes)
@type packagePath: string
@param key a unique id for the package being registered
@type key: string
@param prefix: prefix of the packages to be considered
@type prefix: string
"""
new = True
packagePath = os.path.abspath(packagePath)
if not os.path.exists(packagePath):
log.warning(
'bundle',
'registering a non-existing package path %s' % packagePath)
self.log('registering packagePath %s' % packagePath)
# check if a packagePath for this bundle was already registered
if key in self._paths:
oldPath = self._paths[key]
if packagePath == oldPath:
self.log('already registered %s for key %s' %
(packagePath, key))
return
new = False
# Find the packages in the path and sort them,
# the following algorithm only works if they're sorted.
# By sorting the list we can ensure that a parent package
# is always processed before one of its children
if not os.path.isdir(packagePath):
log.warning('bundle', 'package path not a dir: %s', packagePath)
packageNames = []
else:
packageNames = _findPackageCandidates(packagePath, prefix)
if not packageNames:
log.log(
'bundle',
'packagePath %s does not have candidates starting with %s' %
(packagePath, prefix))
return
packageNames.sort()
self.log('package candidates %r' % packageNames)
if not new:
# it already existed, and now it's a different path
log.log(
'bundle', 'replacing old path %s with new path %s for key %s' %
(oldPath, packagePath, key))
if oldPath in sys.path:
log.log('bundle',
'removing old packagePath %s from sys.path' % oldPath)
sys.path.remove(oldPath)
# clear this key from our name -> key cache
for keys in self._packages.values():
if key in keys:
keys.remove(key)
self._paths[key] = packagePath
# put packagePath at the top of sys.path if not in there
if not packagePath in sys.path:
self.log('adding packagePath %s to sys.path' % packagePath)
sys.path.insert(0, packagePath)
# update our name->keys cache
for name in packageNames:
if name not in self._packages:
self._packages[name] = [key]
else:
self._packages[name].insert(0, key)
self.log('packagePath %s has packageNames %r' %
(packagePath, packageNames))
# since we want sub-modules to be fixed up before parent packages,
# we reverse the list
packageNames.reverse()
for packageName in packageNames:
if packageName not in sys.modules:
continue
self.log('fixing up %s ...' % packageName)
# the package is imported, so mess with __path__ and rebuild
package = sys.modules.get(packageName)
for path in package.__path__:
if not new and path.startswith(oldPath):
self.log('%s.__path__ before remove %r' %
(packageName, package.__path__))
self.log('removing old %s from %s.__path__' % (path, name))
package.__path__.remove(path)
self.log('%s.__path__ after remove %r' %
(packageName, package.__path__))
# move the new path to the top
# insert at front because FLU_REGISTRY_PATH paths should override
# base components, and because subsequent reload() should prefer
# the latest registered path
newPath = os.path.join(packagePath,
packageName.replace('.', os.sep))
# if path already at position 0, everything's fine
# if it's in there at another place, it needs to move to front
# if not in there, it needs to be put in front
if len(package.__path__) == 0:
# FIXME: this seems to happen to e.g. flumotion.component.base
# even when it was just rebuilt and had the __path__ set
# can be triggered by choosing a admin_gtk depending on
# the base admin_gtk where the base admin_gtk changes
self.debug('WARN: package %s does not have __path__ values' %
(packageName))
elif package.__path__[0] == newPath:
self.log('path %s already at start of %s.__path__' %
(newPath, packageName))
continue
if newPath in package.__path__:
package.__path__.remove(newPath)
self.log('moving %s to front of %s.__path__' %
(newPath, packageName))
else:
self.log('inserting new %s into %s.__path__' %
(newPath, packageName))
package.__path__.insert(0, newPath)
# Rebuilding these packages just to get __path__ fixed in
# seems not necessary - but re-enable it if it breaks
# self.log('rebuilding package %s from paths %r' % (packageName,
# package.__path__))
# rebuild.rebuild(package)
# self.log('rebuilt package %s with paths %r' % (packageName,
# package.__path__))
self.log('fixed up %s, __path__ %s ...' %
(packageName, package.__path__))
# now rebuild all non-package modules in this packagePath if this
# is not a new package
if not new:
self.log('finding end module candidates')
if not os.path.isdir(packagePath):
log.warning('bundle', 'package path not a dir: %s', path)
moduleNames = []
else:
moduleNames = findEndModuleCandidates(packagePath, prefix)
self.log('end module candidates to rebuild: %r' % moduleNames)
for name in moduleNames:
if name in sys.modules:
# fixme: isn't sys.modules[name] sufficient?
self.log("rebuilding non-package module %s" % name)
try:
module = reflect.namedAny(name)
except AttributeError:
log.warning(
'bundle',
"could not reflect non-package module %s" % name)
continue
if hasattr(module, '__path__'):
self.log('rebuilding module %s with paths %r' %
(name, module.__path__))
rebuild.rebuild(module)
#if paths:
# module.__path__ = paths
self.log('registered packagePath %s for key %s' % (packagePath, key))
def _ebRequestAvatarId(self, f):
if not f.check(UnauthorizedLogin, error.ValidPublicKey):
log.warning('manhole', 'failed login: %r',
log.getFailureMessage(f))
return failure.Failure(UnauthorizedLogin())
return f
def _ebRequestAvatarId(self, f):
if not f.check(UnauthorizedLogin, error.ValidPublicKey):
log.warning('manhole', 'failed login: %r',
log.getFailureMessage(f))
return failure.Failure(UnauthorizedLogin())
return f
def _ebRequestAvatarId(self, f):
if not f.check(UnauthorizedLogin, error.ValidPublicKey):
log.warning("failed login %r", f)
return failure.Failure(UnauthorizedLogin())
return f
return [n[len('flumotion.project.'):] for n in modules]
def get(project, attribute, default=None):
"""
Get an attribute from a project's module.
"""
log.debug('project', 'Getting attribute %s from project %s', attribute,
project)
# short-circuit flumotion, the core project
if project == 'flumotion':
return getattr(configure, attribute, default)
moduleName = "flumotion.project.%s" % project
try:
exec("import %s" % moduleName)
except ImportError, e:
msg = ('Could not load project %s: %s' %
(project, log.getExceptionMessage(e)))
log.warning('project', msg)
raise errors.NoProjectError(project, msg)
except SyntaxError, e:
msg = ('Syntax error while loading project %s: %s' %
(project, log.getExceptionMessage(e)))
log.warning('project', msg)
raise errors.NoProjectError(project, msg)
m = sys.modules[moduleName]
return getattr(m, attribute, default)
def _ebRequestAvatarId(self, f):
if not f.check(UnauthorizedLogin, error.ValidPublicKey):
log.warning('failed login %r', f)
return failure.Failure(UnauthorizedLogin())
return f
return [n[len('flumotion.project.'):] for n in modules]
def get(project, attribute, default=None):
"""
Get an attribute from a project's module.
"""
log.debug('project', 'Getting attribute %s from project %s',
attribute, project)
# short-circuit flumotion, the core project
if project == 'flumotion':
return getattr(configure, attribute, default)
moduleName = "flumotion.project.%s" % project
try:
exec("import %s" % moduleName)
except ImportError, e:
msg = ('Could not load project %s: %s' %
(project, log.getExceptionMessage(e)))
log.warning('project', msg)
raise errors.NoProjectError(project, msg)
except SyntaxError, e:
msg = ('Syntax error while loading project %s: %s' %
(project, log.getExceptionMessage(e)))
log.warning('project', msg)
raise errors.NoProjectError(project, msg)
m = sys.modules[moduleName]
return getattr(m, attribute, default)
if not hasattr(module, methodName):
raise err("module %s has no method named %s"
% (moduleName, methodName))
log.debug('reflectcall', 'calling method %s.%s'
% (moduleName, methodName))
try:
ret = getattr(module, methodName)(*args, **kwargs)
except err:
# already nicely formatted, so fall through
log.debug('reflectcall', 'letting error fall through')
raise
except Exception, e:
msg = log.getExceptionMessage(e)
log.warning('reflectcall', msg)
log.warning('reflectcall', 'raising error')
raise err(msg)
log.debug('reflectcall', 'returning %r' % ret)
return ret
def createComponent(moduleName, methodName, config):
"""
@param moduleName: name of the module to create the component from
@type moduleName: string
@param methodName: the factory method to use to create the component
@type methodName: string
@param config: the component's config dict
