def __init__(self, streamer_name, namespace, website_url, publish_address,
subscribe_address, service_name):
self.log = logging.getLogger(__name__)
self.log.setLevel(0)
if not _WEBSOCKET_INSTALLED:
self.log.error('Must install `websocket`')
if not _REQUESTS_INSTALLED:
self.log.error('Must install `requests')
self.messaging = ZmqMessaging(service_name, publish_address,
subscribe_address, service_name)
self.messaging.start_messaging()
self._streamer_name = streamer_name
self.namespace = namespace
self._website_url = website_url
self.log.info('Getting Socket IO key!')
self.key, heartbeat = self._connect_to_server_helper()
self.log.info('Socket IO key got!')
self.command_manager = AdapterCommandManager(self.messaging)
self._thread = Thread(target=self.handle_subscription)
self._thread.daemon = True
self._thread.start()
# alters URL to be more websocket...ie
self._website_socket = self._website_url.replace('http', 'ws')
self._website_socket += 'websocket/'
self.nick = None
super().__init__(self._website_socket + self.key,
on_open=self.on_open,
on_close=self.on_close,
on_message=self.on_message,
on_error=self.on_error)
async def _run(
messaging,
live_chat_messages,
live_chat_id,
):
command_manager = AdapterCommandManager(messaging)
frame = None
while True:
try:
frame = messaging.sub_socket.recv_multipart(zmq.NOBLOCK)
except zmq.error.ZMQError:
pass
if frame:
message = decode_vex_message(frame)
if message.type == 'CMD':
command_manager.parse_commands(message)
elif message.type == 'RSP':
message = message.contents.get('response')
body = {
'snippet': {
'type': 'textmessageEvent',
'liveChatId': live_chat_id,
'textMessageDetails': {
'messageText': message
}
}
}
live_chat_messages.insert(part='snippet', body=body).execute()
frame = None
await asyncio.sleep(1)
class TestAdapapterCommandManager(unittest.TestCase):
def setUp(self):
self.command_manager = AdapterCommandManager(Message())
def test_alive(self):
messaging = self.command_manager._messaging
self.command_manager._alive()
self.assertIsNotNone(messaging.status)
self.assertEqual(messaging.status, 'CONNECTED')
class TestAdapapterCommandManager(unittest.TestCase):
def setUp(self):
self.command_manager = AdapterCommandManager(Message())
def test_alive(self):
messaging = self.command_manager._messaging
self.command_manager._alive()
self.assertIsNotNone(messaging.status)
self.assertEqual(messaging.status, 'CONNECTED')
def main(nick,
password,
host,
channel,
publish_address,
subscribe_address,
service_name):
if not _IRC3_INSTALLED:
logging.error('irc requires `irc3` to be installed. Please install '
'using `pip install irc3`')
irc_client = create_irc_bot(nick,
password,
host,
channel=channel)
try:
messaging = ZmqMessaging(service_name,
publish_address,
subscribe_address,
socket_filter=service_name)
messaging.start_messaging()
except ZMQError:
return
# Duck type messaging onto irc_client, FTW
irc_client.messaging = messaging
command_parser = AdapterCommandManager(messaging)
irc_client.command_parser = command_parser
"""
command_parser.register_command('server config', _default)
command_parser.register_command('ip', _default)
command_parser.register_command('join', _default)
command_parser.register_command('kick', _default)
command_parser.register_command('part', _default)
command_parser.register_command('invite', _default)
command_parser.register_command('topic', _default)
command_parser.register_command('away', _default)
"""
irc_client.create_connection()
irc_client.add_signal_handlers()
event_loop = asyncio.get_event_loop()
asyncio.ensure_future(_check_subscription(irc_client))
atexit.register(_send_disconnected(messaging))
handle_close = _handle_close(messaging, event_loop)
signal.signal(signal.SIGINT, handle_close)
signal.signal(signal.SIGTERM, handle_close)
try:
event_loop.run_forever()
except KeyboardInterrupt:
pass
event_loop.close()
sys.exit()
def __init__(self,
jid,
password,
room,
publish_address,
subscribe_address,
service_name,
bot_nick='EchoBot',
**kwargs):
# Initialize the parent class
if not _SLEEKXMPP_INSTALLED:
logging.error('must install sleekxmpp')
super().__init__(jid, password)
self.messaging = ZmqMessaging(service_name,
publish_address,
subscribe_address,
service_name)
self.messaging.start_messaging()
self.command_manager = AdapterCommandManager(self.messaging)
self.room = room
self.nick = bot_nick
self.log = logging.getLogger(__file__)
# One-shot helper method used to register all the plugins
self._register_plugin_helper()
self.add_event_handler("session_start", self.start)
self.add_event_handler("groupchat_message", self.muc_message)
self.add_event_handler('connected', self._connected)
self.add_event_handler('disconnected', self._disconnected)
self._thread = Thread(target=self.run)
self._thread.daemon = True
self._thread.start()
async def _run(messaging, live_chat_messages, live_chat_id, ):
command_manager = AdapterCommandManager(messaging)
frame = None
while True:
try:
frame = messaging.sub_socket.recv_multipart(zmq.NOBLOCK)
except zmq.error.ZMQError:
pass
if frame:
message = decode_vex_message(frame)
if message.type == 'CMD':
command_manager.parse_commands(message)
elif message.type == 'RSP':
message = message.contents.get('response')
body={'snippet':{'type': 'textmessageEvent',
'liveChatId': live_chat_id,
'textMessageDetails': {'messageText': message}}}
live_chat_messages.insert(part='snippet',
body=body).execute()
frame = None
await asyncio.sleep(1)
def __init__(self,
streamer_name,
namespace,
website_url,
publish_address,
subscribe_address,
service_name):
self.log = logging.getLogger(__name__)
self.log.setLevel(0)
if not _WEBSOCKET_INSTALLED:
self.log.error('Must install `websocket`')
if not _REQUESTS_INSTALLED:
self.log.error('Must install `requests')
self.messaging = ZmqMessaging(service_name,
publish_address,
subscribe_address,
service_name)
self.messaging.start_messaging()
self._streamer_name = streamer_name
self.namespace = namespace
self._website_url = website_url
self.log.info('Getting Socket IO key!')
self.key, heartbeat = self._connect_to_server_helper()
self.log.info('Socket IO key got!')
self.command_manager = AdapterCommandManager(self.messaging)
self._thread = Thread(target=self.handle_subscription)
self._thread.daemon = True
self._thread.start()
# alters URL to be more websocket...ie
self._website_socket = self._website_url.replace('http', 'ws')
self._website_socket += 'websocket/'
self.nick = None
super().__init__(self._website_socket + self.key,
on_open=self.on_open,
on_close=self.on_close,
on_message=self.on_message,
on_error=self.on_error)
def setUp(self):
self.command_manager = AdapterCommandManager(Message())
def setUp(self):
self.command_manager = AdapterCommandManager(Message())
class WebSocket(WebSocketApp):
def __init__(self,
streamer_name,
namespace,
website_url,
publish_address,
subscribe_address,
service_name):
self.log = logging.getLogger(__name__)
self.log.setLevel(0)
if not _WEBSOCKET_INSTALLED:
self.log.error('Must install `websocket`')
if not _REQUESTS_INSTALLED:
self.log.error('Must install `requests')
self.messaging = ZmqMessaging(service_name,
publish_address,
subscribe_address,
service_name)
self.messaging.start_messaging()
self._streamer_name = streamer_name
self.namespace = namespace
self._website_url = website_url
self.log.info('Getting Socket IO key!')
self.key, heartbeat = self._connect_to_server_helper()
self.log.info('Socket IO key got!')
self.command_manager = AdapterCommandManager(self.messaging)
self._thread = Thread(target=self.handle_subscription)
self._thread.daemon = True
self._thread.start()
# alters URL to be more websocket...ie
self._website_socket = self._website_url.replace('http', 'ws')
self._website_socket += 'websocket/'
self.nick = None
super().__init__(self._website_socket + self.key,
on_open=self.on_open,
on_close=self.on_close,
on_message=self.on_message,
on_error=self.on_error)
def handle_subscription(self):
while True:
frame = self.messaging.sub_socket.recv_multipart()
message = decode_vex_message(frame)
if message.type == 'CMD':
self.command_manager.parse_commands(message)
if message.type == 'RSP':
data = {}
data['name'] = 'message'
data['args'] = [message.contents.get('response'),
self._streamer_name]
self.send_packet_helper(5, data)
def repeat_run_forever(self):
while True:
try:
self.run_forever()
except (KeyboardInterrupt, SystemExit):
break
except Exception as e:
self.log.info('Socket IO errors: {}'.format(e))
self.messaging.send_status('DISCONNECTED')
sleep(3)
key, _ = self._connect_to_server_helper()
self.url = self._website_socket + key
def _connect_to_server_helper(self):
r = requests.post(self._website_url)
params = r.text
# unused variables are connection_timeout and supported_formats
key, heartbeat_timeout, _, _ = params.split(':')
heartbeat_timeout = int(heartbeat_timeout)
return key, heartbeat_timeout
def on_open(self, *args):
logging.info('Websocket open!')
def on_close(self, *args):
logging.info('Websocket closed :(')
def on_message(self, *args):
message = args[1].split(':', 3)
key = int(message[0])
# namespace = message[2]
if len(message) >= 4:
data = message[3]
else:
data = ''
if key == 1 and args[1] == '1::':
self.send_packet_helper(1)
elif key == 1 and args[1] == '1::{}'.format(self.namespace):
self.send_packet_helper(5, data={'name': 'initialize'})
data = {'name': 'join',
'args': ['{}'.format(self._streamer_name)]}
self.send_packet_helper(5, data=data)
self.log.info('Connected to channel with socket io!')
self.messaging.send_status('CONNECTED')
elif key == 2:
self.send_packet_helper(2)
elif key == 5:
data = json.loads(data, )
if data['name'] == 'message':
message = data['args'][0]
sender = html.unescape(message['sender'])
message = html.unescape(message['text'])
self.messaging.send_message(author=sender, message=message)
elif data['name'] == 'join':
self.nick = data['args'][1]
def on_error(self, *args):
logging.error(args[1])
def disconnect(self):
callback = ''
data = ''
# '1::namespace'
self.send(':'.join([str(self.TYPE_KEYS['DISCONNECT']),
callback, self.namespace, data]))
def send_packet_helper(self,
type_key,
data=None):
if data is None:
data = ''
else:
data = json.dumps(data)
# NOTE: callbacks currently not implemented
callback = ''
message = ':'.join([str(type_key), callback, self.namespace, data])
self.send(message)
class XMPPBot(ClientXMPP):
def __init__(self,
jid,
password,
room,
publish_address,
subscribe_address,
service_name,
bot_nick='EchoBot',
**kwargs):
# Initialize the parent class
if not _SLEEKXMPP_INSTALLED:
logging.error('must install sleekxmpp')
super().__init__(jid, password)
self.messaging = ZmqMessaging(service_name,
publish_address,
subscribe_address,
service_name)
self.messaging.start_messaging()
self.command_manager = AdapterCommandManager(self.messaging)
self.room = room
self.nick = bot_nick
self.log = logging.getLogger(__file__)
# One-shot helper method used to register all the plugins
self._register_plugin_helper()
self.add_event_handler("session_start", self.start)
self.add_event_handler("groupchat_message", self.muc_message)
self.add_event_handler('connected', self._connected)
self.add_event_handler('disconnected', self._disconnected)
self._thread = Thread(target=self.run)
self._thread.daemon = True
self._thread.start()
def run(self):
while True:
frame = self.messaging.sub_socket.recv_multipart()
message = decode_vex_message(frame)
if message.type == 'CMD':
self.command_manager.parse_commands(message)
elif message.type == 'RSP':
channel = message.contents.get('channel')
contents = message.contents.get('response')
self.send_message(channel, contents, mtype='groupchat')
def _disconnected(self, *args):
self.messaging.send_status('DISCONNECTED')
def _connected(self, *args):
self.messaging.send_status('CONNECTED')
def _register_plugin_helper(self):
"""
One-shot helper method used to register all the plugins
"""
# Service Discovery
self.register_plugin('xep_0030')
# XMPP Ping
self.register_plugin('xep_0199')
# Multiple User Chatroom
self.register_plugin('xep_0045')
def start(self, event):
self.log.info('starting xmpp')
self.send_presence()
self.plugin['xep_0045'].joinMUC(self.room,
self.nick,
wait=True)
self.get_roster()
def muc_message(self, msg):
self.messaging.send_message(author=msg['mucnick'],
message=msg['body'],
channel=msg['from'].bare)
class WebSocket(WebSocketApp):
def __init__(self, streamer_name, namespace, website_url, publish_address,
subscribe_address, service_name):
self.log = logging.getLogger(__name__)
self.log.setLevel(0)
if not _WEBSOCKET_INSTALLED:
self.log.error('Must install `websocket`')
if not _REQUESTS_INSTALLED:
self.log.error('Must install `requests')
self.messaging = ZmqMessaging(service_name, publish_address,
subscribe_address, service_name)
self.messaging.start_messaging()
self._streamer_name = streamer_name
self.namespace = namespace
self._website_url = website_url
self.log.info('Getting Socket IO key!')
self.key, heartbeat = self._connect_to_server_helper()
self.log.info('Socket IO key got!')
self.command_manager = AdapterCommandManager(self.messaging)
self._thread = Thread(target=self.handle_subscription)
self._thread.daemon = True
self._thread.start()
# alters URL to be more websocket...ie
self._website_socket = self._website_url.replace('http', 'ws')
self._website_socket += 'websocket/'
self.nick = None
super().__init__(self._website_socket + self.key,
on_open=self.on_open,
on_close=self.on_close,
on_message=self.on_message,
on_error=self.on_error)
def handle_subscription(self):
while True:
frame = self.messaging.sub_socket.recv_multipart()
message = decode_vex_message(frame)
if message.type == 'CMD':
self.command_manager.parse_commands(message)
if message.type == 'RSP':
data = {}
data['name'] = 'message'
data['args'] = [
message.contents.get('response'), self._streamer_name
]
self.send_packet_helper(5, data)
def repeat_run_forever(self):
while True:
try:
self.run_forever()
except (KeyboardInterrupt, SystemExit):
break
except Exception as e:
self.log.info('Socket IO errors: {}'.format(e))
self.messaging.send_status('DISCONNECTED')
sleep(3)
key, _ = self._connect_to_server_helper()
self.url = self._website_socket + key
def _connect_to_server_helper(self):
r = requests.post(self._website_url)
params = r.text
# unused variables are connection_timeout and supported_formats
key, heartbeat_timeout, _, _ = params.split(':')
heartbeat_timeout = int(heartbeat_timeout)
return key, heartbeat_timeout
def on_open(self, *args):
logging.info('Websocket open!')
def on_close(self, *args):
logging.info('Websocket closed :(')
def on_message(self, *args):
message = args[1].split(':', 3)
key = int(message[0])
# namespace = message[2]
if len(message) >= 4:
data = message[3]
else:
data = ''
if key == 1 and args[1] == '1::':
self.send_packet_helper(1)
elif key == 1 and args[1] == '1::{}'.format(self.namespace):
self.send_packet_helper(5, data={'name': 'initialize'})
data = {'name': 'join', 'args': ['{}'.format(self._streamer_name)]}
self.send_packet_helper(5, data=data)
self.log.info('Connected to channel with socket io!')
self.messaging.send_status('CONNECTED')
elif key == 2:
self.send_packet_helper(2)
elif key == 5:
data = json.loads(data, )
if data['name'] == 'message':
message = data['args'][0]
sender = html.unescape(message['sender'])
message = html.unescape(message['text'])
self.messaging.send_message(author=sender, message=message)
elif data['name'] == 'join':
self.nick = data['args'][1]
def on_error(self, *args):
logging.error(args[1])
def disconnect(self):
callback = ''
data = ''
# '1::namespace'
self.send(':'.join([
str(self.TYPE_KEYS['DISCONNECT']), callback, self.namespace, data
]))
def send_packet_helper(self, type_key, data=None):
if data is None:
data = ''
else:
data = json.dumps(data)
# NOTE: callbacks currently not implemented
callback = ''
message = ':'.join([str(type_key), callback, self.namespace, data])
self.send(message)