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