def __init__(self, manager, port, password, secure=False, key_path=None, crt_path=None, unix_socket_path=None):
self.manager = manager
self.password = password
from twisted.internet import reactor, ssl
from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol
class MyServerProtocol(WebSocketServerProtocol):
def onConnect(self, request):
log.info("Client connecting: {0}".format(request.origin if request.origin else "self"))
pass
def onOpen(self):
log.info("WebSocket connection open")
WebSocketServer.clients.append(self)
def onMessage(self, payload, isBinary):
if isBinary:
log.info(f"Binary message received: {len(payload)} bytes")
else:
log.info(f"Text message received: {payload.decode('utf8')}")
try:
parsedPayload = json.loads(payload.decode("utf8"))
except json.decoder.JSONDecodeError:
return
if self.websocket_origin:
if "password" in parsedPayload and parsedPayload["password"] == password:
del parsedPayload["password"]
for client in WebSocketServer.clients:
client.sendMessage(json.dumps(parsedPayload).encode("utf8"), False)
else:
if parsedPayload["event"] == "open_bets":
HandlerManager.trigger("on_open_bets")
elif parsedPayload["event"] == "lock_bets":
HandlerManager.trigger("on_lock_bets")
elif parsedPayload["event"] == "end_bets":
HandlerManager.trigger(
"on_end_bets",
winning_team=parsedPayload["data"]["winning_team"],
player_team=parsedPayload["data"]["player_team"],
)
else:
for client in WebSocketServer.clients:
client.sendMessage(payload, False)
def onClose(self, wasClean, code, reason):
log.info(f"WebSocket connection closed: {reason}")
try:
WebSocketServer.clients.remove(self)
except:
pass
factory = WebSocketServerFactory()
factory.setProtocolOptions(autoPingInterval=15, autoPingTimeout=5)
factory.protocol = MyServerProtocol
def reactor_run(reactor, factory, port, context_factory=None, unix_socket_path=None):
if unix_socket_path:
sock_file = Path(unix_socket_path)
if sock_file.exists():
sock_file.unlink()
reactor.listenUNIX(unix_socket_path, factory)
else:
if context_factory:
log.info("wss secure")
reactor.listenSSL(port, factory, context_factory)
else:
log.info("ws unsecure")
reactor.listenTCP(port, factory)
reactor.run(installSignalHandlers=0)
if secure:
context_factory = ssl.DefaultOpenSSLContextFactory(key_path, crt_path)
else:
context_factory = None
reactor_thread = threading.Thread(
target=reactor_run, args=(reactor, factory, port, context_factory, unix_socket_path), name="WebSocketThread"
)
reactor_thread.daemon = True
reactor_thread.start()
else:
yield sleep(1)
returnValue(x * x)
@inlineCallbacks
def onMessage(self, payload, isBinary):
if not isBinary:
x = json.loads(payload.decode('utf8'))
try:
res = yield self.slowsquare(x)
except Exception as e:
self.sendClose(1000, "Exception raised: {0}".format(e))
else:
self.sendMessage(json.dumps(res).encode('utf8'))
if __name__ == '__main__':
import sys
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
factory = WebSocketServerFactory("ws://localhost:9000", debug=False)
factory.protocol = SlowSquareServerProtocol
reactor.listenTCP(9000, factory)
reactor.run()
# echo back message verbatim
self.sendMessage(payload, isBinary)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
def startPolling():
log.startLogging(sys.stdout)
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = MyServerProtocol
# factory.setProtocolOptions(maxConnections=2)
# note to self: if using putChild, the child must be bytes...
reactor.listenTCP(9000, factory)
reactor.run()
if __name__ == '__main__':
# log.startLogging(sys.stdout)
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = MyServerProtocol
# factory.setProtocolOptions(maxConnections=2)
# note to self: if using putChild, the child must be bytes...
reactor.listenTCP(9000, factory)
reactor.run()
# THE SOFTWARE.
#
###############################################################################
import hashlib
from twisted.internet import reactor
from autobahn.twisted.websocket import WebSocketServerFactory, \
WebSocketServerProtocol, \
listenWS
class MessageBasedHashServerProtocol(WebSocketServerProtocol):
"""
Message-based WebSockets server that computes a SHA-256 for every
message it receives and sends back the computed digest.
"""
def onMessage(self, payload, isBinary):
sha256 = hashlib.sha256()
sha256.update(payload)
digest = sha256.hexdigest()
self.sendMessage(digest.encode('utf8'))
print("Sent digest for message: {}".format(digest))
if __name__ == '__main__':
factory = WebSocketServerFactory("ws://localhost:9000")
factory.protocol = MessageBasedHashServerProtocol
listenWS(factory)
reactor.run()
# echo back message verbatim
for client in self.factory.clients:
client.sendMessage(payload, isBinary)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
try:
self.factory.clients.remove(self)
except ValueError:
pass
if __name__ == '__main__':
import sys
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
factory = WebSocketServerFactory(u"ws://0.0.0.0:5123")
factory.protocol = MyServerProtocol
factory.clients = []
# factory.setProtocolOptions(maxConnections=2)
# note to self: if using putChild, the child must be bytes...
reactor.listenTCP(5123, factory)
reactor.run()
def setUp(self):
self.factory = WebSocketServerFactory()
self.proto = WebSocketServerProtocol()
self.proto.factory = self.factory
self.proto.log = Mock()
def start_webserver(options,
protocol=vtk_wamp.ServerProtocol,
disableLogging=False):
"""
Starts the web-server with the given protocol. Options must be an object
with the following members:
options.host : the interface for the web-server to listen on
options.port : port number for the web-server to listen on
options.timeout : timeout for reaping process on idle in seconds
options.content : root for web-pages to serve.
"""
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File
import sys
if not disableLogging:
log.startLogging(sys.stdout)
contextFactory = None
use_SSL = False
if options.sslKey and options.sslCert:
use_SSL = True
wsProtocol = "wss"
from twisted.internet import ssl
contextFactory = ssl.DefaultOpenSSLContextFactory(
options.sslKey, options.sslCert)
else:
wsProtocol = "ws"
# Create WAMP router factory
from autobahn.twisted.wamp import RouterFactory
router_factory = RouterFactory()
# create a user DB
authdb = vtk_wamp.AuthDb()
# create a WAMP router session factory
from autobahn.twisted.wamp import RouterSessionFactory
session_factory = RouterSessionFactory(router_factory)
session_factory.session = vtk_wamp.CustomWampCraRouterSession
session_factory.authdb = authdb
# Create ApplicationSession and register protocols
appSession = protocol(types.ComponentConfig(realm="vtkweb"))
appSession.setAuthDB(authdb)
session_factory.add(appSession)
# create a WAMP-over-WebSocket transport server factory
transport_factory = vtk_wamp.TimeoutWampWebSocketServerFactory(session_factory, \
url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \
debug = options.debug, \
debug_wamp = options.debug, \
timeout = options.timeout )
root = Resource()
# Do we serve static content or just websocket ?
if len(options.content) > 0:
# Static HTTP + WebSocket
root = File(options.content)
# Handle possibly complex ws endpoint
if not options.nows:
wsResource = WebSocketResource(transport_factory)
handle_complex_resource_path(options.ws, root, wsResource)
# Handle binary push WebSocket for images
if not options.nobws:
wsbFactory = WebSocketServerFactory( \
url = "%s://%s:%d" % (wsProtocol, options.host, options.port), \
debug = options.debug)
wsbFactory.protocol = vtk_wamp.ImagePushBinaryWebSocketServerProtocol
wsbResource = WebSocketResource(wsbFactory)
handle_complex_resource_path('wsb', root, wsbResource)
# Handle possibly complex lp endpoint
if not options.nolp:
lpResource = WampLongPollResource(session_factory,
timeout=options.timeout,
debug=options.debug)
#killAfter = 30000,
#queueLimitBytes = 1024 * 1024,
#queueLimitMessages = 1000,
#debug=True,
#reactor=reactor)
handle_complex_resource_path(options.lp, root, lpResource)
if options.uploadPath != None:
from upload import UploadPage
uploadResource = UploadPage(options.uploadPath)
root.putChild("upload", uploadResource)
if len(options.fsEndpoints) > 3:
for fsResourceInfo in options.fsEndpoints.split('|'):
infoSplit = fsResourceInfo.split(':')
handle_complex_resource_path(infoSplit[0], root,
File(infoSplit[1]))
site = Site(root)
if use_SSL:
reactor.listenSSL(options.port, site, contextFactory)
else:
reactor.listenTCP(options.port, site)
# flush ready line
sys.stdout.flush()
# Work around to force the output buffer to be flushed
# This allow the process launcher to parse the output and
# wait for "Start factory" to know that the WebServer
# is running.
if options.forceFlush:
for i in range(200):
log.msg("+" * 80, logLevel=logging.CRITICAL)
# Initialize testing: checks if we're doing a test and sets it up
testing.initialize(options, reactor, stop_webserver)
# Start the reactor
if options.nosignalhandlers:
reactor.run(installSignalHandlers=0)
else:
reactor.run()
# Give the testing module a chance to finalize, if necessary
testing.finalize()
__email__ = "*****@*****.**"
from autobahn.twisted.websocket import WebSocketServerFactory
from webprotocol import WebInterfaceProtocol
from playerprotocol import PlayerProtocol
from game import Game
import sys
from twisted.python import log
from twisted.internet import reactor, protocol
if __name__ == '__main__':
log.startLogging(sys.stdout)
game = Game()
# to speak with the web page we use a websocket
factory_web = WebSocketServerFactory(u"ws://127.0.0.1:9000", debug=False)
factory_web.protocol = WebInterfaceProtocol
factory_web.game = game
# to speak with C client, we use standard TCP sockets
factory_client = protocol.ServerFactory()
factory_client.protocol = PlayerProtocol
factory_client.game = game
reactor.listenTCP(9000, factory_web)
reactor.listenTCP(10000, factory_client)
reactor.run()
global tracker_dict
tracker_dict = dict()
# A dictionary to store old messages in for subsequent assembly
global message_dict
message_dict = dict()
# A dictionary to store incremental messages to send to the end user.
global message_to_send
message_to_send = dict()
global test_dict
test_dict = dict()
global subscriber_dict
subscriber_dict = dict()
global publisher_dict
publisher_dict = dict()
global control_dict
control_dict = dict()
global lock
lock = threading.Lock()
global channelstatedetails
factory = WebSocketServerFactory("ws://127.0.0.1:8080")
factory.protocol = MyServerProtocol
# factory.setProtocolOptions(maxConnections=2)
example = ThreadingExample(factory)
# note to self: if using putChild, the child must be bytes...
reactor.listenTCP(8080, factory)
reactor.run()
phoneclients.append(self)
if not (gameclient is None):
print("Let the phone know te client exists")
self.sendMessage('c')
elif ((payload == 'g' or payload == 's') and self == gameclient):
print("Game client said something")
for pc in phoneclients:
pc.sendMessage(payload)
else:
gameclient.sendMessage(payload)
def onOpen(self):
print("Client connected")
def onClose(self, wasClean, code, reason):
global gameclient
if (self in phoneclients):
phoneclients.remove(self)
elif (self == gameclient):
gameclient = None
print("Goodbye game client")
for pc in phoneclients:
pc.sendMessage('q')
if __name__ == '__main__':
factory = WebSocketServerFactory("ws://127.0.0.1:9001", debug=True)
factory.protocol = MyServerProtocol
reactor.listenTCP(9001, factory)
reactor.run()
def __init__(self,
manager,
port,
secure=False,
key_path=None,
crt_path=None,
unix_socket_path=None):
self.manager = manager_ext = manager
class MyServerProtocol(WebSocketServerProtocol):
def __init__(self):
self.isAuthed = False
self.user_id = None
self.user_name = None
self.login = None
WebSocketServerProtocol.__init__(self)
def onOpen(self):
SongRequestWebSocketServer.clients.append(self)
def onMessage(self, payload, isBinary):
with DBManager.create_session_scope() as db_session:
if not isBinary:
try:
json_msg = json.loads(payload)
except:
self._close_conn()
return
if "event" not in json_msg:
self._close_conn()
return
switcher = {
"AUTH": self._auth,
"PAUSE": self._pause,
"RESUME": self._resume,
"NEXT": self._next,
"PREVIOUS": self._previous,
"SEEK": self._seek,
"VOLUME": self._volume,
"SHOWVIDEO": self._showvideo,
"HIDEVIDEO": self._hidevideo,
"CLOSESR": self._closesr,
"OPENSR": self._opensr,
"MOVE": self._move,
"FAVOURITE": self._favourite,
"UNFAVOURITE": self._unfavourite,
"BAN": self._ban,
"UNBAN": self._unban,
"DELETE": self._delete,
}
method = switcher.get(json_msg["event"], None)
if not manager_ext.bot.songrequest_manager.module_state[
"enabled"]:
return
if not method or not method(
db_session, json_msg.get("data", None)):
self._close_conn()
return
def onClose(self, wasClean, code, reason):
try:
SongRequestWebSocketServer.clients.remove(self)
except:
pass
def _close_conn(self):
self.sendClose()
def _pause(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.pause_function()
def _showvideo(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.show_function()
def _hidevideo(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.hide_function()
def _closesr(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.close_module_function(
)
def _opensr(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.open_module_function(
)
def _resume(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.resume_function()
def _next(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.skip_function(
self.login)
def _previous(self, db_session, data):
if not self.isAuthed:
return False
return manager_ext.bot.songrequest_manager.previous_function(
self.login)
def _seek(self, db_session, data):
if not self.isAuthed or not data.get("seek_time", False):
return False
return manager_ext.bot.songrequest_manager.seek_function(
data.get("seek_time"))
def _volume(self, db_session, data):
if not self.isAuthed or not data or not data.get(
"volume", False):
return False
return manager_ext.bot.songrequest_manager.volume_function(
data.get("volume"))
def _move(self, db_session, data):
if not self.isAuthed or not data or not data.get(
"database_id", False) or not data.get("to_id", False):
return False
return manager_ext.bot.songrequest_manager.move_function(
int(data["database_id"]),
int(data["to_id"]) - 1)
def _favourite(self, db_session, data):
if not self.isAuthed or not data or not data.get(
"database_id", data.get("hist_database_id", False)):
return False
return manager_ext.bot.songrequest_manager.favourite_function(
database_id=data.get("database_id", None),
hist_database_id=data.get("hist_database_id", None))
def _unfavourite(self, db_session, data):
if (not self.isAuthed or not data or not data.get(
"database_id",
data.get("songinfo_database_id",
data.get("hist_database_id", False)))):
return False
return manager_ext.bot.songrequest_manager.unfavourite_function(
database_id=data.get("database_id", None),
hist_database_id=data.get("hist_database_id", None),
songinfo_database_id=data.get("songinfo_database_id",
None),
)
def _ban(self, db_session, data):
if not self.isAuthed or not data or not data.get(
"database_id", data.get("hist_database_id", False)):
return False
return manager_ext.bot.songrequest_manager.ban_function(
database_id=data.get("database_id", None),
hist_database_id=data.get("hist_database_id", None))
def _unban(self, db_session, data):
if (not self.isAuthed or not data or not data.get(
"database_id",
data.get("songinfo_database_id",
data.get("hist_database_id", False)))):
return False
return manager_ext.bot.songrequest_manager.unban_function(
database_id=data.get("database_id", None),
hist_database_id=data.get("hist_database_id", None),
songinfo_database_id=data.get("songinfo_database_id",
None),
)
def _delete(self, db_session, data):
if not self.isAuthed or not data or not data.get(
"database_id", False):
return False
return manager_ext.bot.songrequest_manager.remove_function(
int(data["database_id"]))
def _auth(self, db_session, data):
access_token = data["access_token"]
user = manager_ext.bot.twitch_v5_api.user_from_access_token(
access_token, manager_ext.bot.twitch_helix_api, db_session)
if not user or user.level < 500:
return False
self.isAuthed = True
self.login = user.login
self._dump_state(db_session)
return True
def _dump_state(self, db_session):
song = (SongrequestQueue._from_id(
db_session,
manager_ext.bot.songrequest_manager.current_song_id)
if manager_ext.bot.songrequest_manager.current_song_id
else None)
data = {
"volume":
manager_ext.bot.songrequest_manager.volume_val,
"current_song":
song.webjsonify() if song else {},
"module_state":
manager_ext.bot.songrequest_manager.module_state,
"playlist":
SongrequestQueue._get_playlist(db_session, limit=30),
"backup_playlist":
SongrequestQueue._get_backup_playlist(db_session,
limit=30),
"history_list":
SongrequestHistory._get_history(db_session, limit=30),
"banned_list":
SongRequestSongInfo._get_banned_list(db_session),
"favourite_list":
SongRequestSongInfo._get_favourite_list(db_session),
"current_timestamp":
str(utils.now().timestamp()),
}
payload = {"event": "initialize", "data": data}
self.sendMessage(json.dumps(payload).encode("utf8"), False)
factory = WebSocketServerFactory()
factory.setProtocolOptions(autoPingInterval=15, autoPingTimeout=5)
factory.protocol = MyServerProtocol
def reactor_run(reactor,
factory,
port,
context_factory=None,
unix_socket_path=None):
if unix_socket_path:
sock_file = Path(unix_socket_path)
if sock_file.exists():
sock_file.unlink()
reactor.listenUNIX(unix_socket_path, factory)
else:
if context_factory:
log.info("wss secure")
reactor.listenSSL(port, factory, context_factory)
else:
log.info("ws unsecure")
reactor.listenTCP(port, factory)
reactor.run(installSignalHandlers=0)
reactor_thread = threading.Thread(
target=reactor_run,
args=(reactor, factory, port, None, unix_socket_path),
name="SongRequestWebSocketServerThread",
)
reactor_thread.daemon = True
reactor_thread.start()
except (JSONDecodeError, UnicodeDecodeError):
return {}
def _digest_incoming_data(self, data):
_data = self.load(data)
if not _data:
return
try:
method = getattr(self, _data.get("operation"))
except AttributeError:
return
method(_data.get("payload"))
def transfer(self, payload, to=None):
if not to:
to = self.transport
print(payload)
self.sendMessage(json.dumps(payload).encode("utf-8"))
if __name__ == '__main__':
factory = WebSocketServerFactory(u"ws://172.20.10.3:8585")
factory.protocol = EiderProtocol
factory.clients = dict()
# noinspection PyUnresolvedReferences
reactor.listenTCP(8585, factory)
# noinspection PyUnresolvedReferences
reactor.run()
def __init__(self,
manager,
port,
secure=False,
key_path=None,
crt_path=None):
self.manager = manager
from twisted.internet import reactor, ssl
from autobahn.twisted.websocket import WebSocketServerFactory, \
WebSocketServerProtocol
class MyServerProtocol(WebSocketServerProtocol):
def onConnect(self, request):
# log.info(self.factory)
# log.info('Client connecting: {0}'.format(request.peer))
pass
def onOpen(self):
log.info('WebSocket connection open')
WebSocketServer.clients.append(self)
def onMessage(self, payload, isBinary):
if isBinary:
log.info('Binary message received: {0} bytes'.format(
len(payload)))
else:
log.info('Text message received: {0}'.format(
payload.decode('utf8')))
def onClose(self, wasClean, code, reason):
log.info('WebSocket connection closed: {0}'.format(reason))
try:
WebSocketServer.clients.remove(self)
except:
pass
factory = WebSocketServerFactory()
factory.protocol = MyServerProtocol
def reactor_run(reactor, factory, port, context_factory=None):
if context_factory:
log.info('wss secure')
reactor.listenSSL(port, factory, context_factory)
else:
log.info('ws unsecure')
reactor.listenTCP(port, factory)
reactor.run(installSignalHandlers=0)
if secure:
context_factory = ssl.DefaultOpenSSLContextFactory(
key_path, crt_path)
else:
context_factory = None
reactor_thread = threading.Thread(target=reactor_run,
args=(reactor, factory, port,
context_factory),
name='WebSocketThread')
reactor_thread.daemon = True
reactor_thread.start()
def start():
factory = WebSocketServerFactory(u"ws://0.0.0.0:" + str(PORT))
factory.protocol = ProcessClient
reactor.listenTCP(PORT, factory)
reactor.run()
self.sendMessage(payload, isBinary)
if __name__ == '__main__':
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key',
'keys/server.crt')
factory = WebSocketServerFactory(u"wss://127.0.0.1:8080",
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoServerProtocol
resource = WebSocketResource(factory)
# we server static files under "/" ..
root = File(".")
# and our WebSocket server under "/ws"
root.putChild(u"ws", resource)
# both under one Twisted Web Site
site = Site(root)
reactor.listenSSL(8080, site, contextFactory)
'-cu', username, '-cp', password, '-pa', 'scrypt', \
'-nm', '-q'], stdout=subprocess.PIPE, shell=False)
self.isRunning = True
def stop(self):
if self.isRunning:
self.proxy.kill()
os.wait()
self.isRunning = False
if __name__ == '__main__':
stratum_proxy = StratumProxy()
factory = WebSocketServerFactory('ws://127.0.0.1:9000', debug=True)
factory.protocol = WebUIProtocol
reactor.listenTCP(9000, factory)
print 'Reading config.ini...'
if os.path.isfile('config.ini'):
config = ArgsConfig('config.ini')
config.read_config()
else:
print 'config.ini does exist!'
sys.exit()
if (config.protocol == 'stratum+tcp:'):
stratum_host = config.host
stratum_port = config.port
config.host = 'localhost'
def onMessage(self, payload, isBinary):
messageUTF8 = payload.decode('utf8')
message = payload
print messageUTF8
if messageUTF8 == 'request game':
self.game.respondToGameRequest(self)
elif messageUTF8.find('action') == 0:
actionString = messageUTF8[6:]
print 'action received: ' + actionString
self.game.action(self.player, actionString)
def onOpen(self):
pass
def onClose(self, wasClean, code, reason):
if wasClean:
print 'connction closed cleanly'
else:
print 'connction closed uncleanly code: {code} reason: {reason}'.format(
code=code, reason=reason)
print 'starting ' + 'Connect N' + ' server'
#port=raw_input("Please enter the port to listen for connections on: ")
factory = WebSocketServerFactory("ws://localhost:44444", debug=True)
factory.protocol = GameServerProtocol
reactor.listenTCP(
44444, factory
) # args are: port, server factory instance, listening queue size, interface
print 'server is running'
reactor.run()
if certfile is not None and keyfile is not None:
protocol = 'wss'
context_factory = ssl.DefaultOpenSSLContextFactory(keyfile, certfile)
else:
protocol = 'ws'
context_factory = None
# For testing purposes, use an ephemeral port if port == 0.
if port == 0:
rospy.loginfo('Rosbridge WebSocket Picking an ephemeral port')
port = get_ephemeral_port()
# Write the actual port as a param for tests to read.
rospy.set_param('~actual_port', port)
uri = '{}://{}:{}'.format(protocol, address, port)
factory = WebSocketServerFactory(uri, externalPort=external_port)
factory.protocol = RosbridgeWebSocket
factory.setProtocolOptions(
perMessageCompressionAccept=handle_compression_offers,
autoPingInterval=ping_interval,
autoPingTimeout=ping_timeout,
)
connected = False
while not connected and not rospy.is_shutdown():
try:
listenWS(factory, context_factory)
rospy.loginfo(
'Rosbridge WebSocket server started at {}'.format(uri))
connected = True
except CannotListenError as e:
def onOpen(self):
print("WebSocket connection open.")
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
print("Text message received: {0}".format(payload.decode('utf8')))
self.sendMessage(payload, isBinary)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
import sys
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
factory = WebSocketServerFactory(u"ws://0.0.0.0:9000")
factory.protocol = MyServerProtocol
factory.setProtocolOptions(maxConnections=2)
reactor.listenTCP(9000, factory)
reactor.run()
def open(self, transport_config, options, protocol_class=None):
"""
Implement IWebSocketClientAgent with in-memory transports.
:param transport_config: a string starting with 'wss://' or
'ws://'
:param options: a dict containing options
:param protocol_class: the client protocol class to
instantiate (or `None` for defaults, which is to use
`WebSocketClientProtocol`)
"""
is_secure = transport_config.startswith("wss://")
# call our "real" agent
real_client_protocol = self._agent.open(
transport_config,
options,
protocol_class=protocol_class,
)
if is_secure:
host, port, factory, context_factory, timeout, bindAddress = self._reactor.sslClients[
-1]
else:
host, port, factory, timeout, bindAddress = self._reactor.tcpClients[
-1]
server_address = IPv4Address('TCP', '127.0.0.1', port)
client_address = IPv4Address('TCP', '127.0.0.1', 31337)
server_protocol = self._server_protocol()
# the protocol could already have a factory
if getattr(server_protocol, "factory", None) is None:
server_protocol.factory = WebSocketServerFactory()
server_transport = iosim.FakeTransport(server_protocol,
isServer=True,
hostAddress=server_address,
peerAddress=client_address)
clientProtocol = factory.buildProtocol(None)
client_transport = iosim.FakeTransport(clientProtocol,
isServer=False,
hostAddress=client_address,
peerAddress=server_address)
if is_secure:
directlyProvides(server_transport, ISSLTransport)
directlyProvides(client_transport, ISSLTransport)
pump = iosim.connect(server_protocol, server_transport, clientProtocol,
client_transport)
self._pumper.add(pump)
def add_mapping(proto):
self._servers[proto] = server_protocol
return proto
real_client_protocol.addCallback(add_mapping)
return real_client_protocol
def connection_main(sysargs=None):
"""Main entry point to setup a connection node, aka the autopush script"""
args, parser = _parse_connection(sysargs)
setup_logging("Autopush", args.human_logs)
settings = make_settings(
args,
port=args.port,
endpoint_scheme=args.endpoint_scheme,
endpoint_hostname=args.endpoint_hostname,
endpoint_port=args.endpoint_port,
router_scheme="https" if args.router_ssl_key else "http",
router_hostname=args.router_hostname,
router_port=args.router_port,
env=args.env,
hello_timeout=args.hello_timeout,
)
r = RouterHandler
r.ap_settings = settings
n = NotificationHandler
n.ap_settings = settings
# Internal HTTP notification router
site = cyclone.web.Application([
(r"/push/([^\/]+)", r),
(r"/notif/([^\/]+)(/([^\/]+))?", n),
],
default_host=settings.router_hostname,
debug=args.debug,
log_function=skip_request_logging)
mount_health_handlers(site, settings)
# Public websocket server
proto = "wss" if args.ssl_key else "ws"
factory = WebSocketServerFactory(
"%s://%s:%s/" % (proto, args.hostname, args.port),
debug=args.debug,
debugCodePaths=args.debug,
)
factory.protocol = PushServerProtocol
factory.protocol.ap_settings = settings
factory.setProtocolOptions(
webStatus=False,
maxFramePayloadSize=args.max_message_size,
maxMessagePayloadSize=args.max_message_size,
openHandshakeTimeout=5,
autoPingInterval=args.auto_ping_interval,
autoPingTimeout=args.auto_ping_timeout,
maxConnections=args.max_connections,
closeHandshakeTimeout=args.close_handshake_timeout,
)
settings.factory = factory
settings.metrics.start()
# Wrap the WebSocket server in a default resource that exposes the
# `/status` handler, and delegates to the WebSocket resource for all
# other requests.
resource = DefaultResource(WebSocketResource(factory))
resource.putChild("status", StatusResource())
siteFactory = Site(resource)
# Start the WebSocket listener.
if args.ssl_key:
contextFactory = AutopushSSLContextFactory(args.ssl_key, args.ssl_cert)
if args.ssl_dh_param:
contextFactory.getContext().load_tmp_dh(args.ssl_dh_param)
reactor.listenSSL(args.port, siteFactory, contextFactory)
else:
reactor.listenTCP(args.port, siteFactory)
# Start the internal routing listener.
if args.router_ssl_key:
contextFactory = AutopushSSLContextFactory(args.router_ssl_key,
args.router_ssl_cert)
if args.ssl_dh_param:
contextFactory.getContext().load_tmp_dh(args.ssl_dh_param)
reactor.listenSSL(args.router_port, site, contextFactory)
else:
reactor.listenTCP(args.router_port, site)
reactor.suggestThreadPoolSize(50)
l = task.LoopingCall(periodic_reporter, settings)
l.start(1.0)
reactor.run()
self.websocket_extensions_in_use))
def onMessage(self, payload, isBinary):
self.sendMessage(payload, isBinary)
if __name__ == '__main__':
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
factory = WebSocketServerFactory("ws://127.0.0.1:9000",
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoServerProtocol
# Enable WebSocket extension "permessage-deflate".
##
# Function to accept offers from the client ..
def accept(offers):
for offer in offers:
if isinstance(offer, PerMessageDeflateOffer):
return PerMessageDeflateOfferAccept(offer)
factory.setProtocolOptions(perMessageCompressionAccept=accept)
from twisted.python import log
from twisted.web.server import Site
from twisted.web.static import File
from autobahn.twisted.websocket import WebSocketServerFactory, \
WebSocketServerProtocol, \
listenWS
from autobahn.twisted.resource import WebSocketResource
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WebSocketServerFactory("ws://127.0.0.1:9000",
debug=False,
debugCodePaths=True)
factory.protocol = WebSocketServerProtocol
factory.setProtocolOptions(autoPingInterval=1,
autoPingTimeout=3,
autoPingSize=20)
listenWS(factory)
resource = WebSocketResource(factory)
root = File(".")
root.putChild("ws", resource)
site = Site(root)
if __name__ == '__main__':
from twisted.python import log
from twisted.internet import reactor
log.startLogging(sys.stdout)
#sys.argv.append('script_server')
sys.argv.append('localhost')
sys.argv.append('9000')
# sys.argv[0] = file name of this script
# sys.argv[1] = ip address of this server
# sys.argv[2] = port to listen on
factory = WebSocketServerFactory("ws://" + 'localhost' + ":" +
str(sys.argv[2]),
debug=True)
factory.setProtocolOptions(failByDrop=False)
factory.protocol = MyServerProtocol
udpbport = 8085
multicast = reactor.listenMulticast(udpbport,
MulticastProtocol(),
listenMultiple=True)
check = task.LoopingCall(check_for_main_server)
call_period = 1 #sec
check.start(call_period)
try:
reactor.listenTCP(int(sys.argv[2]), factory)
except twisted.internet.error.CannotListenError:
check_timeouts()
def send_clock_updates():
manager.send_clock_updates()
reactor.callLater(5.0, send_clock_updates)
send_clock_updates()
# line server
factory = Factory()
factory.protocol = ChessLineProtocol
factory.clients = []
reactor.listenTCP(args.port, factory)
# websocket server
websocket_factory = WebSocketServerFactory()
websocket_factory.protocol = ChessWebSocketsProtocol
reactor.listenTCP(args.websocket_port, websocket_factory)
# HTTP server
reactor.listenTCP(args.http_port, server.Site(HttpRoot(manager)))
reactor.run()
self.websocket_extensions_in_use))
def onMessage(self, payload, isBinary):
self.sendMessage(payload, isBinary)
if __name__ == '__main__':
if len(sys.argv) > 1 and sys.argv[1] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
factory = WebSocketServerFactory("ws://localhost:9000",
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoServerProtocol
# Enable WebSocket extension "permessage-deflate".
##
# Function to accept offers from the client ..
def accept(offers):
for offer in offers:
if isinstance(offer, PerMessageDeflateOffer):
return PerMessageDeflateOfferAccept(offer)
factory.setProtocolOptions(perMessageCompressionAccept=accept)
"type": "ANNOTATED",
"content": content
}
plt.close()
#from random import randint
#if randint(0,9) > 5:
self.sendMessage(json.dumps(msg))
def open(self, openFlag):
print("Remote open command: '{0}'".format(openFlag))
payload = {'open': openFlag}
# GET with params in URL
r = requests.get(rb_url, params=payload)
r.text
r.status_code
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WebSocketServerFactory("ws://localhost:{}".format(args.port),
debug=False)
factory.protocol = OpenFaceServerProtocol
reactor.listenTCP(args.port, factory)
reactor.run()
def start(self) -> None:
ws = WebSocketServerFactory("ws://127.0.0.1:" + str(self.PORT))
ws.protocol = WebSocketProtocol
reactor.listenTCP(self.PORT, ws)
class MyWebSocketProtocol(WebSocketServerProtocol):
def onConnect(self, request):
logging.error("Client connecting: {}".format(request.peer))
def onOpen(self):
logging.error("WebSocket connection open.")
def onMessage(self, payload, isBinary):
if isBinary:
logging.error("Binary message received: {} bytes".format(
len(payload)))
text = None
else:
logging.error("Text message received: {}".format(
payload.decode('utf8')))
for i in tuling_request(payload.decode('utf8')):
self.sendMessage(i.encode('utf-8'), isBinary)
def onClose(self, wasClean, code, reason):
logging.error("WebSocket connection closed: {}".format(reason))
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WebSocketServerFactory()
factory.protocol = MyWebSocketProtocol
reactor.listenTCP(8007, factory)
reactor.run()
payload.decode("utf8"),
self.factory.clientconnection.request.peer))
message = payload.decode("utf8")
message = message.replace(os.environ.get("OLD_HOST", ""),
os.environ.get("NEW_HOST", ""))
self.factory.clientconnection.sendMessage(message.encode("utf8"))
def onClose(self, wasClean, code, reason):
"""
If the BACKEND connection gets closed also close the client connection
"""
print("{1}: backend WebSocket connection closed: {0}".format(
reason, self.factory.clientconnection.request.peer))
self.factory.clientconnection.sendClose()
if __name__ == "__main__":
load_dotenv()
log.startLogging(sys.stdout)
# txaio.start_logging(level="debug")
FACTORY = WebSocketServerFactory()
FACTORY.protocol = WebsocketInfoServerProtocol
FACTORY.setProtocolOptions(autoPingInterval=10,
autoPingTimeout=3,
trustXForwardedFor=1)
reactor.listenTCP(os.environ.get("PORT", 8080), FACTORY)
reactor.run()
