def login(): port = self.feedServer.getPortNum() self.assertAdditionalFDsOpen(1, 'connect (socket)') reactor.connectTCP('localhost', port, factory) self.assertAdditionalFDsOpen(2, 'connect (socket, client)') return factory.login(fpb.Authenticator(username='******', password='******'))
def testWrongUser(self): factory = pb.FPBClientFactory() # create a = pb.Authenticator(username="******", password="******", address="127.0.0.1") # send d = factory.login(a) c = reactor.connectTCP("127.0.0.1", self.portno, factory) def WrongUserCb(keycard): self.fail("Should have returned NotAuthenticatedError") def WrongUserEb(failure): # find copied failure self.failUnless( failure.check("flumotion.common.errors.NotAuthenticatedError")) return self.clientDisconnect(factory, None) d.addCallback(WrongUserCb) d.addErrback(WrongUserEb) return d
def login(): port = self.feedServer.getPortNum() self.assertAdditionalFDsOpen(1, 'connect (socket)') d = client.startConnecting('localhost', port, fpb.Authenticator(username='******', password='******')) self.assertAdditionalFDsOpen(2, 'connect (socket, client)') return d
def testIssueUACPP(self): # our authenticator by default only does challenge-based keycards a = pb.Authenticator(username="******", password="******", address="localhost") d = a.issue([ "flumotion.common.keycards.KeycardGeneric", ]) d.addCallback(lambda r: self.failIf(r))
def testIssueNoInfo(self): # not setting any useful auth info on the authenticator does not # allow us to issue a keycard a = pb.Authenticator(username="******") d = a.issue([ "flumotion.common.keycards.KeycardGeneric", ]) d.addCallback(lambda r: self.failIf(r)) return d
def testIssueUACPCC(self): a = pb.Authenticator(username="******", password="******", address="localhost") d = a.issue([ "flumotion.common.keycards.KeycardUACPCC", ]) d.addCallback( lambda r: self.failUnless(isinstance(r, keycards.KeycardUACPCC))) return d
def requestFeed(): port = self.feedServer.getPortNum() self.assertAdditionalFDsOpen(1, 'connect (socket)') d = client.requestFeed('localhost', port, fpb.Authenticator(username='******', password='******'), '/foo/bar:baz') self.failIf(client.hasRemoteReference()) self.assertAdditionalFDsOpen(2, 'connect (socket, client)') return d
def __init__(self): log.init() self.medium = admin.AdminModel() i = connection.PBConnectionInfo( "127.0.0.1", 7531, True, pb.Authenticator(username='******', password='******')) d = self.medium.connectToManager(i) d.addCallback(self.connected) d.addErrback(twistedlog.err)
def testWrongPassword(self): factory = pb.FPBClientFactory() a = pb.Authenticator() a = pb.Authenticator(username="******", password="******", address="127.0.0.1") d = factory.login(a) c = reactor.connectTCP("127.0.0.1", self.portno, factory) log.debug("trial", "wait for result") def WrongPasswordErrback(failure): self.failUnless(isinstance(factory.keycard, keycards.KeycardUACPCC)) # This is a CopiedFailure self.assert_( failure.check("flumotion.common.errors.NotAuthenticatedError")) log.debug("trial", "got failure %r" % failure) c.disconnect() return True d.addErrback(WrongPasswordErrback) return d
def testConnectFailure(self): def connected(_): self.fail('should not have connected') def failure(f): # ok! a.shutdown() a = admin.AdminModel() # create a connectionInfo that will not succeed i = connection.PBConnectionInfo( self.connectionInfo.host, self.connectionInfo.port, self.connectionInfo.use_ssl, pb.Authenticator(username='******', password='******')) d = a.connectToManager(i, writeConnection=False) d.addCallbacks(connected, failure) return d
def testOk(self): factory = pb.FPBClientFactory() a = pb.Authenticator(username="******", password="******", address="127.0.0.1") # send d = factory.login(a) c = reactor.connectTCP("127.0.0.1", self.portno, factory) def OkCallback(result): # make sure we really used an SHA256 challenge/response keycard self.failUnless(isinstance(factory.keycard, keycards.KeycardUASPCC)) self.assert_(isinstance(result, tpb.RemoteReference)) return self.clientDisconnect(factory, result) d.addCallback(OkCallback) return d
def testConnectFailure(self): def connected(_): self.fail('should not have connected') def failure(f): # ok! self.assertEqual(len(self.vishnu.adminHeaven.avatars), 0) self.assertEqual(m.admins, {}) self.assertEqual(m._reconnectHandlerIds, {}) m = multi.MultiAdminModel() i = connection.PBConnectionInfo( self.connectionInfo.host, self.connectionInfo.port, self.connectionInfo.use_ssl, pb.Authenticator(username='******', password='******')) d = m.addManager(i, writeConnection=False) d.addCallbacks(connected, failure) return d
def parsePBConnectionInfo(string, username='******', password='******', port=7531, use_ssl=True): """ Parse a string representation of a PB connection into a PBConnectionInfo object. The expected format is [user[:pass]@]host[:port]. Only the host is mandatory. The default values for username, password, and port will be taken from the optional username, password and port arguments. @param string: A string describing the PB connection. @type string: str @param username: Default username, or 'user' if not given. @type username: str @param password: Default password, or 'test' if not given. @type password: str @param port: Default port, or 7531 if not given. @type port: int @param use_ssl: Whether to use SSL, or True if not given. Note that there is no syntax in the connection string for specifying whether or not to use SSL; if you want to control this you will have to provide another method. @type use_ssl: bool @rtype: L{PBConnectionInfo} """ auth = fpb.Authenticator(username=username, password=password) ret = PBConnectionInfo(None, port, use_ssl, auth) matched = _pat.search(string) if not matched: raise TypeError('Invalid connection string: %s ' '(looking for [user[:pass]@]host[/ssl|/tcp][:port])' % string) groups = matched.groups() for o, k, i, f in ((auth, 'username', 1, str), (auth, 'password', 3, str), (ret, 'host', 4, str), (ret, 'port', 6, int)): if groups[i]: setattr(o, k, f(groups[i])) return ret
def _runInterface(options): # initialise curses stdscr = curses.initscr() curses.noecho() curses.cbreak() stdscr.nodelay(1) stdscr.keypad(1) reactor.addSystemEventTrigger('after', 'shutdown', cleanup_curses, stdscr) # first lets sort out logging in username = '******' password = '******' hostname = 'localhost' insecure = False port = 7531 if options.username and options.password and options.hostname: username = options.username password = options.password hostname = options.hostname if options.port: try: port = int(options.port) except ValueError: pass if options.insecure: insecure = True authenticator = fpb.Authenticator(username=username, password=password) info = PBConnectionInfo(hostname, port, not insecure, authenticator) connection.connect_to_manager(stdscr, info) else: # do greeter # get recent connections greeter = AdminTextGreeter(stdscr) reactor.addReader(greeter) greeter.show()
def connectToManager(self, connection): """ Connect to a manager. @type connection: L{flumotion.common.connection.PBConnectionInfo} @rtype: L{defer.Deferred} firing L{flumotion.admin.admin.AdminModel} """ from flumotion.twisted import pb as fpb if not connection.authenticator: connection.authenticator = fpb.Authenticator( username=connection.username, password=connection.password, address=connection.host) # platform-3/trunk compatibility stuff to guard against # gratuitous changes try: # platform-3 adminMedium = admin.AdminModel(connection.authenticator) self.debug("code is platform-3") except TypeError: # trunk adminMedium = admin.AdminModel() self.debug("code is trunk") if hasattr(adminMedium, 'connectToHost'): # platform-3 d = adminMedium.connectToHost(connection.host, connection.port, not connection.use_ssl) else: d = adminMedium.connectToManager(connection) d.addCallback(self._connectToManagerCb, adminMedium) d.addErrback(self._connectToManagerEb) return d
def doRead(self): c = self.stdscr.getch() if self.state == 0: if c == curses.KEY_DOWN: if self.current_connection >= self.displayed_connections: self.current_connection = 0 else: self.current_connection = self.current_connection + 1 self.show() elif c == curses.KEY_UP: if self.current_connection == 0: self.current_connection = self.displayed_connections else: self.current_connection = self.current_connection - 1 self.show() elif c == curses.KEY_ENTER or c == 10: # if new connection, ask for username, password, hostname etc. if self.current_connection == self.displayed_connections: curses.curs_set(1) self.current_input = self.inputs[1] self.state = 1 self.display_current_input_line() else: # ok a recent connection has been selected curses.curs_set(1) c = self.connections[self.current_connection] info = c.info reactor.removeReader(self) connection.connect_to_manager(self.stdscr, info) else: if c == curses.KEY_ENTER or c == 10: if self.state < 6: self.inputs[self.state] = self.current_input if self.state < 5: self.current_input = self.inputs[self.state + 1] self.state = self.state + 1 self.display_current_input_line() else: # connect reactor.removeReader(self) try: port = int(self.inputs[2]) except ValueError: port = 7531 info = PBConnectionInfo( self.inputs[1], port, self.inputs[3] == 'Yes', fpb.Authenticator(username=self.inputs[4], password=self.inputs[5])) connection.connect_to_manager(self.stdscr, info) pass elif c == curses.KEY_BACKSPACE or c == 127: self.current_input = self.current_input[:-1] self.display_current_input_line() elif c == curses.KEY_UP: if self.state > 0: self.current_input = self.inputs[self.state - 1] self.state = self.state - 1 if self.state == 0: # turn off cursor curses.curs_set(0) self.display_current_input_line() elif c == curses.KEY_DOWN: pass else: self.current_input = self.current_input + chr(c) self.display_current_input_line()
def getConnectionInfo(self): thost = self._tport.getHost() authenticator = fpb.Authenticator(username='******', password='******') return connection.PBConnectionInfo(thost.host, thost.port, True, authenticator)
def main(args): parser = _createParser() log.debug('worker', '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('worker', 'Setting configure.%s to %s' % (d, o)) setattr(configure, d, o) # translate feederports string to range if options.feederports: if not '-' in options.feederports: raise errors.OptionError("feederports '%s' does not contain '-'" % options.feederports) (lower, upper) = options.feederports.split('-') options.feederports = range(int(lower), int(upper) + 1) # check if a config file was specified; if so, parse config and copy over if len(args) > 1: workerFile = args[1] _readConfig(workerFile, options) # set default values for all unset options if not options.host: options.host = 'localhost' if not options.transport: options.transport = 'ssl' if not options.port: if options.transport == "tcp": options.port = configure.defaultTCPManagerPort elif options.transport == "ssl": options.port = configure.defaultSSLManagerPort # set a default name if none is given if not options.name: if options.host == 'localhost': options.name = 'localhost' log.debug('worker', 'Setting worker name localhost') else: import socket options.name = socket.gethostname() log.debug('worker', 'Setting worker name %s (from hostname)' % options.name) if options.feederports is None and not options.randomFeederports: options.feederports = configure.defaultGstPortRange log.debug('worker', 'Using default feederports %r' % options.feederports) # check for wrong options/arguments if not options.transport in ['ssl', 'tcp']: sys.stderr.write('ERROR: wrong transport %s, must be ssl or tcp\n' % options.transport) return 1 # reset FLU_DEBUG which could be different after parsing XML file if options.debug: log.setFluDebug(options.debug) if options.daemonizeTo and not options.daemonize: sys.stderr.write( 'ERROR: --daemonize-to can only be used with -D/--daemonize.\n') return 1 if options.serviceName and not options.daemonize: sys.stderr.write( 'ERROR: --service-name can only be used with -D/--daemonize.\n') return 1 brain = worker.WorkerBrain(options) # Now bind and listen to our unix and tcp sockets if not brain.listen(): sys.stderr.write('ERROR: Failed to listen on worker ports.\n') return 1 name = options.name if options.daemonize: if options.serviceName: name = options.serviceName if not options.daemonizeTo: options.daemonizeTo = "/" startup("worker", name, options.daemonize, options.daemonizeTo) log.debug('worker', 'Running Flumotion version %s' % configure.version) import twisted.copyright log.debug('worker', 'Running against Twisted version %s' % twisted.copyright.version) # register all package paths (FIXME: this should go away when # components come from manager) from flumotion.common import setup setup.setupPackagePath() # FIXME: why address='localhost' ? authenticator = pb.Authenticator(username=options.username, password=options.password, address='localhost', avatarId=options.name) info = connection.PBConnectionInfo(options.host, options.port, options.transport == "ssl", authenticator) brain.login(info) log.info('worker', 'Connecting to manager %s using %s' % (info, options.transport.upper())) # go into the reactor main loop reactor.run() return 0