def query(self, metric):
request = dict(type='cache-query', metric=metric)
results = self.send_request(request)
log.cache(
"CarbonLink cache-query request for %s returned %d datapoints" %
(metric, len(results['datapoints'])))
return results['datapoints']
def load_keyfunc():
if settings.CARBONLINK_HASHING_KEYFUNC:
module_path, func_name = settings.CARBONLINK_HASHING_KEYFUNC.rsplit(':', 1)
log.cache("Using keyfunc %s found in %s" % (str(func_name), str(module_path)))
return load_module(module_path, member=func_name)
else:
return lambda x: x
def load_keyfunc():
if settings.CARBONLINK_HASHING_KEYFUNC:
module_path, func_name = settings.CARBONLINK_HASHING_KEYFUNC.rsplit(
':', 1)
log.cache("Using keyfunc %s found in %s" %
(str(func_name), str(module_path)))
return load_module(module_path, member=func_name)
else:
return lambda x: x
def set_metadata(self, metric, key, value):
request = dict(type='set-metadata',
metric=metric,
key=key,
value=value)
results = self.send_request(request)
log.cache("CarbonLink set-metadata request received for %s:%s" %
(metric, key))
return results
def send_request_to_all(self, request):
metric = request['metric']
serialized_request = pickle.dumps(request, protocol=-1)
len_prefix = struct.pack("!L", len(serialized_request))
request_packet = len_prefix + serialized_request
results = {}
results.setdefault('datapoints', [])
for host in self.hosts:
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" %
(metric, str(host)))
try:
conn.sendall(request_packet)
result = self.recv_response(conn)
except Exception, e:
self.last_failure[host] = time.time()
log.cache("Exception getting data from cache %s: %s" %
(str(host), e))
else:
self.connections[host].add(conn)
if 'error' in result:
log.cache("Error getting data from cache %s: %s" %
(str(host), result['error']))
else:
if len(result['datapoints']) > 1:
results['datapoints'].extend(result['datapoints'])
log.cache("CarbonLink finished receiving %s from %s" %
(str(metric), str(host)))
def send_request_to_all(self, request):
metric = request['metric']
serialized_request = pickle.dumps(request, protocol=-1)
len_prefix = struct.pack("!L", len(serialized_request))
request_packet = len_prefix + serialized_request
results = {}
results.setdefault('datapoints', [])
for host in self.hosts:
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" % (metric, str(host)))
try:
conn.sendall(request_packet)
result = self.recv_response(conn)
except Exception,e:
self.last_failure[host] = time.time()
log.cache("Exception getting data from cache %s: %s" % (str(host), e))
else:
self.connections[host].add(conn)
if 'error' in result:
log.cache("Error getting data from cache %s: %s" % (str(host), result['error']))
else:
if len(result['datapoints']) > 1:
results['datapoints'].extend(result['datapoints'])
log.cache("CarbonLink finished receiving %s from %s" % (str(metric), str(host)))
def send_request(self, request):
metric = request['metric']
serialized_request = pickle.dumps(request, protocol=-1)
len_prefix = struct.pack("!L", len(serialized_request))
request_packet = len_prefix + serialized_request
result = {}
result.setdefault('datapoints', [])
if metric.startswith(settings.CARBON_METRIC_PREFIX):
return self.send_request_to_all(request)
host = self.select_host(metric)
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" % (metric, str(host)))
try:
conn.sendall(request_packet)
result = self.recv_response(conn)
except Exception,e:
self.last_failure[host] = time.time()
log.cache("Exception getting data from cache %s: %s" % (str(host), e))
def get_connection(self, host):
# First try to take one out of the pool for this host
(server, instance) = host
port = self.ports[host]
connectionPool = self.connections[host]
try:
return connectionPool.pop()
except KeyError:
pass #nothing left in the pool, gotta make a new connection
log.cache("CarbonLink creating a new socket for %s" % str(host))
connection = socket.socket()
connection.settimeout(self.timeout)
try:
connection.connect((server, port))
except:
self.last_failure[host] = time.time()
raise
else:
connection.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
return connection
def get_connection(self, host):
# First try to take one out of the pool for this host
(server, instance) = host
port = self.ports[host]
connectionPool = self.connections[host]
try:
return connectionPool.pop()
except KeyError:
pass #nothing left in the pool, gotta make a new connection
log.cache("CarbonLink creating a new socket for %s" % str(host))
connection = socket.socket()
connection.settimeout(self.timeout)
try:
connection.connect( (server, port) )
except:
self.last_failure[host] = time.time()
raise
else:
connection.setsockopt( socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1 )
return connection
def send_request(self, request):
metric = request['metric']
serialized_request = pickle.dumps(request, protocol=-1)
len_prefix = struct.pack("!L", len(serialized_request))
request_packet = len_prefix + serialized_request
result = {}
result.setdefault('datapoints', [])
if metric.startswith(settings.CARBON_METRIC_PREFIX):
return self.send_request_to_all(request)
host = self.select_host(metric)
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" %
(metric, str(host)))
try:
conn.sendall(request_packet)
result = self.recv_response(conn)
except Exception, e:
self.last_failure[host] = time.time()
log.cache("Exception getting data from cache %s: %s" %
(str(host), e))
host = self.select_host(metric)
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" %
(metric, str(host)))
try:
conn.sendall(request_packet)
result = self.recv_response(conn)
except Exception, e:
self.last_failure[host] = time.time()
log.cache("Exception getting data from cache %s: %s" %
(str(host), e))
else:
self.connections[host].add(conn)
if 'error' in result:
log.cache("Error getting data from cache: %s" %
result['error'])
raise CarbonLinkRequestError(result['error'])
log.cache("CarbonLink finished receiving %s from %s" %
(str(metric), str(host)))
return result
def send_request_to_all(self, request):
metric = request['metric']
serialized_request = pickle.dumps(request, protocol=-1)
len_prefix = struct.pack("!L", len(serialized_request))
request_packet = len_prefix + serialized_request
results = {}
results.setdefault('datapoints', [])
for host in self.hosts:
conn = self.get_connection(host)
def get_metadata(self, metric, key):
request = dict(type='get-metadata', metric=metric, key=key)
results = self.send_request(request)
log.cache("CarbonLink get-metadata request received for %s:%s" % (metric, key))
return results['value']
def query(self, metric):
request = dict(type='cache-query', metric=metric)
results = self.send_request(request)
log.cache("CarbonLink cache-query request for %s returned %d datapoints" % (metric, len(results['datapoints'])))
return results['datapoints']
if metric.startswith(settings.CARBON_METRIC_PREFIX):
return self.send_request_to_all(request)
host = self.select_host(metric)
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" % (metric, str(host)))
try:
conn.sendall(request_packet)
result = self.recv_response(conn)
except Exception,e:
self.last_failure[host] = time.time()
log.cache("Exception getting data from cache %s: %s" % (str(host), e))
else:
self.connections[host].add(conn)
if 'error' in result:
log.cache("Error getting data from cache: %s" % result['error'])
raise CarbonLinkRequestError(result['error'])
log.cache("CarbonLink finished receiving %s from %s" % (str(metric), str(host)))
return result
def send_request_to_all(self, request):
metric = request['metric']
serialized_request = pickle.dumps(request, protocol=-1)
len_prefix = struct.pack("!L", len(serialized_request))
request_packet = len_prefix + serialized_request
results = {}
results.setdefault('datapoints', [])
for host in self.hosts:
conn = self.get_connection(host)
log.cache("CarbonLink sending request for %s to %s" % (metric, str(host)))
