class MemcacheStore(DictProxy): def __init__(self, host, port): from memcache import Client self.mc= Client(['%s:%s' % (host, port)]) def update(self, updates): for update in updates: (processId, data)= update self.mc.set(processId, data) def get(self, processId, default= None): data= self.mc.get(processId) if data == None: return default return data def pop(self, processId): data= self.mc.get(processId) self.mc.delete(processId) return data if data == None: return default def __len__(self): return int(self.mc.get_stats()[0][1].get('curr_items'))
def preset(sample): global addresses conn = Client([gethostname()+':11211']) if conn.get_stats()[0][1]['curr_items'] == 0: for k in addresses: conn.set(addr_prefix+k, 0)
def preset(sample): global addresses conn = Client([gethostname() + ':11211']) if conn.get_stats()[0][1]['curr_items'] == 0: for k in addresses: conn.set(addr_prefix + k, 0)
class MemcacheBackend(StorageBackend): def __init__(self, options, args): if not options.servers: raise Exception("memcache servers are required") self.servers = options.servers.split(",") self.open() @classmethod def parse_arguments(cls, optparse): optparse.add_option( "-m", "--servers", dest="servers", help="comma-separated list of memcached servers", metavar="SERVERS", default="localhost:11211", ) def _encode_key(self, key): return key.encode("base64").rstrip("\n") def _decode_key(self, key): return key.decode("base64") def _get(self, key, default=None): return self.mc.get(self._encode_key(key)) def _get_multi(self, keys): keys = map(self._encode_key, keys) ret = self.mc.get_multi(keys) return dict((self._decode_key(key), value) for (key, value) in ret.iteritems()) def _put(self, key, val): return self.mc.set(self._encode_key(key), val) def _put_multi(self, keys): keys = dict((self._encode_key(key), value) for (key, value) in keys.iteritems()) self.mc.set_multi(keys) def _delete(self, key): self.mc.delete(self._encode_key(key)) def close(self): if getattr(self, "mc", None): self.mc.disconnect_all() self.mc = None def open(self): self.close() self.mc = MemcacheClient(self.servers) def stats(self): return dict(self.mc.get_stats())
class MemcacheCli(cmd.Cmd, object): def __init__(self, host_list): super(MemcacheCli, self).__init__() self.memcache = Client( host_list) # Use our memcache library to initiate a connection self._check_connection( host_list ) # Make sure we actually have connections, since our library doesn't make this apparent self.prompt = '(memcache) ' # Time for some hardcore introspection and dynamic method creation for name in dir(self.memcache): # List our methods, ignoring private methods and ones that should be hidden to our CLI if not name.startswith('_') and not self._is_hidden(name): attr = getattr(self.memcache, name) if callable(attr): # Make sure we only keep callable methods, let's pin the doc strings to them while we are at it setattr(self.__class__, 'do_' + name, self._make_cmd(name)) doc = (getattr(attr, '__doc__') or '').strip() if doc: # Not everything has a docstring setattr(self.__class__, 'help_' + name, self._make_help(doc)) @staticmethod def _make_cmd(name): # Whats a little functional passing between friends? # This is our core factory for creating dynamic methods def _get_stats(self, line): try: # Rabbit Holes can get pretty deep, better to keep a lid on it pp = pprint.PrettyPrinter(depth=4) pp.pprint(self.memcache.get_stats(line)) except Exception, e: print_error(e) def handler(self, line): parts = line.split() try: # This is where the magic happens, get our function by name, pass the arguments, then pretty-print the results pprint.pprint(getattr(self.memcache, name)(*parts)) except Exception, e: print_error(e)
def stats(socket): client = Client([f'unix://{SOCKET_DIR}/{socket}']) stats = client.get_stats() if not stats: print(json.dumps({})) else: data = stats[0][1] data['hit_rate'] = "0" data['cache_rate'] = "0" # Calculate hit rate try: data['hit_rate'] = str( round(float(data['get_hits']) / float(data['cmd_get']) * 100)) data['cache_rate'] = str( round( float(data['bytes']) / float(data['limit_maxbytes']) * 100)) except ZeroDivisionError: pass print(json.dumps(data))
class MemcacheCli(cmd.Cmd, object): def __init__(self, host_list): super(MemcacheCli, self).__init__() self.memcache = Client(host_list) # Use our memcache library to initiate a connection self._check_connection(host_list) # Make sure we actually have connections, since our library doesn't make this apparent self.prompt = '(memcache) ' # Time for some hardcore introspection and dynamic method creation for name in dir(self.memcache): # List our methods, ignoring private methods and ones that should be hidden to our CLI if not name.startswith('_') and not self._is_hidden(name): attr = getattr(self.memcache, name) if callable(attr): # Make sure we only keep callable methods, let's pin the doc strings to them while we are at it setattr(self.__class__, 'do_' + name, self._make_cmd(name)) doc = (getattr(attr, '__doc__') or '').strip() if doc: # Not everything has a docstring setattr(self.__class__, 'help_' + name, self._make_help(doc)) @staticmethod def _make_cmd(name): # Whats a little functional passing between friends? # This is our core factory for creating dynamic methods def _get_stats(self, line): try: pp = pprint.PrettyPrinter(depth=4) pp.pprint(self.memcache.get_stats(line)) except Exception, e: print_error(e) def handler(self, line): parts = line.split() try: # This is where the magic happens, get our function by name, pass the arguments, then pretty-print the results pprint.pprint(getattr(self.memcache, name)(*parts)) except Exception, e: print_error(e)