示例#1
0
    def _recv(self):
        print "<%s> observe receive responses" % self.__class__.__name__

        responses = []
        for server in self.obs_keys.iterkeys():
            hdr = ''
            while len(hdr) < ObservePktFmt.OBS_RES_HDR_LEN:
                try:
                    hdr += self.conns[server].s.recv(ObservePktFmt.OBS_RES_HDR_LEN)
                except Exception as e:
                    print "<%s> failed to recv observe pkt: %s" % (self.__class__.__name__, e)
                    return None
            res = ObserveResponse()

            if not res.unpack_hdr(hdr):
                return None

            body = ''
            while len(body) < res.body_len:
                body += self.conns[server].s.recv(res.body_len)
            res.unpack_body(body)

            # TODO: error check

            self.save_latency_stats(res.persist_stat/1000)

            print "res::<%s>" % server
            print res
            responses.append(res)

        return responses
示例#2
0
    def _recv(self):

        responses = {}  # {server: [responses]}
        for server in self.obs_keys.iterkeys():
            hdr = ''
            while len(hdr) < ObservePktFmt.OBS_RES_HDR_LEN:
                try:
                    hdr += self.conns[server].s.recv(
                        ObservePktFmt.OBS_RES_HDR_LEN)
                except KeyError as e:
                    print "<%s> failed to recv observe pkt : %s" % (
                        self.__class__.__name__, e)
                    self._add_conn(server)
                    return None
                except Exception as e:
                    print "<%s> failed to recv observe pkt: %s" % (
                        self.__class__.__name__, e)
                    self._refresh_conns()
                    return None
            res = ObserveResponse()

            if not res.unpack_hdr(hdr):
                if res.status == ERR_NOT_MY_VBUCKET:
                    self._refresh_conns()
                return None

            body = ''
            while len(body) < res.body_len:
                body += self.conns[server].s.recv(res.body_len)
            res.unpack_body(body)

            # TODO: error check

            self.save_latency_stats(res.persist_stat / 1000)

            print "res::<%s>" % server
            print res
            vals = responses.get(server, [])
            vals.append(res)
            responses[server] = vals

        return responses
示例#3
0
    def _recv(self):

        responses = {}      # {server: [responses]}
        for server in self.obs_keys.iterkeys():
            hdr = ''
            while len(hdr) < ObservePktFmt.OBS_RES_HDR_LEN:
                try:
                    hdr += self.conns[server].s.recv(ObservePktFmt.OBS_RES_HDR_LEN)
                except KeyError as e:
                    print "<%s> failed to recv observe pkt : %s" % (self.__class__.__name__, e)
                    self._add_conn(server)
                    return None
                except Exception as e:
                    print "<%s> failed to recv observe pkt: %s" % (self.__class__.__name__, e)
                    self._refresh_conns()
                    return None
            res = ObserveResponse()

            if not res.unpack_hdr(hdr):
                if res.status == ERR_NOT_MY_VBUCKET:
                    self._refresh_conns()
                return None

            body = ''
            while len(body) < res.body_len:
                body += self.conns[server].s.recv(res.body_len)
            res.unpack_body(body)

            # TODO: error check

            self.save_latency_stats(res.persist_stat/1000)

            print "res::<%s>" % server
            print res
            vals = responses.get(server, [])
            vals.append(res)
            responses[server] = vals

        return responses
示例#4
0
    def observe_single(self, key, server="", timeout=0):
        """
        send an observe command and get the response back

        parse the response afterwards

        @return (status, cas)

        @status -1 : network error
        @status -2 : protocol error
        @status ObserveKeyState
        """
        cas = ""
        if not key:
            print "<%s> observe_single: invalid key" % self.__class__.__name__
            return -1

        vbucketid = \
            VbucketHelper.get_vbucket_id(key, self.cfg.get("vbuckets", 0))
        if not server:
            server = self._get_server_str(vbucketid)
        req_key = ObserveRequestKey(key, vbucketid)

        req = ObserveRequest([req_key])
        pkt = req.pack()

        try:
            skt = self.conns[server].s
        except KeyError:
            print "<%s> observe_single: KeyError: %s" \
                % (self.__class__.__name__, server)
            self._add_conn(server)
            return -1, cas

        try:
            SocketHelper.send_bytes(skt, pkt, timeout)
        except IOError:
            print "<%s> observe_single: IOError: " \
                  "failed to send observe pkt : %s" \
                  % (self.__class__.__name__, pkt)
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return -1, cas
        except socket.timeout:
            print "<%s> observe_single: timeout: " \
                "failed to send observe pkt : %s" \
                % (self.__class__.__name__, pkt)
            return -1, cas
        except Exception as e:
            print "<%s> observe_single: failed to send observe pkt : %s" \
                % (self.__class__.__name__, e)
            return -1, cas

        try:
            hdr = SocketHelper.recv_bytes(
                skt, ObservePktFmt.OBS_RES_HDR_LEN, timeout)
            res = ObserveResponse()
            if not res.unpack_hdr(hdr):
                if res.status == ERR_NOT_MY_VBUCKET:
                    self._refresh_conns()
                return -1, cas
            body = SocketHelper.recv_bytes(skt, res.body_len, timeout)
            res.unpack_body(body)
        except IOError:
            print "<%s> observe_single: IOError: failed to recv observe pkt" \
                % self.__class__.__name__
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return -1, cas
        except socket.timeout:
            print "<%s> observe_single: timeout: failed to recv observe pkt" \
                % self.__class__.__name__
            return -1, cas
        except Exception as e:
            print "<%s> observe_single: failed to recv observe pkt : %s" \
                % (self.__class__.__name__, e)
            return -1, cas

        if not res:
            print "<%s> observe_single: empty response" \
                % self.__class__.__name__
            return -1, cas

        key_len = len(res.keys)
        if key_len != 1:
            # we are not supposed to receive responses for more than one key,
            # otherwise, it's a server side protocol error
            print "<%s> observe_single: invalid number of keys in response: %d"\
                    % (self.s.__name__, key_len)
            return -2, cas

        res_key = res.keys[0]
        cas = res_key.cas

        if res_key.key != key:
            print "<%s> observe_single: invalid key %s in response"\
                % self.__class__.__name__
            return -2, cas

        return res_key.key_state, cas
示例#5
0
    def observe_single(self, key, timeout=0):
        """
        send an observe command and get the response back
        """
        if not key:
            print "<%s> observe_single: invalid key" % self.__class__.__name__
            return None

        vbucketid = VbucketHelper.get_vbucket_id(key,
                                                 self.cfg.get("vbuckets", 0))
        server = self._get_server_str(vbucketid)
        req_key = ObserveRequestKey(key, vbucketid)

        req = ObserveRequest([req_key])
        pkt = req.pack()

        try:
            skt = self.conns[server].s
        except KeyError:
            print "<%s> KeyError: %s" % (self.__class__.__name__, server)
            self._add_conn(server)
            return None

        try:
            SocketHelper.send_bytes(skt, pkt, timeout)
        except IOError:
            print "<%s> IOError: failed to send observe pkt : %s" \
                % (self.__class__.__name__, pkt)
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return None
        except socket.timeout:
            print "<%s> timeout: failed to send observe pkt : %s" \
                % (self.__class__.__name__, pkt)
            return None
        except Exception as e:
            print "<%s> failed to send observe pkt : %s" \
                % (self.__class__.__name__, e)
            return None

        try:
            hdr = SocketHelper.recv_bytes(skt, ObservePktFmt.OBS_RES_HDR_LEN,
                                          timeout)
            res = ObserveResponse()
            if not res.unpack_hdr(hdr):
                if res.status == ERR_NOT_MY_VBUCKET:
                    self._refresh_conns()
                return None
            body = SocketHelper.recv_bytes(skt, res.body_len, timeout)
            res.unpack_body(body)
        except IOError:
            print "<%s> IOError: failed to recv observe pkt" \
                % self.__class__.__name__
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return None
        except socket.timeout:
            print "<%s> timeout: failed to recv observe pkt" \
                % self.__class__.__name__
            return None
        except Exception as e:
            print "<%s> failed to recv observe pkt : %s" \
                % (self.__class__.__name__, e)
            return None

        return res
示例#6
0
    def observe_single(self, key, timeout=0):
        """
        send an observe command and get the response back
        """
        if not key:
            print "<%s> observe_single: invalid key" % self.__class__.__name__
            return None

        vbucketid = VbucketHelper.get_vbucket_id(key, self.cfg.get("vbuckets", 0))
        server = self._get_server_str(vbucketid)
        req_key = ObserveRequestKey(key, vbucketid)

        req = ObserveRequest([req_key])
        pkt = req.pack()

        try:
            skt = self.conns[server].s
        except KeyError:
            print "<%s> KeyError: %s" % (self.__class__.__name__, server)
            self._add_conn(server)
            return None

        try:
            SocketHelper.send_bytes(skt, pkt, timeout)
        except IOError:
            print "<%s> IOError: failed to send observe pkt : %s" \
                % (self.__class__.__name__, pkt)
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return None
        except socket.timeout:
            print "<%s> timeout: failed to send observe pkt : %s" \
                % (self.__class__.__name__, pkt)
            return None
        except Exception as e:
            print "<%s> failed to send observe pkt : %s" \
                % (self.__class__.__name__, e)
            return None

        try:
            hdr = SocketHelper.recv_bytes(skt, ObservePktFmt.OBS_RES_HDR_LEN, timeout)
            res = ObserveResponse()
            if not res.unpack_hdr(hdr):
                if res.status == ERR_NOT_MY_VBUCKET:
                    self._refresh_conns()
                return None
            body = SocketHelper.recv_bytes(skt, res.body_len, timeout)
            res.unpack_body(body)
        except IOError:
            print "<%s> IOError: failed to recv observe pkt" \
                % self.__class__.__name__
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return None
        except socket.timeout:
            print "<%s> timeout: failed to recv observe pkt" \
                % self.__class__.__name__
            return None
        except Exception as e:
            print "<%s> failed to recv observe pkt : %s" \
                % (self.__class__.__name__, e)
            return None

        return res
示例#7
0
    def observe_single(self, key, server="", timeout=0):
        """
        send an observe command and get the response back

        parse the response afterwards

        @return (status, cas)

        @status -1 : network error
        @status -2 : protocol error
        @status ObserveKeyState
        """
        cas = ""
        if not key:
            print "<%s> observe_single: invalid key" % self.__class__.__name__
            return -1

        vbucketid = \
            VbucketHelper.get_vbucket_id(key, self.cfg.get("vbuckets", 0))
        if not server:
            server = self._get_server_str(vbucketid)
        req_key = ObserveRequestKey(key, vbucketid)

        req = ObserveRequest([req_key])
        pkt = req.pack()

        try:
            skt = self.conns[server].s
        except KeyError:
            print "<%s> observe_single: KeyError: %s" \
                % (self.__class__.__name__, server)
            self._add_conn(server)
            return -1, cas

        try:
            SocketHelper.send_bytes(skt, pkt, timeout)
        except IOError:
            print "<%s> observe_single: IOError: " \
                  "failed to send observe pkt : %s" \
                  % (self.__class__.__name__, pkt)
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return -1, cas
        except socket.timeout:
            print "<%s> observe_single: timeout: " \
                "failed to send observe pkt : %s" \
                % (self.__class__.__name__, pkt)
            return -1, cas
        except Exception as e:
            print "<%s> observe_single: failed to send observe pkt : %s" \
                % (self.__class__.__name__, e)
            return -1, cas

        try:
            hdr = SocketHelper.recv_bytes(
                skt, ObservePktFmt.OBS_RES_HDR_LEN, timeout)
            res = ObserveResponse()
            if not res.unpack_hdr(hdr):
                if res.status == ERR_NOT_MY_VBUCKET:
                    self._refresh_conns()
                return -1, cas
            body = SocketHelper.recv_bytes(skt, res.body_len, timeout)
            res.unpack_body(body)
        except IOError:
            print "<%s> observe_single: IOError: failed to recv observe pkt" \
                % self.__class__.__name__
            self._reconnect(self.conns[server])
            self._refresh_conns()
            return -1, cas
        except socket.timeout:
            print "<%s> observe_single: timeout: failed to recv observe pkt" \
                % self.__class__.__name__
            return -1, cas
        except Exception as e:
            print "<%s> observe_single: failed to recv observe pkt : %s" \
                % (self.__class__.__name__, e)
            return -1, cas

        if not res:
            print "<%s> observe_single: empty response" \
                % self.__class__.__name__
            return -1, cas

        key_len = len(res.keys)
        if key_len != 1:
            # we are not supposed to receive responses for more than one key,
            # otherwise, it's a server side protocol error
            print "<%s> observe_single: invalid number of keys in response: %d"\
                    % (self.s.__name__, key_len)
            return -2, cas

        res_key = res.keys[0]
        cas = res_key.cas

        if res_key.key != key:
            print "<%s> observe_single: invalid key %s in response"\
                % self.__class__.__name__
            return -2, cas

        return res_key.key_state, cas