def __init__(self, hostname=cache_server_host, port=cache_server_port): self.server = Client((hostname, port))
def connect_cache(): return Client('cache') # Docker DNS routes 'cache' -> memcache
import mrpacker from pymemcache.client.base import Client c = Client(('localhost', 11211)) c.set("mrsession43709dd361cc443e976b05714581a7fb", mrpacker.pack({"user": "******"})) c = Client(('localhost', 11212)) c.set("mrsession43709dd361cc443e976b05714581a7fb", mrpacker.pack({"user": "******"})) #print( c.get("mrsessionZZZZ9dd361cc443e976b05714581a7fb")) import asyncmrcache, asyncio def lcb(client): print("Lost conn") async def run(loop): rc = await asyncmrcache.create_client([("localhost", 7000)], loop, lost_cb=lcb) await rc.set(b"mrsession43709dd361cc443e976b05714581a7fb", mrpacker.pack({"user": "******"})) print(await rc.get(b"mrsession43709dd361cc443e976b05714581a7fb")) exit() loop = asyncio.get_event_loop() loop.run_until_complete(run(loop))
def _cache_client(self): client = Client((self.host, self.port), self.kwargs) return client
#!/usr/bin/python3 from pymemcache.client.base import Client client = Client(('localhost', 8888)) client.set('some_key', 'some_value') result = client.get('some_key') print(result)
import os import json from benwaonlineapi.config import app_config from pymemcache.client.base import Client cfg = app_config[os.getenv('FLASK_CONFIG')] def json_serializer(key, value): if type(value) == str: return value, 1 return json.dumps(value), 2 def json_deserializer(key, value, flags): if flags == 1: return value.decode('utf-8') if flags == 2: return json.loads(value.decode('utf-8')) raise Exception("Unknown serialization format") cache = Client((cfg.MEMCACHED_HOST, cfg.MEMCACHED_PORT), connect_timeout=5, serializer=json_serializer, deserializer=json_deserializer)
def main(): client = Client(('localhost', 11211)) client.set('key', 'value') result = client.get('key') print("Got value: {}".format(result))
def make_client(self, values): client = Client(None) client.sock = MockSocket(list(values)) return client
def make_client(self, mock_socket_values, **kwargs): mock_client = Client(None, **kwargs) mock_client.sock = MockSocket(list(mock_socket_values)) client = PooledClient(None, **kwargs) client.client_pool = pool.ObjectPool(lambda: mock_client) return client
parser.add_argument( "--memcache-port", help="Memcache port, by default 11211", default=11211, ) parser.add_argument( "--concurrency", help="Number of concurrency clients, by default 32", type=int, default=32, ) parser.add_argument( "--duration", help="Test duration in seconds, by default 60", type=int, default=60, ) args = parser.parse_args() client = Client( #(args.memcache_address, args.memcache_port), ('localhost', 11211), #max_pool_size=args.concurrency ) benchmark("SET", cmd_set, MAX_NUMBER_OF_KEYS, client, args.concurrency, args.duration) benchmark("GET", cmd_set, MAX_NUMBER_OF_KEYS, client, args.concurrency, args.duration)
def make_client(self, mock_socket_values, **kwargs): client = Client(None, key_prefix=b'xyz:', **kwargs) client.sock = MockSocket(list(mock_socket_values)) return client
def test_set_get(self): client = Client(('localhost', 11211)) client.set('some_key', 'some_value') result = client.get('some_key') self.assertEqual(result, 'some_value')
def test_delete(self): client = Client(('localhost', 11212)) client.set('some_key', 'some_value') client.delete('some_key') result = client.get('some_key') self.assertEqual(result, None)
def __init__(self): # instantiate the memchached client with the HOST and PORT self.__client = Client((settings.HOST, settings.PORT), serializer=json_serializer, deserializer=json_deserializer)
from pymemcache.client.base import Client import pickle import binascii def retrieve3(key): result = client.get_multi(['%s-%s' % (key, i) for i in xrange(32)]) serialized = '' for i in range(25): serialized = serialized + result[key + '-' + str(i)] return pickle.loads(binascii.unhexlify(serialized)) client = Client(('localhost', 11211)) print retrieve3("flag3")
def __getClient(): return Client(('localhost', 11211), serializer=Cache.json_serializer, deserializer=Cache.json_deserializer)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from pymemcache.client.base import Client from pprintpp import pprint import socket host = socket.gethostbyname("localhost") # setup Memcached client running under 11211 port on localhost client = Client((host, 11211)) pprint(type(client)) # cache some value under some key and expire it after 10 seconds try: client.set('some_key', 'some_value', expire=10) except ConnectionRefusedError as ex: print("ConnectionRefusedError: {0}".format(ex)) except Exception as ex: print("Exception: {0}".format(ex)) # retrieve value for the same key result = client.get('some_key') pprint(result)
def setup(self): self.client = Client((self.memc_params['host'], self.memc_params['port']), default_noreply=not self.wait_on_insert) return self
def getEmployeesFromCache(): print("Retrieving from cache") memcache = Client(('localhost', 11211), serde=serde.pickle_serde) emp_list = memcache.get('query_1999_employees') return emp_list
def __del__(self): if self.flush_on_del: self.client = Client((self.memc_params['host'], self.memc_params['port']), default_noreply=not self.wait_on_insert) self.client.flushdb()
def client(self): if self._client is None: self._client = Client((self.address, self.port)) return self._client
def __init__(self, host='127.0.0.1', port=11211, **kwargs): CacheMixin.__init__(self, **kwargs) self._memcache = Client( (host, port), serializer=pack, deserializer=unpack)
#!/usr/bin/env python import argparse import time import json import RPi.GPIO as GPIO from pythonosc import udp_client from pymemcache.client.base import Client GPIOState = Client(('localhost', 11211)) ########## # Config # ########## with open('/var/www/html/config.json') as config_file: config = json.load(config_file) ########## # Config # ########## ############### # Send Output # ############### def send_OSC(json_raw): data = json.loads(json_raw) if __name__ == "__main__": parser = argparse.ArgumentParser()
import json from pymemcache.client.base import Client def json_serializer(key, value): if type(value) == str: return value, 1 return json.dumps(value), 2 def json_deserializer(key, value, flags): if flags == 1: return value if flags == 2: return json.loads(value) raise Exception("Unknown serialization format") def cli(): pass memcache = Client(('localhost', 11211), serializer=json_serializer, deserializer=json_deserializer)
def json_serializer(key, value): # if value is a list of np arrays, make sure to convert it to \ # np array too, .tolist() works all the subsequent arrays if type(value) == np.ndarray: value = value.tolist() return json.dumps(value), 2 def json_deserializer(key, value, flags): value = json.loads(value.decode('utf-8')) return value mc = Client(('127.0.0.1', 1111), serializer=json_serializer, deserializer=json_deserializer) t0 = time.time() print("Reading faces, normalizing face data and preparing grid data... ", end="", flush=True) processes = [] for i in range(1, len(file_paths) + 1): process = Process(target=get_data, args=(file_paths["path" + str(i)], "face" + str(i), mc)) process.start() processes.append(process) for process in processes: process.join() #t = time.time()
from flask import Flask from pymemcache.client.base import Client import os from time import gmtime, strftime from utils import * app = Flask(__name__) client = Client((os.getenv("MEMCACHED_HOST"), 11211), serde=JsonSerde()) @app.route('/') def hello_world(): return '{}'.format(strftime("%Y-%m-%d %H:%M:%S", gmtime())) @app.route('/<n>') def fibo(n): if client.get(n) is None: print(n) result = fib(int(n)) print(type(result)) client.set(str(n), str(result)) return 'Твоё число Фибоначе {}! Оно только что посчитано'.format( result) else: result = client.get(str(n)) return 'Твоё число Фибоначе {}! Оно взято из кэша'.format(result)
server = os.getenv("MEMCACHED_SERVERS", "localhost") if ',' in server: servers = [] for s in server.split(','): if ':' in s: servers.append(tuple(s.split(':'))) else: servers.append((s, 11211)) mc = HashClient(servers) else: s = server if ':' in s: server = tuple(s.split(':')) else: server = (s, 11211) mc = Client(server) key = sys.argv[1] val = mc.get(key) if val[0:4] == MEMCCACHE_BIG: numkeys = struct.unpack('!I', val[4:8])[0] assert struct.unpack('!I', val[8:12])[0] == 16 assert struct.unpack('!I', val[12:16])[0] == 0 size = struct.unpack('!I', val[16:20])[0] val = val[20:] buf = "" while val: md4 = val[0:16] size = struct.unpack('!I', val[16:20])[0] val = val[20:] subkey = "%s-%d" % (binascii.hexlify(md4), size)
def memcache_tst(self): client = Client(('xuni.com', 11211)) client.set('some_key', 'some_value') result = client.get('some_key') return HttpResponse(client.get('some_key'))
#Home Page @app.route('/') def HomePage(): return render_template("login.html") Uploadpath = "/home/ubuntu/Upload" Downloadpath = "/home/ubuntu/Download" connection = MySQLdb.connect("sql-db-instance", "Username", "password", "Db-Name") engine = create_engine( "mysql+pymysql://Username:Password@AWS-Db-Instance/dbName") memc = Client(('AWS-elasticache-endpoint', 11211)) #Login Page @app.route('/login', methods=['POST', 'GET']) def UserLogin(): if 'username' in session: return render_template('index.html', username=session['username']) if request.method == 'POST': cursor = connection.cursor() username = request.form['username'] if (username == ''): return render_template('login.html', resultText="Invalid UserName ") sql = "select Username from Users where Username = '******'" cursor.execute(sql)
import json from pymemcache.client.base import Client def enJson(key, value): if type(value) == str: return value, 1 return json.dumps(value), 2 def deJson(key, value, flags): if flags == 1: return value if flags == 2: return json.loads(value) client = Client(('127.0.0.1', 11211), serializer=enJson, deserializer=deJson) client.set('name', 'jinhao2') client.set('json', {"name": "jinhao", "age": 2}) result = client.get('name') print(f"name:{result}") print(f"json:{client.get('json')}")