def test_requestAvatarId_noinitLock(self): portstr = "tcp:0:interface=127.0.0.1" reg = yield self.pbm.register(portstr, "boris", "pass", self.perspectiveFactory) disp = self.pbm.dispatchers[portstr] d = disp.requestAvatarId( credentials.UsernamePassword(b'boris', b'pass')) self.assertTrue( d.called, "requestAvatarId should have been called since the lock is free") yield reg.unregister()
def process_change(self, payload): """ Consumes the JSON as a python object and actually starts the build. :arguments: payload Python Object that represents the JSON sent by Bitbucket POST Service Hook. """ if self.private: repo_url = 'ssh://hg@%s%s' % ( self.bitbucket, payload['repository']['absolute_url'], ) else: repo_url = 'http://%s%s' % ( self.bitbucket, payload['repository']['absolute_url'], ) changes = [] for commit in payload['commits']: files = [file_info['file'] for file_info in commit['files']] revlink = 'http://%s%s/changeset/%s/' % ( self.bitbucket, payload['repository']['absolute_url'], commit['node'], ) change = { 'revision': commit['node'], 'revlink': revlink, 'comments': commit['message'], 'who': commit['author'], 'files': files, 'repository': repo_url, 'properties': dict(), } changes.append(change) # Submit the changes, if any if not changes: logging.warning("No changes found") return host, port = self.master.split(':') port = int(port) factory = pb.PBClientFactory() deferred = factory.login( credentials.UsernamePassword("change", "changepw")) logging.debug('Trying to connect to: %s:%d' % (host, port)) reactor.connectTCP(host, port, factory) deferred.addErrback(self.connectFailed) deferred.addCallback(self.connected, changes)
def avatar(): #lego = CachingRealm. closeshop = closeShop() sender = Sender('data', closeshop, 'no_file') factory = pb.PBClientFactory() reactor.connectTCP("dashboard.hdd.lab", 1331, factory) def1 = factory.login(credentials.UsernamePassword("user1", "pass1")) def1.addCallback(connected) #def1.addCallback(connectedAgain) #deferred = factory.getRootObject() #deffed.addCallback(connected) #deferred.addCallback(sender.phase360) reactor.run()
def startConnecting(self): try: host, port = re.search(r'(.+):(\d+)', self.master).groups() port = int(port) except: print "unparseable master location '%s'" % self.master print " expecting something more like localhost:8007" raise cf = pb.PBClientFactory() creds = credentials.UsernamePassword(self.username, self.passwd) d = cf.login(creds) reactor.connectTCP(host, port, cf) d.addCallbacks(self.connected, self.not_connected) return d
def main(): c = checkers.InMemoryUsernamePasswordDatabaseDontUse(user=b"pass") p = portal.Portal(Realm(), [c]) server = pb.PBServerFactory(p) server.unsafeTracebacks = True client = pb.PBClientFactory() login = client.login(credentials.UsernamePassword(b"user", b"pass")) login.addCallback(cbLogin).addErrback(ebLogin).addBoth( lambda: reactor.stop()) from twisted.internet import reactor p = reactor.listenTCP(0, server) c = reactor.connectTCP("127.0.0.1", p.getHost().port, client) reactor.run()
def decode(self, response, request): """ Parse the base64-encoded, colon-separated username and password into a L{credentials.UsernamePassword} instance. """ try: creds = binascii.a2b_base64(response + '===') except binascii.Error: raise error.LoginFailed('Invalid credentials') creds = creds.split(':', 1) if len(creds) == 2: return credentials.UsernamePassword(*creds) else: raise error.LoginFailed('Invalid credentials')
def test_validCreds(self): username = '******' pw = 'pass' c = credentials.UsernamePassword(username, pw) # Write them to Database credstring = self.servicename + self.sep + username + self.sep + pw + self.sep self.addCredentials(credstring) # Make sure you got UserName back ==> creds are valid actual = self.db.requestAvatarId(c).result self.assertEqual(username, actual) # Delete creds from file self.clearCredentials()
def send(self, branch, revision, comments, files, who=None, category=None, when=None, properties={}, repository='', vc=None, project='', revlink=''): change = { 'project': project, 'repository': repository, 'who': who, 'files': files, 'comments': comments, 'branch': branch, 'revision': revision, 'category': category, 'when': when, 'properties': properties, 'revlink': revlink, 'src': vc } for key in change: if type(change[key]) == str: change[key] = change[key].decode(self.encoding, 'replace') change['files'] = list(change['files']) for i, file in enumerate(change.get('files', [])): if type(file) == str: change['files'][i] = file.decode(self.encoding, 'replace') f = pb.PBClientFactory() d = f.login(credentials.UsernamePassword(self.username, self.password)) reactor.connectTCP(self.host, self.port, f) def call_addChange(remote): d = remote.callRemote('addChange', change) d.addCallback(lambda res: remote.broker.transport.loseConnection()) return d d.addCallback(call_addChange) return d
def test_password_auth_user_with_correct_password(self): """ AccountFileChecker.requestAvatarId returns a Deferred that fires with the user if the correct password is given. """ key_credentials = credentials.UsernamePassword(b"alice", b"herpassword") d = self.checker.requestAvatarId(key_credentials) def authenticated(avatarId): self.assertEqual(( b"alice", b"URI:DIR2:aaaaaaaaaaaaaaaaaaaaaaaaaa:1111111111111111111111111111111111111111111111111111" ), (avatarId.username, avatarId.rootcap)) return d
def __init__(self, host, port, user, passwd, prefix=None): self.host = host self.port = port self.username = user self.password = passwd if prefix is not None and not prefix.endswith("/"): log.msg("WARNING: prefix '%s' should probably end with a slash" \ % prefix) self.prefix = prefix self.listener = l = FreshCVSListener() l.source = self self.factory = f = FreshCVSConnectionFactory() f.source = self self.creds = credentials.UsernamePassword(user, passwd) f.startLogin(self.creds, client=l) TCPClient.__init__(self, host, port, f)
def decode(self, response, request): """ Decode the credentials for basic auth. @see L{ICredentialFactory.decode} """ try: creds = (response + '===').decode('base64') except: raise error.LoginFailed('Invalid credentials') creds = creds.split(':', 1) if len(creds) == 2: return succeed(credentials.UsernamePassword(*creds)) else: return fail(error.LoginFailed('Invalid credentials'))
def __init__(self, buildmaster_host, port, name, passwd, basedir, keepalive, usePTY, keepaliveTimeout=30, umask=None, maxdelay=300, debugOpts={}, unicode_encoding=None): log.msg("Creating BuildSlave -- buildbot.version: %s" % buildbot.version) service.MultiService.__init__(self) self.debugOpts = debugOpts.copy() bot = self.botClass(basedir, usePTY, unicode_encoding=unicode_encoding) bot.setServiceParent(self) self.bot = bot if keepalive == 0: keepalive = None self.umask = umask bf = self.bf = BotFactory(keepalive, keepaliveTimeout, maxdelay) bf.startLogin(credentials.UsernamePassword(name, passwd), client=bot) self.connection = c = internet.TCPClient(buildmaster_host, port, bf) c.setServiceParent(self)
def __init__(self, buildmaster_host, port, name, passwd, basedir, keepalive, usePTY=None, keepaliveTimeout=None, umask=None, maxdelay=300, numcpus=None, unicode_encoding=None, allow_shutdown=None): # note: keepaliveTimeout is ignored, but preserved here for # backward-compatibility assert usePTY is None, "worker-side usePTY is not supported anymore" service.MultiService.__init__(self) WorkerBase.__init__(self, name, basedir, umask=umask, unicode_encoding=unicode_encoding) if keepalive == 0: keepalive = None self.numcpus = numcpus self.shutdown_loop = None if allow_shutdown == 'signal': if not hasattr(signal, 'SIGHUP'): raise ValueError("Can't install signal handler") elif allow_shutdown == 'file': self.shutdown_file = os.path.join(basedir, 'shutdown.stamp') self.shutdown_mtime = 0 self.allow_shutdown = allow_shutdown bf = self.bf = BotFactory(buildmaster_host, port, keepalive, maxdelay) bf.startLogin(credentials.UsernamePassword(name, passwd), client=self.bot) self.connection = c = internet.TCPClient( buildmaster_host, port, HangCheckFactory(bf, hung_callback=self._hung_connection)) c.setServiceParent(self)
def process_change(self, payload, user, repo, repo_url, project): """ Consumes the JSON as a python object and actually starts the build. :arguments: payload Python Object that represents the JSON sent by GitHub Service Hook. """ branch = payload['ref'].split('/')[-1] if payload['deleted'] is True: logging.info("Branch `%s' deleted, ignoring", branch) else: changes = [{ 'revision': c['id'], 'revlink': c['url'], 'who': c['author']['username'] + " <" + c['author']['email'] + "> ", 'comments': c['message'], 'repository': payload['repository']['url'], 'files': c['added'] + c['removed'] + c['modified'], 'project': project, 'branch': branch } for c in payload['commits']] if not changes: logging.warning("No changes found") return host, port = self.master.split(':') port = int(port) factory = pb.PBClientFactory() deferred = factory.login( credentials.UsernamePassword("change", "changepw")) reactor.connectTCP(host, port, factory) deferred.addErrback(self.connectFailed) deferred.addCallback(self.connected, changes)
def main(): OPTIONS, argv = getOptions('mmolite/config/servers.cfg', 'world server', sys.argv) if OPTIONS.username == "-": OPTIONS.username = raw_input("Username: "******"-": OPTIONS.password = raw_input("Password: "******"Setting up World Server..." dbconn.resetDB() print "Successfully" return else: print "Initialize World Server database..." dbconn.startDB() Clients.dropTable(ifExists=True) Clients.createTable() print "Run TGE dedicated server" argv.extend([ '-dedicated', '-game', 'test.mmo', '-mission', 'test.mmo/data/missions/chatspot.mis' ]) pytorque.initialize(len(argv), argv) print "World server connecting to master server: ip[%s] port[%d]" % ( OPTIONS.master_ip, OPTIONS.master_port) creds = credentials.UsernamePassword(OPTIONS.username, OPTIONS.password) world = WorldServer(OPTIONS.master_ip, OPTIONS.master_port, OPTIONS.world_port, PeerType.World, creds, WorldPortal()) world.run() #reactor.run() reactor.startRunning() #the main loop is broken out and can be combined with other frameworks rather easily while pytorque.tick(): reactorTick() #cleanup pytorque.. goodbye! pytorque.shutdown()
def connect(self, hostname, port): """ Connect to a server Positional arguments: hostname -- The hostname of the server port -- The port to connect to """ if self.document is None: return self.factory = pb.PBClientFactory() reactor.connectTCP(hostname, port, self.factory) d = self.factory.login(credentials.UsernamePassword(USERNAME.encode(), PASSWORD.encode()), client=self) d.addCallbacks(self.connected, self.connection_failed) return d
def testBasicLogin(self): l = [] f = [] self.portal.login(credentials.UsernamePassword("bob", "hello"), self, ITestable).addCallback(l.append).addErrback(f.append) if f: raise f[0] # print l[0].getBriefTraceback() iface, impl, logout = l[0] # whitebox self.assertEqual(iface, ITestable) self.failUnless(iface.providedBy(impl), "%s does not implement %s" % (impl, iface)) # greybox self.failUnless(impl.original.loggedIn) self.failUnless(not impl.original.loggedOut) logout() self.failUnless(impl.original.loggedOut)
def send_changes(): # Submit the changes, if any if not changes: logging.warning("No changes found") return host, port = master.split(':') port = int(port) f = pb.PBClientFactory() d = f.login(credentials.UsernamePassword(username, auth)) reactor.connectTCP(host, port, f) d.addErrback(connectFailed) d.addCallback(connected) d.addBoth(cleanup) reactor.run()
def send(self, op, bb_username, bb_password, ids, info): f = pb.PBClientFactory() d = f.login(credentials.UsernamePassword(self.username, self.password)) reactor.connectTCP(self.host, self.port, f) @d.addCallback def call_commandline(remote): d = remote.callRemote("commandline", op, bb_username, bb_password, ids, info) @d.addCallback def returnAndLose(res): remote.broker.transport.loseConnection() return res return d return d
def getCredentials(self, request): """Get username, password from post args or if they don't exist we have an anonymous session """ if request.args.get('startup_token', [''])[0]: import avatars return avatars.TokenCred(request.args.get('startup_token', [''])[0]) if request.headers.getHeader('cookie'): for C in request.headers.getHeader('cookie'): if C.name == 'cookie_test': username = request.args.get('email', [''])[0] password = request.args.get('password', [''])[0] else: username = password = '******' else: username = password = '******' return credentials.UsernamePassword(username, password)
def loginCommand(self, username): """send a login command to server. That might be a normal login or adduser/deluser/change passwd encoded in the username""" factory = pb.PBClientFactory() reactor = Internal.reactor if self.useSocket and os.name != 'nt': self.connector = reactor.connectUNIX(socketName(), factory, timeout=2) else: self.connector = reactor.connectTCP(self.dlg.host, self.dlg.port, factory, timeout=5) utf8Password = self.dlg.password.encode('utf-8') utf8Username = username.encode('utf-8') cred = credentials.UsernamePassword(utf8Username, utf8Password) return factory.login(cred, client=self.client)
def getAvailableBuilderNames(self): # This logs into the master using the PB protocol to # get the names of the configured builders that can # be used for the --builder argument if self.connect == "pb": user = self.getopt("username", "try_username") passwd = self.getopt("passwd", "try_password") master = self.getopt("master", "try_master") tryhost, tryport = master.split(":") tryport = int(tryport) f = pb.PBClientFactory() d = f.login(credentials.UsernamePassword(user, passwd)) reactor.connectTCP(tryhost, tryport, f) d.addCallback(self._getBuilderNames, self._getBuilderNames2) return d if self.connect == "ssh": raise RuntimeError("ssh connection type not supported for this command") raise RuntimeError("unknown connecttype '%s', should be 'pb'" % self.connect)
def process_changes(): # Read branch updates from stdin and generate Change events while True: line = sys.stdin.readline() if not line: break [oldrev, newrev, refname] = line.split(None, 2) # We only care about regular heads, i.e. branches m = re.match(r"^refs\/heads\/(.+)$", refname) if not m: logging.info("Ignoring refname `%s': Not a branch" % refname) continue branch = m.group(1) # Find out if the branch was created, deleted or updated. Branches # being deleted aren't really interesting. if re.match(r"^0*$", newrev): logging.info("Branch `%s' deleted, ignoring" % branch) continue elif re.match(r"^0*$", oldrev): gen_create_branch_changes(newrev, refname, branch) else: gen_update_branch_changes(oldrev, newrev, refname, branch) # Submit the changes, if any if not changes: logging.warning("No changes found") return host, port = master.split(':') port = int(port) f = pb.PBClientFactory() d = f.login(credentials.UsernamePassword("change", "changepw")) reactor.connectTCP(host, port, f) d.addErrback(connectFailed) d.addCallback(connected) d.addBoth(cleanup) reactor.run()
def login(self, username, password): """Authenticate to connected server with username and password. @param username: @param password: The SHA-1 hash of the password string is transmitted, protecting the user's password from eavesdroppers. """ def gotServerVersion(version): self.serverVersion = version def gotRoster(roster, name): if name == 'tables': self.tableRoster = roster elif name == 'users': self.userRoster = roster self.notify('gotRoster', name=name, roster=roster) def connectedAsRegisteredUser(avatar): """Actions to perform when connection succeeds.""" self.avatar = avatar self.username = username self.notify('loggedIn', username=username) # Report client version number to server. d = avatar.callRemote('setClientVersion', CLIENT_VERSION) d.addCallbacks(gotServerVersion, self.errback) # Request services from server. for rostername in ['tables', 'users']: d = avatar.callRemote('getRoster', rostername) d.addCallbacks(gotRoster, self.errback, callbackArgs=[rostername]) # Generate a SHA-1 hash of password pw_hash = self.__hashPass(password) creds = credentials.UsernamePassword(username.encode('utf-8'), pw_hash.encode('utf-8')) d = self.factory.login(creds, client=None) d.addCallbacks(connectedAsRegisteredUser, self.errback) return d
def AttemptConnection(self): print "attempting a connection to", serverHost, serverPort self.state = NetworkServerView.STATE_CONNECTING if self.reactor: self.reactor.stop() self.PumpReactor() else: self.reactor = SelectReactor() installReactor(self.reactor) connection = self.reactor.connectTCP(serverHost, serverPort, self.pbClientFactory) # TODO: make this anonymous login() #deferred = self.pbClientFactory.login(credentials.Anonymous()) userCred = credentials.UsernamePassword(avatarID, 'pass1') controller = NetworkServerController(self.evManager) deferred = self.pbClientFactory.login(userCred, client=controller) deferred.addCallback(self.Connected) deferred.addErrback(self.ConnectFailed) self.reactor.startRunning()
def test_basicLogin(self): """ Calling C{login} on a portal with correct credentials and an interface that the portal's realm supports works. """ login = self.successResultOf(self.portal.login( credentials.UsernamePassword(b"bob", b"hello"), self, ITestable)) iface, impl, logout = login # whitebox self.assertEqual(iface, ITestable) self.assertTrue(iface.providedBy(impl), "%s does not implement %s" % (impl, iface)) # greybox self.assertTrue(impl.original.loggedIn) self.assertTrue(not impl.original.loggedOut) logout() self.assertTrue(impl.original.loggedOut)
def forceBuild(self, builder, reason, branch, revision, properties): factory = pb.PBClientFactory() reactor.connectTCP(self.pb_host, self.pb_port, factory) creds = credentials.UsernamePassword(self.pb_user, self.pb_pass) d = factory.login(creds) d.addErrback(log.err, "error while connecting") dr = defer.Deferred() def connected(remote): log.msg('connected to pb') d2 = remote.callRemote('force', builder, reason, branch, revision, properties) d2.addCallback(lambda bnum: dr.callback(bnum)) d.addCallback(connected) return dr
def connectWorker(self, waitForBuilderList=True): """ Connect a worker the master via PB @param waitForBuilderList: don't return until the setBuilderList has been called @returns: L{FakeWorkerWorker} and a Deferred that will fire when it is detached; via deferred """ factory = pb.PBClientFactory() creds = credentials.UsernamePassword(b"testworker", b"pw") setBuilderList_d = defer.Deferred() workerworker = FakeWorkerWorker( lambda: setBuilderList_d.callback(None)) login_d = factory.login(creds, workerworker) @login_d.addCallback def logged_in(persp): workerworker.setMasterPerspective(persp) # set up to hear when the worker side disconnects workerworker.detach_d = defer.Deferred() persp.broker.notifyOnDisconnect( lambda: workerworker.detach_d.callback(None)) self._detach_deferreds.append(workerworker.detach_d) return workerworker self.endpoint = clientFromString( reactor, self.client_connection_string_tpl.format(port=self.port)) connected_d = self.endpoint.connect(factory) dlist = [connected_d, login_d] if waitForBuilderList: dlist.append(setBuilderList_d) d = defer.DeferredList(dlist, consumeErrors=True, fireOnOneErrback=True) d.addCallback(lambda _: workerworker) return d
def deliver_job_pb(self): user = self.getopt("username") passwd = self.getopt("passwd") master = self.getopt("master") tryhost, tryport = master.split(":") tryport = int(tryport) f = pb.PBClientFactory() d = f.login( credentials.UsernamePassword(unicode2bytes(user), unicode2bytes(passwd))) reactor.connectTCP(tryhost, tryport, f) remote = yield d ss = self.sourcestamp output("Delivering job; comment=", self.comment) self.buildsetStatus = \ yield remote.callRemote("try", ss.branch, ss.revision, ss.patch, ss.repository, self.project, self.builderNames, self.who, self.comment, self.config.get('properties', {}))
def getAvailableBuilderNames(self): # This logs into the master using the PB protocol to # get the names of the configured builders that can # be used for the --builder argument if self.connect == "pb": user = self.getopt("username") passwd = self.getopt("passwd") master = self.getopt("master") tryhost, tryport = master.split(":") tryport = int(tryport) f = pb.PBClientFactory() d = f.login(credentials.UsernamePassword(unicode2bytes(user), unicode2bytes(passwd))) reactor.connectTCP(tryhost, tryport, f) d.addCallback(self._getBuilderNames) return d if self.connect == "ssh": output("Cannot get available builders over ssh.") sys.exit(1) raise RuntimeError( "unknown connecttype '{}', should be 'pb'".format(self.connect))