def remote_login(self, keycard, mind, *interfaces):
"""
Start of keycard login.
@param interfaces: list of fully qualified names of interface objects
@returns: one of
- a L{flumotion.common.keycards.Keycard} when more steps
need to be performed
- a L{twisted.spread.pb.AsReferenceable} when authentication
has succeeded, which will turn into a
L{twisted.spread.pb.RemoteReference} on the client side
- a L{flumotion.common.errors.NotAuthenticatedError} when
authentication is denied
"""
def loginResponse(result):
self.log("loginResponse: result=%r", result)
# if the result is a keycard, we're not yet ready
if isinstance(result, keycards.Keycard):
return result
else:
# authenticated, so the result is the tuple
interface, perspective, logout = result
self.broker.notifyOnDisconnect(logout)
return pb.AsReferenceable(perspective, "perspective")
# corresponds with FPBClientFactory._cbSendKeycard
self.log("remote_login(keycard=%s, *interfaces=%r" %
(keycard, interfaces))
interfaces = [freflect.namedAny(interface) for interface in interfaces]
d = self.bouncerPortal.login(keycard, mind, *interfaces)
d.addCallback(loginResponse)
return d
def remote_login(self, keycard, mind, *interfaces):
"""
Start of keycard login.
@param interfaces: list of fully qualified names of interface objects
@returns: one of
- a L{flumotion.common.keycards.Keycard} when more steps
need to be performed
- a L{twisted.spread.pb.AsReferenceable} when authentication
has succeeded, which will turn into a
L{twisted.spread.pb.RemoteReference} on the client side
- a L{flumotion.common.errors.NotAuthenticatedError} when
authentication is denied
"""
def loginResponse(result):
self.log("loginResponse: result=%r", result)
# if the result is a keycard, we're not yet ready
if isinstance(result, keycards.Keycard):
return result
else:
# authenticated, so the result is the tuple
interface, perspective, logout = result
self.broker.notifyOnDisconnect(logout)
return pb.AsReferenceable(perspective, "perspective")
# corresponds with FPBClientFactory._cbSendKeycard
self.log("remote_login(keycard=%s, *interfaces=%r" % (
keycard, interfaces))
interfaces = [freflect.namedAny(interface) for interface in interfaces]
d = self.bouncerPortal.login(keycard, mind, *interfaces)
d.addCallback(loginResponse)
return d
def catching(proc, *args, **kwargs):
env = os.getenv('FLU_ATEXIT').split(' ')
fqfn = env.pop(0)
log.info('atexit', 'FLU_ATEXIT set, will call %s(*%r) on exit',
fqfn, env)
atexitproc = reflect.namedAny(fqfn)
try:
return proc(*args, **kwargs)
finally:
log.info('atexit', 'trying to call %r(*%r)',
atexitproc, env)
atexitproc(*env)
def do_setup(self):
# Create our combined PB-server/fd-passing channel
self.have_properties()
realm = PorterRealm(self)
checker = checkers.FlexibleCredentialsChecker()
checker.addUser(self._username, self._password)
if not self._requirePassword:
checker.allowPasswordless(True)
p = portal.Portal(realm, [checker])
serverfactory = pb.PBServerFactory(p)
try:
# Rather than a normal listenTCP() or listenUNIX(), we use
# listenWith so that we can specify our particular Port, which
# creates Transports that we know how to pass FDs over.
try:
os.unlink(self._socketPath)
except OSError:
pass
self._socketlistener = reactor.listenWith(
fdserver.FDPort, self._socketPath,
serverfactory, mode=self._socketMode)
self.info("Now listening on socketPath %s", self._socketPath)
except error.CannotListenError:
self.warning("Failed to create socket %s" % self._socketPath)
m = messages.Error(T_(N_(
"Network error: socket path %s is not available."),
self._socketPath))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
# Create the class that deals with the specific protocol we're proxying
# in this porter.
try:
proto = reflect.namedAny(self._porterProtocol)
self.debug("Created proto %r" % proto)
except (ImportError, AttributeError):
self.warning("Failed to import protocol '%s', defaulting to HTTP" %
self._porterProtocol)
proto = HTTPPorterProtocol
# And of course we also want to listen for incoming requests in the
# appropriate protocol (HTTP, RTSP, etc.)
factory = PorterProtocolFactory(self, proto)
try:
reactor.listenWith(
fdserver.PassableServerPort, self._port, factory,
interface=self._interface)
self.info("Now listening on interface %r on port %d",
self._interface, self._port)
except error.CannotListenError:
self.warning("Failed to listen on interface %r on port %d",
self._interface, self._port)
m = messages.Error(T_(N_(
"Network error: TCP port %d is not available."), self._port))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
def testSimple(self):
s = reflect.namedAny('flumotion.test.test_reflect.TestSimple')
self.failUnlessIdentical(s, TestSimple)
#
# there is no race condition here -- the reactor doesn't handle
# signals until it is run().
reactor.killed = False
def setkilled(killed):
reactor.killed = killed
reactor.addSystemEventTrigger('before', 'startup', setkilled, False)
reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True)
from flumotion.twisted import reflect
from flumotion.common import errors
from flumotion.common import setup
setup.setup()
from flumotion.common import log
log.logTwisted()
main = reflect.namedAny(path)
wrapped = wrap_for_profiling(main)
wrapped.__name__ = main.__name__
try:
sys.exit(wrapped(sys.argv))
except (errors.FatalError, SystemError), e:
safeprintf(sys.stderr, 'ERROR: %s\n', e)
sys.exit(1)
def do_setup(self):
# Create our combined PB-server/fd-passing channel
self.have_properties()
realm = PorterRealm(self)
checker = checkers.FlexibleCredentialsChecker()
checker.addUser(self._username, self._password)
if not self._requirePassword:
checker.allowPasswordless(True)
p = portal.Portal(realm, [checker])
serverfactory = pb.PBServerFactory(p)
try:
# Rather than a normal listenTCP() or listenUNIX(), we use
# listenWith so that we can specify our particular Port, which
# creates Transports that we know how to pass FDs over.
try:
os.unlink(self._socketPath)
except OSError:
pass
self._socketlistener = reactor.listenWith(fdserver.FDPort,
self._socketPath,
serverfactory,
mode=self._socketMode)
self.info("Now listening on socketPath %s", self._socketPath)
except error.CannotListenError:
self.warning("Failed to create socket %s" % self._socketPath)
m = messages.Error(
T_(N_("Network error: socket path %s is not available."),
self._socketPath))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
# Create the class that deals with the specific protocol we're proxying
# in this porter.
try:
proto = reflect.namedAny(self._porterProtocol)
self.debug("Created proto %r" % proto)
except (ImportError, AttributeError):
self.warning("Failed to import protocol '%s', defaulting to HTTP" %
self._porterProtocol)
proto = HTTPPorterProtocol
# And of course we also want to listen for incoming requests in the
# appropriate protocol (HTTP, RTSP, etc.)
factory = PorterProtocolFactory(self, proto)
try:
reactor.listenWith(fdserver.PassableServerPort,
self._port,
factory,
interface=self._interface)
self.info("Now listening on interface %r on port %d",
self._interface, self._port)
except error.CannotListenError:
self.warning("Failed to listen on interface %r on port %d",
self._interface, self._port)
m = messages.Error(
T_(N_("Network error: TCP port %d is not available."),
self._port))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
def boot(path, gtk=False, gst=True, installReactor=True):
# python 2.5 and twisted < 2.5 don't work together
pythonMM = sys.version_info[0:2]
from twisted.copyright import version
twistedMM = tuple([int(n) for n in version.split('.')[0:2]])
if pythonMM >= (2, 5) and twistedMM < (2, 5):
raise SystemError(
"Twisted versions older than 2.5.0 do not work with "
"Python 2.5 and newer. "
"Please upgrade Twisted or downgrade Python.")
if gtk or gst:
init_gobject()
if gst:
from flumotion.configure import configure
configure.gst_version = init_gst()
global USE_GTK, USE_GST
USE_GTK=gtk
USE_GST=gst
init_option_parser(gtk, gst)
# installing the reactor could override our packager's import hooks ...
if installReactor:
from twisted.internet import gtk2reactor
gtk2reactor.install(useGtk=gtk)
from twisted.internet import reactor
# ... so we install them again here to be safe
from flumotion.common import package
package.getPackager().install()
# this monkeypatched var exists to let reconnecting factories know
# when they should warn about a connection being closed, and when
# they shouldn't because the system is shutting down.
#
# there is no race condition here -- the reactor doesn't handle
# signals until it is run().
reactor.killed = False
def setkilled(killed):
reactor.killed = killed
reactor.addSystemEventTrigger('before', 'startup', setkilled, False)
reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True)
from flumotion.twisted import reflect
from flumotion.common import errors
from flumotion.common import setup
setup.setup()
from flumotion.common import log
log.logTwisted()
# we redefine catching
__pychecker__ = 'no-reuseattr'
if os.getenv('FLU_PROFILE'):
def catching(proc, *args, **kwargs):
import statprof
statprof.start()
try:
return proc(*args, **kwargs)
finally:
statprof.stop()
statprof.display()
elif os.getenv('FLU_ATEXIT'):
def catching(proc, *args, **kwargs):
env = os.getenv('FLU_ATEXIT').split(' ')
fqfn = env.pop(0)
log.info('atexit', 'FLU_ATEXIT set, will call %s(*%r) on exit',
fqfn, env)
atexitproc = reflect.namedAny(fqfn)
try:
return proc(*args, **kwargs)
finally:
log.info('atexit', 'trying to call %r(*%r)',
atexitproc, env)
atexitproc(*env)
else:
def catching(proc, *args, **kwargs):
return proc(*args, **kwargs)
main = reflect.namedAny(path)
try:
sys.exit(catching(main, sys.argv))
except (errors.FatalError, SystemError), e:
safeprintf(sys.stderr, 'ERROR: %s\n', e)
sys.exit(1)
self.warning(msg)
raise errors.EntrySyntaxError(msg)
except NameError, e:
# the syntax error can happen in the entry file, or any import
msg = "NameError while executing %s: %s" % (filename, " ".join(
e.args))
self.warning(msg)
raise errors.EntrySyntaxError(msg)
except ImportError, e:
msg = "ImportError while executing %s: %s" % (filename, " ".join(
e.args))
self.warning(msg)
raise errors.EntrySyntaxError(msg)
# make sure we're running the latest version
module = reflect.namedAny(moduleName)
rebuild.rebuild(module)
# check if we have the method
if not hasattr(module, methodName):
self.warning('method %s not found in file %s' %
(methodName, filename))
raise #FIXME: something appropriate
klass = getattr(module, methodName)
# instantiate the GUIClass, giving ourself as the first argument
# FIXME: we cheat by giving the view as second for now,
# but let's decide for either view or model
instance = klass(self._components[name], self.admin)
self.debug("Created entry instance %r" % instance)
self.warning(msg)
raise errors.EntrySyntaxError(msg)
except NameError, e:
# the syntax error can happen in the entry file, or any import
msg = "NameError while executing %s: %s" % (filename,
" ".join(e.args))
self.warning(msg)
raise errors.EntrySyntaxError(msg)
except ImportError, e:
msg = "ImportError while executing %s: %s" % (filename,
" ".join(e.args))
self.warning(msg)
raise errors.EntrySyntaxError(msg)
# make sure we're running the latest version
module = reflect.namedAny(moduleName)
rebuild.rebuild(module)
# check if we have the method
if not hasattr(module, methodName):
self.warning('method %s not found in file %s' % (
methodName, filename))
raise #FIXME: something appropriate
klass = getattr(module, methodName)
# instantiate the GUIClass, giving ourself as the first argument
# FIXME: we cheat by giving the view as second for now,
# but let's decide for either view or model
instance = klass(self._components[name], self.admin)
self.debug("Created entry instance %r" % instance)
def testSimple(self):
s = reflect.namedAny('flumotion.test.test_reflect.TestSimple')
self.failUnlessIdentical(s, TestSimple)
def boot(path, gtk=False, gst=True, installReactor=True):
# python 2.5 and twisted < 2.5 don't work together
pythonMM = sys.version_info[0:2]
from twisted.copyright import version
twistedMM = tuple([int(n) for n in version.split('.')[0:2]])
if pythonMM >= (2, 5) and twistedMM < (2, 5):
raise SystemError("Twisted versions older than 2.5.0 do not work with "
"Python 2.5 and newer. "
"Please upgrade Twisted or downgrade Python.")
if gtk or gst:
init_gobject()
if gtk:
init_kiwi()
if gst:
from flumotion.configure import configure
configure.gst_version = init_gst()
global USE_GTK, USE_GST
USE_GTK = gtk
USE_GST = gst
init_option_parser(gtk, gst)
# installing the reactor could override our packager's import hooks ...
if installReactor:
from twisted.internet import gtk2reactor
gtk2reactor.install(useGtk=gtk)
from twisted.internet import reactor
# ... so we install them again here to be safe
from flumotion.common import package
package.getPackager().install()
# this monkeypatched var exists to let reconnecting factories know
# when they should warn about a connection being closed, and when
# they shouldn't because the system is shutting down.
#
# there is no race condition here -- the reactor doesn't handle
# signals until it is run().
reactor.killed = False
def setkilled(killed):
reactor.killed = killed
reactor.addSystemEventTrigger('before', 'startup', setkilled, False)
reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True)
from flumotion.twisted import reflect
from flumotion.common import errors
from flumotion.common import setup
setup.setup()
from flumotion.common import log
log.logTwisted()
main = reflect.namedAny(path)
wrapped = wrap_for_profiling(main)
wrapped.__name__ = main.__name__
try:
sys.exit(wrapped(sys.argv))
except (errors.FatalError, SystemError), e:
safeprintf(sys.stderr, 'ERROR: %s\n', e)
sys.exit(1)
global exitCode
sys.stderr.write("Component %s from %s %s.\n" %(
c.type, c.filename, msg))
exitCode += 1
for c in registry.getComponents():
if c.type != c.type.lower():
componentError(c, 'contains capitals')
if c.type.find('_') > -1:
componentError(c, 'contains underscores')
if not c.description:
componentError(c, 'is missing a description')
for s in c.sockets:
try:
function = reflect.namedAny(s)
except AttributeError:
componentError(c, 'could not import socket %s' % s)
def propertyError(c, p, msg):
global exitCode
sys.stderr.write("Property %s on component %s from %s %s.\n" %(
p.name, c.type, c.filename, msg))
exitCode += 1
for p in c.getProperties():
if p.name != p.name.lower():
propertyError(c, p, "contains capitals")
if p.name.find('_') > -1:
propertyError(c, p, "contains underscores")
if not p.description:
def boot(path, gtk=False, gst=True, installReactor=True):
# python 2.5 and twisted < 2.5 don't work together
pythonMM = sys.version_info[0:2]
from twisted.copyright import version
twistedMM = tuple([int(n) for n in version.split('.')[0:2]])
if pythonMM >= (2, 5) and twistedMM < (2, 5):
raise SystemError(
"Twisted versions older than 2.5.0 do not work with "
"Python 2.5 and newer. "
"Please upgrade Twisted or downgrade Python.")
if gtk or gst:
init_gobject()
if gtk:
init_kiwi()
if gst:
from flumotion.configure import configure
configure.gst_version = init_gst()
global USE_GTK, USE_GST
USE_GTK=gtk
USE_GST=gst
init_option_parser(gtk, gst)
# installing the reactor could override our packager's import hooks ...
if installReactor:
from twisted.internet import gtk2reactor
gtk2reactor.install(useGtk=gtk)
from twisted.internet import reactor
# ... so we install them again here to be safe
from flumotion.common import package
package.getPackager().install()
# this monkeypatched var exists to let reconnecting factories know
# when they should warn about a connection being closed, and when
# they shouldn't because the system is shutting down.
#
# there is no race condition here -- the reactor doesn't handle
# signals until it is run().
reactor.killed = False
def setkilled(killed):
reactor.killed = killed
reactor.addSystemEventTrigger('before', 'startup', setkilled, False)
reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True)
from flumotion.twisted import reflect
from flumotion.common import errors
from flumotion.common import setup
setup.setup()
from flumotion.common import log
log.logTwisted()
main = reflect.namedAny(path)
wrapped = wrap_for_profiling(main)
wrapped.__name__ = main.__name__
try:
sys.exit(wrapped(sys.argv))
except (errors.FatalError, SystemError), e:
safeprintf(sys.stderr, 'ERROR: %s\n', e)
sys.exit(1)
#
# there is no race condition here -- the reactor doesn't handle
# signals until it is run().
reactor.killed = False
def setkilled(killed):
reactor.killed = killed
reactor.addSystemEventTrigger('before', 'startup', setkilled, False)
reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True)
from flumotion.twisted import reflect
from flumotion.common import errors
from flumotion.common import setup
setup.setup()
from flumotion.common import log
log.logTwisted()
main = reflect.namedAny(path)
wrapped = wrap_for_profiling(main)
wrapped.__name__ = main.__name__
try:
sys.exit(wrapped(sys.argv))
except (errors.FatalError, SystemError), e:
safeprintf(sys.stderr, 'ERROR: %s\n', e)
sys.exit(1)
for plug in registry.getPlugs():
if plug.type != plug.type.lower():
plugError(plug, 'contains capitals')
if plug.type.find('_') > -1:
plugError(plug, 'contains underscores')
if not plug.description:
plugError(plug, 'is missing a description')
# a plug should be creatable
for name, entry in plug.entries.items():
moduleName = common.pathToModuleName(entry.location)
entryPoint = "%s.%s" % (moduleName, entry.function)
try:
function = reflect.namedAny(entryPoint)
except AttributeError:
plugError(plug, 'could not import plug %s' % entryPoint)
def propertyError(plug, p, msg):
global exitCode
sys.stderr.write("Property %s on plug %s from %s %s.\n" %(
p.name, plug.type, plug.filename, msg))
exitCode += 1
for p in plug.getProperties():
if p.name != p.name.lower():
propertyError(plug, p, "contains capitals")
if p.name.find('_') > -1:
propertyError(plug, p, "contains underscores")
if not p.description:
