Beispiel #1
0
    def handleRequest(self, interest):
        length = len(self.service_prefix)

        iname = str(interest.name)
        assert(iname.startswith(self.service_prefix))

        args = iname[length:].split('/')

        if args[0] == 'handshake':
            return self.doHandshake(args, interest)
        elif args[0] == 'auth':
            log.debug("'auth' interest received {}".format(args))
            return self.doAuth(args, interest)
        elif len(args) == 3:
            log.debug("interest received {}".format(args))
            (sid, seq, data) = tuple(args)
            seq = int(seq)
            s = self.getSessionItem(sid)
            if not s:
                log.warn("session not found")
                return self.buildResponse(interest, seq, statuscode.STATUS_AUTH_ERROR, '')
            if s.seq+1 != seq:
                log.error("sequence number error, {} expected, but {} received".format(s.seq+1, seq))
                return None
            else:
                s.seq += 1

            try:
                result, status = self.OnDataRecv(s.session_decrypt_data(data))
                return self.buildResponse(interest, seq, status, s.session_encrypt_data(result))
            except Exception, e:
                log.error(e)

            return self.buildResponse(interest, seq, statuscode.STATUS_INTERNAL_ERROR, '')
Beispiel #2
0
    def Connect(self, timeout):
        """Shake hand and authorize with server (may block)"""
        self.connect_timeout = timeout
        auth = security.Auth()
        if self.state != STATE_NOT_AUTH:
            raise ValueError
        log.debug('Connecting to %s' % self.name_prefix)
        self.auth_cond.acquire()
        self._auth_result = None
        self.ndn_interface.send(self.name_prefix + '/auth/{}'.format(hex(auth.getDHKey())), timeout, 0)
        self.auth_cond.wait(timeout)
        self.auth_cond.release()

        if not self._auth_result:
            raise RMSAuthException('Authorization timed out')

        try:
            data = json.loads(self._auth_result)

            auth.setOtherDHKey(long(data['randS'], 0))
            auth.decryptPreMasterKey(unhexlify(data['preMaster']), self.pemFile)
            self.cipher = security.AESCipher(auth.genMasterKey())
            
            self.session_id = data['session']
            self.state = STATE_IDLE
            log.debug('Connected')
        except Exception, e:
            log.error(e)
            raise RMSAuthException('Illegal authorization response received')
Beispiel #3
0
    def PublishFiles(self, hosts, name, flaskFileUp):
        key = 'something fun'
        filename = hashlib.md5(name).hexdigest()+'.upload'
        log.debug('args: {} {}'.format(name, filename))
        flaskFileUp.save(os.path.join(self.tmp_dir, filename))

        self.thread.publish(hosts, name, self.tmp_naming+'/'+filename, key)
Beispiel #4
0
 def name2filepath(self, name):
     #TODO: restrict file in ndnflow_dir
     while name.startswith('/'):
         name = name[1:]
     p = os.path.join(self.ndnflow_dir, name)
     log.debug('name:{} path:{}'.format(name, p))
     return p
Beispiel #5
0
    def ReConnect(self, timeout):
        log.debug('Reconnecting to %s' % self.name_prefix)
        self.state = STATE_NOT_AUTH
        self.session_id = ''
        self.seq = 0
        self.cipher = None

        self.Connect(timeout)
Beispiel #6
0
 def Start(self):
     # self.thread = _thread()
     # self.thread.start()
     
     log.info('Starting...')
     log.debug('Trying to connect servers')
     for x in self.clients:
         self.doConnect(x)
     CmdLineBackend._monitor(self.clients).start()
Beispiel #7
0
 def DeleteFile(self, name):
     obj = {
         'op': 'delete',
         'name': name
     }
     self.send_cmd(obj)
     status, content = self.Recv(self.cmd_timeout)
     log.debug('status:{} content:{}'.format(status, content))
     return status == statuscode.STATUS_OK
Beispiel #8
0
 def mark_uploading(self, name, b):
     self.uploading_mutex.acquire()
     try:
         if b:
             log.debug('set uploading mark %s' % name)
             self.uploading_set.add(name)
         else:
             log.debug('remove uploading mark %s' % name)
             self.uploading_set.remove(name)
     except Exception, e:
         log.error(e)
Beispiel #9
0
 def SendFile(self, name, remotename, key):
     obj = {
         'op': 'send',
         'name': name,
         'remotename': remotename,
         'key': key
     }
     self.send_cmd(obj)
     status, content = self.Recv(self.cmd_timeout)
     log.debug('status:{} content:{}'.format(status, content))
     return status == statuscode.STATUS_OK
Beispiel #10
0
def api_content_del(hosts, name):
    name = unhexlify(name)
    hosts = hosts.split(',')

    # ask hosts to delete file
    hosts = filter(lambda h:backend_content.DeleteFiles(h,name), hosts)
    log.debug("successfully deleted {}: {}".format(name,hosts))

    with closing(connect_db()) as db:
        placeholders = ','.join('?'*len(hosts))
        sql = 'DELETE FROM content WHERE id IN (SELECT content.id FROM content JOIN hosts ON (hosts.id = content.host_id) WHERE hosts.name IN (%s) AND content.name=?)' % placeholders
        hosts.append(name)
        db.execute(sql, hosts)
        db.commit()
        return '{"error": 0}'
Beispiel #11
0
    def _recv_thread(self):
        while True:
            try:
                item = self.recv_queue.get()
            except Exception, e:
                log.error(e)
                continue

            if self.state == STATE_NOT_AUTH:
                #handle auth response
                if item.status == QueueItem.STATUS_TIME_OUT:
                    self._auth_timed_out()
                else:
                    self._auth_response(item.content)
                continue

            if item.status == QueueItem.STATUS_TIME_OUT:
                log.info("send timed out %s" % item.name)
                self.state = STATE_IDLE
                continue

            if self.state != STATE_WAIT_RECV:
                log.warn('content received in a wrong state %d'%self.state)
                continue

            if item.status in [QueueItem.STATUS_BAD, QueueItem.STATUS_UNVERIFIED]:
                log.warn('got bad content')
                self.state = STATE_IDLE
            elif item.status == QueueItem.STATUS_OK:
                log.debug('got content')
                try:
                    (seq, status, content) = self._decode_response(item.content)
                    if int(status) == common.statuscode.STATUS_AUTH_ERROR:
                        log.warn("session expired")
                        self.ReConnect(self.connect_timeout or 10.0)
                        raise RMSAuthException #quit normal receiving procedure
                    seq = int(seq)
                    content = self._decrypt(content)
                    log.debug("content: %s" %(content))
                except RMSAuthException:
                    pass
                except Exception, e:
                    log.error("unable to decode content, %s" % e)
                except:
Beispiel #12
0
    def CheckFileState(self, name):
        obj = {
            'op': 'send',
            'name': name
        }
        self.send_cmd(obj)
        status, content = self.Recv(self.cmd_timeout)
        log.debug('status:{} content:{}'.format(status, content))
        if status != statuscode.STATUS_OK:
            return rmsContentClient.QUERY_FAILED

        if content == 'exist':
            return rmsContentClient.FILE_EXIST
        elif content == 'upload':
            return rmsContentClient.FILE_UPLOADING
        elif content == 'notfount':
            return rmsContentClient.FILE_NOT_FOUND
        else:
            log.debug('invalid response: {}'.format(content))
            return rmsContentClient.QUERY_FAILED
Beispiel #13
0
        self.daemon = True
        self.hostname = hostname

    def run(self):
        with open('common/testkey.pub') as f:
            s = service.SystemService(self.hostname, f.read())
        s.start()

class content_service_thread(threading.Thread):
    def __init__(self, hostname):
        super(content_service_thread, self).__init__()
        self.daemon = True
        self.hostname = hostname

    def run(self):
        with open('common/testkey.pub') as f:
            s = service.ContentService(self.hostname, f.read())
        s.start()

if __name__ == "__main__":
    signal.signal(signal.SIGHUP, signal.SIG_IGN)
    h = get_host()
    cmd_service_thread(h).start()
    sys_service_thread(h).start()
    content_service_thread(h).start()
    log.debug("RMS server started!")
    signal.signal(signal.SIGINT, signal_handler)

    import time
    while True:
        time.sleep(1)
Beispiel #14
0
 def publish(self, target, name, remote, key):
     log.debug('publish %s from %s' % (name, remote))
     for h in target:
         idx = self.hosts.index(h)
         self.clients[idx].SendFile(name, remote, key)
Beispiel #15
0
                        info['alive'], info['delay'] = x.Ping()
                    except Exception, e:
                        log.error(e)

                    try:
                        self.mutex.acquire()
                        self.host_status[self.hosts[i]] = info
                    except Exception, e:
                        log.error(e)
                    finally:
                        try:
                            self.mutex.release()
                        except Exception, e:
                            pass

                log.debug("Monitor result: {}".format(self.host_status))
                time.sleep(webconfig.MOD_SYS_MONITOR_INTERVAL)

        def getHostStatus(self, h):
            s = None
            try:
                self.mutex.acquire()
                s = copy(self.host_status[h])
            except Exception, e:
                log.error(e)
            finally:
                try:
                    self.mutex.release()
                except Exception, e:
                    pass
            return s