def setup_local(myName, virtualNet, classicalNet, lNode, func, *args,
**kwargs):
"""
Sets up
- local classical communication server (if desired according to the configuration file)
- client connection to the local virtual node quantum backend
- client connections to all other classical communication servers
Arguments
myName name of this node (string)
virtualNet servers of the virtual nodes (dictionary of host objects)
classicalNet servers on the classical communication network (dictionary of host objects)
lNode Twisted PB root to use as local server (if applicable)
func function to run if all connections are set up
args, kwargs additional arguments to be given to func
"""
logging.basicConfig(
format="%(asctime)s:%(levelname)s:%(message)s",
level=simulaqron_settings.log_level,
)
# Initialize Twisted callback framework
dList = []
# If we are listed as a server node for the classical network, start this server
if myName in classicalNet.hostDict:
try:
logging.debug(
"LOCAL %s: Starting local classical communication server.",
myName)
nb = classicalNet.hostDict[myName]
nb.root = lNode
nb.factory = pb.PBServerFactory(nb.root)
reactor.listenTCP(nb.port, nb.factory)
except Exception as e:
logging.error(
"LOCAL {}: Cannot start classical communication servers: {}".
format(myName, e))
return
# Give the server some time to start up
time.sleep(3)
# Connect to the local virtual node simulating the "local" qubits
logging.debug("LOCAL %s: Connecting to local virtual node.", myName)
node = virtualNet.hostDict[myName]
factory = pb.PBClientFactory()
reactor.connectTCP(node.hostname, node.port, factory)
deferVirtual = factory.getRootObject()
dList.append(deferVirtual)
# Set up a connection to all the other nodes in the classical network
for node in classicalNet.hostDict:
nb = classicalNet.hostDict[node]
if nb.name != myName:
logging.debug("LOCAL %s: Making classical connection to %s.",
myName, nb.name)
nb.factory = pb.PBClientFactory()
reactor.connectTCP(nb.hostname, nb.port, nb.factory)
dList.append(nb.factory.getRootObject())
deferList = DeferredList(dList, consumeErrors=True)
deferList.addCallback(init_register, myName, virtualNet, classicalNet,
lNode, func, *args, **kwargs)
deferList.addErrback(localError)
try:
reactor.run()
except error.ReactorNotRestartable:
pass
def joinCluster(self):
def startHeartbeats():
self._startSlave()
self.s_rpc.startService()
if self.role == MasterService.RL_ACTIVE:
self._startMaster()
def joinRefused(reason):
reason.trap(NodeRefusedError, RPCRefusedError)
log.err("Join to cluster %s failed: Master %s has refused me: %s" %
(core.cfg['CLUSTER_NAME'], self.master,
reason.getErrorMessage()))
self.stopService()
def joinAccepted(result):
self.role = MasterService.RL_PASSIVE
log.info("Join successfull, I'm now part of cluster %s." %
(core.cfg['CLUSTER_NAME']))
startHeartbeats()
def masterConnected(obj):
d = obj.callRemote("register", DNSCache.getInstance().name)
d.addCallbacks(joinAccepted, joinRefused)
d.addErrback(log.err)
d.addBoth(lambda _: rpcConnector.disconnect())
return d
try:
if self.master is None:
# New active master
if DNSCache.getInstance(
).name not in core.cfg['ALLOWED_NODES']:
log.warn(
"I'm not allowed to create a new cluster. Exiting.")
raise Exception("Cluster creation not allowed")
if DiskHeartbeat.is_in_use():
log.err("Heartbeat disk is in use but we are alone !")
raise Exception("Heartbeat disk already in use")
log.info("No master found. I'm now the new master of %s." %
(core.cfg['CLUSTER_NAME']))
self.role = MasterService.RL_ACTIVE
self.master = DNSCache.getInstance().name
self.status[self.master] = {
'timestamp': 0,
'offset': 0,
'vms': []
}
self.disk.make_slot(DNSCache.getInstance().name)
startHeartbeats()
else:
# Passive master
self.role = MasterService.RL_JOINING
log.info("Trying to join cluster %s..." %
(core.cfg['CLUSTER_NAME']))
factory = pb.PBClientFactory()
rpcConnector = reactor.connectTCP(self.master,
core.cfg['TCP_PORT'],
factory)
d = factory.getRootObject()
d.addCallback(masterConnected)
d.addErrback(log.err)
except Exception, e:
log.err("Startup failed: %s. Shutting down." % (e))
self.stopService()
if last_checkin:
self.last_checkin = last_checkin
return changes
poller = ViewCvsPoller()
def error(*args):
log.err()
reactor.stop()
def poll_changes(remote):
print("GET CHANGES SINCE", poller.last_checkin, end=' ')
changes = poller.get_changes()
for change in changes:
print(change["who"], "\n *", "\n * ".join(change["files"]))
change['src'] = 'cvs'
remote.callRemote('addChange', change).addErrback(error)
print()
reactor.callLater(60, poll_changes, remote)
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 9999, factory)
deferred = factory.login(credentials.UsernamePassword("change", "changepw"))
deferred.addCallback(poll_changes).addErrback(error)
reactor.run()
def __init__(self):
self.factory = pb.PBClientFactory()
reactor.connectUNIX(settings.CIA_BOT_SOCKET, self.factory)
self.root = block(self.factory.getRootObject())
def __init__(self):
self.pbfactory = pb.PBClientFactory()
def main():
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8800, factory)
d = factory.getRootObject()
d.addCallbacks(got_obj)
reactor.run()
def connect(self):
password = md5(MASTER_PASSWORD).digest()
factory = pb.PBClientFactory()
reactor.connectTCP(MASTER_IP,MASTER_PORT,factory)
factory.login(UsernamePassword("CharacterServer-CharacterServer", password),self).addCallbacks(self.connected, self.failure)
print "Connecting to Master Server..."
def runTest(self):
factory = pb.PBClientFactory()
reactor.connectTCP(self.hostname, self.portno, factory)
factory.login(UsernamePassword(
b"benchmark", b"benchmark")).addCallback(self._cbPerspective)
def get_remote(sock):
conn = pb.PBClientFactory()
reactor.connectUNIX(sock, conn)
return conn.getRootObject()
from twisted.spread import pb
from twisted.internet import reactor, defer
class MethodsF(pb.Root):
def remote_test(self):
print('WORK')
return 'Result'
client = pb.PBClientFactory()
d = client.getRootObject()
@defer.inlineCallbacks
def callback(ref):
d1 = yield ref.callRemote('call', MethodsF())
d2 = yield ref.callRemote('callDT')
print(d1, d2)
d.addCallback(callback)
reactor.connectTCP('localhost', 8000, client) # big_mixin_example.py
reactor.run()
def connect(self):
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8789, factory)
return factory.login(self.credentials).addCallback(self._connected)
def connect(self, directory, ip, port, sdirectory, selfip, selfport):
self.directory = directory
clientfactory = pb.PBClientFactory()
reactor.connectTCP(ip, port, clientfactory)
d = clientfactory.getRootObject()
d.addCallback(self.got_connected, sdirectory, selfip, selfport)
def connect(self):
clientfactory = pb.PBClientFactory()
reactor.connectTCP("localhost", 6001, clientfactory)
d = clientfactory.getRootObject()
d.addCallback(self.got_connected)
def sendChanges(self, opts, changes):
pbcf = pb.PBClientFactory()
reactor.connectTCP(opts['bbserver'], int(opts['bbport']), pbcf)
d = pbcf.login(credentials.UsernamePassword('change', 'changepw'))
d.addCallback(self.sendAllChanges, changes)
return d
def connect(self):
factory = pb.PBClientFactory()
reactor.connectTCP(GMSERVERIP,GMSERVERPORT,factory)
password = md5(GMSERVER_PASSWORD).digest()
factory.login(UsernamePassword("CharacterServer-CharacterServer", password),self).addCallbacks(self.connected, self.failure)
def main():
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8800, factory)
def1 = factory.login(credentials.UsernamePassword("user1", "pass1"))
def1.addCallback(connected)
reactor.run()
def login(self, cred, ip, port):
factory = pb.PBClientFactory()
reactor.connectTCP(ip, port, factory)
return factory.login(cred, client=self)
def deliverJob(self):
# returns a Deferred that fires when the job has been delivered
if self.connect == "ssh":
tryhost = self.getopt("host")
tryport = self.getopt("port")
tryuser = self.getopt("username")
trydir = self.getopt("jobdir")
buildbotbin = self.getopt("buildbotbin")
ssh_command = self.getopt("ssh")
if not ssh_command:
ssh_commands = which("ssh")
if not ssh_commands:
raise RuntimeError(
"couldn't find ssh executable, make sure "
"it is available in the PATH")
argv = [ssh_commands[0]]
else:
# Split the string on whitespace to allow passing options in
# ssh command too, but preserving whitespace inside quotes to
# allow using paths with spaces in them which is common under
# Windows. And because Windows uses backslashes in paths, we
# can't just use shlex.split there as it would interpret them
# specially, so do it by hand.
if runtime.platformType == 'win32':
# Note that regex here matches the arguments, not the
# separators, as it's simpler to do it like this. And then we
# just need to get all of them together using the slice and
# also remove the quotes from those that were quoted.
argv = [
string.strip(a, '"') for a in re.split(
r'''([^" ]+|"[^"]+")''', ssh_command)[1::2]
]
else:
# Do use standard tokenization logic under POSIX.
argv = shlex.split(ssh_command)
if tryuser:
argv += ["-l", tryuser]
if tryport:
argv += ["-p", tryport]
argv += [tryhost, buildbotbin, "tryserver", "--jobdir", trydir]
pp = RemoteTryPP(self.jobfile)
reactor.spawnProcess(pp, argv[0], argv, os.environ)
d = pp.d
return d
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(user, passwd))
reactor.connectTCP(tryhost, tryport, f)
d.addCallback(self._deliverJob_pb)
return d
raise RuntimeError(
"unknown connecttype '%s', should be 'ssh' or 'pb'" % self.connect)
def connect(self):
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8790, factory)
def1 = factory.getRootObject()
def1.addCallbacks(self.got_obj1, self.err_obj1)
def __init__(self, name):
self.name = name
self._factory = pb.PBClientFactory()
self._reference = ProxyReference()
self._addr = None
def connect(self):
factory = pb.PBClientFactory()
reactor.connectTCP(self.serverIP, self.serverPort, factory)
return factory.login(self.credentials,
client=self).addCallback(self._connected)
def one(port, user, pw, service, perspective, number):
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", port, factory)
def1 = factory.getPerspective(user, pw, service, perspective)
def1.addCallback(connected, number)
def _setUpClient(self):
portNo = self.serverPort.getHost().port
self.clientFactory = pb.PBClientFactory()
self.clientConnector = reactor.connectTCP("127.0.0.1", portNo,
self.clientFactory)
def main():
foo = Foo()
factory = pb.PBClientFactory()
reactor.connectTCP("localhost", 8800, factory)
factory.getRootObject().addCallback(foo.step1)
reactor.run()
def get_store(self):
factory = pb.PBClientFactory()
factory.noisy = False
reactor.connectTCP(self.host, 8789, factory)
return factory.getRootObject()
def connect(self):
factory = pb.PBClientFactory()
reactor.connectTCP("10.111.101.206", 24498, factory)
self.remote = yield factory.getRootObject()
print 'connected'
yield self.remote.callRemote("setRemote", port=24496)
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.
"""
changes = []
newrev = payload['after']
refname = payload['ref']
# We only care about regular heads, i.e. branches
match = re.match(r"^refs\/heads\/(.+)$", refname)
if not match:
logging.info("Ignoring refname `%s': Not a branch" % refname)
branch = match.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)
else:
for commit in payload['commits']:
files = []
files.extend(commit['added'])
files.extend(commit['modified'])
files.extend(commit['removed'])
change = {
'revision':
commit['id'],
'revlink':
commit['url'],
'comments':
commit['message'],
'branch':
branch,
'who':
commit['author']['name'] + " <" +
commit['author']['email'] + ">",
'files':
files,
'links': [commit['url']],
'repository':
repo_url,
'project':
project,
}
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"))
reactor.connectTCP(host, port, factory)
deferred.addErrback(self.connectFailed)
deferred.addCallback(self.connected, changes)
def runClient(self):
f = pb.PBClientFactory()
self.cport = reactor.connectTCP("127.0.0.1", self.port, f)
d = f.getRootObject()
d.addCallback(self.clientConnected)
return d
def start(self, address, port):
print("Client.")
pygame.init()
factory = pb.PBClientFactory()
engine = Engine(ClientState(factory))
def send_press_up(obj):
obj.callRemote('setUpArrow', True)
@engine.handle_keydown(pygame.locals.K_UP)
def press_up():
d = factory.getRootObject()
d.addCallback(send_press_up)
def send_release_up(obj):
obj.callRemote('setUpArrow', False)
@engine.handle_keyup(pygame.locals.K_UP)
def release_up():
d = factory.getRootObject()
d.addCallback(send_release_up)
def send_press_down(obj):
obj.callRemote('setDownArrow', True)
@engine.handle_keydown(pygame.locals.K_DOWN)
def press_down():
d = factory.getRootObject()
d.addCallback(send_press_down)
def send_release_down(obj):
obj.callRemote('setDownArrow', False)
@engine.handle_keyup(pygame.locals.K_DOWN)
def release_down():
d = factory.getRootObject()
d.addCallback(send_release_down)
def send_press_left(obj):
obj.callRemote('setLeftArrow', True)
@engine.handle_keydown(pygame.locals.K_LEFT)
def press_left():
d = factory.getRootObject()
d.addCallback(send_press_left)
def send_release_left(obj):
obj.callRemote('setLeftArrow', False)
@engine.handle_keyup(pygame.locals.K_LEFT)
def release_left():
d = factory.getRootObject()
d.addCallback(send_release_left)
def send_press_right(obj):
obj.callRemote('setRightArrow', True)
@engine.handle_keydown(pygame.locals.K_RIGHT)
def press_right():
d = factory.getRootObject()
d.addCallback(send_press_right)
def send_release_right(obj):
obj.callRemote('setRightArrow', False)
@engine.handle_keyup(pygame.locals.K_RIGHT)
def release_right():
d = factory.getRootObject()
d.addCallback(send_release_right)
@engine.handle_keyup(pygame.locals.K_q)
def stop():
reactor.stop()
pygame.display.set_caption('TPG Client')
engine.start()
reactor.connectTCP(address, port, factory)
reactor.run()
