def __init__(self, sample):
self.sample = sample
self.counter = AtomicLong(0)
self.minimum = AtomicLong(sys.maxsize)
self.maximum = AtomicLong(-sys.maxsize - 1)
self.sum = AtomicLong(0)
self.var = AtomicLongArray([-1, 0])
class Stat(object):
gen_tasks = AtomicLong(0)
finished_tasks = AtomicLong(0)
task_queue = queue.Queue()
# Each result contains several fields
# 1. TaskID
# 2. TimePoints: create time, send time, response time
# 3. Succ
result_queue = queue.Queue()
def __init__(self, average_class=EWMA):
self.counter = AtomicLong(0)
self.start_time = now()
self.last_tick = AtomicLong(self.start_time)
self.interval = EWMA.INTERVAL
self.m1_rate = EWMA.m1()
self.m5_rate = EWMA.m5()
self.m15_rate = EWMA.m15()
def __init__(self, alpha, interval):
self.alpha = alpha
self.interval = interval
self.initialized = False
self._rate = 0.0
self._uncounted = AtomicLong(0)
def test_compare_and_swap(self):
atomic = AtomicLong(1000)
swapped = atomic.compare_and_swap(1000, 1001)
self.assertEqual(1001, atomic.value)
self.assertEqual(True, swapped)
swapped = atomic.compare_and_swap(1000, 1024)
self.assertEqual(1001, atomic.value)
self.assertEqual(False, swapped)
def __init__(self, reservoir_size, alpha):
self.values = []
self.next_scale_time = AtomicLong(0)
self.alpha = alpha
self.reservoir_size = reservoir_size
self.lock = RLock()
self.rescale_threshold = \
ExponentiallyDecayingSample.calculate_rescale_threshold(alpha)
self.clear()
class ToggleGauge(Gauge):
_value = AtomicLong(1)
@property
def value(self):
try:
return self._value.value
finally:
self._value.value = 0
def __init__(self, service_meta, client_id=None):
self.service_meta = service_meta
self.client_id = client_id
if not self.client_id:
self.client_id = gen_uuid()
if service_meta.serverimpl != "rabbitmq":
raise RuntimeError("serverimpl {} not implemented yet".format(
service_meta.serverimpl))
self._sender = RabbitmqClientSender(service_meta)
if service_meta.callmode != "notify":
# need a queue to receive response
self._receiver = RabbitmqClientReceiver(self.client_id)
else:
self._receiver = None
if service_meta.coder != "mail":
raise RuntimeError("coder {} is not supported yet".format(
service_meta.coder))
self.requestid_base = AtomicLong(0)
self.running = True
"""Hive signal handling."""
import logging
from signal import SIGINT
from atomic import AtomicLong
log = logging.getLogger(__name__)
EXCEPTION_THROWN = AtomicLong(0)
FINISH_SIGNAL_DURING_SYNC = AtomicLong(0)
def finish_signals_handler(signal, frame):
global FINISH_SIGNAL_DURING_SYNC
FINISH_SIGNAL_DURING_SYNC += 1
log.info("""
**********************************************************
CAUGHT {}. PLEASE WAIT... PROCESSING DATA IN QUEUES...
**********************************************************
""".format("SIGINT" if signal == SIGINT else "SIGTERM"))
def set_exception_thrown():
global EXCEPTION_THROWN
EXCEPTION_THROWN += 1
def can_continue_thread():
return EXCEPTION_THROWN.value == 0 and FINISH_SIGNAL_DURING_SYNC.value == 0
def __init__(self, reservoir_size):
self.counter = AtomicLong(0)
self.values = [0] * reservoir_size
def __init__(self, service_meta):
self.requestid_gen = AtomicLong(0)
pass
class StopSignal(object):
stop_workers = AtomicLong(0)
def __init__(self, service_meta, **kwargs):
self.raise_if_connect_error = kwargs.get('raise_if_connect_error',True) #add by wxt 2015-12-16 如果初始化失败是否raise异常
self.running = False
try:
self.service_meta = service_meta
# atexit
if self.service_meta.callmode == "notify":
atexit.register(self.batch_notify_flush)
self.client_id = kwargs.get("client_id")
if not self.client_id:
self.client_id = gen_uuid()
self.client_id = '_client.{}.{}'.format(self.service_meta.name,self.client_id)
if service_meta.serverimpl == "rabbitmq":
from . import babelrabbitmq
self.impl = babelrabbitmq
elif service_meta.serverimpl == "redis":
from . import babelredis
self.impl = babelredis
else:
raise RuntimeError("serverimpl {} not implemented yet".format(service_meta.serverimpl))
if "sdc" not in self.service_meta.options:
raise RuntimeError("sdc not in service meta")
self.sdc = self.service_meta.options.get("sdc", "")
if "cdc" not in self.service_meta.options:
raise RuntimeError("cdc not in service meta")
self.cdc = self.service_meta.options.get("cdc", "")
if "," in self.service_meta.options["sdc"] and self.service_meta.callmode != "notify":
raise RuntimeError("only notify supports multiple data center")
self._sender = self.impl.get_client_sender(service_meta, **kwargs)
if service_meta.callmode != "notify":
# need a queue to receive response
self._receiver = self.impl.get_client_receiver(service_meta, self.client_id, **kwargs)
else:
self._receiver = None
if service_meta.coder != "mail":
raise RuntimeError("coder {} is not supported yet".format(service_meta.coder))
self.requestid_base = AtomicLong(0)
self.request_cache = RequestCache()
self.running = True
self.response_task = None
self.metrics_tags = {
"service": service_meta.name,
"delivery": service_meta.delivermode,
"call": service_meta.callmode,
"impl": service_meta.serverimpl,
"clientid": self.client_id,
"sdc": self.sdc,
"cdc": self.cdc
}
# caching requests for batch_notify
self.batch_cache = list()
self.running = True
except Exception,e:
if self.raise_if_connect_error:
print e
raise RuntimeError('babel connect error')
def __init__(self, average_class=EWMA):
self.last = AtomicLong(0)
super(Derive, self).__init__(average_class)
def test_init(self):
atomic = AtomicLong()
self.assertEqual(0, atomic.value)
atomic = AtomicLong(0)
self.assertEqual(0, atomic.value)
def test_set_obj(self):
atomic = AtomicLongArray([-1, 0])
atomic[1] = AtomicLong(-2)
self.assertEqual(atomic[1], -2)
def test_sub(self):
atomic = AtomicLong(1000)
atomic -= 1
self.assertEqual(999, atomic.value)
def test_add(self):
atomic = AtomicLong(1000)
atomic += 1
self.assertEqual(1001, atomic.value)
def __init__(self):
self._count = AtomicLong(0)
def test_swap(self):
atomic = AtomicLong(1000)
swapped = atomic.swap(1001)
self.assertEqual(1001, atomic.value)
self.assertEqual(1000, swapped)
def test_value(self):
atomic = AtomicLong(0)
atomic.value = 1
self.assertEqual(1, atomic.value)
