def start(ip_address, http_port, ws_port):
global SERVER, SERVER_THREAD
SERVER = _HTTPServer(ip_address, http_port, ws_port, _HTTPRequestHandler)
if encryption.enabled():
cert_file, key_file = encryption.get_cert()
if key_file and cert_file:
import ssl
SERVER.socket = ssl.wrap_socket (SERVER.socket, keyfile=key_file, certfile=cert_file, server_side=True)
SERVER_THREAD = threading.Thread(target=SERVER.serve_forever, name="webserver")
SERVER_THREAD.daemon = True
SERVER_THREAD.start()
def __init__(self, config):
#coro = None
self._started = False
self._config = config
self._spine = Spine()
try:
import asyncio
except ImportError:
## Trollius >= 0.3 was renamed
import trollius as asyncio
from autobahn.asyncio.websocket import WebSocketServerFactory
ssl_context = None
if encryption.enabled():
self._spine.log.debug("socket using ssl")
cert_file, key_file = encryption.get_cert()
try:
import ssl
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.load_cert_chain(cert_file, key_file)
#self._spine.log.debug("socket ssl found")
except:
ssl_context = None
self._spine.log.error("socket failed to use ssl")
self._spine.log.debug(
"start websocket on:{0}, port:{1}",
self._config.network.ip,
self._config.network.ws_port
)
self.factory = WebSocketServerFactory()
self.factory.protocol = _SpineProtocol
self.loop = asyncio.get_event_loop()
_SpineProtocol.loop = self.loop
self.coro = self.loop.create_server(
self.factory,
self._config.network.ip,
self._config.network.ws_port,
ssl=ssl_context
)
def __init__(self, camera_id, name, camera_source=None, **kwargs):
CameraBase.__init__(self, camera_id, name, type="frame", **kwargs)
self._device_driver = hal.get_camera_driver(camera_source)
self._device_driver.camera = self
self._frame_format = self._device_driver.buffer_type
protocol = "http://"
if encryption.enabled():
protocol = "https://"
self.ip_address = nethelper.get_ip_address()
self.ip_port = nethelper.get_free_port()
self.source = protocol + str(self.ip_address) + ":" + str(
self.ip_port) + "/" + camera_id # + ".png"
self.source = {
"server":
protocol + str(self.ip_address) + ":" + str(self.ip_port),
"path": "/" + camera_id
}
self.current_frame = None
self.current_frame_number = 0
from threading import Lock
self.mutex = Lock()
self.server = _HTTPFrameServer((self.ip_address, self.ip_port),
_HTTPFrameHandler, self, self.mutex)
if encryption.enabled():
cert_file, key_file = encryption.get_cert()
if key_file and cert_file:
import ssl
self.server.socket = ssl.wrap_socket(self.server.socket,
keyfile=key_file,
certfile=cert_file,
server_side=True)
self.server_thread = threading.Thread(target=self.server.serve_forever,
name="CameraStreamer server")
self.server_thread.daemon = True
self.server_thread.start()
self.frame_thread = _CameraFrameThread(self, self.mutex)
def start(self):
self._server = _HTTPServer(self.plugin_config.ip_address,
self.plugin_config.http_port,
self.plugin_config.ws_port,
_HTTPRequestHandler, self._http_docs)
if encryption.enabled():
cert_file, key_file = encryption.get_cert()
if key_file and cert_file:
import ssl
self._server.socket = ssl.wrap_socket(self._server.socket,
keyfile=key_file,
certfile=cert_file,
server_side=True)
self._use_encryption = True
self._server_thread = threading.Thread(
target=self._server.serve_forever, name="webserver")
self._server_thread.daemon = True
self._server_thread.start()