def __init__(self, endpoint=None, id=None, secret=None,
debug=False, bot=SputnikSession, ca_certs_dir="/etc/ssl/certs", **kwargs):
EventEmitter.__init__(self)
self.debug = debug
self.session_factory = BotFactory(username=id,
password=secret,
**kwargs)
self.session_factory.on("connect", self.onConnect)
self.session_factory.on("disconnect", self.onDisconnect)
self.session_factory.on("join", self.onJoin)
self.session_factory.session = bot
self.base_uri = endpoint
from urlparse import urlparse
parse = urlparse(endpoint)
if parse.scheme == 'wss':
if parse.port is None:
port = 8443
else:
port = parse.port
self.connection_string = "ssl:host=%s:port=%d:caCertsDir=%s" % (parse.hostname, port, ca_certs_dir)
elif parse.scheme == 'ws':
if parse.port is None:
port = 8880
else:
port = parse.port
self.connection_string = "tcp:%s:%d" % (parse.hostname, port)
else:
raise NotImplementedError
self.session = None
self.transport_factory = websocket.WampWebSocketClientFactory(self.session_factory,
url = self.base_uri, debug=self.debug,
debug_wamp=self.debug)
def _connect(self):
if self.client:
self.logger.debug('already connected to broadcaster %s' % self.url)
return
broadcaster = self
self.logger.debug('trying to connect to broadcaster %s' % self.url)
class BroadcasterComponent(wamp.ApplicationSession):
def onJoin(self, details):
broadcaster.client = self
broadcaster.onSessionOpen()
def onDisconnect(self):
broadcaster.logger.debug(
"Disconnected from broadcaster at %s, will reconnect" %
broadcaster.host)
broadcaster.client = None
component_config = types.ComponentConfig(realm="yadt")
session_factory = wamp.ApplicationSessionFactory(
config=component_config)
session_factory.session = BroadcasterComponent
serializers = [JsonSerializer()]
transport_factory = websocket.WampWebSocketClientFactory(
session_factory,
serializers=serializers,
url="ws://{0}:{1}/wamp".format(self.host, self.port),
debug=False,
debug_wamp=False)
client = clientFromString(reactor,
"tcp:{0}:{1}".format(self.host, self.port))
from functools import partial
client.connect(transport_factory).addErrback(
partial(broadcaster.logger.warning,
"Could not connect to broadcaster at %s"))
def onRandomDataEvent(self, i):
print("Random data event: {}".format(i))
if __name__ == '__main__':
# Start logging to console
log.startLogging(sys.stdout)
## Create an application session factory
component_config = types.ComponentConfig(realm="default")
session_factory = wamp.ApplicationSessionFactory(config=component_config)
session_factory.session = Component
# Setup the serializers that we can support
serializers = []
#serializers.append(JsonSerializer(batched = True))
#serializers.append(MsgPackSerializer(batched = True))
#serializers.append(JsonSerializer())
serializers.append(MsgPackSerializer())
# Create a websocket transport factory
transport_factory = websocket.WampWebSocketClientFactory(
session_factory, serializers=serializers, debug=False, debug_wamp=True)
## Start the client and connect
client = clientFromString(reactor, "tcp:127.0.0.1:8001")
client.connect(transport_factory)
# Run the reactor loop
reactor.run()
if self.received > 5:
self.leave()
sub = yield self.subscribe(on_event, u'com.myapp.topic1')
print("Subscribed with subscription ID {}".format(sub.id))
def onDisconnect(self):
reactor.stop()
if __name__ == '__main__':
## 0) start logging to console
log.startLogging(sys.stdout)
## 1) create a WAMP application session factory
session_factory = wamp.ApplicationSessionFactory()
session_factory.session = MyFrontendComponent
## 2) create a WAMP-over-WebSocket transport client factory
transport_factory = websocket.WampWebSocketClientFactory(session_factory, \
debug = False, \
debug_wamp = False)
## 3) start the client from a Twisted endpoint
client = clientFromString(reactor, "tcp:127.0.0.1:8080")
client.connect(transport_factory)
## 4) now enter the Twisted reactor loop
reactor.run()
log.startLogging(sys.stdout)
## 1) create a WAMP application session factory
component_config = types.ComponentConfig(realm="realm2")
session_factory = wamp.ApplicationSessionFactory(config=component_config)
session_factory.session = MyFrontendComponent
## optional: use specific set of serializers
if False:
serializers = None
else:
from autobahn.wamp.serializer import *
serializers = []
#serializers.append(JsonSerializer(batched=True))
serializers.append(JsonSerializer(batched=False))
## 2) create a WAMP-over-WebSocket transport client factory
transport_factory = websocket.WampWebSocketClientFactory(
session_factory,
url="ws://127.0.0.1:8080/wamp",
serializers=serializers,
debug=True,
debug_wamp=True)
## 3) start the client from a Twisted endpoint
client = clientFromString(reactor, "tcp:127.0.0.1:8080")
client.connect(transport_factory)
## 4) now enter the Twisted reactor loop
reactor.run()
print("onLeave: {}".format(details))
self.disconnect()
def onDisconnect(self):
reactor.stop()
if __name__ == '__main__':
## 0) start logging to console
log.startLogging(sys.stdout)
## 1) create a WAMP application session factory
component_config = types.ComponentConfig(realm="realm1")
session_factory = wamp.ApplicationSessionFactory(config=component_config)
session_factory.session = MyFrontendComponent
## 2) create a WAMP-over-WebSocket transport client factory
transport_factory = websocket.WampWebSocketClientFactory(
session_factory,
url="ws://127.0.0.1:8080/ws",
debug=False,
debug_wamp=False)
## 3) start the client from a Twisted endpoint
client = clientFromString(reactor, "tcp:127.0.0.1:8080")
client.connect(transport_factory)
## 4) now enter the Twisted reactor loop
reactor.run()
def onLeave(self, details):
print "Left realm."
self.join(self.config.realm, [self.methods[self.index]], u"marketmaker")
def onDisconnect(self):
reactor.stop()
if __name__ == '__main__':
## 0) start logging to console
log.startLogging(sys.stdout)
## 1) create a WAMP application session factory
component_config = types.ComponentConfig(realm = "sputnik")
session_factory = wamp.ApplicationSessionFactory(config = component_config)
session_factory.session = MyFrontendComponent
## 2) create a WAMP-over-WebSocket transport client factory
transport_factory = websocket.WampWebSocketClientFactory(session_factory,
url = "ws://127.0.0.1:8080/ws", debug = False, debug_wamp = False, headers={"X-Forwarded-For":"10.0.0.1"})
## 3) start the client from a Twisted endpoint
client = clientFromString(reactor, "tcp:127.0.0.1:8080")
client.connect(transport_factory)
## 4) now enter the Twisted reactor loop
reactor.run()
help="The WAMP realm to start the component in (if any).")
return parser
if __name__ == '__main__':
parser = get_options()
args = parser.parse_args()
if args.debug:
log.startLogging(sys.stdout)
session_factory = wamp.ApplicationSessionFactory(
types.ComponentConfig(realm=args.realm))
session_factory.session = MyFrontendComponent
username, password = args.auth.split(':', 1)
session_factory.credentials = {
'username': username,
'password': password,
}
transport_factory = websocket.WampWebSocketClientFactory(
session_factory, debug=args.debug, debug_wamp=args.debug)
from autobahn.twisted.websocket import connectWS
transport_factory = ReconnectingWampWebSocketClientFactory(
session_factory,
url=args.wsurl,
debug_wamp=args.debug,
)
transport_factory.setProtocolOptions(failByDrop=False)
connectWS(transport_factory)
reactor.run()
