class CHIDriverMemcache(CHIDriver):
"""Драйвер Memcache."""
def __init__(self, *av, **kw):
"""Конструктор."""
super().__init__(*av, **kw)
self.client = Memcache(
(self.server[0]["host"], self.server[0]["port"]),
connect_timeout=self.connect_timeout,
timeout=self.request_timeout,
)
def driver_set(self, key, packed_chi_object, ttl):
"""Переопределение для установки драйвера - в редисе используются две команды, а тут - одна."""
self.client.set(key, packed_chi_object, ttl)
def keys(self, mask):
"""Возвращает ключи по маске."""
raise CHIMethodIsNotSupportedException(
"Метод keys для мемкеша не поддерживается.")
def erase(self, mask):
"""Удаление ключей по маске."""
raise CHIMethodIsNotSupportedException(
"Метод erase для мемкеша не поддерживается.")
def run(self):
client = Client(('127.0.0.1', 11211))
url = 'https://talosintelligence.com/documents/ip-blacklist'
talosvalue = 'talos-ip'
try:
response = requests.get(url)
if (response):
responseArr = []
for line in response.text.splitlines():
if (line.startswith('#') == False):
responseArr.append(line)
valueCheck = client.get_many(responseArr)
for k in responseArr:
valueArr = []
tempArr = []
tempArr.append(talosvalue)
if k in valueCheck:
val = valueCheck[k].decode()
valueArr = talosToMemcache.stringHelper(val)
for item in valueArr:
if item not in tempArr:
tempArr.append(item)
client.set(k, tempArr, 300)
except Exception as e:
with open('/var/log/misppullLog.txt', 'a') as file:
file.write(
'{0} - talosFeed-script failed with error: {1} \n'.format(
str(time.asctime()), str(e)))
class Client:
def __init__(self, config):
self.config = config
self.memcache_client = PymemcacheClient(server=(self.config["ip"], self.config["port"]), serializer=self.json_serializer, deserializer=self.json_deserializer, connect_timeout=self.config["connect_timeout"], timeout=self.config["timeout"])
def json_serializer(self, key, value):
if type(value) == str:
return value, 1
return json.dumps(value), 2
def json_deserializer(self, key, value, flags):
if flags == 1:
return value
if flags == 2:
return json.loads(value)
raise Exception("Unknown serialization format")
def write(self, key, message):
logger.info("Writing to cache: {}".format(key))
self.memcache_client.set(key,
message,
expire=self.config["key_expiration"],
noreply=self.config["noreply_flag"])
def read(self, key):
logger.info("Reading from cache: {}".format(key))
return self.memcache_client.get(key)
class NoSQLCache:
__instance = None
timeout = 5
@staticmethod
def inst():
if NoSQLCache.__instance == None:
NoSQLCache.__instance = NoSQLCache(SqliteDb.inst())
return NoSQLCache.__instance
def __init__(self, sql_db_object):
self.client = Client(('localhost', 11211))
self.sql_db = sql_db_object
def get(self, key):
key_corrector = re.sub(r' ', '$', key)
value = self.client.get(key_corrector)
if value:
return eval(value.decode('utf-8'))
else:
value = self.sql_db.get(key)
self.set(key_corrector, value, self.timeout)
return value
def set(self, key, value, timeout):
self.client.set(key, value, expire=timeout)
class MemcachedWrapper():
MEMCACHED_CONNECT_TIMEOUT = 5 # 5 seconds
MEMCACHED_TIMEOUT = 5 # 5 seconds
def __init__(self, memcached_location):
memcached_location_portions = memcached_location.split(":")
if len(memcached_location_portions) != 2:
raise ValueError(
f"Found incorrectly formatted parameter memcached location: {memcached_location}"
)
memcached_host = memcached_location_portions[0]
memcached_port = int(memcached_location_portions[1])
self.memcached_client = Client(
server=(memcached_host, memcached_port),
serializer=serde.python_memcache_serializer,
deserializer=serde.python_memcache_deserializer,
connect_timeout=MemcachedWrapper.MEMCACHED_CONNECT_TIMEOUT,
timeout=MemcachedWrapper.MEMCACHED_TIMEOUT)
def get(self, key):
return self.memcached_client.get(key)
def set(self, key, value, timeout=None):
self.memcached_client.set(key, value, timeout)
def delete(self, key):
self.memcached_client.delete(key)
def execqueryWithMem(name, c1, c2):
try:
mysql_conn = mysql.connector.connect(host=host, user=dbusername, password=dbpassword, database=dbname,
port=port)
mc = Client(('cloudassgn.hw0lsb.0001.use2.cache.amazonaws.com', 11211))
query = 'select ' + name + ' from Earthquake where ' + c1 + ' and ' + c2
hashVal = hashlib.sha224(query).hexdigest()
starttime = int(round(time.time() * 1000))
data = mc.get(hashVal)
count = 0
if not data:
for i in range(0, 250):
cursor = mysql_conn.cursor()
cursor.execute(query)
row = cursor.fetchall()
count = cursor.rowcount
cursor.close()
mc.set(hashVal, count)
endtime = int(round(time.time() * 1000))
totalexectime = endtime - starttime
mysql_conn.close()
resultStr = '<div style="font-size:14px;margin-top: 30px;"><div> Last Name : Manakan </div><div> Last 4 digit ID : 6131 </div><div> Class Section : 10:30 AM </div></div>'
resultStr = resultStr + '<br> Time taken : ' + str(totalexectime) + ' msecs'
resultStr = resultStr + '<br> Rows effected : ' + str(count)
return resultStr
except Exception as e:
print e
return 'Error ' + str(e)
class Cache:
client = None
__path = ""
__md5 = ""
__chunks = []
def __init__(self, chunk_size=1000000):
self.client = Client(('localhost', 11211))
self.__chunk_size = chunk_size
def readFile(self, path, data=None):
self.__path = path
if data is not None:
data = data.encode()
self.__md5 = self.__getMd5(data)
self.__getChunks(data)
self.__cache()
return self.__chunks
def getFile(self, name):
""" TODO: use join() instead """
i = 0
content = bytearray()
while True:
data = self.client.get("{}:{}".format(name, i))
if not data:
break
content += data
i += 1
checksum = self.client.get("{}:hash".format(name))
new_md5 = hashlib.md5(content).digest()
assert checksum == new_md5, 'data corrupted'
return content
def __cache(self):
self.client.set("{}:hash".format(self.__path), self.__md5)
for i, chunk in enumerate(self.__chunks):
item_key = "{}:{}".format(self.__path, i)
self.client.set(item_key, chunk)
def __getMd5(self, data=None):
if data is not None:
return hashlib.md5(data).digest()
file = open(self.__path, 'rb')
content = file.read()
file.close()
return hashlib.md5(content).digest()
def __getChunks(self, data=None):
self.__chunks = []
if data is not None:
return hashlib.md5(data).digest()
file = open(self.__path, 'rb')
count = 0
while True:
data = file.read(self.__chunk_size)
if not data:
break
self.__chunks.append(data)
class MyMemcache(object):
def __init__(self, ip='localhost', port=11211):
# json_serializer(key, value)
def json_serializer(key, value):
if type(value) == str:
return value, 1
return json.dumps(value), 2
# json_deserializer(key, value, flags) python3
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")
self.ip = ip
self.port = port
self.client = Client((ip, port),
serializer=json_serializer,
deserializer=json_deserializer,
key_prefix='',
encoding='utf8',
allow_unicode_keys=True)
'''
set_task_result
'''
@catch_exception
def set_value(self, key, value):
# set(key, value, expire=0, noreply=None, flags=None)
# result = "-".join(result.split())
expire_second = int(60 * 60 * 24 * 1.2) # expire_second must int
self.client.set(key=key, value=value, expire=expire_second)
# debug_p('[set_value]', key, value)
'''
get_task_result
'''
@catch_exception
def get_value(self, key, default=''):
result = self.client.get(key=key, default=default)
debug_p('[get_value]', key, result)
return result
'''
close
'''
def client_close(self):
try:
self.client.close()
except Exception as e:
#
pass
def main():
line1 = Line(1, 5)
line2 = Line(2, 6)
line3 = Line(6, 8)
line4 = Line(7, 9)
assert do_intersect(line1, line2) == True
assert do_intersect(line1, line3) == False
assert do_intersect(line2, line1) == True
assert do_intersect(line3, line1) == False
assert do_intersect(line3, line4) == True
assert compare_versions("1.1", "1.2") == -1
assert compare_versions("1.2.1", "1.2") == 1
assert compare_versions("1.2.1", "1.2.1a") == -1
assert compare_versions("1.2.1b", "1.2.1a") == 1
assert compare_versions("1.2.1", "1.21") == -1
assert compare_versions("2.1.1", "1.2.1") == 1
assert compare_versions("1.2.1", "1.2.1") == 0
assert compare_versions("1.", "1") == 0
assert compare_versions("a1", "1a") == 1
assert compare_versions("1.2.1", "1.19.0") == -1
client = Client('127.0.0.1', 11211)
client.set('some_key', 'some_value', expire = 30)
assert client.get('some_key') == 'some_value'
print("OK")
class Reader(BaseReader):
"""
Memcached settings Reader
A simple memcached getter using pymemcache library.
"""
_default_conf = {
'host': 'localhost',
'port': 11211
}
def __init__(self, conf):
super(Reader, self).__init__(conf)
self.client = Client((self.conf['host'], self.conf['port']))
def _get(self, key):
result = self.client.get(key)
if isinstance(result, six.binary_type):
result = result.decode('utf-8')
return result
def _set(self, key, value):
self.client.set(key, value, noreply=False)
def startClient(id):
global active_threads
global max_active_threads
try:
client = Client(('localhost', 8888))
print('Client ' + str(id) + ' connected')
start = time.time()
lock.acquire()
active_threads += 1
max_active_threads = max(max_active_threads, active_threads)
lock.release()
for _ in range(500):
key, value = randomString(5), randomString(5)
client.set(key, value)
result = client.get(key)
lock.acquire()
active_threads -= 1
lock.release()
end = time.time()
print('Client ' + str(id) + ' exiting. Time spent: ' +
str(end - start))
end = time.time()
except BaseException as e:
print('Exception' + str(e))
return
def runOTX():
'''Retrieve intel from OTXv2 API.'''
days = int(parser.get('otx', 'days_of_history'))
key = parser.get('otx', 'api_key')
mem_host = parser.get('memcached', 'mem_host')
mem_port = int(parser.get('memcached', 'mem_port'))
memcached = Client((mem_host, mem_port))
memcached_agetime = int(parser.get('memcached', 'agetime'))
memcached_sleeptime = int(parser.get('memcached', 'sleeptime'))
mtime = (datetime.now() - timedelta(days=days)).isoformat()
for pulse in iter_pulses(key, mtime):
pulse_name = pulse['name']
pulse_id = pulse['id']
for indicator in pulse[u'indicators']:
ioc = indicator['indicator']
ioc_type = map_indicator_type(indicator[u'type'])
tag = pulse_name + '-' + pulse_id
if ioc_type is None:
continue
try:
url = pulse[u'references'][0]
except IndexError:
url = 'https://otx.alienvault.com'
memcached_key = ioc_type + '-' + ioc
try:
memcached.set(memcached_key.encode('utf-8'),
tag.encode('utf-8'), memcached_agetime)
except:
pass
time.sleep(memcached_sleeptime)
def UpdateClassifier():
print("Update Classifier")
clf = LogisticRegression(
random_state=0, solver='lbfgs', multi_class='multinomial')
smt = SMOTETomek(random_state=42)
discussions = list(Discussion.objects.filter(reviewed=True))
globalFeaturesIndex = ef.GetGlobalFeaturesIndex(
discussions, list(range(0, len(discussions))), ef.E19)
X, y = [], []
for discussion in discussions:
featureVector = ef.ExtractFeatureFromCorpus(
globalFeaturesIndex, discussion.content, ef.E19)
X.append(featureVector)
y.append(discussion.tag.tag_id)
X, y = smt.fit_sample(X, y)
selector = GenericUnivariateSelect(chi2, 'percentile', param=20)
X = selector.fit_transform(X, y)
try:
clf.fit(X, y)
print("fit done")
client = Client(('localhost', 11211))
model = (clf, globalFeaturesIndex, selector)
client.set('model', pickle.dumps(model))
model_in_bytes = client.get('model')
model_from_cache = pickle.loads(model_in_bytes)
print(len(model_from_cache))
except:
print("clf failed to cache...")
def run_island(island):
import pygmo as pg
from multiprocessing import cpu_count
from pymemcache.client.base import Client
mc_client = Client((island.mc_host, island.mc_port))
#udp = island.problem_factory()
algorithm = pg.algorithm(pg.de())
#problem = pg.problem(udp)
problem = island.problem_factory()
# TODO: configure pop size
i = pg.island(algo=algorithm, prob=problem, size=20)
mc_client.set(island.domain_qualifier('island', str(island.id), 'status'),
'Running', 10000)
mc_client.set(island.domain_qualifier('island', str(island.id), 'n_cores'),
str(cpu_count()), 10000)
#print('Starting island {} with {} cpus'.format(str(i.id), str(cpu_count())))
i.evolve()
i.wait()
import socket
hostname = socket.gethostname()
ip = [
l for l in ([
ip for ip in socket.gethostbyname_ex(socket.gethostname())[2]
if not ip.startswith("127.")
][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close())
for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]
][0][1]]) if l
][0][0]
return (ip, hostname, i.get_population().problem.get_fevals())
def set_test(request):
client = Client(('/opt/www/memcached/memcached.sock'),
serializer=json_serializer,
deserializer=json_deserializer)
client.set('new', {'status': 'updated'})
# result = client.get('key')
return JsonResponse({'status': 'ok'})
def adduser(request):
if request.method == 'POST':
data = request.get_data()
json_data = json.loads(data.decode('utf-8'))
username = json_data.get('username')
password = json_data.get('password')
email = json_data.get('email')
userid = ''.join([
random.choice(string.ascii_letters + string.digits)
for i in range(16)
])
if username is None or password is None or email is None:
return json.dumps({'status': 'error', "error": "have empty block"})
key = ''.join([
random.choice(string.ascii_letters + string.digits)
for i in range(16)
])
timestamp = int(time.time())
res = dbcontroller.mysql_checkuser(username, email)
if res == False:
return json.dumps({
'status':
'error',
'error':
'email already register or username already in use'
})
#use memcache
mc = Client((memhost, memport))
info = {
"username": username,
"password": password,
"email": email,
"timestamp": timestamp,
"key": key,
"userid": userid
}
print(info)
mc.set(email, info)
#return json.dumps({'status':mc.get(email)})
if sendMail(email, key) == True:
return json.dumps({'status': 'OK'})
else:
return json.dumps({
'status': 'error',
'error': 'invalid email address'
})
else:
return json.dumps({'status': 'error'})
class Memcached(object):
"""Memcached based caching.
This is extremely lightweight in terms of memory usage, but it
appears to be slightly slower than local database caching, and a
lot slower than local memory based caching. This should be used if
the cache is to be shared between multiple users.
"""
LRU = LeastRecentlyUsed = 0
def __init__(self, url='127.0.0.1', mode=LRU, ttl=None):
"""Create a new engine.
Parameters:
url (str): Memcached server to connect to.
mode (int): How to purge the old keys.
This does not affect anything as memcached is LRU only.
The option is there to match the other engines.
ttl (int): Time the cache is valid for.
Set to None or 0 for infinite.
"""
try:
from pymemcache.client.base import Client
self.client = Client(url, timeout=3, connect_timeout=3)
except ImportError:
from memcache import Client
self.client = Client([url], socket_timeout=3)
self.ttl = ttl
# Don't allow cross version caches
# Pickle may have incompatibilities between versions
self._key_prefix = '{}.{}.'.format(sys.version_info.major,
sys.version_info.minor)
def get(self, key):
"""Get the value belonging to a key.
An error will be raised if the cache is expired or doesn't
exist.
"""
value = self.client.get(self._key_prefix + key)
if value is None:
raise exceptions.CacheNotFound(key)
return _decode(value)
def put(self, key, value, ttl=None):
"""Write a new value to the cache.
This will overwrite any old cache with the same key.
"""
if ttl is None:
ttl = self.ttl
self.client.set(self._key_prefix + key,
_encode(value),
ttl or 0,
noreply=True)
def delete(self, key):
"""Delete an item of cache if it exists."""
return self.client.delete(self._key_prefix + key, noreply=False)
def test_memcached(mc_host, mc_port):
# test that memcache is working
from pymemcache.client.base import Client
mc_client = Client((mc_host, mc_port))
my_id = str(uuid4())
my_val = str(uuid4())
mc_client.set(my_id, my_val, 1000)
if mc_client.get(my_id).decode('utf8') != my_val:
raise RuntimeError('Unable to communicate with Memcached')
class MemcacheTool(object):
def __init__(self, host, port):
self.client = Client((host, port))
def set(self, key, value):
self.client.set(key, value)
def get(self, key):
return self.client.get(key)
def set_memcache(k, data):
'''将数据加入到缓存中
'''
try:
client = Client(('127.0.0.1', 1121))
client.set(k, json.dump(data))
return True
except Exception as e:
print(e)
return False
class MemClient():
def __init__(self):
self.client = Client(('localhost', 11211))
def get(self, key):
value = self.client.get(key)
return json.loads(value)
def set(self, key, value):
self.client.set(key, json.dumps(value), expire=18000)
def memcclient(self, host):
c = Client(host)
lock = c.get('lock')
while lock:
sleep(.25)
lock = c.get('lock')
c.set('lock', 'true')
try:
yield c
finally:
c.delete('lock')
def fib_handler(k):
client = Client((MEMCACHED_HOST, '11211')
, serializer=json_serializer
, deserializer=json_deserializer) # клиент кэширования
fib_result = client.get(str(k)) # число фибоначчи из кэша
if fib_result is None:
result = fib(k)
client.set(str(k), result) # кэшируем число фибоначчи
else:
result = fib_result
print('fib_result=', fib_result)
return str(result)
def __init__(self, islands, topology, initial_score=None):
from pymemcache.client.base import Client
if initial_score is None:
self.initial_score = ...
else:
self.initial_score = initial_score
self.topology = topology
self.mc_host = mc_host
self.mc_port = mc_port
mc_client = Client((self.mc_host, self.mc_port))
mc_client.set(self.domain_qualifier('islandIds'),
dumps(topology.island_ids), 10000)
def fib_handler(num):
client = Client((MEMCACHED_HOST, '11211'),
serializer=json_serializer,
deserializer=json_deserializer)
fib_result = client.get(str(num))
if fib_result is None:
result = fib(num)
client.set(str(num), result)
else:
result = fib_result
print('fib_result=', fib_result)
return str(result)
def memcached_load_nosql(objects, numbers):
from pymemcache.client.base import Client
import hashlib
mc = Client(('localhost', 11211), serializer=mem_serializer, deserializer=mem_deserializer)
test_name = 'memcached nosql '
for i, o in enumerate(objects):
mc.set(str(hashlib.sha1(o["name"]).hexdigest()), o["coords"])
if (i + 1) in numbers:
print test_name + "Objects: %s, Usage: %s" % (i + 1, mc.stats()["bytes"] * 1.0 / (1024 * 1024))
print "finsihed"
class MemcachedCache(object):
""" a memcached cache which stores the states as pickled objects """
def __init__(self, master):
self.is_master = False
self.wait_on_insert = master.wait_on_insert
self.memc_params = master.memc_params
self.val_ttl = master.val_ttl
def __del__(self):
self.teardown()
def setup(self):
self.client = Client((self.memc_params['host'], self.memc_params['port']),
default_noreply=not self.wait_on_insert)
return self
def teardown(self):
return self
def fetch(self, routingkey, key):
cache_key = str(routingkey) + '_' + str(key)
obj_pickle = self.client.get(cache_key)
if obj_pickle is None:
return None
try:
obj = pickle.loads(obj_pickle)
except:
# logger.debug("Error decoding pickle")
obj = None
return obj
def insert(self, routingkey, key, obj):
cache_key = str(routingkey) + '_' + key
obj_pickle = pickle.dumps(obj)
if self.wait_on_insert:
self.client.set(key=cache_key, value=obj_pickle, expire=self.val_ttl)
else:
threading.Thread(target=self.client.set,
kwargs={'key': cache_key, 'value': obj_pickle, 'expire': self.val_ttl},
daemon=False).start()
def get_client(self):
return self.__copy__()
def __copy__(self):
if not self.is_master:
raise Exception('not allowed; already a slave')
return MemcachedCache(self)
def copy(self):
return self.__copy__()
def set_api_throttle():
client = Client((CACHE_CLIENT_ENDPOINT, CACHE_PORT))
result = client.get('daily_requests')
if (result):
result = int(result) + 1
else:
result = 1
client.set('daily_requests',result, expire=CACHE_EXPIRE)
return result
class MemcachedCacheDriver(CacheDriver):
def init(self):
self.expiration = None
self.client = MemClient(('localhost', 11211))
def get(self, key):
cache = self.client.get(key)
if cache is None:
return None
return json.loads(cache.decode('utf8'))
def set(self, key, value):
self.client.set(key, value, self.expiration)
def set(self, k, data):
"""将数据加入到缓存中
"""
logger.info("memcached: %s %s: %s" %
(data, self.memcachedendpoint, self.memcachedport))
try:
client = Client((self.memcachedendpoint, self.memcachedport))
client.set(k, data, 300)
logger.debug(data)
return True
except Exception as e:
logger.info(e)
return False
class MemcachedCache(CachualCache):
"""A cache using `Memcached <https://memcached.org/>`_ as the backing
cache. The same caveats apply to keys and values as for Redis - you should
only try to store strings (using the packing/unpacking functions). See the
documentation on Keys and Values here:
:class:`pymemcache.client.base.Client`.
:type host: string
:param host: The Memcached host to use for the cache.
:type port: integer
:param port: The port to use for the Memcached server.
:type kwargs: dict
:param kwargs: Any additional args to pass to the :class:`CachualCache`
constructor.
"""
def __init__(self, host='localhost', port=11211, **kwargs):
super(MemcachedCache, self).__init__(**kwargs)
self.client = MemcachedClient((host, port))
def get(self, key):
"""Get a value from the cache using the given key.
:type key: string
:param key: The cache key to get the value for.
:returns: The value for the cache key, or None in the case of cache
miss.
"""
return self.client.get(key)
def put(self, key, value, ttl=None):
"""Put a value into the cache at the given key. For constraints on keys
and values, see :class:`pymemcache.client.base.Client`.
:type key: string
:param key: The cache key to use for the value.
:param value: The value to store in the cache.
:type ttl: integer
:param ttl: The time-to-live for key in seconds, after which it will
expire.
"""
if ttl is None:
ttl = 0
self.client.set(key, value, expire=ttl)
def test_incr_decr(client_class, host, port, socket_module):
client = Client((host, port), socket_module=socket_module)
client.flush_all()
result = client.incr(b'key', 1, noreply=False)
assert result is None
result = client.set(b'key', b'0', noreply=False)
assert result is True
result = client.incr(b'key', 1, noreply=False)
assert result == 1
def _bad_int():
client.incr(b'key', b'foobar')
with pytest.raises(MemcacheClientError):
_bad_int()
result = client.decr(b'key1', 1, noreply=False)
assert result is None
result = client.decr(b'key', 1, noreply=False)
assert result == 0
result = client.get(b'key')
assert result == b'0'
def test_serialization_deserialization(host, port, socket_module):
def _ser(key, value):
return json.dumps(value).encode('ascii'), 1
def _des(key, value, flags):
if flags == 1:
return json.loads(value.decode('ascii'))
return value
client = Client((host, port), serializer=_ser, deserializer=_des,
socket_module=socket_module)
client.flush_all()
value = {'a': 'b', 'c': ['d']}
client.set(b'key', value)
result = client.get(b'key')
assert result == value
class Memcached(object):
DELAY = 0.5
DEBUG = False
def __init__(self, hostname, port, **params):
self.mc = Client((hostname, port))
def handle(self, topic, message):
"""
"""
if 'cmd' not in message:
raise Exception("Bad message: no command")
cmd = message['cmd']
if not hasattr(self, cmd):
raise Exception("Unknown command: " + cmd)
tryit = True
while tryit:
tryit = False
try:
getattr(self, cmd)(message)
except MemcacheUnexpectedCloseError:
# Server dropped dead - we'll retry
tryit = True
except IOError:
# Something network-related - retry
tryit = True
if tryit:
time.sleep(self.DELAY)
def set(self, message):
text = message['val'].encode('utf-8')
if message.get('sbt', None):
purge_time = time.time() + message.get('uto', 0)
text = text.replace('$UNIXTIME$', '%.6f' % purge_time)
if self.DEBUG:
print("Set {0}-{1}-{2}".format(message['key'].encode('utf-8'), text, int(message['ttl'])))
self.mc.set(message['key'].encode('utf-8'), text, int(message['ttl']))
def delete(self, message):
self.mc.delete(message['key'])
m, n = getscreenimage()
return m, n
#------------------------
#logging.basicConfig(
# format='# %(levelname)s: %(message)s',
# level=logging.DEBUG,
#)
client = Client(('127.0.0.1', 11211))
try:
result = client.get('appletv')
if result:
sys.exit("time is not passed")
else:
print ("appletv is on")
# get current channel and change input to HDMI2
# tv should be on
m, n = getCHandHDMI2()
if m != n:
changeinout(m, n)
else:
handleCommand("20")
client.set('appletv', 'true', 60)
except Exception, e:
print e.__doc__
print e.message
sys.exit(1)
def gao_memcache():
client = Client((app.config['MEMCACHE_HOST'], app.config['MEMCACHE_PORT']))
client.set('some_key', 'some_value', expire=10)
result = client.get('some_key')
print result
import time
import urllib2
from PIL import Image
from pymemcache.client.base import Client
client = Client(('127.0.0.1', 11211))
url = "http://127.0.0.1:5080/index1.jpg"
i = 0
try:
while True:
try:
input = urllib2.urlopen(url)
input.readline(); input.readline()
content_length = int(input.readline().split(": ")[1].strip())
input.readline(); input.readline()
data = input.read(content_length)
client.set(str(i), data, 30)
client.set('curno', i)
i = i + 1
time.sleep(0.7)
except Exception, e:
print e.__doc__
print e.message
sys.exit(1)
except KeyboardInterrupt:
sys.exit(1)
