def _configure_server(restarting=False):
global websocket_plugin
# Configure server error log
cherrypy.config.update({'log.error_file': 'cherrypy.error.log'})
# Configure server url
cherrypy.config.update({'server.socket_host': utils.s2n(autosubliminal.WEBSERVERIP),
'server.socket_port': int(autosubliminal.WEBSERVERPORT)
})
# Disable engine plugins (no need for autoreload plugin)
cherrypy.config.update({'engine.autoreload.on': False})
# Configure authentication in if a username and password is set by the user
if autosubliminal.USERNAME and autosubliminal.PASSWORD:
users = {utils.s2n(autosubliminal.USERNAME): utils.s2n(autosubliminal.PASSWORD)}
cherrypy.config.update({'tools.auth_digest.on': True,
'tools.auth_digest.realm': 'Auto-Subliminal website',
'tools.auth_digest.get_ha1': auth_digest.get_ha1_dict_plain(users),
'tools.auth_digest.key': 'yek.tsegid_htua.lanimilbuS-otuA' # Can be any random string
})
if not restarting:
# Enable websocket plugin
websocket_plugin = WebSocketPlugin(cherrypy.engine)
websocket_plugin.subscribe()
cherrypy.tools.websocket = WebSocketTool()
else:
# When restarting we need to create a new websocket manager thread (you cannot start the same thread twice!)
websocket_plugin.manager = WebSocketManager()
# When restarting we need to clear the httpserver to force the creation of a new one (needed for ip/port change)
cherrypy.server.httpserver = None
def test_websocket_close_all(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
m.add(ws)
m.close_all()
ws.terminate.assert_call_once_with(1001, 'Server is shutting down')
def init(self, interface):
""" Initializes the PB WS Client"""
self.logger = logging.getLogger('PAI').getChild(__name__)
self.pb = Pushbullet(cfg.PUSHBULLET_KEY, cfg.PUSHBULLET_SECRET)
self.manager = WebSocketManager()
self.alarm = None
self.interface = interface
def test_websocket_close_all(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
m.add(ws)
m.close_all()
ws.close.assert_called_once_with(code=1001,
reason='Server is shutting down')
def initialize_websockets_manager(self):
"""
Call thos to start the underlying websockets
manager. Make sure to call it once your server
is created.
"""
self.manager = WebSocketManager()
self.manager.start()
def test_broadcast(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
ws.terminated = False
m.add(ws)
m.broadcast(b'hello there')
ws.send.assert_called_once_with(b'hello there', False)
def test_mainloop_can_be_stopped_when_no_websocket_were_registered(
self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
self.assertFalse(m.running)
m.start()
self.assertTrue(m.running)
m.stop()
self.assertFalse(m.running)
def test_cannot_add_websocket_more_than_once(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
ws.sock.fileno.return_value = 1
m.add(ws)
self.assertEqual(len(m), 1)
m.add(ws)
self.assertEqual(len(m), 1)
def test_add_and_remove_websocket(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
ws.sock.fileno.return_value = 1
m.add(ws)
m.poller.register.assert_called_once_with(1)
m.remove(ws)
m.poller.unregister.assert_called_once_with(1)
def test_broadcast_failure_must_not_break_caller(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
ws.terminated = False
ws.send.side_effect = RuntimeError
m.add(ws)
try:
m.broadcast(b'hello there')
except:
self.fail("Broadcasting shouldn't have failed")
def test_mainloop_can_be_stopped(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
def poll():
yield 1
m.stop()
yield 2
m.poller.poll.return_value = poll()
self.assertFalse(m.running)
m.start()
# just make sure it had the time to finish
time.sleep(0.1)
self.assertFalse(m.running)
def _configure_server(restarting=False):
global websocket_plugin
# Configure server error log
cherrypy.config.update({'log.error_file': 'cherrypy.error.log'})
# Configure server url
cherrypy.config.update({
'server.socket_host':
s2n(autosubliminal.WEBSERVERIP),
'server.socket_port':
int(autosubliminal.WEBSERVERPORT)
})
# Disable engine plugins (no need for autoreload plugin)
cherrypy.config.update({'engine.autoreload.on': False})
# Read and store cherrypy server version (if not set, it returns CherryPy/Unknown because it's not installed)
server_header = 'CherryPy/%s' % get_library_version('cherrypy')
cherrypy.config.update({'response.headers.server': server_header})
# Configure authentication in if a username and password is set by the user
if autosubliminal.USERNAME and autosubliminal.PASSWORD:
users = {s2n(autosubliminal.USERNAME): s2n(autosubliminal.PASSWORD)}
cherrypy.config.update({
'tools.auth_digest.on':
True,
'tools.auth_digest.realm':
'Auto-Subliminal website',
'tools.auth_digest.get_ha1':
auth_digest.get_ha1_dict_plain(users),
'tools.auth_digest.key':
'yek.tsegid_htua.lanimilbuS-otuA' # Can be any random string
})
# Configure our custom json_out_handler (Uncomment if it should be used for any @cherrypy.tools.json_out())
# cherrypy.config.update({'tools.json_out.handler': json_out_handler})
if not restarting:
# Enable websocket plugin
websocket_plugin = WebSocketPlugin(cherrypy.engine)
websocket_plugin.subscribe()
cherrypy.tools.websocket = WebSocketTool()
else:
# When restarting we need to create a new websocket manager thread (you cannot start the same thread twice!)
websocket_plugin.manager = WebSocketManager()
# When restarting we need to clear the httpserver to force the creation of a new one (needed for ip/port change)
cherrypy.server.httpserver = None
def test_websocket_terminated_from_mainloop(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
m.poller.poll.return_value = [1]
ws = MagicMock()
ws.terminated = False
ws.sock.fileno.return_value = 1
ws.once.return_value = False
m.add(ws)
m.start()
ws.terminate.assert_call_once_with()
m.stop()
def execute(self, commands, environment={}):
"""Execute a command on the container.
In pylxd 2.2, this method will be renamed `execute` and the existing
`execute` method removed.
"""
if not _ws4py_installed:
raise ValueError(
'This feature requires the optional ws4py library.')
if isinstance(commands, six.string_types):
raise TypeError("First argument must be a list.")
response = self.api['exec'].post(
json={
'command': commands,
'environment': environment,
'wait-for-websocket': True,
'interactive': False,
})
fds = response.json()['metadata']['metadata']['fds']
operation_id = response.json()['operation'].split('/')[-1]
parsed = parse.urlparse(
self.client.api.operations[operation_id].websocket._api_endpoint)
with managers.web_socket_manager(WebSocketManager()) as manager:
stdin = _StdinWebsocket(self.client.websocket_url)
stdin.resource = '{}?secret={}'.format(parsed.path, fds['0'])
stdin.connect()
stdout = _CommandWebsocketClient(manager,
self.client.websocket_url)
stdout.resource = '{}?secret={}'.format(parsed.path, fds['1'])
stdout.connect()
stderr = _CommandWebsocketClient(manager,
self.client.websocket_url)
stderr.resource = '{}?secret={}'.format(parsed.path, fds['2'])
stderr.connect()
manager.start()
while len(manager.websockets.values()) > 0:
time.sleep(.1)
operation = self.client.operations.get(operation_id)
return _ContainerExecuteResult(operation.metadata['return'],
stdout.data, stderr.data)
def __init__(self, interface, url):
""" Initializes the PB WS Client"""
super().__init__(url)
self.pb = Pushbullet(cfg.PUSHBULLET_KEY)
self.manager = WebSocketManager()
self.interface = interface
self.device = None
for i, device in enumerate(self.pb.devices):
if device.nickname == 'pai':
logger.debug("Device found")
self.device = device
break
else:
logger.exception("Device not found. Creating 'pai' device")
self.device = self.pb.new_device(nickname='pai', icon='system')
def run(script_options):
global logger
level = logging.DEBUG if script_options.verbose else logging.INFO
logger = configure_logger(level = level)
mgr = WebSocketManager()
try:
mgr.start()
clients = []
# Connect
for connection_idx in range(script_options.concurrency):
client = EchoClient(script_options.url, mgr,
script_options.ca, script_options.key, script_options.cert)
client.connect()
clients.append(client)
logger.info("%d clients are connected" % (connection_idx + 1))
# Send
msg = getMessage(script_options)
if msg:
msg = json.write(msg)
logger.info("Sending messages (num=%d):\n%s", script_options.num, msg)
for client in clients:
for _ in range(script_options.num):
client.send(msg)
time.sleep(SEND_INTERVAL)
logger.info("Done sending")
# Sleep before disconnecting
logger.info("Sleeping for %d s before disconnecting",
script_options.interval)
time.sleep(script_options.interval)
except KeyboardInterrupt:
logger.info("Interrupted by user")
finally:
logger.info("Disconnecting!")
mgr.close_all(code = 1000,
message = "Client is closing the connection")
mgr.stop()
mgr.join()
def execute(self, commands, environment={}):
"""Execute a command on the container."""
if not _ws4py_installed:
raise ValueError(
'This feature requires the optional ws4py library.')
if isinstance(commands, six.string_types):
raise TypeError("First argument must be a list.")
response = self.api['exec'].post(
json={
'command': commands,
'environment': environment,
'wait-for-websocket': True,
'interactive': False,
})
fds = response.json()['metadata']['metadata']['fds']
operation_id = response.json()['operation'].split('/')[-1]
parsed = parse.urlparse(
self.client.api.operations[operation_id].websocket._api_endpoint)
manager = WebSocketManager()
stdin = _StdinWebsocket(manager, self.client.websocket_url)
stdin.resource = '{}?secret={}'.format(parsed.path, fds['0'])
stdin.connect()
stdout = _CommandWebsocketClient(manager, self.client.websocket_url)
stdout.resource = '{}?secret={}'.format(parsed.path, fds['1'])
stdout.connect()
stderr = _CommandWebsocketClient(manager, self.client.websocket_url)
stderr.resource = '{}?secret={}'.format(parsed.path, fds['2'])
stderr.connect()
manager.start()
while True: # pragma: no cover
for websocket in manager.websockets.values():
if not websocket.terminated:
break
else:
break
time.sleep(1)
return stdout.data, stderr.data
def test_cannot_remove_unregistered_websocket(self, MockSelectPoller):
m = WebSocketManager(poller=MockSelectPoller())
ws = MagicMock()
ws.sock.fileno.return_value = 1
m.remove(ws)
self.assertEqual(len(m), 0)
self.assertFalse(m.poller.unregister.called)
m.add(ws)
self.assertEqual(len(m), 1)
m.remove(ws)
self.assertEqual(len(m), 0)
m.poller.unregister.assert_called_once_with(1)
m.poller.reset_mock()
m.remove(ws)
self.assertEqual(len(m), 0)
self.assertFalse(m.poller.unregister.called)
from core.database import Database
from core.timezone import *
from core.cmn import *
import time
import traceback
import datetime
import threading
import json
import sys
import os
import random
import re
import urllib
import math
main_session = WebSocketManager()
online_camgirls={}
def main_keep_alive(web_sock):
print "Starting Keep alive for MFCCUCKmgr\n"
while web_sock.is_running == 1:
#s_time=(math.floor(10 * random.random()) + 10)
time.sleep(5);
try:
for ws in web_sock.websockets.itervalues():
if not ws.terminated:
ws.send("0 0 0 0 0 -\n\0")
except:
pass
def start_cuckmgr():
main_session.start()
import os
import sys
import time
import thread
import logging
import json
import boto3
import botocore
import pymongo
from sys import stdout
from pymongo import MongoClient
from sqs_client import SQSClient
from ws4py.client.threadedclient import WebSocketClient
from ws4py.manager import WebSocketManager
manager = WebSocketManager()
timeout = 60
logging.basicConfig(filename='queue.log', filemode='w', level=logging.INFO)
############################### Get the service resources
sqs = boto3.resource('sqs')
s3 = boto3.resource('s3')
bucketName = 'spreza-audio'
queueIn = 'transcribe'
queueOut = 'complete'
#URI = '54.205.82.96'
URI = '54.221.51.233'
ASR_URI = 'ws://' + URI + '/client/ws/speech'
STATUS_URI = 'ws://' + URI + '/client/ws/status'
baseS3 = 'https://' + bucketName + '.s3.amazonaws.com/'
def __init__(self, bus):
plugins.SimplePlugin.__init__(self, bus)
self.manager = WebSocketManager()
def execute(self,
commands,
environment={},
encoding=None,
decode=True,
stdin_payload=None,
stdin_encoding="utf-8",
stdout_handler=None,
stderr_handler=None):
"""Execute a command on the container.
In pylxd 2.2, this method will be renamed `execute` and the existing
`execute` method removed.
:param commands: The command and arguments as a list of strings
:type commands: [str]
:param environment: The environment variables to pass with the command
:type environment: {str: str}
:param encoding: The encoding to use for stdout/stderr if the param
decode is True. If encoding is None, then no override is
performed and whatever the existing encoding from LXD is used.
:type encoding: str
:param decode: Whether to decode the stdout/stderr or just return the
raw buffers.
:type decode: bool
:param stdin_payload: Payload to pass via stdin
:type stdin_payload: Can be a file, string, bytearray, generator or
ws4py Message object
:param stdin_encoding: Encoding to pass text to stdin (default utf-8)
:param stdout_handler: Callable than receive as first parameter each
message recived via stdout
:type stdout_handler: Callable[[str], None]
:param stderr_handler: Callable than receive as first parameter each
message recived via stderr
:type stderr_handler: Callable[[str], None]
:raises ValueError: if the ws4py library is not installed.
:returns: The return value, stdout and stdin
:rtype: _ContainerExecuteResult() namedtuple
"""
if not _ws4py_installed:
raise ValueError(
'This feature requires the optional ws4py library.')
if isinstance(commands, six.string_types):
raise TypeError("First argument must be a list.")
response = self.api['exec'].post(
json={
'command': commands,
'environment': environment,
'wait-for-websocket': True,
'interactive': False,
})
fds = response.json()['metadata']['metadata']['fds']
operation_id = response.json()['operation'].split('/')[-1]
parsed = parse.urlparse(
self.client.api.operations[operation_id].websocket._api_endpoint)
with managers.web_socket_manager(WebSocketManager()) as manager:
stdin = _StdinWebsocket(self.client.websocket_url,
payload=stdin_payload,
encoding=stdin_encoding)
stdin.resource = '{}?secret={}'.format(parsed.path, fds['0'])
stdin.connect()
stdout = _CommandWebsocketClient(manager,
self.client.websocket_url,
encoding=encoding,
decode=decode,
handler=stdout_handler)
stdout.resource = '{}?secret={}'.format(parsed.path, fds['1'])
stdout.connect()
stderr = _CommandWebsocketClient(manager,
self.client.websocket_url,
encoding=encoding,
decode=decode,
handler=stderr_handler)
stderr.resource = '{}?secret={}'.format(parsed.path, fds['2'])
stderr.connect()
manager.start()
# watch for the end of the command:
while True:
operation = self.client.operations.get(operation_id)
if 'return' in operation.metadata:
break
time.sleep(.5) # pragma: no cover
while len(manager.websockets.values()) > 0:
time.sleep(.1) # pragma: no cover
manager.stop()
manager.join()
return _ContainerExecuteResult(operation.metadata['return'],
stdout.data, stderr.data)
def execute(
self,
commands,
environment=None,
encoding=None,
decode=True,
stdin_payload=None,
stdin_encoding="utf-8",
stdout_handler=None,
stderr_handler=None,
):
"""Execute a command on the instance. stdout and stderr are buffered if
no handler is given.
:param commands: The command and arguments as a list of strings
:type commands: [str]
:param environment: The environment variables to pass with the command
:type environment: {str: str}
:param encoding: The encoding to use for stdout/stderr if the param
decode is True. If encoding is None, then no override is
performed and whatever the existing encoding from LXD is used.
:type encoding: str
:param decode: Whether to decode the stdout/stderr or just return the
raw buffers.
:type decode: bool
:param stdin_payload: Payload to pass via stdin
:type stdin_payload: Can be a file, string, bytearray, generator or
ws4py Message object
:param stdin_encoding: Encoding to pass text to stdin (default utf-8)
:param stdout_handler: Callable than receive as first parameter each
message received via stdout
:type stdout_handler: Callable[[str], None]
:param stderr_handler: Callable than receive as first parameter each
message received via stderr
:type stderr_handler: Callable[[str], None]
:raises ValueError: if the ws4py library is not installed.
:returns: A tuple of `(exit_code, stdout, stderr)`
:rtype: _InstanceExecuteResult() namedtuple
"""
if not _ws4py_installed:
raise ValueError(
"This feature requires the optional ws4py library.")
if isinstance(commands, str):
raise TypeError("First argument must be a list.")
if environment is None:
environment = {}
response = self.api["exec"].post(
json={
"command": commands,
"environment": environment,
"wait-for-websocket": True,
"interactive": False,
})
fds = response.json()["metadata"]["metadata"]["fds"]
operation_id = Operation.extract_operation_id(
response.json()["operation"])
parsed = parse.urlparse(
self.client.api.operations[operation_id].websocket._api_endpoint)
with managers.web_socket_manager(WebSocketManager()) as manager:
stdin = _StdinWebsocket(
self.client.websocket_url,
payload=stdin_payload,
encoding=stdin_encoding,
)
stdin.resource = "{}?secret={}".format(parsed.path, fds["0"])
stdin.connect()
stdout = _CommandWebsocketClient(
manager,
self.client.websocket_url,
encoding=encoding,
decode=decode,
handler=stdout_handler,
)
stdout.resource = "{}?secret={}".format(parsed.path, fds["1"])
stdout.connect()
stderr = _CommandWebsocketClient(
manager,
self.client.websocket_url,
encoding=encoding,
decode=decode,
handler=stderr_handler,
)
stderr.resource = "{}?secret={}".format(parsed.path, fds["2"])
stderr.connect()
manager.start()
# watch for the end of the command:
while True:
operation = self.client.operations.get(operation_id)
if "return" in operation.metadata:
break
time.sleep(0.5) # pragma: no cover
try:
stdin.close()
except BrokenPipeError:
pass
stdout.finish_soon()
stderr.finish_soon()
try:
manager.close_all()
except BrokenPipeError:
pass
while not stdout.finished or not stderr.finished:
time.sleep(0.1) # progma: no cover
manager.stop()
manager.join()
return _InstanceExecuteResult(operation.metadata["return"],
stdout.data, stderr.data)
""" Sets up websockets for Dashboard """
# pylint: disable-msg=C0103
import json
import os
from ws4py.client import WebSocketBaseClient
from ws4py.manager import WebSocketManager
from ws4py import format_addresses, configure_logger
import queue
import requests
LOGGER = configure_logger()
MANAGER = WebSocketManager()
coin_queue = queue.Queue()
#FIXME: Change these global to local variable
BTC_USD = 0.0
XRB_BTC = 0.0
STORM_USD = 0.0
class SetQueue():
"""
Custom Queue that uses a set instead of a regular queue. This keeps a set of coin names as well as a dict of it's coin:value
:param queue.Queue:
"""
def __init__(self):
self.queue = set()
self.values = dict({})
def __enter__(self):
self._container = None
self._container_name = 'piper' + uuid.uuid4().hex
container_config = {
'name': self._container_name,
'profiles': self._lxd_profiles,
'source': self._job.lxd_source,
'devices': {
'piper_repository': {
'type': 'disk',
'path': '/piper',
'source': str(self._repository_path),
}
}
}
try:
self._container = self._lxd_client.containers.create(
container_config, wait=True)
except LXDAPIException as e:
raise PScriptException('Failed to create LXD container. Raw: ' +
str(e))
try:
self._container.start(wait=True)
except LXDAPIException as e:
raise PScriptException('Failed to start LXD container. Raw: ' +
str(e))
env = {k: str(v) for k, v in self._job.env.items()}
config = {
'command': ['/bin/sh', '-c', self._job.script],
'wait-for-websocket': True,
'interactive': False,
'environment': env,
}
try:
response = self._lxd_client.api.containers[
self._container_name].exec.post(json=config)
except LXDAPIException as e:
raise PScriptException('Failed to execute command. Raw: ' + str(e))
fds = response.json()['metadata']['metadata']['fds']
self.operation_id = response.json()['operation'].split('/')[-1]
websocket_url = '/1.0/operations/{}/websocket'.format(
self.operation_id)
stdin_url = '{}?secret={}'.format(websocket_url, fds['0'])
stdout_url = '{}?secret={}'.format(websocket_url, fds['1'])
stderr_url = '{}?secret={}'.format(websocket_url, fds['2'])
stdin = self.NullWebSocket(self._lxd_client.websocket_url)
stdin.resource = stdin_url
stdin.connect()
self.manager = WebSocketManager()
self.manager.start()
self._handler = BufferHandler()
stdout = self.WebSocket(self.manager, self._handler,
self._lxd_client.websocket_url)
stdout.resource = stdout_url
stdout.connect()
stderr = self.WebSocket(self.manager, self._handler,
self._lxd_client.websocket_url)
stderr.resource = stderr_url
stderr.connect()
return self
def init(self):
""" Initializes the PB WS Client"""
self.pb = Pushbullet(cfg.PUSHBULLET_KEY, cfg.PUSHBULLET_SECRET)
self.manager = WebSocketManager()
self.alarm = None
