def main():
server_username = "******"
subprocess_username = "******"
host = "0.0.0.0"
port = 10123
srv_uid, srv_gid = get_uid_gid(server_username)
sp_uid, sp_gid = get_uid_gid(subprocess_username)
Privileges.set_low(subprocess_username, sp_uid, sp_gid)
Privileges.set_high(server_username, srv_uid, srv_gid)
uid = os.getuid()
if uid == 0:
info("Running as a root. Trying to lose privileges.")
demote_server()
else:
info("Running as a normal user. Warning! Dangerous code will have the same rights as the server, enabling a malicious user to kill the server!")
# Run the server
server = bjsonrpc.createserver(host=host, port=port, handler_factory=ConnectionHandler)
server.debug_socket(False)
for i in range(10):
if 0 == os.fork():
server.serve()
os._exit(0)
os.waitpid(-1, 0)
def start():
global server, server_thread
if server: return
server = createserver(handler_factory=ServerHandler)
server_thread = threading.Thread(target=server.serve)
server_thread.daemon = True
server_thread.start()
def create_server(self):
if self.host is None or self.port is None:
print "HOST AND/OR PORT HASN'T BEEN SET YET!"
else:
self.tournament_server = bjsonrpc.createserver(host=self.host,
port=self.port,
handler_factory=TournamentService)
def create_server(self):
if self.host is None or self.port is None:
print "HOST AND/OR PORT HASN'T BEEN SET YET!"
else:
self.tournament_server = bjsonrpc.createserver(
host=self.host,
port=self.port,
handler_factory=TournamentService)
def start(verbose = False):
global thread_server
#signal.signal(signal.SIGINT, handler)
rpcserver = bjsonrpc.createserver(host="0.0.0.0", port=10123, handler_factory=ServerHandler)
rpcserver.debug_socket(verbose)
thread_server = threading.Thread(target=rpcserver.serve)
thread_server.daemon = True
thread_server.start()
def start():
global server, server_thread
if server: return
server = createserver(handler_factory=ServerHandler)
server.debug_socket(True)
server.debug_dispatch(True)
server_thread = threading.Thread(target=server.serve)
server_thread.daemon = True
server_thread.start()
def start(*args, **kwargs):
"""The final startup step in the system.
Create the server.
"""
s = bjsonrpc.createserver(host="0.0.0.0", handler_factory=Monitor)
s.serve()
print("served!")
def server_thread():
try:
s = bjsonrpc.createserver(host="0.0.0.0", port=JSONRPC_EXT_PORT, handler_factory=ElementumRPCServer)
log.info("elementum: starting jsonrpc service")
s.serve()
log.info("elementum: exiting jsonrpc service")
except Exception:
import traceback
map(log.error, traceback.format_exc().split("\n"))
raise
def server_thread():
try:
s = bjsonrpc.createserver(port=JSONRPC_EXT_PORT, handler_factory=PulsarRPCServer)
log.info("pulsar: starting jsonrpc service")
s.serve()
log.info("pulsar: exiting jsonrpc service")
except Exception, e:
import traceback
map(log.info, traceback.format_exc().split("\n"))
raise
def start(verbose=False):
global thread_server
#signal.signal(signal.SIGINT, handler)
rpcserver = bjsonrpc.createserver(host="0.0.0.0",
port=10123,
handler_factory=ServerHandler)
rpcserver.debug_socket(verbose)
thread_server = threading.Thread(target=rpcserver.serve)
thread_server.daemon = True
thread_server.start()
def server_thread():
try:
bjsonrpc.bjsonrpc_options['threaded'] = True
s = bjsonrpc.createserver(host="0.0.0.0", port=JSONRPC_EXT_PORT, handler_factory=da_incRPCServer)
log.info("da_inc: starting jsonrpc service")
s.serve()
log.info("da_inc: exiting jsonrpc service")
except Exception:
import traceback
map(log.error, traceback.format_exc().split("\n"))
raise
def server_thread():
try:
bjsonrpc.bjsonrpc_options['threaded'] = True
s = bjsonrpc.createserver(port=JSONRPC_EXT_PORT, handler_factory=QuasarRPCServer)
log.info("quasar: starting jsonrpc service")
s.serve()
log.info("quasar: exiting jsonrpc service")
except Exception:
import traceback
list(map(log.error, traceback.format_exc().split("\n")))
raise
def start(santiago, *args, **kwargs):
"""The final startup step in the system.
Create the server.
"""
global SANTIAGO_INSTANCE, BJSONRPC_SERVER
SANTIAGO_INSTANCE = santiago
BJSONRPC_SERVER = bjsonrpc.createserver(host="127.0.0.1",
handler_factory=BjsonRpcHost)
BJSONRPC_SERVER.serve()
print("served!")
def start(santiago_to_use, *args, **kwargs):
"""The final startup step in the system.
Create the server.
"""
global SANTIAGO_INSTANCE, BJSONRPC_SERVER
SANTIAGO_INSTANCE = santiago_to_use
BJSONRPC_SERVER = bjsonrpc.createserver(host="127.0.0.1",
handler_factory=BjsonRpcHost)
BJSONRPC_SERVER.serve()
print("served!")
def server_thread():
import xbmc
import bjsonrpc
try:
s = bjsonrpc.createserver(port=JSONRPC_EXT_PORT, handler_factory=PulsarRPCServer)
s._do_serve = lambda: (not xbmc.abortRequested)
log.info("pulsar: starting jsonrpc service")
s.serve()
log.info("pulsar: exiting jsonrpc service")
except Exception, e:
import traceback
map(log.info, traceback.format_exc().split("\n"))
raise
def create_server(self):
success = False
if self.host is None or self.port is None:
pass
else:
try:
self.tournament_server = bjsonrpc.createserver(host=self.host,
port=self.port,
handler_factory=TournamentService)
success = True
except Exception:
success = None
return success
def __init__(self, config, database, sessions, prefixes):
self.config = config
self.database = database
self.sessions = sessions
self.prefixes = prefixes
self.thread = None
# TODO: add ability to bind RPC to alternative IP not just localhost
self.s = createserver(host=self.config.ipc.rpcip, port=int(self.config.ipc.port), \
handler_factory=TBRPCServerHandler._factory(self.config, \
self.database, \
self.sessions, \
self.prefixes))
def server_thread():
import xbmc
import bjsonrpc
try:
s = bjsonrpc.createserver(port=JSONRPC_EXT_PORT, handler_factory=PulsarRPCServer)
s._do_serve = lambda: (not xbmc.abortRequested)
xbmc.log("pulsar: starting jsonrpc service")
s.serve()
xbmc.log("pulsar: exiting jsonrpc service")
except Exception, e:
import traceback
map(xbmc.log, traceback.format_exc().split("\n"))
raise
def __init__(self, config, database, sessions, prefixes):
self.config = config
self.database = database
self.sessions = sessions
self.prefixes = prefixes
self.thread = None
# TODO: add ability to bind RPC to alternative IP not just localhost
self.s = createserver(host=self.config.ipc.rpcip, port=int(self.config.ipc.port), \
handler_factory=TBRPCServerHandler._factory(self.config, \
self.database, \
self.sessions, \
self.prefixes))
def create_server(self):
success = False
if self.host is None or self.port is None:
pass
else:
try:
self.tournament_server = bjsonrpc.createserver(
host=self.host,
port=self.port,
handler_factory=TournamentService)
success = True
except Exception:
success = None
return success
def run(self):
sensor_events = bjsonrpc.createserver(host="0.0.0.0", port=9001, handler_factory=SensorEvents)
sensor_events.serve()
class SdpServer(BaseHandler):
def _setup(self):
print("_setup")
def setId(self, playerID: int):
print("setId: {}".format(playerID))
global conns
conns[playerID] = self._conn
def setSdp(self, playerA: int, playerB: int, sdp: str):
print("setSdp: {} -> {}: {}".format(playerA, playerB, sdp))
global conns
if playerB in conns:
conns[playerB].call.onSdp(playerA, playerB, sdp)
else:
print("remote player {} not connected".format(playerB))
def addHostedGame(self, hostPlayerId: int, hostPlayerLogin: str):
global games
games.append((hostPlayerId, hostPlayerLogin))
def hostedGames(self):
global games
return games
s = bjsonrpc.createserver(handler_factory=SdpServer,
port=10123,
host="127.0.0.1")
s.serve()
def getrandom(self):
return random.randint(0,100)
def gettotal(self):
self._conn.notify.notify("total")
return self.value_total
def getcount(self):
return self.value_count
def echo(self, string):
#print self._addr
#print self._conn
#print self._methods
print(string)
return string
import threading
def thread1():
time.sleep(0.2)
conn = bjsonrpc.connect(host="127.0.0.1",port=10123)
conn.call.echo("Hello world")
conn.close()
s = bjsonrpc.createserver(handler_factory=MyHandler._factory(domain="yourdomain-dot-com"), port = 10123, host = "0.0.0.0")
s.debug_socket(True)
threading.Thread(target=thread1).start()
s.serve()
import bjsonrpc
from bjsonrpc.handlers import BaseHandler
class MyServerHandler(BaseHandler):
def hello(self, txt):
response = "hello, %s!." % txt
print("*%s" % response)
return response
s = bjsonrpc.createserver(host='0.0.0.0',
port=8002,
handler_factory=MyServerHandler)
s.debug_socket(True)
s.serve()
if self._username:
self._usernames.remove(self._username)
self._post(u" -*- User '%s' is now known as '%s' -*- " % (self._username, name))
self._username = name
self._usernames.append(self._username)
self._update()
return "Username changed to '%s'" % self._username
def get_userlist(self):
"""
leer los nombres de los usuarios.
"""
return self._usernames
def whoami(self):
"""
obtener el nombre de usuario para esta conexión.
"""
return self._username
s = createserver(handler_factory=Chatter, host="0.0.0.0") # creamos el servidor
s.debug_socket(True) # imprimir las tramas enviadas y recibidas.
s.serve() # empieza el bucle infinito de servicio.
help="Valid password to connect DB. Default '%default'.")
parser.add_option("-H",
"--host",
dest="host",
default="127.0.0.1",
help="Host where is the DB. Default '%default'.")
parser.add_option("-P",
"--port",
dest="port",
default="5432",
help="Port of the host to acces DB. Default '%default'.")
(options, args) = parser.parse_args()
try:
conn = psycopg2.connect("dbname=" + options.dbname + " user="******" password="******" host=" + options.host +
" port=" + options.port)
except:
import sys
print "Could not connect to DB."
parser.print_help()
sys.exit(1)
s = createserver(handler_factory=LlampexProject,
host="0.0.0.0") # creamos el servidor
s.debug_socket(True) # imprimir las tramas enviadas y recibidas.
s.serve() # empieza el bucle infinito de servicio.
"""
self._end = time.time()
self._state = 0
def lapse(self):
"""
devuelve la cantidad de tiempo en segundos que ha pasado
desde el inicio del crono hasta su fin
(o hasta ahora si no ha parado)
"""
return self.end() - self.begin()
def stoplapse(self, arg1):
self.stop()
return self.lapse()
s = createserver(handler_factory=Chronometer) # creamos el servidor
# handler_factory especifica qué objeto es que se crea con cada conexión.
# por defecto escucha en "127.0.0.1" pero se puede definir con host=".."
# por defecto el puerto es el 10123 pero se puede cambiar con port=123
s.debug_socket(True) # Esto indica que debe imprimir por pantalla lo que
# se envía y se recibe por el socket. Es útil para entender cómo funciona el
# protocolo.
s.serve(
) # empieza el bucle infinito de servicio. Sale de la función en cuanto
# se tenga que detener el programa. Normalmente por fallo inesperado o porque
# se recibe una señal de detener (SIGINT, SIGTERM) del sistema operativo.
)
parser.add_option(
"-P", "--port", dest="port", default="5432", help="Port of the host to acces DB. Default '%default'."
)
(options, args) = parser.parse_args()
try:
conn = psycopg2.connect(
"dbname="
+ options.dbname
+ " user="******" password="******" host="
+ options.host
+ " port="
+ options.port
)
except:
import sys
print "Could not connect to DB."
parser.print_help()
sys.exit(1)
s = createserver(handler_factory=LlampexProject, host="0.0.0.0") # creamos el servidor
s.debug_socket(True) # imprimir las tramas enviadas y recibidas.
s.serve() # empieza el bucle infinito de servicio.
raise ValueError, "username '%s' is too long! (maximum 8 characters)" % name
if self._username:
self._usernames.remove(self._username)
self._post(u" -*- User '%s' is now known as '%s' -*- " %
(self._username, name))
self._username = name
self._usernames.append(self._username)
self._update()
return "Username changed to '%s'" % self._username
def get_userlist(self):
"""
leer los nombres de los usuarios.
"""
return self._usernames
def whoami(self):
"""
obtener el nombre de usuario para esta conexión.
"""
return self._username
s = createserver(handler_factory=Chatter,
host="0.0.0.0") # creamos el servidor
s.debug_socket(True) # imprimir las tramas enviadas y recibidas.
s.serve() # empieza el bucle infinito de servicio.
def bigShowServer(port): s = bjsonrpc.createserver( host = '', port=port, handler_factory = BigShowServerHandler ) s.debug_socket(True) s.serve()
def slaveSimplateServer(port): s = bjsonrpc.createserver( host = '', port=port, handler_factory = SlaveSimplateHandler ) s.debug_socket(True) s.serve()
def bigShowServer(port):
s = bjsonrpc.createserver(host='',
port=port,
handler_factory=BigShowServerHandler)
s.debug_socket(True)
s.serve()
from vBBU_client import attachNSSF
from bjsonrpc.handlers import BaseHandler
from bjsonrpc import createserver
import time
# class for server handlers
class ServerHandler(BaseHandler):
def attachvBBU(self, ueAttachedObj):
return attachNSSF(ueAttachedObj)
# creating the server to listen
print "\n"
print "...initializing vBBU"
time.sleep(1)
print "vBBU initialized\n"
s = createserver(host="192.168.186.61",
port=10123,
handler_factory=ServerHandler)
s.serve() #.setmaxtimeout("write", 10)
self._end = time.time()
self._state = 0
def lapse(self):
"""
devuelve la cantidad de tiempo en segundos que ha pasado
desde el inicio del crono hasta su fin
(o hasta ahora si no ha parado)
"""
return self.end() - self.begin()
def stoplapse(self,arg1):
self.stop()
return self.lapse()
s = createserver(handler_factory=Chronometer) # creamos el servidor
# handler_factory especifica qué objeto es que se crea con cada conexión.
# por defecto escucha en "127.0.0.1" pero se puede definir con host=".."
# por defecto el puerto es el 10123 pero se puede cambiar con port=123
s.debug_socket(True) # Esto indica que debe imprimir por pantalla lo que
# se envía y se recibe por el socket. Es útil para entender cómo funciona el
# protocolo.
s.serve() # empieza el bucle infinito de servicio. Sale de la función en cuanto
# se tenga que detener el programa. Normalmente por fallo inesperado o porque
# se recibe una señal de detener (SIGINT, SIGTERM) del sistema operativo.
return self.value_total
def getcount(self):
return self.value_count
def echo(self, string):
#print self._addr
#print self._conn
#print self._methods
print(string)
return string
# Note: for testing: sudo socat pty,link=/dev/ttyS0,raw,echo=0,crnl pty,link=/dev/ttyS1,raw,echo=0,crnl
# Serial port /dev/ttyS0: 115200,8,N,1, no timeout
import threading
def thread1():
time.sleep(.2)
conn_socket = bjsonrpc.serialsocket.SerialSocket(serial.Serial('/dev/ttyS1', 115200))
conn = bjsonrpc.connect(sock = conn_socket)
conn.call.echo("Hello world")
conn.close()
serv_socket = bjsonrpc.serialsocket.SerialSocket(serial.Serial('/dev/ttyS0', 115200))
s = bjsonrpc.createserver(handler_factory = MyHandler._factory(domain="yourdomain-dot-com"), sock = serv_socket)
s.debug_socket(True)
threading.Thread(target=thread1).start()
s.serve()
def set_socket_trig_string(self, value):
m_configure.socket_trig_string = value
return "OK"
def get_socket_trig_string(self):
return m_configure.socket_trig_string
def set_task_mapper(self, value):
m_configure.task_mapper = value
return "OK"
def get_task_mapper(self):
return m_configure.task_mapper
def trig(self):
m_configure.rpc_trig = True
return "OK"
def set_eth0_ip(self, newip):
m_configure.eth0_ip = newip
print newip
swtichIP(newip)
return "OK"
def get_eth0_ip(self):
return m_configure.eth0_ip
rpcserver = createserver(host="0.0.0.0", handler_factory=ServerHandler)
def getcount(self):
return self.value_count
def echo(self, string):
#print self._addr
#print self._conn
#print self._methods
print string
return string
import threading
def thread1():
time.sleep(0.2)
conn = bjsonrpc.connect(host="127.0.0.1", port=10123)
conn.call.echo("Hello world")
conn.close()
s = bjsonrpc.createserver(
handler_factory=MyHandler._factory(domain="yourdomain-dot-com"),
port=10123,
host="0.0.0.0")
s.debug_socket(True)
threading.Thread(target=thread1).start()
s.serve()
def slaveSimplateServer(port):
s = bjsonrpc.createserver(host='',
port=port,
handler_factory=SlaveSimplateHandler)
s.debug_socket(True)
s.serve()
