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')}")
