def __init__(self, host='127.0.0.1', port=11211):
"""Memcached Binary Protocol Client"""
self.host = host
self.port = port
self.s = socket.create_connection((host, port))
self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.r = random.Random()
self.log = logger("MemcachedClient")
self.vbucket_count = 1024
def __init__(self, host='127.0.0.1', port=11211):
"""Memcached Binary Protocol Client"""
self.host = host
self.port = port
self.s = socket.create_connection((host, port))
self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.r = random.Random()
self.log = logger("MemcachedClient")
self.vbucket_count = 1024
def __init__(self, host='127.0.0.1', port=11211):
"""Memcached Binary Protocol Client"""
self.host = host
self.port = port
self.s = socket.socket()
self.s.connect_ex((host, port))
self.r = random.Random()
self.log = logger("MemcachedClient")
self.vbucket_count = 1024
def __init__(self, vbaware, verbose=False):
# have a queue , in case of not my vbucket error
# let's reinitialize the config/memcached socket connections ?
self.queue = Queue(1000000)
self.status = "initialized"
self.vbaware = vbaware
self.reconfig_callback = self.vbaware.reconfig_vbucket_map
self.start_connection_callback = self.vbaware.start_vbucket_connection
self.restart_connection_callback = self.vbaware.restart_vbucket_connection
self.verbose = verbose
self.log = logger("CommandDispatcher")
self._dispatcher_stopped_event = Event()
def __init__(self, vbaware, verbose=False):
#have a queue , in case of not my vbucket error
#let's reinitialize the config/memcached socket connections ?
self.queue = Queue(10000)
self.status = "initialized"
self.vbaware = vbaware
self.reconfig_callback = self.vbaware.reconfig_vbucket_map
self.start_connection_callback = self.vbaware.start_vbucket_connection
self.restart_connection_callback =\
self.vbaware.restart_vbucket_connection
self.verbose = verbose
self.log = logger("CommandDispatcher")
self._dispatcher_stopped_event = Event()
def __init__(self, url, bucket, password="", verbose=False,
dispatcher=CommandDispatcher):
self.log = logger("CouchbaseClient")
self.rest_username = bucket
self.rest_password = password
self._memcacheds = {}
self._vBucketMap = {}
self._vBucketMap_lock = Lock()
self._vBucketMapFastForward = {}
self._vBucketMapFastForward_lock = Lock()
#TODO: use regular expressions to parse the url
server = {}
if not bucket:
raise InvalidArgumentException("bucket can not be an empty string",
parameters="bucket")
if not url:
raise InvalidArgumentException("url can not be an empty string",
parameters="url")
if (url.find("http://") != -1 and url.rfind(":") != -1 and
url.find("/pools/default") != -1):
server["ip"] = (url[url.find("http://")
+ len("http://"):url.rfind(":")])
server["port"] = url[url.rfind(":") + 1:url.find("/pools/default")]
server["username"] = self.rest_username
server["password"] = self.rest_password
else:
raise InvalidArgumentException("invalid url string",
parameters=url)
self.servers = [server]
self.servers_lock = Lock()
self.rest = RestConnection(server)
self.bucket = self.rest.get_bucket(bucket)
if self.bucket.vbuckets:
self.reconfig_vbucket_map()
self.init_vbucket_connections()
self.streaming_thread = Thread(name="streaming",
target=self._start_streaming,
args=())
self.streaming_thread.daemon = True
self.streaming_thread.start()
self.dispatcher = dispatcher(self, verbose)
self.dispatcher_thread = Thread(name="dispatcher-thread",
target=self._start_dispatcher)
self.dispatcher_thread.daemon = True
self.dispatcher_thread.start()
self.verbose = verbose
#
import json
import urllib
import socket
import time
import warnings
import requests
from couchbase.logger import logger
from couchbase.exception import ServerAlreadyJoinedException, \
ServerUnavailableException, InvalidArgumentException, \
BucketCreationException, ServerJoinException, BucketUnavailableException
log = logger("rest_client")
#helper library methods built on top of RestConnection interface
class RestHelper(object):
def __init__(self, rest_connection):
self.rest = rest_connection
def is_ns_server_running(self, timeout_in_seconds=360):
end_time = time.time() + timeout_in_seconds
while time.time() <= end_time:
try:
if self.is_cluster_healthy():
return True
except ServerUnavailableException:
time.sleep(1)
#
import hmac
import socket
import random
import zlib
import struct
import warnings
import cPickle as pickle
from cStringIO import StringIO
from couchbase.logger import logger
from couchbase.constants import MemcachedConstants
from couchbase.exception import MemcachedError
log = logger("client")
class MemcachedClient(object):
"""Simple memcached client."""
vbucketId = 0
def __init__(self, host='127.0.0.1', port=11211):
"""Memcached Binary Protocol Client"""
self.host = host
self.port = port
self.s = socket.create_connection((host, port))
self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.r = random.Random()
self.log = logger("MemcachedClient")
#
import hmac
import socket
import random
import zlib
import struct
import warnings
import cPickle as pickle
from cStringIO import StringIO
from couchbase.logger import logger
from couchbase.constants import MemcachedConstants
from couchbase.exception import MemcachedError
log = logger("client")
class MemcachedClient(object):
"""Simple memcached client."""
vbucketId = 0
def __init__(self, host='127.0.0.1', port=11211):
"""Memcached Binary Protocol Client"""
self.host = host
self.port = port
self.s = socket.create_connection((host, port))
self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.r = random.Random()
self.log = logger("MemcachedClient")
#
import json
import urllib
import socket
import time
import warnings
import requests
from couchbase.logger import logger
from couchbase.exception import ServerAlreadyJoinedException, \
ServerUnavailableException, InvalidArgumentException, \
BucketCreationException, ServerJoinException, BucketUnavailableException
log = logger("rest_client")
#helper library methods built on top of RestConnection interface
class RestHelper(object):
def __init__(self, rest_connection):
self.rest = rest_connection
def is_ns_server_running(self, timeout_in_seconds=360):
end_time = time.time() + timeout_in_seconds
while time.time() <= end_time:
try:
if self.is_cluster_healthy():
return True
except ServerUnavailableException:
time.sleep(1)
