def _connectClient(self, connected, opened, clientDisconnected):
factory = WampClientFactory('ws://localhost:9000', debugWamp=True)
factory.protocol = ClientProtocol
factory.onConnectionMade = connected
factory.onSessionOpen = opened
factory.onConnectionLost = clientDisconnected
self.factory = factory
return connectWS(factory)
def connect(self):
if self.client:
self.logger.debug('already connected to %s' % self.url)
return
broadcaster = self
self.logger.debug('trying to connect to %s' % self.url)
class BroadcastClientProtocol(WampClientProtocol):
def onSessionOpen(self):
broadcaster.client = self
broadcaster.logger.info('connected to broadcast-server %s' %
broadcaster.url)
broadcaster.onSessionOpen()
self.factory = WampClientFactory(self.url)
self.factory.protocol = BroadcastClientProtocol
reactor.connectTCP(self.host, self.port, self.factory)
def publisher(c_name="all", debug=True):
log.startLogging(sys.stdout)
if c_name != "all":
channel_name = "notifications:%s" % c_name
else:
channel_name = "notifications:all"
#print "user name in Publisher: ", channel_name
PUBSUB.subscribe(channel_name)
'''
factory = WampClientFactory("ws://%s:9000" % socket.gethostname(),
debugWamp=debug)
'''
factory = WampClientFactory("ws://localhost:9000", debugWamp=debug)
factory.protocol = PubSubClient1
connectWS(factory)
reactor.run()
class KeyValueClientProtocol(WampClientProtocol):
def done(self, *args):
self.sendClose()
reactor.stop()
def show(self, key, value):
print key, value
def get(self, keys):
defs = []
for key in keys:
d = self.call(
"keyvalue:get",
key).addCallback(lambda value, key=key: self.show(key, value))
defs.append(d)
return DeferredList(defs)
def onSessionOpen(self):
self.prefix("keyvalue", "http://example.com/simple/keyvalue#")
self.call("keyvalue:keys").addCallbacks(self.get).addCallback(
self.done)
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WampClientFactory("ws://localhost:8080/ws")
factory.protocol = KeyValueClientProtocol
connectWS(factory)
reactor.run()
def onPong(self, payload):
id = payload[:16]
l = len(payload) - 16
now = datetime.datetime.utcnow()
if self.beats.has_key(id):
rtt_ms = (now - self.beats[id]).total_seconds() * 1000.
print "Got heartbeat: " + id, l, rtt_ms
if __name__ == '__main__':
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
log.startLogging(sys.stdout)
debug = False
#factory = WebSocketClientFactory(sys.argv[1], debug = True, debugCodePaths = True)
factory = WampClientFactory(sys.argv[1],
debug = debug,
debugCodePaths = True,
debugWamp = debug)
factory.protocol = HeartbeatClientProtocol
connectWS(factory)
reactor.run()
reactor.callLater(2, self.sendSimpleEvent)
break
#reactor.callLater(2, self.sendSimpleEvent)
if __name__ == '__main__':
log.startLogging(sys.stdout)
#debug = len(sys.argv) > 1 and sys.argv[1] == 'debug'
debug = True
if len(sys.argv) > 1:
channel_name = "notifications:%s:%s" % (sys.argv[1], sys.argv[2])
else:
channel_name = "notifications:all"
PUBSUB.subscribe(channel_name)
#factory = WampClientFactory("ws://localhost:9000", debugWamp=debug)
factory = ""
host_name = socket.gethostname()
if host_name == 'ip-172-31-29-49':
print "Running WS as oposod.com"
factory = WampClientFactory("ws://oposod.com:9000", debugWamp=None)
else:
print "Running WS as localhost"
factory = WampClientFactory("ws://localhost:9000", debugWamp=debug)
factory.protocol = PubSubClient1
connectWS(factory)
reactor.run()
d3 = self.call("calc:sum", [1, 2, 3, 4, 5]).addCallback(self.show)
d4 = self.call("calc:square", 23).addCallback(lambda res: \
self.call("calc:sqrt", res)).addCallback(self.show)
d5 = self.call("calc:sqrt", -1).addCallbacks(self.show,
self.logerror)
d6 = self.call("calc:square", 1001).addCallbacks(self.show,
self.logerror)
d7 = self.call("calc:asum", [1, 2, 3]).addCallback(self.show)
d8 = self.call("calc:sum", [4, 5, 6]).addCallback(self.show)
d9 = self.call("calc:pickySum", range(0, 30)).addCallbacks(self.show,
self.logerror)
## we want to shutdown the client exactly when all deferreds are finished
DeferredList([d1, d2, d3, d4, d5, d6, d7, d8, d9]).addCallback(self.done)
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WampClientFactory("ws://mozart.kawigi.com:9000", debugWamp = True)
factory.protocol = SimpleClientProtocol
connectWS(factory)
reactor.run()
from autobahn.websocket import connectWS
from autobahn.wamp import WampClientFactory, WampClientProtocol
class KeyValueClientProtocol(WampClientProtocol):
def done(self, *args):
self.sendClose()
def show(self, key, value):
print key, value
def get(self, keys):
for key in keys:
self.call(
"keyvalue:get",
key).addCallback(lambda value, key=key: self.show(key, value))
def onSessionOpen(self):
self.prefix("keyvalue", "http://example.com/simple/keyvalue#")
self.call("keyvalue:keys").addCallbacks(self.get).addCallback(
self.done)
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WampClientFactory("ws://localhost:9000")
factory.protocol = KeyValueClientProtocol
connectWS(factory)
reactor.run()
def onSessionOpen(self):
print "Session Opened"
# Set the App Prefix
self.prefix("moirai", "http://%s/%s/" % (app_domain, app_name))
# shortname for the domain + app name + topic
GraphAddr = "moirai:graph" + topicId
print "Subscribing to " + GraphAddr
self.subscribe(GraphAddr, self.onApp)
# lets try and publish something
self.publish(GraphAddr, {"an":{"C":{"label":"DOMAIN","Class":"Attribute","Metadata":{"DOMAIN":"fark.com"}}}})
self.publish(GraphAddr, {"an":{"C":{"label":"DOMAIN","Class":"Attribute","Metadata":{"DOMAIN":"fark.com"}, "bool": True}}})
self.publish(GraphAddr, {"an":{"C":{"label":"DOMAIN","Class":"Attribute","Metadata":{"DOMAIN":"fark.com"}, "size":0.5}}})
self.publish(GraphAddr, testDict)
# quit after publishing
self.done()
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WampClientFactory("ws://" + ws_host + ":" + ws_port)
factory.protocol = MyClientProtocol
connectWS(factory)
reactor.run()
def onOpen(self):
self.prefix("calc", "http://example.com/simple/calc#")
d1 = self.call("calc:square", 23).addCallback(self.show)
d2 = self.call("calc:add", 23, 7).addCallback(self.show)
d3 = self.call("calc:sum", [1, 2, 3, 4, 5]).addCallback(self.show)
d4 = self.call("calc:square", 23).addCallback(lambda res: \
self.call("calc:sqrt", res)).addCallback(self.show)
d5 = self.call("calc:sqrt", -1).addCallbacks(self.show, self.logerror)
d6 = self.call("calc:square", 1001).addCallbacks(self.show, self.logerror)
d7 = self.call("calc:asum", [1, 2, 3]).addCallback(self.show)
d8 = self.call("calc:sum", [4, 5, 6]).addCallback(self.show)
## we want to shutdown the client exactly when all deferreds are finished
DeferredList([d1, d2, d3, d4, d5, d6, d7, d8]).addCallback(self.done)
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WampClientFactory(debug = False)
factory.protocol = SimpleClientProtocol
reactor.connectTCP("localhost", 9000, factory)
reactor.run()
def onOpen(self):
self.bm = BluetoothManager("07:12:05:16:67:00", 1)
self.bm.registerListener(self.onBluetoothMessage)
self.bm.start()
def onSessionOpen(self):
self.subscribe("http://leddimmer.unserHaus.name/event", self.onSimpleEvent)
def onSimpleEvent(self, topicUri, event):
self.sendBluetoothMessage(event)
def onBluetoothMessage(self, message):
#print message
self.publish("http://leddimmer.unserHaus.name/event", message)
def sendBluetoothMessage(self, message):
self.bm.sendMessage(message)
if __name__ == '__main__':
log.startLogging(sys.stdout)
debug = len(sys.argv) > 1 and sys.argv[1] == 'debug'
debug = True
factory = WampClientFactory("ws://localhost:9000", debugWamp=debug)
factory.protocol = PubSubClient1
factory.setProtocolOptions(tcpNoDelay=True)
connectWS(factory)
reactor.run()
})
reactor.callLater(2, sendMyEvent1)
sendMyEvent1()
def onClose(self, wasClean, code, reason):
print "Connection closed", reason
reactor.stop()
if __name__ == '__main__':
log.startLogging(sys.stdout)
if len(sys.argv) > 1:
wsuri = sys.argv[1]
else:
wsuri = "ws://localhost:9000"
print "Connecting to", wsuri
## our WAMP/WebSocket client
##
factory = WampClientFactory(wsuri, debugWamp=False)
factory.protocol = MyPubSubClientProtocol
connectWS(factory)
## run the Twisted network reactor
##
reactor.run()
def logerror(self, e):
erroruri, errodesc, errordetails = e.value.args
print "ERROR: %s ('%s') - %s" % (erroruri, errodesc, errordetails)
def done(self, *args):
self.sendClose()
reactor.stop()
def onSessionOpen(self):
# Set the App Prefix
self.prefix("moirai", "http://%s/%s/" % (app_domain, app_name))
query = "START n=node(*) RETURN n;"
params = {}
self.call("moirai:cypher", query, params).addCallbacks(self.nodesFirst)
############## STUFF HAPPENS HERE #############
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WampClientFactory("ws://%s:%s" % (ws_host, ws_port),
debugWamp=True)
factory.protocol = SimpleClientProtocol
connectWS(factory)
reactor.run()
class GephiClientProtocol(WebSocketClientProtocol):
def onOpen(self):
print "connected to Gephi"
def onMessage(self, msg, binary):
if not binary:
obj = json.loads(msg)
self.factory.forwarder.publish(GEPHI_TOPIC_URI + "1", obj)
class GephiForwardingProtocol(WampClientProtocol):
def onSessionOpen(self):
print "connected to WAMP server"
factory = WebSocketClientFactory(GEPHI_SERVER_URL)
factory.protocol = GephiClientProtocol
factory.forwarder = self
connectWS(factory)
if __name__ == '__main__':
log.startLogging(sys.stdout)
debug = len(sys.argv) > 1 and sys.argv[1] == 'debug'
factory = WampClientFactory(WAMP_SERVER_URL, debugWamp=debug)
factory.protocol = GephiForwardingProtocol
connectWS(factory)
reactor.run()
