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 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)
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: