Example #1
0
    def __init__(self, app):

        #
        # Setup the zmq socket used for receiving images.
        #
        self.zmq_factory = ZmqFactory()

        #
        # Socket for pushing images and crops to the automatic processing servers.
        #
        endpoint = ZmqEndpoint(
            'bind',
            'tcp://*:{zmq_port}'.format(zmq_port=gs.ZMQ_AUTO_WORKER_PUSH))
        self.push_socket = ZmqPushConnection(self.zmq_factory, endpoint)

        #
        # Socket for pulling results from the automatic processing servers.
        #
        endpoint = ZmqEndpoint(
            'bind',
            'tcp://*:{zmq_port}'.format(zmq_port=gs.ZMQ_AUTO_WORKER_PULL))
        self.pull_socket = ZmqPullConnection(self.zmq_factory, endpoint)
        self.pull_socket.onPull = self.handleNewMessage

        self.app = app
class BenchmarkWorker:

    def __init__(self,server,port,secret,requests,concurrency,username,password, verb=False,timeout=600,rate=1000):
        logname = "/tmp/trbctl-worker-{}.log".format(os.environ.get("LOGID",0))
        log.startLogging(open(logname,'w'))
        self.timeout = timeout
        self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/toughbt-message'))
        self.pusher.push("write worker %s log into %s" % (os.getpid(),logname))
        log.msg("init BenchmarkWorker pusher : %s " % repr(self.pusher))
        # define client cycle list
        raddict = dictionary.Dictionary(os.path.join(os.path.dirname(__file__),"dictionary"))
        new_cli = lambda : RadAuthClient(str(secret), raddict, server,port=port,debug=verb,stat_push=self.pusher)
        clis = itertools.cycle([new_cli() for c in range(concurrency)])

        # send radius message
        send = lambda:next(clis).sendAuth(**{'User-Name' : username,'User-Password':password})
        
        send_rate = 1.0/rate
        send_delay = send_rate
        for i in xrange(requests):
            reactor.callLater(send_delay,send)
            send_delay += send_rate

        reactor.callLater(self.timeout,self.on_timeout)



    def on_timeout(self):
        self.pusher.push("logger: BenchmarkWorker timeout, running times: %s" % self.timeout)
        reactor.stop()
Example #3
0
class RADIUSMaster(protocol.DatagramProtocol):
    """ 
     radius协议监听主进程, 本身不处理任何业务逻辑, 只做消息的路由与转发。
     auth_master 和 acct_master 可以以独立的进程来运行, 保证认证与记账业务互不影响。
     消息通过msgpack进行二进制封装转发, 保证性能和兼容性。
    """

    def __init__(self, config, service = 'auth'):
        self.config = config
        self.service = service
        self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_message']))
        self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_result']))
        self.puller.onPull = self.radiusReply
        logger.info('%s master message bind @ %s' % (self.service, self.pusher))
        logger.info('%s master result bind @ %s' % (self.service, self.puller))

    def datagramReceived(self, datagram, addr):
        host, port = addr
        logger.info('request from %s:%s' % (host, port))
        message = msgpack.packb([datagram, host, port])
        self.pusher.push(message)

    def radiusReply(self, result):
        data, host, port = msgpack.unpackb(result[0])
        self.transport.write(data, (host, int(port)))
class ZeroMQDelegatorService(Service):
    """
    This is an outbound PUSH connection to the web API ZeroMQRepeaterService
    that allows a worker to delegate any sub-links it finds (instead of taking
    a detour to crawl them on their own).
    """

    def __init__(self):
        self.conn = None

    def startService(self):
        factory = ZmqFactory()
        log.msg("Delegator connecting to repeater: %s" % ZMQ_REPEATER)
        endpoint = ZmqEndpoint('connect', ZMQ_REPEATER)
        self.conn = ZmqPushConnection(factory, endpoint)

    def send_message(self, message):
        """
        Matches the signature of ZeroMQBroadcastService so we can use them
        interchangably in the job queue code.

        :param str message: A JSON crawler message.
        """

        log.msg("Delegating job: %s" % message)
        self.conn.push(message)
Example #5
0
    def __init__(self, worker):

        log.msg("Initializing auto server")

        #
        # Setup the zmq socket used for receiving images.
        #
        self.zmq_factory = ZmqFactory()

        #
        # Socket for pulling images and crops from the automatic client.
        #
        endpoint = ZmqEndpoint(
            'connect', 'tcp://localhost:{zmq_port}'.format(
                zmq_port=gs.ZMQ_AUTO_WORKER_PUSH))
        self.pull_socket = ZmqPullConnection(self.zmq_factory, endpoint)
        self.pull_socket.onPull = self.handleNewMessage

        #
        # Socket for pushing results to the automatic client.
        #
        endpoint = ZmqEndpoint(
            'connect', 'tcp://localhost:{zmq_port}'.format(
                zmq_port=gs.ZMQ_AUTO_WORKER_PULL))
        self.push_socket = ZmqPushConnection(self.zmq_factory, endpoint)

        self.worker = worker
Example #6
0
 def __init__(self, config, dbengine, radcache=None):
     self.config = config
     self.dict = dictionary.Dictionary(
         os.path.join(os.path.dirname(toughradius.__file__),
                      'dictionarys/dictionary'))
     self.db_engine = dbengine or get_engine(config)
     self.mcache = radcache
     self.pusher = ZmqPushConnection(
         ZmqFactory(),
         ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-result'))
     self.stat_pusher = ZmqPushConnection(
         ZmqFactory(), ZmqEndpoint('connect',
                                   'ipc:///tmp/radiusd-stat-task'))
     self.puller = ZmqPullConnection(
         ZmqFactory(),
         ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-message'))
     self.puller.onPull = self.process
     logger.info("init acct worker pusher : %s " % (self.pusher))
     logger.info("init acct worker puller : %s " % (self.puller))
     logger.info("init auth stat pusher : %s " % (self.stat_pusher))
     self.acct_class = {
         STATUS_TYPE_START: RadiusAcctStart,
         STATUS_TYPE_STOP: RadiusAcctStop,
         STATUS_TYPE_UPDATE: RadiusAcctUpdate,
         STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
         STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff
     }
Example #7
0
class TwistedZmqClient(object):
    def __init__(self, service):
        zf = ZmqFactory()
        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))
        self.conn = ZmqPushConnection(zf, e)
        
    def send(self, clientid, levellist):
        self.conn.push(json.dumps({'clientid': clientid, 'levellist': levellist}))
Example #8
0
 def __init__(self, config, service = 'auth'):
     self.config = config
     self.service = service
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_message']))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_result']))
     self.puller.onPull = self.radiusReply
     logger.info('%s master message bind @ %s' % (self.service, self.pusher))
     logger.info('%s master result bind @ %s' % (self.service, self.puller))
Example #9
0
class TwistedZmqClient(object):
    def __init__(self, service):
        zf = ZmqFactory()
        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))
        self.conn = ZmqPushConnection(zf, e)
        
    def send(self, msg):
        self.conn.push(msg)
Example #10
0
	def add_push(self, endpoint):
		'''

		:param endpoint:
		:return:
		'''
		if endpoint:
			logger.debug("开始运行 PUSH 服务器,监听地址为:{}...".format(endpoint))
			self.push_ = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', endpoint))
Example #11
0
 def __init__(self, config, dbengine):
     self.config = config
     self.dict = dictionary.Dictionary(
         os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
     self.db_engine = dbengine or get_engine(config)
     self.aes = utils.AESCipher(key=self.config.system.secret)
     self.mcache = mcache.Mcache()
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-result'))
     self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-message'))
     self.puller.onPull = self.process
     logger.info("init auth worker pusher : %s " % (self.pusher))
     logger.info("init auth worker puller : %s " % (self.puller))
     logger.info("init auth stat pusher : %s " % (self.stat_pusher))
Example #12
0
class BenchmarkWorker:
    def __init__(self,
                 server,
                 port,
                 secret,
                 requests,
                 concurrency,
                 username,
                 password,
                 verb=False,
                 timeout=600,
                 rate=1000):
        logname = "/tmp/trbctl-worker-{}.log".format(os.environ.get(
            "LOGID", 0))
        log.startLogging(open(logname, 'w'))
        self.timeout = timeout
        self.pusher = ZmqPushConnection(
            ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/toughbt-message'))
        self.pusher.push("write worker %s log into %s" %
                         (os.getpid(), logname))
        log.msg("init BenchmarkWorker pusher : %s " % repr(self.pusher))
        # define client cycle list
        raddict = dictionary.Dictionary(
            os.path.join(os.path.dirname(__file__), "dictionary"))
        new_cli = lambda: RadAuthClient(str(secret),
                                        raddict,
                                        server,
                                        port=port,
                                        debug=verb,
                                        stat_push=self.pusher)
        clis = itertools.cycle([new_cli() for c in range(concurrency)])

        # send radius message
        send = lambda: next(clis).sendAuth(**{
            'User-Name': username,
            'User-Password': password
        })

        send_rate = 1.0 / rate
        send_delay = send_rate
        for i in xrange(requests):
            reactor.callLater(send_delay, send)
            send_delay += send_rate

        reactor.callLater(self.timeout, self.on_timeout)

    def on_timeout(self):
        self.pusher.push("logger: BenchmarkWorker timeout, running times: %s" %
                         self.timeout)
        reactor.stop()
Example #13
0
 def __init__(self, config, dbengine, radcache=None):
     self.config = config
     self.dict = dictionary.Dictionary(
         os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
     self.db_engine = dbengine or get_engine(config)
     self.aes = utils.AESCipher(key=self.config.system.secret)
     self.mcache = radcache
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-result'))
     self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-message'))
     self.puller.onPull = self.process
     reactor.listenUDP(0, self)
     logger.info("init auth worker pusher : %s " % (self.pusher))
     logger.info("init auth worker puller : %s " % (self.puller))
     logger.info("init auth stat pusher : %s " % (self.stat_pusher))
Example #14
0
    def __init__(self, zmq_notice_port, zmq_files_port, vn=None):

        self._loadSearchArea()

        #
        # Setup the zmq socket used for sending notice of images.
        #
        zmq_factory = ZmqFactory()
        endpoint = ZmqEndpoint('bind', 'tcp://*:{zmq_port}'.format(zmq_port=zmq_notice_port))
        self.zmq_socket = ZmqPushConnection(zmq_factory, endpoint)

        #
        # Setup the zmq socket used for sending the images.
        #
        endpoint = ZmqEndpoint('bind', 'tcp://*:{zmq_port}'.format(zmq_port=zmq_files_port))
        self.zmq_files_socket = ImageFileServerConnection(zmq_factory, endpoint, )

        #
        # Setup the zmq socket used for receiving detection results from the
        # jetson.
        #
        endpoint_rx = ZmqEndpoint('connect', 'tcp://{ip}:{port}'.format(ip=JETSON_IP, port=ADLC_RX_PORT))
        self.adlc_rx_socket = ZmqPullConnection(zmq_factory, endpoint_rx)
        self.adlc_rx_socket.onPull = self.handleADLCResults

        #
        # Flag that controls the sending the images
        #
        self._send_images = threading.Event()

        self.manual_crop_cnt = 0
        self.auto_crop_cnt = 0
        self._img_counter = 0
        self._adlc_count = 0
        self._received_image_count = 0

        self._vn = vn

        #
        # Start the upload thread.
        # Note:
        # I am using a separate thread for uploading in order to use an
        # upload queue. We had a problem where slow upload caused many upload
        # processes to start together and cause jamming in communication.
        #
        self.upload_queue = tQueue.Queue(0)
        self.upload_thread = thread.start_new_thread(upload_thread, (self.upload_queue,))
Example #15
0
 def __init__(self, config, dbengine, radcache = None):
     self.config = config
     self.load_plugins(load_types=['radius_auth_req', 'radius_accept'])
     self.dict = dictionary.Dictionary(os.path.join(os.path.dirname(taurusxradius.__file__), 'dictionarys/dictionary'))
     self.db_engine = dbengine or get_engine(config)
     self.aes = utils.AESCipher(key=self.config.system.secret)
     self.mcache = radcache
     self.reject_debug = int(self.get_param_value('radius_reject_debug', 0)) == 1
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['auth_result']))
     self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['task_connect']))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['auth_message']))
     self.puller.onPull = self.process
     logger.info('radius auth worker %s start' % os.getpid())
     logger.info('init auth worker pusher : %s ' % self.pusher)
     logger.info('init auth worker puller : %s ' % self.puller)
     logger.info('init auth stat pusher : %s ' % self.stat_pusher)
     self.license_ulimit = 50000
Example #16
0
 def __init__(self, config, service='auth'):
     self.config = config
     self.service = service
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/radiusd-%s-message' % service))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/radiusd-%s-result' % service))
     self.puller.onPull = self.reply
     logger.info("init %s master pusher : %s " % (self.service, self.pusher))
     logger.info("init %s master puller : %s " % (self.service, self.puller))
class ZeroMQBroadcastService(Service):
    """
    This is used by the HTTP API to hand crawl jobs off to the crawler pool.
    """

    def __init__(self):
        self.conn = None

    def startService(self):
        factory = ZmqFactory()
        bind_point = 'tcp://0.0.0.0:8050'
        log.msg("Broadcaster binding on: %s" % bind_point)
        endpoint = ZmqEndpoint('bind', bind_point)
        self.conn = ZmqPushConnection(factory, endpoint)

    def send_message(self, message):
        log.msg("Sent crawl announcement: %s" % message)
        self.conn.push(message)
Example #18
0
 def __init__(self, config, dbengine, radcache = None):
     self.config = config
     self.load_plugins(load_types=['radius_auth_req', 'radius_accept'])
     self.dict = dictionary.Dictionary(os.path.join(os.path.dirname(taurusxradius.__file__), 'dictionarys/dictionary'))
     self.db_engine = dbengine or get_engine(config)
     self.aes = utils.AESCipher(key=self.config.system.secret)
     self.mcache = radcache
     self.stat_pusher = ZmqPushConnection(ZmqFactory())
     self.zmqrep = ZmqREPConnection(ZmqFactory())
     self.stat_pusher.tcpKeepalive = 1
     self.zmqrep.tcpKeepalive = 1
     self.stat_pusher.addEndpoints([ZmqEndpoint('connect', config.mqproxy.task_connect)])
     self.zmqrep.addEndpoints([ZmqEndpoint('connect', config.mqproxy.auth_connect)])
     self.zmqrep.gotMessage = self.process
     self.reject_debug = int(self.get_param_value('radius_reject_debug', 0)) == 1
     logger.info('radius auth worker %s start' % os.getpid())
     logger.info('init auth worker : %s ' % self.zmqrep)
     logger.info('init auth stat pusher : %s ' % self.stat_pusher)
Example #19
0
def push_proxy_async(address):
    """


    :param address:
    :returns: PushProxyAsync
    """
    socket = ZmqPushConnection(ZmqFactory(), ZmqEndpoint("connect", address))
    return PushProxyAsync(socket)
Example #20
0
 def __init__(self, config, dbengine, radcache = None):
     self.config = config
     self.load_plugins(load_types=['radius_acct_req'])
     self.db_engine = dbengine or get_engine(config)
     self.mcache = radcache
     self.dict = dictionary.Dictionary(os.path.join(os.path.dirname(taurusxradius.__file__), 'dictionarys/dictionary'))
     self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['task_connect']))
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['acct_result']))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', config.mqproxy['acct_message']))
     self.puller.onPull = self.process
     self.acct_class = {STATUS_TYPE_START: RadiusAcctStart,
      STATUS_TYPE_STOP: RadiusAcctStop,
      STATUS_TYPE_UPDATE: RadiusAcctUpdate,
      STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
      STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff}
     logger.info('radius acct worker %s start' % os.getpid())
     logger.info('init acct worker pusher : %s ' % self.pusher)
     logger.info('init acct worker puller : %s ' % self.puller)
     logger.info('init acct stat pusher : %s ' % self.stat_pusher)
Example #21
0
 def __init__(self, config, dbengine):
     self.config = config
     self.dict = dictionary.Dictionary(
         os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
     self.db_engine = dbengine or get_engine(config)
     self.mcache = mcache.Mcache()
     self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-result'))
     self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
     self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-message'))
     self.puller.onPull = self.process
     logger.info("init acct worker pusher : %s " % (self.pusher))
     logger.info("init acct worker puller : %s " % (self.puller))
     logger.info("init auth stat pusher : %s " % (self.stat_pusher))
     self.acct_class = {
         STATUS_TYPE_START: RadiusAcctStart,
         STATUS_TYPE_STOP: RadiusAcctStop,
         STATUS_TYPE_UPDATE: RadiusAcctUpdate,
         STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
         STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff
     }
Example #22
0
 def __init__(self, gdata):
     self.gdata = gdata
     self.config = gdata.config
     self.que = deque() 
     self.cache = gdata.cache
     self.db_engine = gdata.db_engine
     self.metadata = models.get_metadata(self.db_engine)
     self.ops = {
         'radstart':self.start_session,
         'radstop':self.stop_session
     }
     self.radstart = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', self.config.mqproxy.radstart_connect))
     self.radstop = ZmqSubConnection(ZmqFactory(), ZmqEndpoint('connect',self.config.mqproxy.radstop_connect))
     self.radresp = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', self.config.mqproxy.radresp_connect))
     self.radstop.subscribe('radstop')
     self.radstop.gotMessage = self.subdataReceived
     self.radstart.onPull = self.dataReceived
     self.process_poll()
     logger.info("Start radstart %s" % self.radstart)
     logger.info("Start radstop %s" % self.radstop)
     logger.info("Start radresp %s" % self.radresp)
Example #23
0
    def onJoin(self, details):
        s = ZmqPullConnection(ZF, ZFE)
        ss = ZmqPushConnection(ZF, ZFE_SSL)

        def go_pull(sr):
            ss.push(sr)
            chan, sr = sr[0].split(' ', 1)
            sr = pickle.loads(sr)
            #print chan
            #print chan, sr['bdata_mode0']['updated']
            self.publish(chan, sr)

        s.onPull = go_pull
Example #24
0
class pushMode():
	'''
	zmq 推送者模型
	'''
	
	def __init__(self, endpoint):
		if endpoint:
			logger.debug("开始运行 PUSH 服务器,监听地址为:{}...".format(endpoint))
			self._push = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', endpoint))
		else:
			self._push = None
	
	def pushData(self, data):
		'''

        :param data:
        :return:
        '''
		if self._push:
			self._push.push(data)
		else:
			logger.error("Skipping, no pull consumers...")
Example #25
0
class AutoClient(object):
    """Handle the communication with the automatic detection servers."""
    def __init__(self, app):

        #
        # Setup the zmq socket used for receiving images.
        #
        self.zmq_factory = ZmqFactory()

        #
        # Socket for pushing images and crops to the automatic processing servers.
        #
        endpoint = ZmqEndpoint(
            'bind',
            'tcp://*:{zmq_port}'.format(zmq_port=gs.ZMQ_AUTO_WORKER_PUSH))
        self.push_socket = ZmqPushConnection(self.zmq_factory, endpoint)

        #
        # Socket for pulling results from the automatic processing servers.
        #
        endpoint = ZmqEndpoint(
            'bind',
            'tcp://*:{zmq_port}'.format(zmq_port=gs.ZMQ_AUTO_WORKER_PULL))
        self.pull_socket = ZmqPullConnection(self.zmq_factory, endpoint)
        self.pull_socket.onPull = self.handleNewMessage

        self.app = app

    def shutdown(self):
        """Shutdown the zmq connection."""

        self.zmq_factory.shutdown()

    def sendNewImage(self, img_path, data_path):
        """Send a new image (got from the primary ip) to the auto server"""

        data = [gs.RESIZED_IMAGE, img_path, data_path]

        try:
            log.msg("Sending of img {img}.".format(img=img_path))
            self.push_socket.push(data)
        except zmq.error.Again:
            log.msg("Skipping sending of {img}, no pull consumers...".format(
                img=img_path))

    def sendNewCrop(self, crop_path, yaw, lat, lon):
        """Send a new (auto) crop from the primary ip to the auto server."""

        data = [gs.AUTO_CROP, crop_path, yaw, lat, lon]

        try:
            log.msg("Sending of crop {crop}.".format(crop=crop_path))
            self.push_socket.push(data)
        except zmq.error.Again:
            log.msg(
                "Skipping sending of crop {crop}, no pull consumers...".format(
                    crop=crop_path))

    def handleNewMessage(self, new_data_message, ignore_tag=None):
        """Analyze the data received from the auto server."""

        try:
            data_type = new_data_message[0]

            if data_type == gs.CROP_REQUESTS:
                img_path, requested_crops = new_data_message[1], json.loads(
                    new_data_message[2])

                if len(requested_crops) == 0:
                    log.msg('No target candidates found for image {img_name}'.
                            format(img_name=os.path.split(img_path)[-1]))
                    return

                self.app.downloadCrops(img_path, requested_crops)

            elif data_type == gs.TARGET_DATA:
                crop_path, target_details = new_data_message[1], json.loads(
                    new_data_message[2])

                if target_details is {}:
                    log.msg('Crop {crop_name} not a target'.format(
                        crop_name=os.path.split(crop_path)[-1]))
                    return

                self.app.newTarget(crop_path, target_details)
            else:
                log.msg(
                    "Unkown data type received from auto server: {data_type}".
                    format(data_type=data_type))
        except Exception as e:
            log.err(e, 'handleNewMessage')
Example #26
0
	def __init__(self, endpoint):
		if endpoint:
			logger.debug("开始运行 PUSH 服务器,监听地址为:{}...".format(endpoint))
			self._push = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', endpoint))
		else:
			self._push = None
Example #27
0
class RADIUSAuthWorker(TraceMix):
    """ 认证子进程,处理认证授权逻辑,把结果推送个 radius 协议处理主进程
    """

    def __init__(self, config, dbengine, radcache = None):
        self.config = config
        self.load_plugins(load_types=['radius_auth_req', 'radius_accept'])
        self.dict = dictionary.Dictionary(os.path.join(os.path.dirname(taurusxradius.__file__), 'dictionarys/dictionary'))
        self.db_engine = dbengine or get_engine(config)
        self.aes = utils.AESCipher(key=self.config.system.secret)
        self.mcache = radcache
        self.stat_pusher = ZmqPushConnection(ZmqFactory())
        self.zmqrep = ZmqREPConnection(ZmqFactory())
        self.stat_pusher.tcpKeepalive = 1
        self.zmqrep.tcpKeepalive = 1
        self.stat_pusher.addEndpoints([ZmqEndpoint('connect', config.mqproxy.task_connect)])
        self.zmqrep.addEndpoints([ZmqEndpoint('connect', config.mqproxy.auth_connect)])
        self.zmqrep.gotMessage = self.process
        self.reject_debug = int(self.get_param_value('radius_reject_debug', 0)) == 1
        logger.info('radius auth worker %s start' % os.getpid())
        logger.info('init auth worker : %s ' % self.zmqrep)
        logger.info('init auth stat pusher : %s ' % self.stat_pusher)

    def get_account_bind_nas(self, account_number):

        def fetch_result():
            with self.db_engine.begin() as conn:
                sql = '\n                select bas.ip_addr \n                from tr_bas as bas,tr_customer as cus,tr_account as usr,tr_bas_node as bn\n                where cus.customer_id = usr.customer_id\n                    and cus.node_id = bn.node_id\n                    and bn.bas_id = bas.id\n                    and usr.account_number = :account_number\n                '
                cur = conn.execute(_sql(sql), account_number=account_number)
                ipaddrs = [ addr['ip_addr'] for addr in cur ]
                return ipaddrs

        return self.mcache.aget(account_bind_basip_key(account_number), fetch_result, expire=600)

    def do_stat(self, code):
        try:
            stat_msg = {'statattrs': [],
             'raddata': {}}
            if code == packet.AccessRequest:
                stat_msg['statattrs'].append('auth_req')
            elif code == packet.AccessAccept:
                stat_msg['statattrs'].append('auth_accept')
            elif code == packet.AccessReject:
                stat_msg['statattrs'].append('auth_reject')
            else:
                stat_msg['statattrs'] = ['auth_drop']
            self.stat_pusher.push(msgpack.packb(stat_msg))
        except:
            pass

    def process(self, msgid, message):
        datagram, host, port = msgpack.unpackb(message)
        reply = self.processAuth(datagram, host, port)
        if not reply:
            return
        if reply.code == packet.AccessReject:
            logger.error(u'[Radiusd] :: Send Radius Reject %s' % repr(reply), tag='radius_auth_reject')
        else:
            logger.info(u'[Radiusd] :: Send radius response: %s' % repr(reply))
        if self.config.system.debug:
            logger.debug(reply.format_str())
        self.zmqrep.reply(msgid, msgpack.packb([reply.ReplyPacket(), host, port]))
        self.do_stat(reply.code)

    def createAuthPacket(self, **kwargs):
        vendor_id = kwargs.pop('vendor_id', 0)
        auth_message = message.AuthMessage(**kwargs)
        auth_message.vendor_id = vendor_id
        for plugin in self.auth_req_plugins:
            auth_message = plugin.plugin_func(auth_message)

        return auth_message

    def freeReply(self, req):
        reply = req.CreateReply()
        reply.vendor_id = req.vendor_id
        reply['Reply-Message'] = 'user:%s auth success' % req.get_user_name()
        reply.code = packet.AccessAccept
        reply_attrs = {'attrs': {}}
        reply_attrs['input_rate'] = int(self.get_param_value('radius_free_input_rate', 1048576))
        reply_attrs['output_rate'] = int(self.get_param_value('radius_free_output_rate', 4194304))
        reply_attrs['rate_code'] = self.get_param_value('radius_free_rate_code', 'freerate')
        reply_attrs['domain'] = self.get_param_value('radius_free_domain', 'freedomain')
        reply_attrs['attrs']['Session-Timeout'] = int(self.get_param_value('radius_max_session_timeout', 86400))
        for plugin in self.auth_accept_plugins:
            reply = plugin.plugin_func(reply, reply_attrs)

        return reply

    def rejectReply(self, req, errmsg = ''):
        reply = req.CreateReply()
        reply.vendor_id = req.vendor_id
        reply['Reply-Message'] = errmsg
        reply.code = packet.AccessReject
        return reply

    def processAuth(self, datagram, host, port):
        try:
            bas = self.find_nas(host)
            if not bas:
                raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)
            secret, vendor_id = bas['bas_secret'], bas['vendor_id']
            req = self.createAuthPacket(packet=datagram, dict=self.dict, secret=six.b(str(secret)), vendor_id=vendor_id)
            username = req.get_user_name()
            bypass = int(self.get_param_value('radius_bypass', 1))
            if req.code != packet.AccessRequest:
                raise PacketError('non-AccessRequest packet on authentication socket')
            self.log_trace(host, port, req)
            self.do_stat(req.code)
            if self.config.system.debug:
                logger.debug('[Radiusd] :: Received radius request: %s' % req.format_str())
            else:
                logger.info('[Radiusd] :: Received radius request: %s' % repr(req))
            if bypass == 2:
                reply = self.freeReply(req)
                self.log_trace(host, port, req, reply)
                return reply
            if not self.user_exists(username):
                errmsg = u'[Radiusd] :: user:%s not exists' % username
                reply = self.rejectReply(req, errmsg)
                self.log_trace(host, port, req, reply)
                return reply
            bind_nas_list = self.get_account_bind_nas(username)
            if not bind_nas_list or host not in bind_nas_list:
                errmsg = u'[Radiusd] :: nas_addr:%s not bind for user:%s node' % (host, username)
                reply = self.rejectReply(req, errmsg)
                self.log_trace(host, port, req, reply)
                return reply
            aaa_request = dict(account_number=username, domain=req.get_domain(), macaddr=req.client_mac, nasaddr=req.get_nas_addr(), vlanid1=req.vlanid1, vlanid2=req.vlanid2, bypass=bypass, radreq=req)
            auth_resp = RadiusAuth(self.db_engine, self.mcache, self.aes, aaa_request).authorize()
            if auth_resp['code'] > 0:
                reply = self.rejectReply(req, auth_resp['msg'])
                self.log_trace(host, port, req, reply)
                return reply
            reply = req.CreateReply()
            reply.code = packet.AccessAccept
            reply.vendor_id = req.vendor_id
            reply['Reply-Message'] = 'user:%s auth success' % username
            reply_attrs = {}
            reply_attrs.update(auth_resp)
            reply_attrs.update(req.resp_attrs)
            for plugin in self.auth_accept_plugins:
                reply = plugin.plugin_func(reply, reply_attrs)
            if not req.VerifyReply(reply):
                raise PacketError('[Radiusd] :: user:%s auth verify reply error' % username)
            self.log_trace(host, port, req, reply)
            return reply
        except Exception as err:
            if not self.reject_debug:
                self.do_stat(0)
                logger.exception(err, tag='radius_auth_error')
            else:
                reply = self.rejectReply(req, repr(err))
                self.log_trace(host, port, req, reply)
                return reply
Example #28
0
class RadClientWorker(object):

    def __init__(self, gdata):
        self.gdata = gdata
        self.config = gdata.config
        self.que = deque() 
        self.cache = gdata.cache
        self.db_engine = gdata.db_engine
        self.metadata = models.get_metadata(self.db_engine)
        self.ops = {
            'radstart':self.start_session,
            'radstop':self.stop_session
        }
        self.radstart = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', self.config.mqproxy.radstart_connect))
        self.radstop = ZmqSubConnection(ZmqFactory(), ZmqEndpoint('connect',self.config.mqproxy.radstop_connect))
        self.radresp = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', self.config.mqproxy.radresp_connect))
        self.radstop.subscribe('radstop')
        self.radstop.gotMessage = self.subdataReceived
        self.radstart.onPull = self.dataReceived
        self.process_poll()
        logger.info("Start radstart %s" % self.radstart)
        logger.info("Start radstop %s" % self.radstop)
        logger.info("Start radresp %s" % self.radresp)


    def subdataReceived(self, request,tag):
        try:
            message = msgpack.unpackb(request)
            if self.config.system.debug:
                logger.debug(u"received radius start request:"+utils.safeunicode(message))
            self.que.appendleft(message)
        except:
            traceback.print_exc()

    def dataReceived(self, request):
        try:
            message = msgpack.unpackb(request[0])
            if self.config.system.debug:
                logger.debug(u"received radius start request:"+utils.safeunicode(message))
            self.que.appendleft(message)
        except:
            traceback.print_exc()

    def start_session(self,userdata):
        username = userdata['username']
        password = userdata['password']
        radius_ipaddr = userdata['radius_ipaddr']
        num = userdata.get("num",1)
        isresp = int(userdata.get("isresp",0))
        sendresp = lambda r : self.radresp.push(msgpack.packb(['radstart_resp',r])) if isresp else None
        senderror = lambda e: self.radresp.push(msgpack.packb(['radstart_error',dict(code=1,msg=repr(e))])) if isresp else None 
        for i in range(num):
            rad_session = RadiusSession(self.config,self.db_engine,
                statcache=self.gdata.statcache,radius_ipaddr=radius_ipaddr)
            rad_session.start(username,password).addCallbacks(sendresp,senderror)

    def stop_session(self,userdata):
        ipaddr = userdata.get('ipaddr','')
        session_id = userdata.get('session_id','')
        username = userdata.get('username','')
        RadiusSession.stop_session(ipaddr=ipaddr,session_id=session_id,username=username)
        self.radresp.push(msgpack.packb(['radstop_resp',dict(code=0,msg="session(%s,%s,%s) stop done"%(ipaddr,session_id,username))]))

    def process_poll(self):
        try:
            action, objdata = self.que.pop()
        except Exception as err:
            # logger.exception(err)
            reactor.callLater(1,self.process_poll)
        else:
            try:
                opfunc = self.ops.get(action)
                if opfunc:
                    opfunc(objdata)
                else:
                    logger.error('action %s not support'%action)
            except Exception as err:
                self.radresp.push(msgpack.packb(['%s_error'%action,dict(code=1,msg=repr(err))]))
                logger.exception(err)
            finally:
                reactor.callLater(0.001,self.process_poll)
Example #29
0
 def __init__(self):
     self.pusher = ZmqPushConnection(
         ZmqFactory(), ZmqEndpoint('bind', 'ipc:///tmp/tpsim-message'))
     self.logger.info('init TpSimMaster pusher : %s ' % self.pusher)
Example #30
0
def init(gdata):
    appname = os.path.basename(gdata.app_dir)
    utils.update_tz(gdata.config.system.tz)
    syslog = logger.Logger(gdata.config, appname)
    dispatch.register(syslog)
    log.startLoggingWithObserver(syslog.emit, setStdout=0)

    gdata.db_engine = get_engine(gdata.config)
    gdata.db = scoped_session(
        sessionmaker(bind=gdata.db_engine, autocommit=False, autoflush=False))
    # web 应用初始化
    gdata.settings = dict(
        cookie_secret="12oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
        login_url="/admin/login",
        template_path=os.path.join(os.path.dirname(__file__), "views"),
        static_path=os.path.join(os.path.dirname(__file__), "static"),
        xsrf_cookies=True,
        xheaders=True,
        conf=gdata.config)

    # 模板初始化
    gdata.tp_lookup = TemplateLookup(
        directories=[gdata.settings['template_path']],
        default_filters=['decode.utf8'],
        input_encoding='utf-8',
        output_encoding='utf-8',
        encoding_errors='ignore',
        module_directory="/tmp/toughcloud")

    gdata.redisconf = redis_conf(gdata.config)
    gdata.session_manager = session.SessionManager(
        gdata.redisconf, gdata.settings["cookie_secret"], 7200)
    gdata.cache = CacheManager(gdata.redisconf,
                               cache_name='Cache-%s' % os.getpid())
    gdata.aes = utils.AESCipher(key=gdata.config.system.secret)

    # 数据库备份器初始化
    gdata.db_backup = DBBackup(models.get_metadata(gdata.db_engine),
                               excludes=[])

    #cache event init
    dispatch.register(gdata.cache)

    # app handles init
    handler_dir = os.path.join(gdata.app_dir, 'handlers')
    load_handlers(handler_path=handler_dir,
                  pkg_prefix="%s.handlers" % appname,
                  excludes=[])
    gdata.all_handlers = permit.all_handlers

    # app event init
    event_dir = os.path.abspath(os.path.join(gdata.app_dir, 'events'))
    load_events(event_dir, "%s.events" % appname)

    # init zmq
    gdata.radque = deque([], 8192)
    gdata.radstart = ZmqPushConnection(
        ZmqFactory(), ZmqEndpoint('bind', gdata.config.mqproxy.radstart_bind))
    gdata.radstop = ZmqPubConnection(
        ZmqFactory(), ZmqEndpoint('bind', gdata.config.mqproxy.radstop_bind))
    gdata.radresp = ZmqPullConnection(
        ZmqFactory(), ZmqEndpoint('bind', gdata.config.mqproxy.radresp_bind))
    gdata.radresp.onPull = lambda m: gdata.radque.appendleft(
        msgpack.unpackb(m[0]))
    gdata.statcache = StatCounter(gdata)
    gdata.statcache.init()
    gdata.statcache.poll_calc()

    logger.info(gdata.radstart)
    logger.info(gdata.radstop)
    logger.info(gdata.radresp)
Example #31
0
class RADIUSAuthWorker(protocol.DatagramProtocol,TraceMix):

    def __init__(self, config, dbengine, radcache=None):
        self.config = config
        self.dict = dictionary.Dictionary(
            os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
        self.db_engine = dbengine or get_engine(config)
        self.aes = utils.AESCipher(key=self.config.system.secret)
        self.mcache = radcache
        self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-result'))
        self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
        self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-message'))
        self.puller.onPull = self.process
        reactor.listenUDP(0, self)
        logger.info("init auth worker pusher : %s " % (self.pusher))
        logger.info("init auth worker puller : %s " % (self.puller))
        logger.info("init auth stat pusher : %s " % (self.stat_pusher))

    def find_nas(self,ip_addr):
        def fetch_result():
            table = models.TrBas.__table__
            with self.db_engine.begin() as conn:
                return conn.execute(table.select().where(table.c.ip_addr==ip_addr)).first()
        return self.mcache.aget(bas_cache_key(ip_addr),fetch_result, expire=600)

    def do_stat(self,code):
        try:
            stat_msg = {'statattrs':[],'raddata':{}}
            if code == packet.AccessRequest:
                stat_msg['statattrs'].append('auth_req')
            elif code == packet.AccessAccept:
                stat_msg['statattrs'].append('auth_accept')
            elif  code == packet.AccessReject:
                stat_msg['statattrs'].append('auth_reject')
            else:
                stat_msg['statattrs'] = ['auth_drop']
            self.stat_pusher.push(msgpack.packb(stat_msg))
        except:
            pass

    def process(self, message):
        datagram, host, port =  msgpack.unpackb(message[0])
        reply = self.processAuth(datagram, host, port)
        if not reply:
            return
        logger.info("[Radiusd] :: Send radius response: %s" % repr(reply))
        if self.config.system.debug:
            logger.debug(reply.format_str())
        self.pusher.push(msgpack.packb([reply.ReplyPacket(),host,port]))
        # self.transport.write(reply.ReplyPacket(), (host,port))
        self.do_stat(reply.code)

    def createAuthPacket(self, **kwargs):
        vendor_id = kwargs.pop('vendor_id',0)
        auth_message = message.AuthMessage(**kwargs)
        auth_message.vendor_id = vendor_id
        auth_message = mac_parse.process(auth_message)
        auth_message = vlan_parse.process(auth_message)
        return auth_message

    def processAuth(self, datagram, host, port):
        try:
            bas = self.find_nas(host)
            if not bas:
                raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)

            secret, vendor_id = bas['bas_secret'], bas['vendor_id']
            req = self.createAuthPacket(packet=datagram, 
                dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)

            self.log_trace(host,port,req)

            self.do_stat(req.code)

            logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
            if self.config.system.debug:
                logger.debug(req.format_str())

            if req.code != packet.AccessRequest:
                raise PacketError('non-AccessRequest packet on authentication socket')

            reply = req.CreateReply()
            reply.vendor_id = req.vendor_id

            aaa_request = dict(
                account_number=req.get_user_name(),
                domain=req.get_domain(),
                macaddr=req.client_mac,
                nasaddr=req.get_nas_addr() or host,
                vlanid1=req.vlanid1,
                vlanid2=req.vlanid2
            )

            auth_resp = RadiusAuth(self.db_engine,self.mcache,self.aes,aaa_request).authorize()

            if auth_resp['code'] > 0:
                reply['Reply-Message'] = auth_resp['msg']
                reply.code = packet.AccessReject
                self.log_trace(host,port,req,reply)
                return reply

            if 'bypass' in auth_resp and int(auth_resp['bypass']) == 0:
                is_pwd_ok = True
                req.is_valid_pwd(auth_resp.get('passwd'))
            else:
                is_pwd_ok = req.is_valid_pwd(auth_resp.get('passwd'))

            if not is_pwd_ok:
                reply['Reply-Message'] =  "password not match"
                reply.code = packet.AccessReject
                self.log_trace(host,port,req,reply)
                return reply
            else:
                if u"input_rate" in auth_resp and u"output_rate" in auth_resp:
                    reply = rate_process.process(
                        reply, input_rate=auth_resp['input_rate'], output_rate=auth_resp['output_rate'])

                attrs = auth_resp.get("attrs") or {}
                for attr_name in attrs:
                    try:
                        # todo: May have a type matching problem
                        reply.AddAttribute(utils.safestr(attr_name), attrs[attr_name])
                    except Exception as err:
                        errstr = "RadiusError:current radius cannot support attribute {0},{1}".format(
                            attr_name,utils.safestr(err.message))
                        logger.error(RadiusError(err,errstr))

                for attr, attr_val in req.resp_attrs.iteritems():
                    reply[attr] = attr_val

            reply['Reply-Message'] = 'success!'
            reply.code = packet.AccessAccept
            if not req.VerifyReply(reply):
                raise PacketError('VerifyReply error')
            self.log_trace(host,port,req,reply)
            return reply
        except Exception as err:
            self.do_stat(0)
            logger.exception(err)
Example #32
0
class RADIUSAcctWorker(TraceMix):
    """ 记账子进程,处理计费逻辑,把结果推送个 radius 协议处理主进程,
    记账是异步处理的,即每次收到记账消息时,立即推送响应,然后在后台异步处理计费逻辑。
    """

    def __init__(self, config, dbengine, radcache = None):
        self.config = config
        self.load_plugins(load_types=['radius_acct_req'])
        self.db_engine = dbengine or get_engine(config)
        self.mcache = radcache
        self.dict = dictionary.Dictionary(os.path.join(os.path.dirname(taurusxradius.__file__), 'dictionarys/dictionary'))
        self.stat_pusher = ZmqPushConnection(ZmqFactory())
        self.zmqrep = ZmqREPConnection(ZmqFactory())
        self.stat_pusher.tcpKeepalive = 1
        self.zmqrep.tcpKeepalive = 1
        self.stat_pusher.addEndpoints([ZmqEndpoint('connect', config.mqproxy.task_connect)])
        self.zmqrep.addEndpoints([ZmqEndpoint('connect', config.mqproxy.acct_connect)])
        self.zmqrep.gotMessage = self.process
        self.acct_class = {STATUS_TYPE_START: RadiusAcctStart,
         STATUS_TYPE_STOP: RadiusAcctStop,
         STATUS_TYPE_UPDATE: RadiusAcctUpdate,
         STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
         STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff}
        logger.info('radius acct worker %s start' % os.getpid())
        logger.info('init acct worker : %s ' % self.zmqrep)
        logger.info('init acct stat pusher : %s ' % self.stat_pusher)

    def do_stat(self, code, status_type = 0, req = None):
        try:
            stat_msg = {'statattrs': ['acct_drop'],
             'raddata': {}}
            if code in (4, 5):
                stat_msg['statattrs'] = []
                if code == packet.AccountingRequest:
                    stat_msg['statattrs'].append('acct_req')
                elif code == packet.AccountingResponse:
                    stat_msg['statattrs'].append('acct_resp')
                if status_type == 1:
                    stat_msg['statattrs'].append('acct_start')
                elif status_type == 2:
                    stat_msg['statattrs'].append('acct_stop')
                elif status_type == 3:
                    stat_msg['statattrs'].append('acct_update')
                    stat_msg['raddata']['input_total'] = req.get_input_total()
                    stat_msg['raddata']['output_total'] = req.get_output_total()
                elif status_type == 7:
                    stat_msg['statattrs'].append('acct_on')
                elif status_type == 8:
                    stat_msg['statattrs'].append('acct_off')
            self.stat_pusher.push(msgpack.packb(stat_msg))
        except:
            pass

    def process(self, msgid, message):
        datagram, host, port = msgpack.unpackb(message)
        reply = self.processAcct(datagram, host, port)
        self.zmqrep.reply(msgid, msgpack.packb([reply.ReplyPacket(), host, port]))

    def createAcctPacket(self, **kwargs):
        vendor_id = kwargs.pop('vendor_id', 0)
        acct_message = message.AcctMessage(**kwargs)
        acct_message.vendor_id = vendor_id
        for plugin in self.acct_req_plugins:
            acct_message = plugin.plugin_func(acct_message)

        return acct_message

    def processAcct(self, datagram, host, port):
        try:
            bas = self.find_nas(host)
            if not bas:
                raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)
            secret, vendor_id = bas['bas_secret'], bas['vendor_id']
            req = self.createAcctPacket(packet=datagram, dict=self.dict, secret=six.b(str(secret)), vendor_id=vendor_id)
            self.log_trace(host, port, req)
            self.do_stat(req.code, req.get_acct_status_type(), req=req)
            if self.config.system.debug:
                logger.debug('[Radiusd] :: Received radius request: %s' % req.format_str())
            else:
                logger.info('[Radiusd] :: Received radius request: %s' % repr(req))
            if req.code != packet.AccountingRequest:
                raise PacketError('non-AccountingRequest packet on authentication socket')
            if not req.VerifyAcctRequest():
                raise PacketError('VerifyAcctRequest error')
            status_type = req.get_acct_status_type()
            if status_type in self.acct_class:
                ticket = req.get_ticket()
                if not ticket.get('nas_addr'):
                    ticket['nas_addr'] = host
                acct_func = self.acct_class[status_type](self.db_engine, self.mcache, None, ticket).acctounting
                reactor.callLater(0.05, acct_func)
            else:
                raise ValueError('status_type <%s> not support' % status_type)
            reply = req.CreateReply()
            reactor.callLater(0.05, self.log_trace, host, port, req, reply)
            reactor.callLater(0.05, self.do_stat, reply.code)
            if self.config.system.debug:
                logger.debug('[Radiusd] :: Send radius response: %s' % reply.format_str())
            else:
                logger.info('[Radiusd] :: Send radius response: %s' % repr(reply))
            return reply
        except Exception as err:
            self.do_stat(0)
            logger.exception(err, tag='radius_acct_drop')

        return
Example #33
0
class RADIUSAuthWorker(object):

    def __init__(self, config, dbengine):
        self.config = config
        self.dict = dictionary.Dictionary(
            os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
        self.db_engine = dbengine or get_engine(config)
        self.aes = utils.AESCipher(key=self.config.system.secret)
        self.mcache = mcache.Mcache()
        self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-result'))
        self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
        self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-auth-message'))
        self.puller.onPull = self.process
        logger.info("init auth worker pusher : %s " % (self.pusher))
        logger.info("init auth worker puller : %s " % (self.puller))
        logger.info("init auth stat pusher : %s " % (self.stat_pusher))

    def find_nas(self,ip_addr):
        def fetch_result():
            table = models.TrBas.__table__
            with self.db_engine.begin() as conn:
                return conn.execute(table.select().where(table.c.ip_addr==ip_addr)).first()
        return self.mcache.aget(bas_cache_key(ip_addr),fetch_result, expire=600)

    def do_stat(self,code):
        try:
            stat_msg = []
            if code == packet.AccessRequest:
                stat_msg.append('auth_req')
            elif code == packet.AccessAccept:
                stat_msg.append('auth_accept')
            elif  code == packet.AccessReject:
                stat_msg.append('auth_reject')
            else:
                stat_msg = ['auth_drop']
            self.stat_pusher.push(msgpack.packb(stat_msg))
        except:
            pass

    def process(self, message):
        datagram, host, port =  msgpack.unpackb(message[0])
        reply = self.processAuth(datagram, host, port)
        if not reply:
            return
        self.do_stat(reply.code)
        logger.info("[Radiusd] :: Send radius response: %s" % repr(reply))
        if self.config.system.debug:
            logger.debug(reply.format_str())
        self.pusher.push(msgpack.packb([reply.ReplyPacket(),host,port]))

    def createAuthPacket(self, **kwargs):
        vendor_id = kwargs.pop('vendor_id',0)
        auth_message = message.AuthMessage(**kwargs)
        auth_message.vendor_id = vendor_id
        auth_message = mac_parse.process(auth_message)
        auth_message = vlan_parse.process(auth_message)
        return auth_message

    def processAuth(self, datagram, host, port):
        try:
            bas = self.find_nas(host)
            if not bas:
                raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)

            secret, vendor_id = bas['bas_secret'], bas['vendor_id']
            req = self.createAuthPacket(packet=datagram, 
                dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)

            self.do_stat(req.code)

            logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
            if self.config.system.debug:
                logger.debug(req.format_str())

            if req.code != packet.AccessRequest:
                raise PacketError('non-AccessRequest packet on authentication socket')

            reply = req.CreateReply()
            reply.vendor_id = req.vendor_id

            aaa_request = dict(
                account_number=req.get_user_name(),
                domain=req.get_domain(),
                macaddr=req.client_mac,
                nasaddr=req.get_nas_addr(),
                vlanid1=req.vlanid1,
                vlanid2=req.vlanid2
            )

            auth_resp = RadiusAuth(self.db_engine,self.mcache,self.aes,aaa_request).authorize()

            if auth_resp['code'] > 0:
                reply['Reply-Message'] = auth_resp['msg']
                reply.code = packet.AccessReject
                return reply

            if 'bypass' in auth_resp and int(auth_resp['bypass']) == 0:
                is_pwd_ok = True
            else:
                is_pwd_ok = req.is_valid_pwd(auth_resp.get('passwd'))

            if not is_pwd_ok:
                reply['Reply-Message'] =  "password not match"
                reply.code = packet.AccessReject
                return reply
            else:
                if u"input_rate" in auth_resp and u"output_rate" in auth_resp:
                    reply = rate_process.process(
                        reply, input_rate=auth_resp['input_rate'], output_rate=auth_resp['output_rate'])

                attrs = auth_resp.get("attrs") or {}
                for attr_name in attrs:
                    try:
                        # todo: May have a type matching problem
                        reply.AddAttribute(utils.safestr(attr_name), attrs[attr_name])
                    except Exception as err:
                        errstr = "RadiusError:current radius cannot support attribute {0},{1}".format(
                            attr_name,utils.safestr(err.message))
                        logger.error(errstr)

                for attr, attr_val in req.resp_attrs.iteritems():
                    reply[attr] = attr_val

            reply['Reply-Message'] = 'success!'
            reply.code = packet.AccessAccept
            if not req.VerifyReply(reply):
                raise PacketError('VerifyReply error')
            return reply
        except Exception as err:
            self.do_stat(0)
            errstr = 'RadiusError:Dropping invalid auth packet from {0} {1},{2}'.format(
                host, port, utils.safeunicode(err))
            logger.error(errstr)
            import traceback
            traceback.print_exc()
Example #34
0
class RADIUSAcctWorker(object):

    def __init__(self, config, dbengine):
        self.config = config
        self.dict = dictionary.Dictionary(
            os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
        self.db_engine = dbengine or get_engine(config)
        self.mcache = mcache.Mcache()
        self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-result'))
        self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
        self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-message'))
        self.puller.onPull = self.process
        logger.info("init acct worker pusher : %s " % (self.pusher))
        logger.info("init acct worker puller : %s " % (self.puller))
        logger.info("init auth stat pusher : %s " % (self.stat_pusher))
        self.acct_class = {
            STATUS_TYPE_START: RadiusAcctStart,
            STATUS_TYPE_STOP: RadiusAcctStop,
            STATUS_TYPE_UPDATE: RadiusAcctUpdate,
            STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
            STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff
        }


    def find_nas(self,ip_addr):
        def fetch_result():
            table = models.TrBas.__table__
            with self.db_engine.begin() as conn:
                return conn.execute(table.select().where(table.c.ip_addr==ip_addr)).first()
        return self.mcache.aget(bas_cache_key(ip_addr),fetch_result, expire=600)

    def do_stat(self,code, status_type=0):
        try:
            stat_msg = ['acct_drop']
            if code  in (4,5):
                stat_msg = []
                if code == packet.AccountingRequest:
                    stat_msg.append('acct_req')
                elif code == packet.AccountingResponse:
                    stat_msg.append('acct_resp')

                if status_type == 1:
                    stat_msg.append('acct_start')
                elif status_type == 2:
                    stat_msg.append('acct_stop')        
                elif status_type == 3:
                    stat_msg.append('acct_update')        
                elif status_type == 7:
                    stat_msg.append('acct_on')        
                elif status_type == 8:
                    stat_msg.append('acct_off')
            self.stat_pusher.push(msgpack.packb(stat_msg))
        except:
            pass

    def process(self, message):
        datagram, host, port =  msgpack.unpackb(message[0])
        self.processAcct(datagram, host, port)
        
    def createAcctPacket(self, **kwargs):
        vendor_id = 0
        if 'vendor_id' in kwargs:
            vendor_id = kwargs.pop('vendor_id')
        acct_message = message.AcctMessage(**kwargs)
        acct_message.vendor_id = vendor_id
        acct_message = mac_parse.process(acct_message)
        acct_message = vlan_parse.process(acct_message)
        return acct_message

    def processAcct(self, datagram, host, port):
        try:
            bas = self.find_nas(host)
            if not bas:
                raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)

            secret, vendor_id = bas['bas_secret'], bas['vendor_id']
            req = self.createAcctPacket(packet=datagram, 
                dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)

            self.do_stat(req.code, req.get_acct_status_type())

            logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
            if self.config.system.debug:
                logger.debug(req.format_str())

            if req.code != packet.AccountingRequest:
                raise PacketError('non-AccountingRequest packet on authentication socket')

            if not req.VerifyAcctRequest():
                raise PacketError('VerifyAcctRequest error')

            reply = req.CreateReply()
            self.pusher.push(msgpack.packb([reply.ReplyPacket(),host,port]))
            self.do_stat(reply.code)
            logger.info("[Radiusd] :: Send radius response: %s" % repr(reply))
            if self.config.system.debug:
                logger.debug(reply.format_str())

            status_type = req.get_acct_status_type()
            if status_type in self.acct_class:
                acct_func = self.acct_class[status_type](
                        self.db_engine,self.mcache,None,req.get_ticket()).acctounting
                reactor.callLater(0.1,acct_func)
            else:
                logger.error('status_type <%s> not support' % status_type)
        except Exception as err:
            self.do_stat(0)
            errstr = 'RadiusError:Dropping invalid acct packet from {0} {1},{2}'.format(
                host, port, utils.safeunicode(err))
            logger.error(errstr)
            import traceback
            traceback.print_exc()
Example #35
0
class ImagesServer(object):
    """The main server of the airborne computer.

    Manages the camera and the communication with the ground computer and
    ADLC onboard computer.
    """

    def __init__(self, zmq_notice_port, zmq_files_port, vn=None):

        self._loadSearchArea()

        #
        # Setup the zmq socket used for sending notice of images.
        #
        zmq_factory = ZmqFactory()
        endpoint = ZmqEndpoint('bind', 'tcp://*:{zmq_port}'.format(zmq_port=zmq_notice_port))
        self.zmq_socket = ZmqPushConnection(zmq_factory, endpoint)

        #
        # Setup the zmq socket used for sending the images.
        #
        endpoint = ZmqEndpoint('bind', 'tcp://*:{zmq_port}'.format(zmq_port=zmq_files_port))
        self.zmq_files_socket = ImageFileServerConnection(zmq_factory, endpoint, )

        #
        # Setup the zmq socket used for receiving detection results from the
        # jetson.
        #
        endpoint_rx = ZmqEndpoint('connect', 'tcp://{ip}:{port}'.format(ip=JETSON_IP, port=ADLC_RX_PORT))
        self.adlc_rx_socket = ZmqPullConnection(zmq_factory, endpoint_rx)
        self.adlc_rx_socket.onPull = self.handleADLCResults

        #
        # Flag that controls the sending the images
        #
        self._send_images = threading.Event()

        self.manual_crop_cnt = 0
        self.auto_crop_cnt = 0
        self._img_counter = 0
        self._adlc_count = 0
        self._received_image_count = 0

        self._vn = vn

        #
        # Start the upload thread.
        # Note:
        # I am using a separate thread for uploading in order to use an
        # upload queue. We had a problem where slow upload caused many upload
        # processes to start together and cause jamming in communication.
        #
        self.upload_queue = tQueue.Queue(0)
        self.upload_thread = thread.start_new_thread(upload_thread, (self.upload_queue,))

    def __del__(self):
        self.upload_queue.put((None, None))

    def _loadSearchArea(self):
        self._search_area = None

        if not HAS_SHAPELY:
            return

        #
        # Load the search area.
        #
        try:
            data_path = pkg_resources.resource_filename('AUVSIairborne', 'resources/search_area.txt')

            coords = []
            with open(data_path, 'rb') as f:
                for line in f:
                    line = line.strip()
                    if line == '':
                        continue

                    coords.append(tuple(float(val) for val in line.split()))

            self._search_area = Polygon(coords).buffer(gs.SEARCH_AREA_BUFFER_DEG)
        except Exception as e:
            log.err(e, 'Failed to load search area data')

    def sendADLCImage(self, path, flight_data):
        """Send a new image to the ADLC onboard computer."""

        if ADLC_PROCESS_URL:
            self.upload_queue.put((path, flight_data))

    def handleADLCResults(self, message):
        """Handle the analysis result sent back from the ADLC onboard computer."""

        path, results = pickle.loads(message[0])
        try:

            message_data = message[0]

            #
            # Push the results down to the ground station.
            #
            data = [gs.AUTO_ANALYSIS, message_data]
            self.zmq_socket.push(data)
            log.msg(
                "Finished sending Jetson results for image: {path}, found {num} ROIS.".format(
                    path=path,
                    num=len(results)
                )
            )
        except zmq.error.Again:
            log.msg("Skipping sending of Jetson results, no pull consumers...")

    def handleNewImage(self, path, timestamp=None):
        """Handle a new image received from the camera."""

        current_time = datetime.now()
        if timestamp is not None:
            img_time = timestamp
        else:
            img_time = current_time

        #
        # Handle the new image
        #
        img_path, resized_img_path, flight_data = IM.processImg(path, current_time, img_time, self._vn)
        resized_img_name = os.path.split(resized_img_path)[-1]

        send_to_adlc = True

        if self._received_image_count < ADLC_TEST_IMAGE_COUNT:
            # Send without filtering
            pass
        elif self._search_area is not None and 'src_gps' in flight_data \
            and 'lat' in flight_data and 'lon' in flight_data and flight_data['src_gps'] is not None:
            lat = flight_data['lat'] * 1e-7
            lon = flight_data['lon'] * 1e-7
            send_to_adlc = self._search_area.contains(Point(lat, lon))

            if send_to_adlc:
                log.msg('Image is inside search area, sending to ADLC server')
            else:
                log.msg('Image is outside search area, skipping sending to ADLC server')

        self._received_image_count += 1

        if send_to_adlc:
            try:
                self.sendADLCImage(
                    img_path if AUVSIcv.global_settings.ADLC_SEND_FULLSIZE else resized_img_path,
                    flight_data
                )
            except:
                log.err("Failed to send image to ADLC server.")

        #
        # Send the new image and flight_data
        #
        if self._send_images.isSet():
            if self._img_counter == 0:
                resized_img_basename = os.path.splitext(resized_img_name)[0]
                log.msg("Sending notification for {img}...".format(img=resized_img_basename))
                data = [ gs.RESIZED_IMAGE, resized_img_basename ]

                try:
                    log.msg("Started sending of {img}.".format(img=resized_img_name))
                    self.zmq_socket.push(data)
                    log.msg("Finished sending of {img}.".format(img=resized_img_name))

                except zmq.error.Again:
                    log.msg("Skipping sending of {img}, no pull consumers...".format(img=resized_img_name))

            self._img_counter += 1

            if self._img_counter >= SAMPLE_IMAGE_COUNT:
                self._img_counter = 0

    def handleCrop(self, img_name, coords, yaw, lat, lon, crop_type):
        """Handle the request for a new crop"""

        #
        # Get the crop.
        #
        crop_img = IM.handleNewCrop(img_name, coords)

        #
        # Set paths
        #
        base_path = gs.CROPS_FOLDER
        random_str = str(uuid.uuid4()).split('-')[-1]
        if crop_type == gs.MANUAL_CROP:
            crop_name = 'manual_%03d_%s.jpg' % (self.manual_crop_cnt, random_str)
            self.manual_crop_cnt += 1
        else:
            crop_name = 'auto_%03d_%s.jpg' % (self.auto_crop_cnt, random_str)
            self.auto_crop_cnt += 1

        crop_path = os.path.join(base_path, crop_name)

        #
        # Save the crop
        #
        cv2.imwrite(crop_path, crop_img)

        #
        # Send the crop and its data.
        #
        with open(crop_path, 'rb') as f:
            data = [crop_type, img_name]+[str(c) for c in coords]+[yaw, lat, lon, os.path.split(crop_path)[-1], f.read()]

        try:
            self.zmq_socket.push(data)
            log.msg("Finished sending of crop {crop_name}.".format(crop_name=crop_name))

        except zmq.error.Again:
            log.msg("Skipping sending of crop {crop_name}, no pull consumers...".format(crop_name=crop_name))

    def sendImages(self, new_state):
        """Control the state of sending images to the ground station"""

        if new_state:
            log.msg("Start downloading images")
            self._send_images.set()
        else:
            log.msg("Stop downloading images")
            self._send_images.clear()

        self.sendDownloadState()

    def sendFlightData(self):
        """Send flight data (telemetry) to the ground station."""

        fds = []
        time = datetime.now()

        #
        # Get positioning from the vectornav.
        #
        if self._vn is not None:
            view = self._vn.getView()

            if view is not None:
                fds.append(view.dict)

        #
        # Get telemetry from the PixHawk.
        #
        try:
            fds.append(PH.queryPHdata(time.strftime(gs.BASE_TIMESTAMP)))
        except:
            pass

        if len(fds) == 0:
            return

        try:
            flight_data = IM.mergeFlightData(fds)
            flight_data['timestamp'] = time.strftime(gs.BASE_TIMESTAMP)
        except:
            return

        #
        # Send the data down to the ground station.
        #
        try:
            self.zmq_socket.push([gs.FLIGHT_DATA, json.dumps(flight_data)])
        except zmq.error.Again:
            pass


    def sendDownloadState(self):
        self.zmq_socket.push([gs.STATE, gs.STATE_DOWNLOAD, gs.STATE_ON if self._send_images.isSet() else gs.STATE_OFF])

    def sendCameraState(self, shooting):
        self.zmq_socket.push([gs.STATE, gs.STATE_SHOOT, gs.STATE_ON if shooting else gs.STATE_OFF])

    def sendState(self, shooting):
        self.sendDownloadState()
        self.sendCameraState(shooting)
Example #36
0
 def __init__(self, service):
     zf = ZmqFactory()
     e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))
     self.conn = ZmqPushConnection(zf, e)
Example #37
0
class ZMQfactory():
	
	def __init__(self):
		self.pub_ = None
		self.sub_ = None
		self.req_ = None
		self.rep_ = None
		self.push_ = None
		self.pull_ = None
		self.timeout = 0.95
	
	def set_timeout(self, timeout):
		self.timeout = timeout
	
	# pub sub 相关
	def add_pub(self, endpoint):
		if endpoint:
			logger.debug("开始运行 PUB 服务器,服务地址为:{}...".format(endpoint))
			self.pub_ = ZmqPubConnection(ZmqFactory(), ZmqEndpoint("bind", endpoint))
	
	def add_sub(self, endpoint):
		if endpoint:
			logger.debug("开始运行 SUB 客户端 , 连接的服务器地址为:{}...".format(endpoint))
			self.sub_ = ZmqSubConnection(ZmqFactory(), ZmqEndpoint("connect", endpoint))
			self.set_callback()
	
	def set_filter(self, filter_=None):
		'''
		请输入需要接受的主题(必须调用该函数,否则无法收到任何数据)
		:param filter_:  type str_list
		:return:
		'''
		if self.sub_:
			if filter_:
				for item in filter_:
					self.sub_.subscribe(item.encode())
			else:
				self.sub_.subscribe(b'')
		else:
			logger.error("请初始化SUB端口")
	
	def set_callback(self):
		if self.sub_:
			self.sub_.gotMessage = self.subscribeReceived
		else:
			logger.error("请初始化SUB端口")
	
	def subscribeReceived(self, *args):
		'''
		当接收到广播数据时,会触发该函数
		:param data:
		:return:
		'''
	
	def publishData(self, tag, data):
		'''
		从push服务器向外推送数据
		:param tag:
		:param data:
		:return:
		'''
	
	# req-rep 相关
	def add_req(self, endpoint):
		'''
		设置 req 对象
		:param endpoint:
		:return:
		'''
		if endpoint:
			logger.debug("开始运行 REQ 服务器,连接地址为:{}...".format(endpoint))
			self.req_ = ZmqREQConnection(ZmqFactory(), ZmqEndpoint('connect', endpoint))
	
	def add_rep(self, endpoint, callBack=onPrint):
		'''
		设置 rep 对象
		:param endpoint:
		:param callBack:
		:return:
		'''
		if endpoint:
			logger.debug("开始运行 REP 服务器,监听地址为:{}...".format(endpoint))
			self.rep_ = ZmqREPConnection(ZmqFactory(), ZmqEndpoint('bind', endpoint))
			self.rep_.gotMessage = callBack
	
	def sendReq(self, data, callBack=onPrint, errBack=onTimeout):
		'''
		发送 req 信息
		:param data:
		:param callBack:
		:param errBack:
		:return:
		'''
		try:
			d = self.req_.sendMsg(data, timeout=self.timeout)
			d.addCallback(callBack).addErrback(errBack)
		except Exception as e:
			logger.error(e)
	
	# push pull 相关
	def add_push(self, endpoint):
		'''

		:param endpoint:
		:return:
		'''
		if endpoint:
			logger.debug("开始运行 PUSH 服务器,监听地址为:{}...".format(endpoint))
			self.push_ = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', endpoint))
	
	def add_pull(self, endpoint, callBack=onPrint):
		'''

		:param endpoint:
		:param callBack:
		:return:
		'''
		if endpoint:
			logger.debug("开始运行 PULL 服务器,连接地址为:{}...".format(endpoint))
			self.pull_ = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', endpoint))
			self.pull_.onPull = callBack
	
	def pushData(self, data):
		'''

		:param data:
		:return:
		'''
		try:
			self.push_.push(data)
		except zmq.error.Again:
			logger.error("Skipping, no pull consumers...")
Example #38
0
class RADIUSAcctWorker(TraceMix):

    def __init__(self, config, dbengine,radcache=None):
        self.config = config
        self.dict = dictionary.Dictionary(
            os.path.join(os.path.dirname(toughradius.__file__), 'dictionarys/dictionary'))
        self.db_engine = dbengine or get_engine(config)
        self.mcache = radcache
        self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-result'))
        self.stat_pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-stat-task'))
        self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', 'ipc:///tmp/radiusd-acct-message'))
        self.puller.onPull = self.process
        logger.info("init acct worker pusher : %s " % (self.pusher))
        logger.info("init acct worker puller : %s " % (self.puller))
        logger.info("init auth stat pusher : %s " % (self.stat_pusher))
        self.acct_class = {
            STATUS_TYPE_START: RadiusAcctStart,
            STATUS_TYPE_STOP: RadiusAcctStop,
            STATUS_TYPE_UPDATE: RadiusAcctUpdate,
            STATUS_TYPE_ACCT_ON: RadiusAcctOnoff,
            STATUS_TYPE_ACCT_OFF: RadiusAcctOnoff
        }

    def find_nas(self,ip_addr):
        def fetch_result():
            table = models.TrBas.__table__
            with self.db_engine.begin() as conn:
                return conn.execute(table.select().where(table.c.ip_addr==ip_addr)).first()
        return self.mcache.aget(bas_cache_key(ip_addr),fetch_result, expire=600)

    def do_stat(self,code, status_type=0,req=None):
        try:
            stat_msg = {'statattrs':['acct_drop'],'raddata':{}}
            if code  in (4,5):
                stat_msg['statattrs'] = []
                if code == packet.AccountingRequest:
                    stat_msg['statattrs'].append('acct_req')
                elif code == packet.AccountingResponse:
                    stat_msg['statattrs'].append('acct_resp')

                if status_type == 1:
                    stat_msg['statattrs'].append('acct_start')
                elif status_type == 2:
                    stat_msg['statattrs'].append('acct_stop')        
                elif status_type == 3:
                    stat_msg['statattrs'].append('acct_update')   
                    stat_msg['raddata']['input_total'] = req.get_input_total()     
                    stat_msg['raddata']['output_total'] = req.get_output_total()     
                elif status_type == 7:
                    stat_msg['statattrs'].append('acct_on')        
                elif status_type == 8:
                    stat_msg['statattrs'].append('acct_off')

            self.stat_pusher.push(msgpack.packb(stat_msg))
        except:
            pass

    def process(self, message):
        datagram, host, port =  msgpack.unpackb(message[0])
        self.processAcct(datagram, host, port)
        
    def createAcctPacket(self, **kwargs):
        vendor_id = 0
        if 'vendor_id' in kwargs:
            vendor_id = kwargs.pop('vendor_id')
        acct_message = message.AcctMessage(**kwargs)
        acct_message.vendor_id = vendor_id
        acct_message = mac_parse.process(acct_message)
        acct_message = vlan_parse.process(acct_message)
        return acct_message

    def processAcct(self, datagram, host, port):
        try:
            bas = self.find_nas(host)
            if not bas:
                raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)

            secret, vendor_id = bas['bas_secret'], bas['vendor_id']
            req = self.createAcctPacket(packet=datagram, 
                dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)

            self.log_trace(host,port,req)
            self.do_stat(req.code, req.get_acct_status_type(),req=req)

            logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
            if self.config.system.debug:
                logger.debug(req.format_str())

            if req.code != packet.AccountingRequest:
                raise PacketError('non-AccountingRequest packet on authentication socket')

            if not req.VerifyAcctRequest():
                raise PacketError('VerifyAcctRequest error')

            reply = req.CreateReply()
            self.log_trace(host,port,req,reply)
            self.pusher.push(msgpack.packb([reply.ReplyPacket(),host,port]))
            self.do_stat(reply.code)
            logger.info("[Radiusd] :: Send radius response: %s" % repr(reply))
            if self.config.system.debug:
                logger.debug(reply.format_str())

            status_type = req.get_acct_status_type()
            if status_type in self.acct_class:
                ticket = req.get_ticket()
                if not ticket.get('nas_addr'):
                    ticket['nas_addr'] = host
                acct_func = self.acct_class[status_type](
                        self.db_engine,self.mcache,None,ticket).acctounting
                reactor.callLater(0.1,acct_func)
            else:
                logger.error('status_type <%s> not support' % status_type)
        except Exception as err:
            self.do_stat(0)
            logger.exception(error)
Example #39
0
class AutoServer(object):
    """Handle the communication of the automatic detection servers."""
    def __init__(self, worker):

        log.msg("Initializing auto server")

        #
        # Setup the zmq socket used for receiving images.
        #
        self.zmq_factory = ZmqFactory()

        #
        # Socket for pulling images and crops from the automatic client.
        #
        endpoint = ZmqEndpoint(
            'connect', 'tcp://localhost:{zmq_port}'.format(
                zmq_port=gs.ZMQ_AUTO_WORKER_PUSH))
        self.pull_socket = ZmqPullConnection(self.zmq_factory, endpoint)
        self.pull_socket.onPull = self.handleNewMessage

        #
        # Socket for pushing results to the automatic client.
        #
        endpoint = ZmqEndpoint(
            'connect', 'tcp://localhost:{zmq_port}'.format(
                zmq_port=gs.ZMQ_AUTO_WORKER_PULL))
        self.push_socket = ZmqPushConnection(self.zmq_factory, endpoint)

        self.worker = worker

    def shutdown(self):
        """Shutdown the zmq connection."""

        self.zmq_factory.shutdown()

    def requestCrops(self, img_path, crops):
        """Send a request from a worker to the auto client for crops."""

        data = [gs.CROP_REQUESTS, img_path, json.dumps(crops)]

        try:
            log.msg("Sending crop requests for img {img}: {crops}.".format(
                img=img_path, crops=crops))
            self.push_socket.push(data)
        except zmq.error.Again:
            log.msg("Failed sending crops request")

    def sendTarget(self, crop_path, target_details):
        """Send the details of a target (from a worker to the auto client)."""

        data = [gs.TARGET_DATA, crop_path, json.dumps(target_details)]

        try:
            log.msg("Sending of target in {crop}, with {data}.".format(
                crop=crop_path, data=data))
            self.push_socket.push(data)
        except zmq.error.Again:
            log.msg(
                "Skipping sending of crop {crop}, no pull consumers...".format(
                    crop=crop_path))

    def handleNewMessage(self, new_data_message, ignore_tag=None):
        """Analyze the data received from the auto client."""

        try:
            data_type = new_data_message[0]

            if data_type == gs.RESIZED_IMAGE:
                img_path, data_path = new_data_message[1:]

                crops = self.worker.processNewImage(img_path, data_path)
                self.requestCrops(img_path, crops)

            elif data_type == gs.AUTO_CROP:
                crop_path, yaw, lat, lon = new_data_message[1:]
                yaw = float(yaw)
                lat = float(lat)
                lon = float(lon)

                target_details = self.worker.processNewCrop(
                    crop_path, yaw, lat, lon)
                self.sendTarget(crop_path, target_details)
            else:
                log.msg(
                    "Unkown data type received from auto server: {data_type}".
                    format(data_type=data_type))
        except Exception as e:
            log.err(e, 'handleNewMessage')
 def startService(self):
     factory = ZmqFactory()
     bind_point = 'tcp://0.0.0.0:8050'
     log.msg("Broadcaster binding on: %s" % bind_point)
     endpoint = ZmqEndpoint('bind', bind_point)
     self.conn = ZmqPushConnection(factory, endpoint)
 def startService(self):
     factory = ZmqFactory()
     log.msg("Delegator connecting to repeater: %s" % ZMQ_REPEATER)
     endpoint = ZmqEndpoint('connect', ZMQ_REPEATER)
     self.conn = ZmqPushConnection(factory, endpoint)
Example #42
0
from txzmq import ZmqEndpoint, ZmqFactory, ZmqPushConnection, ZmqPullConnection


parser = OptionParser("")
parser.add_option("-m", "--method", dest="method", help="0MQ socket connection: bind|connect")
parser.add_option("-e", "--endpoint", dest="endpoint", help="0MQ Endpoint")
parser.add_option("-M", "--mode", dest="mode", help="Mode: push|pull")
parser.set_defaults(method="connect", endpoint="ipc:///tmp/txzmq-pc-demo")

(options, args) = parser.parse_args()

zf = ZmqFactory()
e = ZmqEndpoint(options.method, options.endpoint)

if options.mode == "push":
    s = ZmqPushConnection(zf, e)

    def produce():
        data = [str(time.time()), socket.gethostname()]
        print "producing %r" % data
        try:
            s.push(data)
        except zmq.error.Again:
            print "Skipping, no pull consumers..."

        reactor.callLater(1, produce)

    reactor.callWhenRunning(reactor.callLater, 1, produce)
else:
    s = ZmqPullConnection(zf, e)