def __init__(self, agent_model=None, agent_channel=None):
if agent_model:
self.agent_model = agent_model
if agent_channel:
self.agent_channel = agent_channel
if not self.agent_model:
raise Exception('Odoo agent model not set!')
if self.debug == '1':
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
logger.info('Odoo agent UID {} version {} init'.format(
self.agent_uid, self.version))
# Init event with disconnected state
self.odoo_disconnected.set()
# Init WEB server
if self.https_enabled:
logger.debug('Loading HTTPS key from %s', self.https_key_file)
logger.debug('Loading HTTPS cert from %s', self.https_cert_file)
self.wsgi_server = WSGIServer(('', self.https_port),
self.wsgi_application,
keyfile=self.https_key_file,
certfile=self.https_cert_file)
# Hack for slef-signed certificates.
if not self.odoo_verify_cert:
# Monkey patch SSL for self signed certificates
import ssl
if hasattr(ssl, '_create_unverified_context'):
ssl._create_default_https_context = ssl._create_unverified_context
# Supress InsecureRequestWarning on odoo_bus_poll
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
logging.getLogger("urllib3").setLevel(logging.ERROR)
# Init RPC
rpc_dispatcher.register_instance(self)
self.bus_rpc_server = RPCServerGreenlets(
AgentCallbackServerTransport(self.receive_bus_rpc_message,
self.send_bus_rpc_reply),
rpc_protocol, rpc_dispatcher)
self.https_rpc_server = RPCServerGreenlets(
AgentCallbackServerTransport(self.receive_https_rpc_message,
self.send_https_rpc_reply),
rpc_protocol, rpc_dispatcher)
if self.trace_rpc:
self.bus_rpc_server.trace = self.trace_rpc_message
self.https_rpc_server.trace = self.trace_rpc_message
def __init__(self, rest_url=None):
self.dispatcher = RESTDispatcher(rest_url)
# TinyRPC WSGI App
self.transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
self.wsgi_app = self.transport.handle
# TinyRPC RPC Server
self.rpc_server = RPCServerGreenlets(self.transport, JSONRPCProtocol(),
self.dispatcher)
gevent.spawn(self.rpc_server.serve_forever)
def __init__(self, app):
log.debug('initializing JSONRPCServer')
BaseService.__init__(self, app)
self.app = app
self.dispatcher = RPCDispatcher()
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
self.wsgi_server = gevent.wsgi.WSGIServer(('127.0.0.1', 5000),
transport.handle)
self.rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(),
self.dispatcher)
def nsRPCBringupServer(ns, path, host, port, maxconn):
name = os.path.basename(path)
dev_path = '/dev/rpc/{}'.format(name)
if nsRPCisServer(ns, path) is not True:
nsError(ns, "RPC service {} misconfigured".format(name))
return False
nsInfo(ns, "Configuring RPC server from {}".format(path))
nsMkdir(ns, dev_path)
nsMkdir(ns, "{}/root".format(dev_path))
_to_root = nsGet(ns, "{}/jail".format(path), [])
for j in _to_root:
_n = os.path.basename(j)
_dst = "{}/root/{}".format(dev_path, _n)
nsInfo(ns, "RPC.JAIL({}): {}".format(name, j))
nsLn(ns, j, _dst)
dispatcher = RPCDispatcher()
nsSet(ns, "{}/dispatcher".format(dev_path), dispatcher)
for h in nsLs(ns, "{}/handlers".format(path)):
nsInfo(ns, "Registering {}->{} ".format(name, h))
_fun = nsGet(ns, "{}/handlers/{}".format(path, h))
dispatcher.add_method(partial(_fun, dev_path), h)
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
nsSet(ns, "{}/transport".format(dev_path), transport)
nsSet(ns, "{}/listen".format(dev_path), host)
nsSet(ns, "{}/port".format(dev_path), host)
nsConsole(
ns, "RPC server {} will be listening on tcp://{}:{}".format(
name, host, port))
pool = gevent.pool.Pool(maxconn)
nsSet(ns, "{}/pool".format(dev_path), pool)
wsgi_server = gevent.pywsgi.WSGIServer((host, port),
transport.handle,
spawn=pool,
log=None)
nsSet(ns, "{}/wsgi".format(dev_path), wsgi_server)
nsDaemon(ns, "{}:WSGI".format(name), wsgi_server.serve_forever, _raw=True)
rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher)
if nsGet(ns, "/config/RPCCatchCalls") is True or nsGet(
ns, "/etc/flags/rpctrace", False) is True:
_q = gevent.queue.Queue()
nsSet(ns, "{}/trace".format(dev_path), _q)
rpc_server.trace = partial(nsRPCCatcher, ns, dev_path, _q)
nsSet(ns, "{}/rpc", rpc_server)
nsDaemon(ns, "{}:RPC".format(name), rpc_server.serve_forever, _raw=True)
nsInfo(ns, "RPC server {} is up".format(name))
return True
def __init__(self, interface):
"""
Args:
interface: Interface to provide.
"""
self.__dispatcher = RPCLoggingDispatcher()
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
self._wsgi_server = gevent.wsgi.WSGIServer(
('', configuration.get_rpc_server_port()),
transport.handle,
log=None)
gevent.spawn(self._wsgi_server.serve_forever)
self.__server = RPCServerGreenlets(transport, JSONRPCProtocol(),
self.__dispatcher)
# register interface's public functions
self.__dispatcher.register_instance(interface, "")
def __init__(self, app):
log.debug('initializing JSONRPCServer')
BaseService.__init__(self, app)
self.app = app
self.dispatcher = LoggingDispatcher()
# register sub dispatchers
for subdispatcher in self.subdispatcher_classes():
subdispatcher.register(self)
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
self.listen_port = app.config['jsonrpc']['listen_port']
self.listen_host = app.config['jsonrpc']['listen_host']
self.wsgi_server = gevent.wsgi.WSGIServer(
(self.listen_host, self.listen_port),
transport.handle,
log=WSGIServerLogger)
self.rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(),
self.dispatcher)
self.default_block = 'latest'
from tinyrpc.dispatch import RPCDispatcher
import subprocess
import json
import radio_data_rate
import time
import re
dispatcher = RPCDispatcher()
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
wsgi_server = gevent.pywsgi.WSGIServer(('192.168.1.100', 8080),
transport.handle)
gevent.spawn(wsgi_server.serve_forever)
rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher)
current_radio_rate_r1 = {'vhf': 9600, 'uhf': 240, 'sat_comm': 512}
def set_vhf_data_rate(interface=None, rate=None, parent=None, classid=None):
if None not in (interface, rate, parent, classid):
if rate == 9600:
rate_in_kbps = '9.6kbps'
elif rate == 4800:
rate_in_kbps = '4.8kbps'
elif rate == 2400:
rate_in_kbps = '2.4kbps'
elif rate == 1200:
rate_in_kbps = '1.2kbps'
else:
