def get(self, user_name):
        if not self.current_user :
            self.redirect('/admin/login')
            return

        if self.get_current_role(self.current_user) != 'admin':
            self.redirect('/')
            return

        try:
            validator = formencode.All(validators.PlainText(not_empty=True),ValidUser())
            login = validator.to_python(user_name)
        except:
            self.set_secure_cookie("message", "User does not exist.")
            self.redirect("/admin/users/manage")
            return

        pg = PasswordGenerator(15)
        passwd = pg.generate()

        try:
            self.rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
            self.rpc.call.changeUserPassword(config.ipc.apikey, base64.b64encode(user_name.encode('utf-8')), base64.b64encode(passwd.encode('utf-8')))
            self.rpc.close()
            self.set_secure_cookie("message", "Password for user %s successfully changed. New password is %s" % (user_id, passwd))
            self.redirect("/admin/users/manage")
            return
        except Exception,e:
            self.set_secure_cookie("message", "Could not change password for user %s. Contact system administrator." % (user_id))
            self.redirect("/admin/users/manage")
            return
示例#2
0
    def open(self,db,user,passwd,host,port,options):
        if DEBUG_MODE:
            print "~~ open database"

        ok = True
        
        if self.conn is None:
            if not host is None and not port is None:
                self.conn = connect(host,port)
            else:
                if DEBUG_MODE:
                    print "~~ Error opening: You must indicate host and port"
                ok = False
        
        if not isinstance(self.conn, RemoteObject):
            if db is not None and user is not None and passwd is not None:
                if not self.conn.call.login(unicode(user),unicode(passwd),unicode(db)):
                    if DEBUG_MODE:
                        print "~~ Error connecting: User, password or project are incorrectly"
                    ok = False                
            else:
                if DEBUG_MODE:
                    print "~~ Error opening: You must indicate db, user and password"
                ok = False
        
        self.setOpen(ok)
        self.setOpenError(not ok)
        
        return ok
    def __init__(self,host="127.0.0.1",port=10123):
        QtGui.QDialog.__init__(self)
        ui_filepath = filedir("example2_chat.ui") # convertimos la ruta a absoluta
        self.ui = uic.loadUi(ui_filepath,self) # cargamos un fichero UI externo    

        self.to_be_updated = True # Indica que debe consultar los nuevos cambios
        self.extracount = 0       # Indica qué delta ha de usar al descargar el log de mensajes
        """ creamos las propiedad antes de que puedan ser usadas. """
        
        # Conectar el botón send
        self.connect(self.ui.btnSend, QtCore.SIGNAL("clicked()"),
                    self.btnSend_clicked)
                    
        # Creamos los dos iconos que usaremos en este diálogo repetidamente:
        self.img_people = QtGui.QIcon(QtGui.QPixmap(filedir("people.png"),"png"))
        self.img_user = QtGui.QIcon(QtGui.QPixmap(filedir("user.png"),"png"))
        
        # Conectamos al servidor remoto. Al pasar el parámetro handler_factory
        # estamos abriendo la puerta a que el servidor remoto llame nuestras
        # funciones.
        self.remote = connect(handler_factory=ClientChatter, host=host,port=port)
        self.remote.handler._setui(self) # enlazamos este formulario con la instancia de RPC.
        
        # Creamos un timer nuevo que revisará cuando hay novedades.
        self.timer = QtCore.QTimer(self)
        self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.timer_timeout)
        self.timer.setInterval(100) # establecemos el intervalo de llamada a 100 milisegundos.
        self.timer.start()       
示例#4
0
    def open(self, db, user, passwd, host, port, options):
        if DEBUG_MODE:
            print "~~ open database"

        ok = True

        if self.conn is None:
            if not host is None and not port is None:
                self.conn = connect(host, port)
            else:
                if DEBUG_MODE:
                    print "~~ Error opening: You must indicate host and port"
                ok = False

        if not isinstance(self.conn, RemoteObject):
            if db is not None and user is not None and passwd is not None:
                if not self.conn.call.login(unicode(user), unicode(passwd),
                                            unicode(db)):
                    if DEBUG_MODE:
                        print "~~ Error connecting: User, password or project are incorrectly"
                    ok = False
            else:
                if DEBUG_MODE:
                    print "~~ Error opening: You must indicate db, user and password"
                ok = False

        self.setOpen(ok)
        self.setOpenError(not ok)

        return ok
    def post(self):
        if self.current_user:
            self.redirect('/')
            return

        message = None
        argumentList = ['user', 'passwd']
        data = { }
        errors = { }
        for argument in argumentList:
            try:
                if self.get_argument(argument):
                    data[argument] = self.get_argument(argument)
                    pass
            except Exception:
                pass

        form = LoginForm()
        try:
            data = form.to_python(data)
            self.rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
            if self.rpc.call.checkLogin(config.ipc.apikey, base64.b64encode(data['user'].encode('utf-8')), base64.b64encode(data['passwd'].encode('utf-8'))):
                self.set_secure_cookie("user", data['user'])
                self.set_secure_cookie("role", 'unprivileged')
                self.set_secure_cookie("message", "User %s successfully logged in." % data['user'])
                self.redirect('/')
                self.rpc.close()
                return
            else:
                self.rpc.close()
            message = 'Invalid username and/or password'
        except Invalid, e:
            errors = e.unpack_errors()
示例#6
0
    def iniciar(self):

        self.notificar("Inicializando . . .")
        settings = ConfigSettings.load()

        self.conn = bjsonrpc.connect(host=settings.host,
                                     port=int(settings.port))
        self.notificar("Conectado.")
        # self.conn._debug_socket = True
        logged = self.conn.call.login(settings.username, settings.password)
        assert (logged)
        self.notificar("Registrado.")
        availableprojects = self.conn.call.getAvailableProjects()
        project = availableprojects[0]['code']
        self.prj = self.conn.call.connectProject(project)
        self.notificar("Proyecto conectado.")
        self.splash.prjconn = self.prj

        self.prj.qtdriver = qtdriver.QSqlLlampexDriver(self.prj)
        self.prj.qtdb = QtSql.QSqlDatabase.addDatabase(
            self.prj.qtdriver, "llampex-qsqlrpcdriver")
        if not self.prj.qtdb.open("", ""):
            print "ERROR: Error trying to connect Qt to RPC Database."
        self.notificar("Esperando a fin de carga.")
        self.splash.show()
示例#7
0
     def _to_python(self, value, state):
        rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
        try:
            usernames = rpc.call.listUsers(config.ipc.apikey)
            rpc.close()

        except Exception,e:
            raise formencode.Invalid('Cannot get pre-existing user list, contact administrator', value, state)
示例#8
0
 def manage_clicked(self):
     host = unicode(self.ui.host.text())
     port = unicode(self.ui.port.text())
     port = int(port)
     
     try:
         self.conn = bjsonrpc.connect(host=host,port=port)
         self.conn._debug_socket = self.debug
     except Exception, e:
         msgBox = QtGui.QMessageBox()
         msgBox.setText("Error trying to connect to %s:%d: %s: %s\n" % (host,port,e.__class__.__name__ ,repr(e.args)))
         msgBox.setIcon(QtGui.QMessageBox.Critical)
         msgBox.exec_()
         return
示例#9
0
 def client_connect(self, host, port=12345, handler=PlayerService):
     """
     Connects to a bjsonrpc server using the given ip, and port.
     :param host: the ip address of the target server
     :param port: the port you are trying to connect with
     :param handler: the class that contains all the handler methods
     :return:
     """
     try:
         self.player_connect = bjsonrpc.connect(host=host, port=port, handler_factory=handler)
         result = 1
         return result
     except Exception:
         raise Exception('client_connect::> Unable to connect to the server.')
示例#10
0
 def client_connect(self, host, port=12345, handler=PlayerService):
     """
     :param host:
     :param port:
     :param handler:
     :return:
     """
     try:
         self.player_connect = bjsonrpc.connect(host=host, port=port, handler_factory=handler)
         result = 1
         return result
     except Exception:
         result = 0
         return result
示例#11
0
 def client_connect(self, host, port=12345, handler=PlayerService):
     """
     :param host:
     :param port:
     :param handler:
     :return:
     """
     try:
         self.player_connect = bjsonrpc.connect(host=host,
                                                port=port,
                                                handler_factory=handler)
         result = 1
         return result
     except Exception:
         result = 0
         return result
示例#12
0
 def client_connect(self, host, port=12345, handler=PlayerService):
     """
     Connects to a bjsonrpc server using the given ip, and port.
     :param host: the ip address of the target server
     :param port: the port you are trying to connect with
     :param handler: the class that contains all the handler methods
     :return:
     """
     try:
         self.player_connect = bjsonrpc.connect(host=host,
                                                port=port,
                                                handler_factory=handler)
         result = 1
         return result
     except Exception:
         raise Exception(
             'client_connect::> Unable to connect to the server.')
示例#13
0
def main():

    parser = OptionParser()
    (options, args) = interpret_args(sys.argv[1:], parser)
    #validate_args(options, parser)

    c = bjsonrpc.connect()

    if options.request:
        print(c.call.incoming_request([options.request]))
    elif options.stop:
        print(c.call.stop())
    elif options.host:
        print(c.call.consuming(options.action, options.host,
                         options.service, options.location))
    elif options.client:
        print(c.call.hosting(options.action, options.client,
                       options.service, options.location))
示例#14
0
def attachReal(ueAttachedObj):
    print "\n--------------------------\n...connecting to vBBU-NSSF"
    c = connect(nssfIp)
    time.sleep(1)
    print "connected vBBU-NSSF."
    time.sleep(1)
    print "...attaching vBBU-NSSF"
    time.sleep(1)

    ueAttachedObjUnpickled = pickle.loads(ueAttachedObj)
    #print "ueAttachObj:"
    #print "\t", ueAttachedObjUnpickled.ip
    #print "\t", ueAttachedObjUnpickled.serviceType

    #response =  c.call.networkAttach(ueIp, serviceType, ueAttachedObjUnpickled)
    response = c.call.networkAttach(ueAttachedObj)
    printNSSFresponse(response)

    return response
    def get(self):
        if not self.current_user:
            self.redirect("/admin/login")
            return
        if self.get_current_role(self.current_user) != 'admin':
            self.redirect('/')
            return

        self.rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
        userNameList = self.rpc.call.listUsers(config.ipc.apikey)
        userList = []
        for user in userNameList:
            userList.append(self.rpc.call.userDetails(config.ipc.apikey, unicode(user)))
        self.rpc.close()
        message=self.get_secure_cookie("message")
        self.clear_cookie('message')
        fieldList =  ['login', 'name', 'email', 'mobile']
        self.render(self.template, message=message, doctype='xhtml-transitional',
                    title=self.title, userList=userList, fieldList=fieldList)
示例#16
0
def main():

    parser = OptionParser()
    (options, args) = interpret_args(sys.argv[1:], parser)
    validate_args(options, parser)

    connect = bjsonrpc.connect()

    if options.request:
        print(connect.call.incoming_request([options.request]))
    elif options.stop:
        print(connect.call.stop())
    elif options.consuming:
        print(connect.call.consuming(options.action, options.key,
                         options.service, options.location))
    elif options.hosting:
        print(connect.call.hosting(options.action, options.key,
                       options.service, options.location))
    elif options.query:
        print(connect.call.query(host=options.key, service=options.service))
    else:
        help_me()
示例#17
0
def SimplateLoop():
    threadName = threading.current_thread().name
    c=connect(host="127.0.0.1", port=settings.SIMPLATE_SERVER_PORT)
    c.call.registrate(cds_settings.SCENARIO_ID_Shop, threadName)
    c.call.startSession("CLIENT" + threadName, "some client info")
    while True:
        time.sleep(random.uniform(0,10))
        if c.call.shouldStartBigShow():
            logging.info("Allowed to start big show")
            time.sleep(random.uniform(1,2))
            r = random.randint(0,2)
            if r == 0:
                logging.info("Starting a succesfull show with id 1")
                c.call.simpleStart(cds_settings.SIMPLE_ID_BIG_SHOW)
                time.sleep(random.uniform(3,5))
                c.call.simpleResult(cds_settings.SIMPLE_ID_BIG_SHOW, (1,1))
            elif r == 1:
                logging.info("Canceling a show")
                c.call.simpleResult(cds_settings.SIMPLE_ID_BIG_SHOW, (0,None))
            elif r == 2:
                logging.info("Starting a succesfull show with id 2")
                time.sleep(random.uniform(3,5))
                c.call.simpleResult(cds_settings.SIMPLE_ID_BIG_SHOW, (1,2))
示例#18
0
    def iniciar(self):
        
        self.notificar("Inicializando . . .")
        settings = ConfigSettings.load()
        
        self.conn = bjsonrpc.connect(host=settings.host,port=int(settings.port))
        self.notificar("Conectado.")
        # self.conn._debug_socket = True
        logged = self.conn.call.login(settings.username,settings.password)
        assert(logged)
        self.notificar("Registrado.")
        availableprojects  = self.conn.call.getAvailableProjects()
        project = availableprojects[0]['code']
        self.prj = self.conn.call.connectProject(project)
        self.notificar("Proyecto conectado.")
        self.splash.prjconn = self.prj

        self.prj.qtdriver = qtdriver.QSqlLlampexDriver(self.prj)
        self.prj.qtdb = QtSql.QSqlDatabase.addDatabase(self.prj.qtdriver, "llampex-qsqlrpcdriver")
        if not self.prj.qtdb.open("",""):
            print "ERROR: Error trying to connect Qt to RPC Database."
        self.notificar("Esperando a fin de carga.")
        self.splash.show()
示例#19
0
 def accept(self):
     username = unicode(self.ui.user.text())
     password = unicode(self.ui.password.text())
     host = unicode(self.ui.host.text())
     port = unicode(self.ui.port.text())
     try:
         port = int(port)
     except ValueError:
         msgBox = QtGui.QMessageBox()
         msgBox.setText("The port number must be integer")
         msgBox.setIcon(QtGui.QMessageBox.Critical)
         msgBox.exec_()
         return
         
     try:
         self.conn = bjsonrpc.connect(host=host,port=port)
         self.conn._debug_socket = self.debug
     except Exception, e:
         msgBox = QtGui.QMessageBox()
         msgBox.setText("Error trying to connect to %s:%d: %s: %s\n" % (host,port,e.__class__.__name__ ,repr(e.args)))
         msgBox.setIcon(QtGui.QMessageBox.Critical)
         msgBox.exec_()
         return
示例#20
0
def SimplateLoop():
    threadName = threading.current_thread().name
    c = connect(host="127.0.0.1", port=settings.SIMPLATE_SERVER_PORT)
    c.call.registrate(cds_settings.SCENARIO_ID_Shop, threadName)
    c.call.startSession("CLIENT" + threadName, "some client info")
    while True:
        time.sleep(random.uniform(0, 10))
        if c.call.shouldStartBigShow():
            logging.info("Allowed to start big show")
            time.sleep(random.uniform(1, 2))
            r = random.randint(0, 2)
            if r == 0:
                logging.info("Starting a succesfull show with id 1")
                c.call.simpleStart(cds_settings.SIMPLE_ID_BIG_SHOW)
                time.sleep(random.uniform(3, 5))
                c.call.simpleResult(cds_settings.SIMPLE_ID_BIG_SHOW, (1, 1))
            elif r == 1:
                logging.info("Canceling a show")
                c.call.simpleResult(cds_settings.SIMPLE_ID_BIG_SHOW, (0, None))
            elif r == 2:
                logging.info("Starting a succesfull show with id 2")
                time.sleep(random.uniform(3, 5))
                c.call.simpleResult(cds_settings.SIMPLE_ID_BIG_SHOW, (1, 2))
示例#21
0
def SimplateLoop():
    threadName = threading.current_thread().name
    c=connect(host="127.0.0.1", port=settings.SIMPLATE_SERVER_PORT)
    c.call.registrate(cds_settings.SCENARIO_ID_Shop, threadName)
    c.call.startSession("CLIENT" + threadName, "some client info")
    for i in range(1,100):
        fb = random.randint(0,3)
        if fb == 0:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (0,0))
            with lock:
                localFeedback['cancel'] += 1
        elif fb == 1:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1,2))
            with lock:
                localFeedback['cancel'] += 1
        elif fb == 2:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1,0))
            with lock:
                localFeedback['no'] += 1
        elif fb == 3:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1,1))
            with lock:
                localFeedback['yes'] += 1
    c.close()
示例#22
0
def run_call(options, connect=None):
    """Print the result of the action.

    connect: The bjsonrpc connection to use, or None to create a new one, with
    defaults.

    """
    if connect is None:
        connect = bjsonrpc.connect()

    if options.request:
        print(connect.call.incoming_request([options.request]))
    elif options.stop:
        print(connect.call.stop())
    elif options.consuming:
        print(connect.call.consuming(options.action, options.key,
                         options.service, options.location))
    elif options.hosting:
        print(connect.call.hosting(options.action, options.key,
                       options.service, options.location))
    elif options.query:
        print(connect.call.query(host=options.key, service=options.service))
    else:
        help_me()
示例#23
0
def main():

    parser = OptionParser()
    (options, args) = interpret_args(sys.argv[1:], parser)
    validate_args(options, parser)

    connect = bjsonrpc.connect()

    if options.request:
        print(connect.call.incoming_request([options.request]))
    elif options.stop:
        print(connect.call.stop())
    elif options.consuming:
        print(
            connect.call.consuming(options.action, options.key,
                                   options.service, options.location))
    elif options.hosting:
        print(
            connect.call.hosting(options.action, options.key, options.service,
                                 options.location))
    elif options.query:
        print(connect.call.query(host=options.key, service=options.service))
    else:
        help_me()
示例#24
0
def SimplateLoop():
    threadName = threading.current_thread().name
    c = connect(host="127.0.0.1", port=settings.SIMPLATE_SERVER_PORT)
    c.call.registrate(cds_settings.SCENARIO_ID_Shop, threadName)
    c.call.startSession("CLIENT" + threadName, "some client info")
    for i in range(1, 100):
        fb = random.randint(0, 3)
        if fb == 0:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (0, 0))
            with lock:
                localFeedback['cancel'] += 1
        elif fb == 1:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1, 2))
            with lock:
                localFeedback['cancel'] += 1
        elif fb == 2:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1, 0))
            with lock:
                localFeedback['no'] += 1
        elif fb == 3:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1, 1))
            with lock:
                localFeedback['yes'] += 1
    c.close()
示例#25
0
    def __init__(self, host="127.0.0.1", port=10123):
        QtGui.QDialog.__init__(self)
        ui_filepath = filedir(
            "example2_chat.ui")  # convertimos la ruta a absoluta
        self.ui = uic.loadUi(ui_filepath,
                             self)  # cargamos un fichero UI externo

        self.to_be_updated = True  # Indica que debe consultar los nuevos cambios
        self.extracount = 0  # Indica qué delta ha de usar al descargar el log de mensajes
        """ creamos las propiedad antes de que puedan ser usadas. """

        # Conectar el botón send
        self.connect(self.ui.btnSend, QtCore.SIGNAL("clicked()"),
                     self.btnSend_clicked)

        # Creamos los dos iconos que usaremos en este diálogo repetidamente:
        self.img_people = QtGui.QIcon(
            QtGui.QPixmap(filedir("people.png"), "png"))
        self.img_user = QtGui.QIcon(QtGui.QPixmap(filedir("user.png"), "png"))

        # Conectamos al servidor remoto. Al pasar el parámetro handler_factory
        # estamos abriendo la puerta a que el servidor remoto llame nuestras
        # funciones.
        self.remote = connect(handler_factory=ClientChatter,
                              host=host,
                              port=port)
        self.remote.handler._setui(
            self)  # enlazamos este formulario con la instancia de RPC.

        # Creamos un timer nuevo que revisará cuando hay novedades.
        self.timer = QtCore.QTimer(self)
        self.connect(self.timer, QtCore.SIGNAL("timeout()"),
                     self.timer_timeout)
        self.timer.setInterval(
            100)  # establecemos el intervalo de llamada a 100 milisegundos.
        self.timer.start()
    def get(self):
        if not self.current_user:
            self.redirect('/login')
            return

        user_role = self.get_current_role(self.current_user)
        if user_role == 'admin':
            self.redirect('/admin/')
            return
        elif user_role == 'unprivileged':
            userDict = { }
            login = self.current_user

            try:
                self.rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
                userDict = self.rpc.call.userDetails(config.ipc.apikey, login)
                self.rpc.close()
            except Exception, e:
                self.set_secure_cookie("message", 'Error fetching user info, contact system administrator')

            message = self.get_secure_cookie('message')
            self.clear_cookie('message')
            self.render('templates/userIndex.html', message=message, userDict=userDict,
                         doctype='xhtml-transitional', title=self.title)
示例#27
0
def before_all():
    pass
    #lettuce.world.application = multiprocessing.Process(target=app.run)
    world.application = subprocess.Popen(['python','/Users/matt/workspace/instruments/app.py'])
    pqaut.client.wait_for_automation_server()
    lettuce.world.qtapp = bjsonrpc.connect(host='0.0.0.0', port=9001)
示例#28
0
 def setUp(self):
     """
         Start the server and connect the client for every test.
     """
     testserver1.start()
     self.conn = bjsonrpc.connect()
示例#29
0
def isActive(config):
    try:
        bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
        return True
    except:
        return False
示例#30
0
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1, 0))
            with lock:
                localFeedback['no'] += 1
        elif fb == 3:
            c.call.simpleResult(cds_settings.SIMPLE_ID_FEEDBACK, (1, 1))
            with lock:
                localFeedback['yes'] += 1
    c.close()


threads = []
for i in range(1, 20):
    t = threading.Thread(target=SimplateLoop, name="Simplate #" + str(i))
    t.daemon = True
    t.start()
    threads += [t]

run = True
while run:
    run = False
    for t in threads:
        t.join(0.01)
        if t.isAlive():
            run = True

print "Local feedback: " + str(localFeedback)
c = connect(host="127.0.0.1", port=settings.SIMPLATE_SERVER_PORT)
c.call.registrate(cds_settings.SCENARIO_ID_Shop, 'simeSimplate')
c.call.startSession("Some CLIENT", "some client info")
print "Remote feedback" + str(c.call.getFeedbackStatistics())
示例#31
0
文件: test.py 项目: oleg84/CDS
# -*- coding: utf-8 -*-

from bjsonrpc import connect
from bjsonrpc.exceptions import ServerError
import cds_settings
import time

#TODO: use some unit-test framework


def StartTest(name):
    print "###TEST: %s" % name


StartTest("Connection")
c = connect(host="127.0.0.1", port=18888)
c.close()

StartTest("Get time")
c = connect(host="127.0.0.1", port=18888)
print c.call.getLocalTime()
print c.call.getUtcTime()
c.close()

StartTest("New client shop -> bar")
c = connect(host="127.0.0.1", port=18888)
c.call.registrate(cds_settings.SCENARIO_ID_Shop, 10)
print "Client just came: " + str(c.call.startSession("client1", "Вася Пупкин"))
c.call.simpleStart('simple id')
c.call.simpleResult('simple id', (1, 1))
c.call.simpleEnd('simple id')
示例#32
0
 def setUp(self):
     """
         Start the server and connect the client for every test.
     """
     testserver1.start()
     self.conn = bjsonrpc.connect()
示例#33
0
import sys
sys.path.insert(0, "../")  # prefer local version
import bjsonrpc
from bjsonrpc.handlers import BaseHandler

import random
import time


class MyHandler(BaseHandler):
    def notify(self, text):
        print("Notify:\n%s" % text)


conn = bjsonrpc.connect(host="127.0.0.1",
                        port=10123,
                        handler_factory=MyHandler)


def benchmark():
    print(conn.call.echo('Hello World!'))
    total = 0
    count = 0
    valuecount = 10000
    start = time.time()
    for i in range(valuecount):
        randval = random.uniform(-100, 100)
        total += randval
        count += 1
        conn.notify.addvalue(randval)
示例#34
0
def isActive(config):
    try:
        bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
        return True
    except:
        return False
def is_unprivileged_class_type(user):
    rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
    retval = (user in rpc.call.listUsers(config.ipc.apikey))
    rpc.close()

    return retval
示例#36
0
#!/usr/bin/python
# -*- coding: utf-8 -*-

from bjsonrpc import connect
from bjsonrpc.exceptions import ServerError
from bjsonrpc.handlers import BaseHandler
import settings
import time
import logging
import threading

logging.basicConfig(format='%(asctime)s %(levelname)s[%(threadName)s]: %(message)s', level=logging.INFO)

class BarStubHandler(BaseHandler):

    def newBarOrder(self, drink, orderId, simplateId):
        logging.info("New order id=%d simplate=%s: %s", orderId, simplateId, unicode(drink))
        self._conn.method.barOrderDone(orderId)

c=connect(host="127.0.0.1", port=settings.BAR_SERVER_PORT, handler_factory=BarStubHandler)
c.call.registrate()

while True:
    c.call.ping()
    c.read_and_dispatch(timeout=5)
        argumentList = ['newPassword', 'newPasswdConfirm', 'oldPassword']
        data = { }
        for argument in argumentList:
            try:
                if self.get_argument(argument):
                    data[argument] = self.get_argument(argument)
            except Exception, e:
                pass

        form = ClientPasswordChangeForm()
        try:
            data = form.to_python(data)
            errors = { }

            print "DEBUG: login = %s" % (login)
            self.rpc = bjsonrpc.connect(host=config.ipc.rpcip, port=int(config.ipc.port))
            if not self.rpc.call.checkLogin(config.ipc.apikey, base64.b64encode(login), base64.b64encode(data['oldPassword'].encode('utf-8'))):
                self.set_secure_cookie("message", '<font color="red">Old password is invalid</font>')
                self.redirect('/passwd')
                self.rpc.close()
                return
            try:
                self.rpc.call.changeUserPassword(config.ipc.apikey, base64.b64encode(login), base64.b64encode(data['newPassword'].encode('utf-8')))
                self.set_secure_cookie("message", "Password changed successfully.")
                self.redirect('/')
                self.rpc.close()
                return
            except Exception, e:
                print e
                self.set_secure_cookie("message", 'Error changing password: %s. Contact system administrator.' %(e))
                self.redirect('/')
示例#38
0
import bjsonrpc
from bjsonrpc.handlers import BaseHandler
from typing import Tuple


class IceAdapterHandler(BaseHandler):
    def _setup(self):
        print("_setup")

    def onGpgNetMessageReceived(self, header: str, chunks: tuple):
        print("from GPGNet: {}: {}".format(header, chunks))
        if header == "GameState":
            if len(chunks) >= 1:
                if chunks[0] == "Lobby":
                    self._conn.call.hostGame("africa.v0005")
                    #self._conn.call.joinGame("asdf", 1234)


iceconn = bjsonrpc.connect(host="127.0.0.1",
                           port=7236,
                           handler_factory=IceAdapterHandler)
iceconn.serve()
示例#39
0
import bjsonrpc

c = bjsonrpc.connect(port=8002)
print("::> %s\n" % c.call.hello(name="john"))
print("::> %s\n" % c.call.hello("arnold"))
示例#40
0
# encoding: UTF-8
# ::::::::::::: Ejemplo básico 1 de json-rpc (CLIENTE) ::::::::::::

from bjsonrpc import connect
import time
c = connect()
c.call.start() # iniciamos el cronómetro
a = 0
# realizamos algunas operaciones al azar, costosas...
for i in range(1000):
    a += i 
res = c.method.stoplapse()

# y preguntamos el tiempo transcurrido:
print "Elapsed:", c.call.lapse()
print res.value()
time.sleep(0.1) # dejamos que pase una decima de segundo mas...
c.call.stop() # y detenemos el cronómetro

# preguntamos el tiempo transcurrido: (habrá pasado aprox. 0.1 segundos)
print "Elapsed:", c.call.lapse()

time.sleep(0.1) # dejamos que pase otra decima de segundo. 

# el cronometro está parado. No debe haber diferencia de tiempo:
print "Elapsed:", c.call.lapse() # debe valer lo mismo que el anterior.

"""
    La salida normal de este programa es aproximadamente ésta:
    
        Elapsed: 0.00327587127686
示例#41
0
import bjsonrpc

test1 = {"args": ['python *.py'],
        "input": [],
        "inputfiles" : {},
        }

codes = {"foo.py": "print 'hello World'"}
references = {"hello.py": "print 'Hello World!'"}
tests = [test1]

c = bjsonrpc.connect()
print c.call.checkWithReference(codes, references, tests)
示例#42
0
#!/usr/bin/python
# -*- coding: utf-8 -*-

from bjsonrpc import connect
from bjsonrpc.exceptions import ServerError
from bjsonrpc.handlers import BaseHandler
import settings
import time
import logging
import threading
from listeners import _logFunction

logging.basicConfig(
    format='%(asctime)s %(levelname)s[%(threadName)s]: %(message)s',
    level=logging.INFO)


class SlaveSimplateStubHandler(BaseHandler):
    def sendToSlave(self, *args):
        _logFunction("args: ", args)


c = connect(host="127.0.0.1",
            port=settings.SLAVE_SIMPLATE_SERVER_PORT,
            handler_factory=SlaveSimplateStubHandler)
c.call.registrate(10)

while True:
    c.call.ping()
    c.read_and_dispatch(timeout=5)
示例#43
0
from typing import Tuple


class SdpHandler(BaseHandler):
    def _setup(self):
        print("_setup")

    def onSdp(self, playerA: int, playerB: int, sdp: str):
        print("onSdp: {} -> {}: {}".format(playerA, playerB, sdp))

    def onGpgNetMessageReceived(self, header: str, chunks: tuple):
        print("from GPGNet: {}: {}".format(header, chunks))


sdpconn = bjsonrpc.connect(host="127.0.0.1",
                           port=10123,
                           handler_factory=SdpHandler)


class IceAdapterHostHandler(BaseHandler):
    def _setup(self):
        print("_setup")

    def onConnectionStateChanged(self, state: str):
        if state == "Connected":
            print("Connected")
            status = self._conn.call.status()
            print("status: {}".format(status))
            myId = status["options"]["player_id"]
            myLogin = status["options"]["player_login"]
            self.sdpconn.call.setId(myId)
示例#44
0
#!/usr/bin/python
# -*- coding: utf-8 -*-

from bjsonrpc import connect
from bjsonrpc.exceptions import ServerError
from bjsonrpc.handlers import BaseHandler
import settings
import time
import logging
import threading

logging.basicConfig(
    format='%(asctime)s %(levelname)s[%(threadName)s]: %(message)s',
    level=logging.INFO)


class BigShowClientStubHandler(BaseHandler):
    def startBigShow(self, showId):
        logging.info("Start big show with id = %s", unicode(showId))


c = connect(host="127.0.0.1",
            port=settings.BIG_SHOW_PORT,
            handler_factory=BigShowClientStubHandler)
c.call.registrate()

while True:
    c.call.ping()
    c.read_and_dispatch(timeout=5)
示例#45
0
def createAttachObj():
    obj = ueAttachObj()
    obj.ip = "192.168.186.51"
    obj.serviceType = 5

    #print "ueAttachObj:"
    #print "\t", obj.ip
    #print "\t", obj.serviceType
    return obj


# connecting to vBBU
print "\n---------------------"
print "...connecting ue-vBBU"
time.sleep(1)
c = connect("192.168.186.61")
print "connected ue-vBBU."
time.sleep(1)

# sending attach request to vBBU with a service-type for video

attachedObj = createAttachObj()
attachedParameter = pickle.dumps(attachedObj)
print "...attaching ue-vBBU-..."
time.sleep(2)
response = c.call.attachvBBU(attachedParameter)
responseUnpickled = pickle.loads(response)

time.sleep(1)
print "attached ue-vBBU-..."
time.sleep(0.5)
示例#46
0
from flask import Flask, render_template, redirect, url_for, request
import bjsonrpc

app = Flask(__name__)
app.debug = True
test_data = {"heading":1}
qtapp = bjsonrpc.connect(host='0.0.0.0', port=9001)

@app.route("/", methods=['get'])
def index():
    return render_template('index.html')

@app.route("/", methods=['post'])
def send_info():
    test_data.update(request.form)
    print test_data
    for key, value in test_data.items():
        test_data[key] = float(value[0])
    qtapp.call.change_position(test_data)
    return redirect('/')

if __name__ =="__main__":
    app.run()
示例#47
0
def thread1():  
    time.sleep(0.2)  
    conn = bjsonrpc.connect(host="127.0.0.1",port=10123)
    conn.call.echo("Hello world")
    conn.close()
示例#48
0
    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.

"""


import sys
sys.path.insert(0,"../") # prefer local version
import bjsonrpc

import time
import random

conn = bjsonrpc.connect(host="127.0.0.1",port=10123)
conn._debug_socket = True
ch1 = conn.call.newChronometer()
ch2 = conn.call.newChronometer()
list1 = conn.call.newList()
list2 = conn.call.newList()

ch1.call.start()
conn._debug_socket = False
print "ch1 start."
time.sleep(0.05); print "  %.4f\t%.4f" % (ch1.call.lapse(), ch2.call.lapse())
time.sleep(0.05)
ch2.call.start(); print "ch2 start."
time.sleep(0.05); print "  %.4f\t%.4f" % (ch1.call.lapse(), ch2.call.lapse())
time.sleep(0.05); 
ch1.call.stop();  print "ch1 stop."
示例#49
0
import gps
from pprint import pprint
import bjsonrpc
 
#session = gps.gps("localhost", "2947")
session = gps.gps("localhost", "9002")
session.stream(gps.WATCH_ENABLE | gps.WATCH_NEWSTYLE)
client = None
try:
    client = bjsonrpc.connect(host="127.0.0.1", port=9001)
except Exception as ex:
    print 'exception happening{}'.format(ex)

 
while True:
    report = session.next()
    print report
    if report['class'] == 'TPV':
        response = client.call.change_position(dict(report))
示例#50
0
文件: bar_stub.py 项目: oleg84/CDS
# -*- coding: utf-8 -*-

from bjsonrpc import connect
from bjsonrpc.exceptions import ServerError
from bjsonrpc.handlers import BaseHandler
import settings
import time
import logging
import threading

logging.basicConfig(
    format='%(asctime)s %(levelname)s[%(threadName)s]: %(message)s',
    level=logging.INFO)


class BarStubHandler(BaseHandler):
    def newBarOrder(self, drink, orderId, simplateId):
        logging.info("New order id=%d simplate=%s: %s", orderId, simplateId,
                     unicode(drink))
        self._conn.method.barOrderDone(orderId)


c = connect(host="127.0.0.1",
            port=settings.BAR_SERVER_PORT,
            handler_factory=BarStubHandler)
c.call.registrate()

while True:
    c.call.ping()
    c.read_and_dispatch(timeout=5)
示例#51
0
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()
示例#52
0
import gps
from pprint import pprint
import bjsonrpc
 
session = gps.gps("localhost", "2947")
session.stream(gps.WATCH_ENABLE | gps.WATCH_NEWSTYLE)
client = None
try:
    client = bjsonrpc.connect(host="10.0.0.22", port=9001)
except Exception as ex:
    print 'exception happening{}'.format(ex)

 
while True:
    report = session.next()
    if report['class'] == 'TPV':
        response = client.call.change_position(dict(report))
示例#53
0
def thread1():
    time.sleep(0.2)
    conn = bjsonrpc.connect(host="127.0.0.1", port=10123)
    conn.call.echo("Hello world")
    conn.close()
示例#54
0
import simplejson
print "starting ... bsonjrpc"
sys.path.insert(0,"..")
import bjsonrpc
print "ready."

from bjsonrpc.handlers import BaseHandler

class MyHandler(BaseHandler):
    def notify(self,text):
        print "Notify:", text
        



conn = bjsonrpc.connect(host="192.168.3.101",port=10123,handler_factory=MyHandler)

def benchmark():
    print conn.call.echo('Hello World!')
    total = 0
    count = 0
    valuecount = 500
    start = time.time()
    prev = start
    for i in range(valuecount):
        randval = i #random.uniform(-100,100)
        total += randval
        count += 1
        conn.notify.addvalue(randval)
        new = time.time()
        if new - prev > 2: