예제 #1
0
    def __init__(self,
                 usr='******',
                 pwd='123456a@',
                 host='localhost',
                 port=5672,
                 vhost='vh1'):
        self.vhost = vhost
        creds = pika.PlainCredentials(username=usr, password=pwd)
        params = pika.ConnectionParameters(host=host,
                                           port=port,
                                           virtual_host=vhost,
                                           credentials=creds)
        self.is_waiting = False
        self.c = Caller()
        try:
            self.conn = pika.BlockingConnection(parameters=params)
            self.ch = self.conn.channel()
        except pika.exceptions.ProbableAccessDeniedError:
            logging.info("[AppServer] Connection error. Check configuration.")
            return None
        except:
            return None

        # declare a queue to reply
        res = self.ch.queue_declare(exclusive=True, queue='reply')
        self.reply_queue = res.method.queue  # get the queue name
        self.ch.basic_consume(queue=self.reply_queue,
                              consumer_callback=self.on_feedback,
                              no_ack=True)
        logging.info("[AppServer] Done init ...")
예제 #2
0
    def __init__(self, usr='******', pwd='123456a@', host='localhost', port=5672, vhost='vh1'):
        logging.info("BEGIN INIT THE [AppServer] ----------------------------->")
        self.vhost = vhost
        creds = pika.PlainCredentials(username=usr, password=pwd)
        params = pika.ConnectionParameters(host=host, port=port, virtual_host=vhost, credentials=creds)
        # is in waiting state
        self.is_waiting = False
        # is initiate successfully
        self.is_init = False
        self.c = Caller()
        try:
            self.conn = pika.BlockingConnection(parameters=params)
            self.ch = self.conn.channel()
        except pika.exceptions.ProbableAccessDeniedError:
            logging.critical("[AppServer] Connection error. Check configuration.")
            return None
        except:
            return None

        # declare a queue to reply
        try:
            res = self.ch.queue_declare(exclusive=True, queue='reply')
            self.reply_queue = res.method.queue # get the queue name
            self.ch.basic_consume(queue=self.reply_queue, consumer_callback=self.on_feedback, no_ack=True)
        except pika.exceptions.ChannelClosed as e:
            logging.critical("[AppServer] The pika channel is closed. Error message: {0}".format(e))
            return None
        except Exception as e:
            logging.critical("[AppServer] Unknown error while init app: {0}".format(e))
            return None

        self.is_init = True
        logging.info("[AppServer] Done init ...")
예제 #3
0
def pm(debug, host):
    """Connect to password manager"""

    logger = Logger(debug)
    logger.debug('debug mode on')

    caller = None
    p_key_derived = None

    try:
        if not Caller.check_up(host):
            logger.error('error creating session: host down')
        else:
            logger.debug('host up')

        key, p_key_derived = Input.get_public_key()

        logger.debug('creating a new session...')
        caller = Caller(host, key)
        logger.info(f'session created')

    except ConnectionError as ce:
        logger.error(f'error creating session: connection error - {str(ce)}')
    except TypeError as te:
        logger.error(f'error creating session: wrong input - {str(te)}')

    if caller is not None:
        InteractiveInput(caller, logger, p_key_derived).cmdloop()
    def call(namespace):
        caller = Caller(verbose=True)
        phone = namespace.phone if namespace.phone is not None else 9023618802
        trunk = namespace.trunk if namespace.trunk is not None else '2'
        phone2 = namespace.phone2 if namespace.phone2 is not None else None

        trunk = decipher(trunk)
        if not trunk:
            print('указан несуществующий транк - ошибка')
            return

        muid = str(uuid.uuid4())
        with TeleDB() as db:
            db << 'INSERT INTO `tele_material` (`intphone`, `region_id`, `extra`, `start_dial`,`trunk_dial`) \
               VALUES (%s,33,2,NOW(),%s)' < (int(phone), muid)
            db << 'SELECT last_insert_id() as id'
            ids = [db.one()['id']]
            if phone2:
                db << 'INSERT INTO `tele_material` (`intphone`, `region_id`, `extra`, `start_dial`,`trunk_dial`) \
                   VALUES (%s,33,2,NOW(),%s)' < (int(phone2), muid)
                db << 'SELECT last_insert_id() as id'
                ids.append(db.one()['id'])

            #import pdb; pdb.set_trace()

            if not caller.produce(db, trunk, ids):
                db << 'UPDATE `tele_material` SET `trunk_dial`=NULL,`start_dial`=NULL WHERE `id` = %s' < muid
예제 #5
0
def webapp_login():
    global caller

    # logging in
    if request.method == 'POST':
        host_param = request.form['host']

        try:

            if not Caller.check_up(host_param):
                return render_template("login.html", msg='host is down', host=host_param)

            private_key_df = request.form['private_key']
            private_key_df_derived = Parser.derive(private_key_df)
            public_key_df = gen_public_key(private_key_df_derived)

            caller = Caller(host_param, public_key_df)

            return redirect(url_for('webapp.webapp_main', path='', dirname=''))

        except TypeError as te:
            return render_template("login.html", msg=str(te), host=host_param)

    elif request.method == 'GET':
        if caller is not None:
            if caller.get_session().status_code == 200:
                return redirect(url_for('webapp.webapp_main', path='', dirname=''))

        return render_template("login.html")
예제 #6
0
 def __init__(self, vhost_data):
     Greenlet.__init__(self)
     self.vhost_data = vhost_data
     self.app1 = AppServer(usr=self.vhost_data['user'],
                           pwd=self.vhost_data['password'],
                           host=self.vhost_data['host'],
                           port=self.vhost_data['port'],
                           vhost=self.vhost_data['name'])
     self.c = Caller()
 def trunk(namespace):
     #import pdb; pdb.set_trace()
     trunk = decipher(namespace.trunk)
     if not trunk:
         print('указан несуществующий транк - ошибка')
         return
     with TeleDB() as db:
         router = MaterialRouter(db)
         feedstock = router.feedstock(trunk)
         if feedstock and namespace.verbose:
             print('Запас ' + str(len(feedstock)))
         caller = Caller(verbose=namespace.verbose)
         if not caller.produce(db, trunk, feedstock):
             db << 'UPDATE `tele_material` SET `trunk_dial`=NULL,`start_dial`=NULL WHERE `trunk_dial` = %s' < router.uid
예제 #8
0
 def times(array):
     return [ 
         Caller.bubble_sort(array=array), 
         Caller.bubble_sort_with_flag(array=array), 
         Caller.insertion_sort(array=array),
         Caller.selection_sort(array=array),
         Caller.shell_sort(array=array),
         Caller.merge_sort(array=array),
         Caller.quick_sort(array=array),
         Caller.counting_sort(array=array),
         Caller.radix_sort(array=array)
     ]
예제 #9
0
class AppCore(Greenlet):
    def __init__(self, vhost_data):
        Greenlet.__init__(self)
        self.vhost_data = vhost_data
        self.app1 = AppServer(usr=self.vhost_data['user'],
                              pwd=self.vhost_data['password'],
                              host=self.vhost_data['host'],
                              port=self.vhost_data['port'],
                              vhost=self.vhost_data['name'])
        self.c = Caller()

    def _run(self):
        current_thread().name = self.vhost_data['name']

        while 1:
            # reload config
            importlib.reload(coreconfig)
            # begin get vhosts & ips
            self.ips = self.c.getIPS(coreconfig.CoreConfig.URL_GET_LIST_IP,
                                     self.vhost_data['name'])

            # self.ips = ['192.168.1.1', '192.168.1.2', '192.168.1.3']

            if self.app1 is not None:
                self.app1.push(self.ips)

            time.sleep(coreconfig.CoreConfig.PING_INTERVAL_SECONDS)
예제 #10
0
 def run(self):
     caller = Caller.Instance()
     notchFreq = [50]
     highCutOff = 80
     caller.raw.filter(l_freq=None, h_freq=highCutOff, n_jobs=2)
     caller.raw.notch_filter(freqs=notchFreq)
     self.emit_filterFinished()
예제 #11
0
    def callFilter(self):

        finished = QtCore.pyqtSignal()
        caller = Caller.Instance()

        caller.raw.filter(l_freq=None, h_freq=self.highCutOff, n_jobs=2)
        caller.raw.notch_filter(freqs=self.notchFreq)
        finished.emit()
예제 #12
0
class Intercom(object):

    def __init__(self,
                 led_red_channel,
                 led_green_channel,
                 doors_channel,
                 btn_call_channel,
                 snd_dev_capture="default",
                 snd_dev_playback="default"):

        self.selected_sipid = "sip:localhost"

        self.led_red = OnOffDevice(led_red_channel)
        self.led_green = OnOffDevice(led_green_channel)
        self.doors = OnOffDevice(doors_channel)
        self.caller = Caller(snd_dev_capture, snd_dev_playback,
                             simple_callback_factory=self._callback_factory)
        self.buttonCall = Button(btn_call_channel, self.call)

    def _callback_factory(self):
        intercom = self

        class _IntercomCallCallback(SimpleCallCallback):
            def on_connecting(self):
                intercom.led_green.start_blinking(0.5)

            def on_connected(self):
                intercom.led_green.set(True)

            def on_disconnected(self):
                intercom.led_green.set(False)

        return _IntercomCallCallback()

    def call(self):
        self.caller.call(self.selected_sipid)

    def cancel_call(self):
        self.caller.cancel_call()

    def open_door(self, duration=5):
        self.doors.set(True)
        time.sleep(duration)
        self.doors.set(False)
예제 #13
0
파일: broker.py 프로젝트: dosadih/broker
 def __init__(self, verbose=0):
     """
     Class constructor
     """
     self.verbose = verbose
     # Object to do dashboard call
     self.dashcall = DashboardCaller(verbose=1)
     # Object shared to do server calls
     self.servercall = Caller(verbose=1)
     self.config_file = None
     self.config = []
예제 #14
0
파일: broker.py 프로젝트: dosadih/broker
 def get_server_status(self):
     """
     Read all server status
     """
     status = []
     for server in self.config:
         stat = {}
         self.servercall = Caller()
         self.servercall.set_cfg(server)
         stat["status"] = self.servercall.call(route="status", verb="GET", data=None)
         stat["name"] = server.name["name"]
         status.append(stat)
     return status
예제 #15
0
    def __init__(self,
                 led_red_channel,
                 led_green_channel,
                 doors_channel,
                 btn_call_channel,
                 snd_dev_capture="default",
                 snd_dev_playback="default"):

        self.selected_sipid = "sip:localhost"

        self.led_red = OnOffDevice(led_red_channel)
        self.led_green = OnOffDevice(led_green_channel)
        self.doors = OnOffDevice(doors_channel)
        self.caller = Caller(snd_dev_capture, snd_dev_playback,
                             simple_callback_factory=self._callback_factory)
        self.buttonCall = Button(btn_call_channel, self.call)
예제 #16
0
    def do_refresh(self, arg):
        """
        Get a fresh new session from server
        """

        key = Input.get_public_key()
        current_host = self.caller.host

        try:
            self.caller = Caller(current_host, key)
            self.logger.info('session refreshed')

        except ConnectionError as ce:
            self.logger.error(
                f'error creating session: connection error - {str(ce)}')

        except TypeError as te:
            self.logger.error(
                f'error creating session: wrong input - {str(te)}')
예제 #17
0
파일: core.py 프로젝트: NGL91/nms
    def __init__(self, usr='******', pwd='123456a@', host='localhost', port=5672, vhost='vh1'):
        self.vhost = vhost
        creds = pika.PlainCredentials(username=usr, password=pwd)
        params = pika.ConnectionParameters(host=host, port=port, virtual_host=vhost, credentials=creds)
        self.is_waiting = False
        self.c = Caller()
        try:
            self.conn = pika.BlockingConnection(parameters=params)
            self.ch = self.conn.channel()
        except pika.exceptions.ProbableAccessDeniedError:
            logging.info("[AppServer] Connection error. Check configuration.")
            return None
        except:
            return None

        # declare a queue to reply
        res = self.ch.queue_declare(exclusive=True, queue='reply')
        self.reply_queue = res.method.queue # get the queue name
        self.ch.basic_consume(queue=self.reply_queue, consumer_callback=self.on_feedback, no_ack=True)
        logging.info("[AppServer] Done init ...")
예제 #18
0
파일: core.py 프로젝트: NGL91/nms
class AppCore(Greenlet):
    def __init__(self, vhost_data):
        Greenlet.__init__(self)
        self.vhost_data = vhost_data
        self.app1 = AppServer(usr=self.vhost_data['user'], pwd=self.vhost_data['password'], host=self.vhost_data['host'], port=self.vhost_data['port'], vhost=self.vhost_data['name'])
        self.c = Caller()

    def _run(self):
        current_thread().name = self.vhost_data['name']

        while 1:
            # reload config
            importlib.reload(coreconfig)
            # begin get vhosts & ips
            self.ips = self.c.getIPS(coreconfig.CoreConfig.URL_GET_LIST_IP, self.vhost_data['name'])

            # self.ips = ['192.168.1.1', '192.168.1.2', '192.168.1.3']

            if self.app1 is not None:
                self.app1.push(self.ips)

            time.sleep(coreconfig.CoreConfig.PING_INTERVAL_SECONDS)
예제 #19
0
class AppCore(Greenlet):
    def __init__(self, vhost_data):
        Greenlet.__init__(self)
        self.vhost_data = vhost_data
        self.app1 = AppServer(usr=self.vhost_data['user'], pwd=self.vhost_data['password'], host=self.vhost_data['host'], port=self.vhost_data['port'], vhost=self.vhost_data['name'])
        self.c = Caller()

    def _run(self):
        current_thread().name = self.vhost_data['name']

        while 1:
            
            # reload config
            importlib.reload(coreconfig)
            # check if app is None
            logging.info("[AppCore] Current app is: {0}".format(self.app1))
            if not self.app1.is_init:
                # re-initate
                logging.info("[AppCore] App isn't init properly. Re-initiate now ...")
                self.app1 = AppServer(usr=self.vhost_data['user'], pwd=self.vhost_data['password'], host=self.vhost_data['host'], port=self.vhost_data['port'], vhost=self.vhost_data['name'])
                logging.info("[AppCore] Now sleeping {0}s...".format(coreconfig.CoreConfig.PING_INTERVAL_SECONDS))
                time.sleep(coreconfig.CoreConfig.PING_INTERVAL_SECONDS)
                # yes, ignore to continue
                continue

            
            # begin get vhosts & ips
            logging.info("[AppCore] Begin getting IPs ...")
            self.ips = self.c.getIPS(coreconfig.CoreConfig.URL_GET_LIST_IP, self.vhost_data['name'])

            # self.ips = ['192.168.1.1', '192.168.1.2', '192.168.1.3']

            if self.app1.is_init and self.ips:
                self.app1.push(self.ips)
            else:
                logging.info("[AppCore] Nothing to push (app is None or get IPs failed)")

            logging.info("[AppCore] Now sleeping {0}s...".format(coreconfig.CoreConfig.PING_INTERVAL_SECONDS))
            time.sleep(coreconfig.CoreConfig.PING_INTERVAL_SECONDS)
예제 #20
0
class TestCaller(unittest.TestCase):
    @patch.object(Caller, '_read_file', mock_read_file)
    def setUp(self):
        self.c = Caller('from', 'sid', 'authkey')

    def test_init(self):
        self.assertEqual(self.c._from_number, 'from')
        self.assertEqual(self.c._account_sid, 'sid')
        self.assertEqual(self.c._auth_key, 'authkey')

    def test_read_file(self):
        self.assertIsNotNone(self.c._data)
        self.assertIsInstance(self.c._data, dict)

    def test_loop(self):
        self.assertIsNotNone(self.c._loop)
        self.assertIsInstance(self.c._loop, AbstractEventLoop)

    def test_session(self):
        self.assertIsNotNone(self.c._session)
        self.assertIsInstance(self.c._session, aiohttp.ClientSession)

    def test_logger(self):
        self.assertIsNotNone(self.c._logger)
        self.assertIsInstance(self.c._logger, logging.Logger)

    def test_parse_data(self):
        self.assertIsInstance(self.c._accounts, set)
        self.assertNotIn('account_two', self.c._accounts)
        for a in self.c._accounts:
            self.assertIsInstance(a, Account)

    def test_make_url(self):
        self.assertEqual(
            self.c._make_url('testpath'),
            'https://api.twilio.com/2010-04-01/Accounts/sid/testpath.json')
예제 #21
0
    def start(self, seq):
        ##         self.db = adbapi.ConnectionPool('MySQLdb', host='localhost',
        ##                                         user='******', passwd='HerrMeister',
        ##                                         db='actor')

        # listen on all devices
        for t in seq.trunks:
            for i in range(t.lines):
                c = Caller(seq, self, t.name)
                self.devices.append(c)
                c.send(c, 'LSTN %s %s' % (t.name, 'any'))

        self.a_hackcenter = A_Hackcenter()
        self.a_haecksen = A_Haecksen(seq)

        self.b_se = B_SE()
        self.b_nw = B_NW()
        self.b_ne = B_NE()
        self.b_sw = B_SW()
        self.b_lounge = B_Lounge(seq)
        self.b_saal2 = B_Saal2(seq)
        self.b_saal3 = B_Saal3(seq)

        self.c_se = C_SE()
        self.c_nw = C_NW()
        self.c_ne = C_NE()
        self.c_sw = C_SW()
        self.c_office = C_Office()
        self.c_saal1 = C_Saal1(seq)

        self.entry = self.b_se

        # Floor A
        connect(self.a_hackcenter, self.a_haecksen, Door(), 'south')

        # Floor B
        connect(self.b_se, self.b_sw, Door(), 'west')
        connect(self.b_se, self.b_ne, Door(), 'north')
        connect(self.b_sw, self.b_nw, Door(), 'north')
        connect(self.b_ne, self.b_nw, Door(), 'west')

        connect(self.b_se, self.b_lounge, Door(), 'northwest')
        connect(self.b_sw, self.b_lounge, Door(), 'northeast')
        connect(self.b_nw, self.b_lounge, Door(), 'southeast')
        connect(self.b_ne, self.b_lounge, Door(), 'southwest')

        connect(self.b_sw, self.b_saal3, Door(), 'west')
        connect(self.b_nw, self.b_saal2, Door(), 'west')

        # Floor C
        connect(self.c_se, self.c_sw, Door(), 'west')
        connect(self.c_se, self.c_ne, Door(), 'north')
        connect(self.c_sw, self.c_nw, Door(), 'north')
        connect(self.c_ne, self.c_nw, Door(), 'west')

        connect(self.c_se, self.c_saal1, Door(), 'northwest')
        connect(self.c_sw, self.c_saal1, Door(), 'northeast')
        connect(self.c_nw, self.c_saal1, Door(), 'southeast')
        connect(self.c_ne, self.c_saal1, Door(), 'southwest')
        connect(self.c_sw, self.c_office, Door(), 'west')

        # Stairs
        connect(self.b_ne, self.a_hackcenter, Stairs(), 'northeast',
                'northeast')
        connect(self.b_se, self.c_se, Stairs(), 'southeast', 'southeast')
        connect(self.b_sw, self.c_sw, Stairs(), 'southwest', 'southwest')
        connect(self.b_nw, self.c_nw, Stairs(), 'northwest', 'northwest')

        self.update_shortcuts()
예제 #22
0
파일: core.py 프로젝트: NGL91/nms
class AppServer(object):
    def __init__(self, usr='******', pwd='123456a@', host='localhost', port=5672, vhost='vh1'):
        self.vhost = vhost
        creds = pika.PlainCredentials(username=usr, password=pwd)
        params = pika.ConnectionParameters(host=host, port=port, virtual_host=vhost, credentials=creds)
        self.is_waiting = False
        self.c = Caller()
        try:
            self.conn = pika.BlockingConnection(parameters=params)
            self.ch = self.conn.channel()
        except pika.exceptions.ProbableAccessDeniedError:
            logging.info("[AppServer] Connection error. Check configuration.")
            return None
        except:
            return None

        # declare a queue to reply
        res = self.ch.queue_declare(exclusive=True, queue='reply')
        self.reply_queue = res.method.queue # get the queue name
        self.ch.basic_consume(queue=self.reply_queue, consumer_callback=self.on_feedback, no_ack=True)
        logging.info("[AppServer] Done init ...")

    def on_feedback(self, ch, method, props, body):
        self.is_waiting = False
        logging.info("[AppServer] Received Corr_id: {0}".format(props.correlation_id))
        # logging.info(body)

        if props.correlation_id == self.corr_id:
            # call a function to insert result to db
            # format data 
            #self.vhost = self.vhost.decode('utf-8')
            body = body.decode('utf-8')
            body = json.loads(body)
            # begin inser
            toinsert = {'vhost': self.vhost, 'data': body}

            #c = Caller()

            self.c.insertIPS(coreconfig.CoreConfig.URL_POST_TRANSACTION, toinsert)
            #logging.info("The post data: {0}".format(toinsert))

            self.res = body
        return False #return false to signal to consume that you're done. other wise it continues to block

    def push(self, msg):
        """
        :param msg: list IP to ping
            msg = ['1.1.1.1', '2.2.2.2', '3.3.3.3', ]
            dumps -> encoder
            loads -> decoder
        :return:
        """
        try:
            self.corr_id = str(uuid.uuid4())
            self.res = None
            self._msg = json.dumps(msg)
            logging.info("[AppServer] Sent corr_id: {0}".format(self.corr_id))
            #logging.info("[x] Processing: {0}".format(self._msg))

            if not self.is_waiting:
                self.ch.basic_publish(
                    exchange='',
                    routing_key='default',
                    properties=pika.BasicProperties(
                        correlation_id=self.corr_id,
                        content_type='text/plain',
                        delivery_mode=2,
                        reply_to=self.reply_queue,
                    ),
                    body=self._msg,
                )
                logging.info("[AppServer] Done pushing ...")
            else:
                logging.info("[AppServer] Is waiting for the queue: {0}".format(self.is_waiting))
                pass

            # waiting
            while (self.res is None):
                self.is_waiting = True
                self.conn.process_data_events(time_limit=0)

            return self.res

        except Exception as e:
            logging.info("[AppServer] Exception while pushing message.")
            raise e
            return False
예제 #23
0
파일: core.py 프로젝트: NGL91/nms
 def __init__(self, vhost_data):
     Greenlet.__init__(self)
     self.vhost_data = vhost_data
     self.app1 = AppServer(usr=self.vhost_data['user'], pwd=self.vhost_data['password'], host=self.vhost_data['host'], port=self.vhost_data['port'], vhost=self.vhost_data['name'])
     self.c = Caller()
예제 #24
0
sys.path.append("./src")

from caller import Caller

if __name__ == '__main__':

    PARSER = argparse.ArgumentParser(description='Options to access micro service')

    PARSER.add_argument('--service', dest='service', help='service to access')
    PARSER.add_argument('--job', dest='job', help='job to report')
    PARSER.add_argument('--status', dest='status', help='job status to report')

    args = PARSER.parse_args()

    APP = Caller(verbose=1, serverip="localhost", port="8080")
    APP.set_verbose(1)
    APP.set_ip(serverip="localhost")
    APP.set_port(port="8080")

    if "create" in args.service:
        ROUTE = "create/" + str(args.job)
        APP.call(route=ROUTE, verb="POST", data=None)

    elif "delete" in args.service:
        ROUTE = "delete/" + str(args.job)
        APP.call(route=ROUTE, verb="DELETE", data=None)

    elif "search" in args.service:
        ROUTE = "search/" + str(args.job)
        APP.call(route=ROUTE, verb="GET", data=None)
예제 #25
0
 async def _init_caller(self):
     self.caller = Caller(settings.TWILIO_FROM_NUMBER,
                          settings.TWILIO_ACCOUNT_SID,
                          settings.TWILIO_AUTH_KEY)
예제 #26
0
#!/usr/bin/env python
# encoding: utf-8

import sys

from caller import Caller

if __name__ == "__main__":

    caller = Caller()
    while True:
        sys.stdout.write("Provide sip id: or q to exit")
        line = sys.stdin.readline().strip()
        if line == "q":
            break
        caller.call(line)
        sys.stdout.write("enter to end the call")
        sys.stdin.readline()
        caller.cancel_call()

    sys.exit(0)
예제 #27
0
 def setUp(self):
     self.c = Caller('from', 'sid', 'authkey')
예제 #28
0
class AppServer(object):
    def __init__(self,
                 usr='******',
                 pwd='123456a@',
                 host='localhost',
                 port=5672,
                 vhost='vh1'):
        self.vhost = vhost
        creds = pika.PlainCredentials(username=usr, password=pwd)
        params = pika.ConnectionParameters(host=host,
                                           port=port,
                                           virtual_host=vhost,
                                           credentials=creds)
        self.is_waiting = False
        self.c = Caller()
        try:
            self.conn = pika.BlockingConnection(parameters=params)
            self.ch = self.conn.channel()
        except pika.exceptions.ProbableAccessDeniedError:
            logging.info("[AppServer] Connection error. Check configuration.")
            return None
        except:
            return None

        # declare a queue to reply
        res = self.ch.queue_declare(exclusive=True, queue='reply')
        self.reply_queue = res.method.queue  # get the queue name
        self.ch.basic_consume(queue=self.reply_queue,
                              consumer_callback=self.on_feedback,
                              no_ack=True)
        logging.info("[AppServer] Done init ...")

    def on_feedback(self, ch, method, props, body):
        self.is_waiting = False
        logging.info("[AppServer] Received Corr_id: {0}".format(
            props.correlation_id))
        # logging.info(body)

        if props.correlation_id == self.corr_id:
            # call a function to insert result to db
            # format data
            #self.vhost = self.vhost.decode('utf-8')
            body = body.decode('utf-8')
            body = json.loads(body)
            # begin inser
            toinsert = {'vhost': self.vhost, 'data': body}

            #c = Caller()

            self.c.insertIPS(coreconfig.CoreConfig.URL_POST_TRANSACTION,
                             toinsert)
            #logging.info("The post data: {0}".format(toinsert))

            self.res = body
        return False  #return false to signal to consume that you're done. other wise it continues to block

    def push(self, msg):
        """
        :param msg: list IP to ping
            msg = ['1.1.1.1', '2.2.2.2', '3.3.3.3', ]
            dumps -> encoder
            loads -> decoder
        :return:
        """
        try:
            self.corr_id = str(uuid.uuid4())
            self.res = None
            self._msg = json.dumps(msg)
            logging.info("[AppServer] Sent corr_id: {0}".format(self.corr_id))
            #logging.info("[x] Processing: {0}".format(self._msg))

            if not self.is_waiting:
                self.ch.basic_publish(
                    exchange='',
                    routing_key='default',
                    properties=pika.BasicProperties(
                        correlation_id=self.corr_id,
                        content_type='text/plain',
                        delivery_mode=2,
                        reply_to=self.reply_queue,
                    ),
                    body=self._msg,
                )
                logging.info("[AppServer] Done pushing ...")
            else:
                logging.info(
                    "[AppServer] Is waiting for the queue: {0}".format(
                        self.is_waiting))
                pass

            # waiting
            while (self.res is None):
                self.is_waiting = True
                self.conn.process_data_events(time_limit=0)

            return self.res

        except Exception as e:
            logging.info("[AppServer] Exception while pushing message.")
            raise e
            return False
예제 #29
0
파일: broker.py 프로젝트: dosadih/broker
class Broker(object):
    """
    Broker object to control regression system
    along Gitlab push/issue/merge requests
    """

    def __init__(self, verbose=0):
        """
        Class constructor
        """
        self.verbose = verbose
        # Object to do dashboard call
        self.dashcall = DashboardCaller(verbose=1)
        # Object shared to do server calls
        self.servercall = Caller(verbose=1)
        self.config_file = None
        self.config = []

    def set_config_file(self, config):
        """
        Configuration file setter
        """
        self.config_file = config

    def setup(self):
        """
        Function to setup the server
        from configuration file
        """

        self.config = []
        tree = etree.parse(self.config_file)
        root = tree.getroot()
        
        # Read from xml configuration file all
        # the available resources
        for server in root.find("servers"):
            srv = {}
            srv["namespace"] = server.attrib['namespace']
            srv["version"] = server.attrib['version']
            srv["name"] = server.attrib['name']
            srv["ip"] = server.attrib['ip']
            srv["port"] = server.attrib['port']
            srv["type"] = server.attrib['type']
            srv["place"] = server.attrib['place']
            srv["vendor"] = server.attrib['vendor']
            srv["board"] = server.attrib['board']
            self.config.append(srv)
        
        # Configure the dashboard caller
        for server in self.config:
            if server["namespace"] == "dashboard":
                self.dashcall.setup(server)

        if self.verbose:
            print "info - broker.py - Configuration loaded:"
            for server in self.config:
                print server

    def filter_hooks(self):
        """
        Function to filter hooks and launch them
        after a mean time to avoid multiple useless runs
        """
        pass

    def get_dashboard(self):
        """
        Read all server status
        """
        return self.dashcall.read_dashboard()

    def get_dashboard_help(self):
        """
        Read all server status
        """
        return self.dashcall.read_help()

    def get_server_status(self):
        """
        Read all server status
        """
        status = []
        for server in self.config:
            stat = {}
            self.servercall = Caller()
            self.servercall.set_cfg(server)
            stat["status"] = self.servercall.call(route="status", verb="GET", data=None)
            stat["name"] = server.name["name"]
            status.append(stat)
        return status