def test_deregister(self, registry):
service = "test"
url = URL("locahost", 80, params={"node": "n1"})
registry.register(service, url)
registry.deregister(service, url)
res = registry.discovery(service)
key = registry._node_key(service, url.get_param("node"))
assert key not in res
def test_deregister(self, registry):
service = 'test'
url = URL('locahost', 80, params={"node": 'n1'})
registry.register(service, url)
registry.deregister(service, url)
res = registry.discovery(service)
key = registry._node_key(service, url.get_param("node"))
assert not key in res
def test_register(self, registry):
service = "test"
url = URL("locahost", 80, params={"node": "n1"})
self.registry = registry
self.args = [service, url]
registry.register(service, url)
res = registry.discovery(service)
key = registry._node_key(service, url.get_param("node"))
assert key in res
assert res[key] == ":".join((url.host, str(url.port)))
def server():
server = StreamServer(
("127.0.0.1", 4399),
DogeRPCServer(
Context(URL(None, None, None, {"name": ""}),
URL(None, None, None, {})),
SumServer,
),
)
g = gevent.spawn(server.serve_forever)
gevent.sleep(0.1)
yield server
g.kill()
def test_zaddress(self):
service = "test"
url = URL("locahost", 80, params={"node": "n1"})
rurl = URL(None, None, params={"ttl": 10, "address": "127.0.0.1:2379"})
registry = EtcdRegistry(rurl)
self.registry = registry
self.args = [service, url]
registry.register(service, url)
res = registry.discovery(service)
key = registry._node_key(service, url.get_param("node"))
assert key in res
assert res[key] == ":".join((url.host, str(url.port)))
def test_context(self, server):
url = URL("127.0.0.1",
4399,
params={
"name": "test",
"node": "n1",
"haStrategy": "backupRequestHA",
"loadbalance": "RandomLB"
})
rurl = URL("127.0.0.1", 4399, params={"protocol": "direct"})
context = Context(url, rurl)
c = Client(context, "test")
self.c = c
assert c.call("sum", 1, 2) == 3
assert c.call("sum", 1, 2) == 3
assert c.call("sum", 1, 2) == 3
def register(self, service: str, url: URL) -> None:
n_key = self._node_key(service, url.get_param("node"))
value = "{}:{}".format(url.host, url.port)
ttl = self.url.get_param("ttl", 10)
logger.info(f"register key: {n_key} value: {value}")
self.heartbeat(n_key, value, ttl=ttl)
def registry_factory(self, url: URL) -> Client:
address = url.get_param("address")
if address:
return etcd.Client(
allow_reconnect=True,
host=tuple([str_to_host(add) for add in address.split(",")]),
)
return etcd.Client(host=url.host, port=url.port)
def parse_service(self):
if not 'service' in self.cfg:
raise ServiceCfgError("service config not exists")
scfg = self.cfg['service']
if (not 'host' in scfg) or (not 'port' in scfg):
raise ServiceCfgError("host and port must be provided")
if (not 'name' in scfg) or (not 'node' in scfg):
raise ServiceCfgError("name and node must be provided")
return URL(str(scfg['host']), int(scfg['port']), params=scfg)
def parse_service(self) -> URL:
if "service" not in self.cfg:
raise ServiceCfgError("service config not exists")
scfg = self.cfg["service"]
if ("host" not in scfg) or ("port" not in scfg):
raise ServiceCfgError("host and port must be provided")
if ("name" not in scfg) or ("node" not in scfg):
raise ServiceCfgError("name and node must be provided")
return URL(str(scfg["host"]), int(scfg["port"]), params=scfg)
def parse_registry(self) -> URL:
if "registry" not in self.cfg:
raise RegistryCfgError("registry config not exists")
rcfg = self.cfg["registry"]
if ("host" not in rcfg) and ("address" not in rcfg):
raise RegistryCfgError("host or address must be provided")
host = rcfg.get("host", None)
port = rcfg.get("port", None)
return URL(host and str(host) or host,
port and int(port) or port,
params=rcfg)
def parse_registry(self):
if not 'registry' in self.cfg:
raise RegistryCfgError("registry config not exists")
rcfg = self.cfg['registry']
if (not 'host' in rcfg) and (not 'address' in rcfg):
raise RegistryCfgError("host or address must be provided")
host = rcfg.get('host', None)
port = rcfg.get('port', None)
return URL(host and str(host) or host,
port and int(port) or port,
params=rcfg)
def test_discovery(self, registry):
service = "test"
url = URL("locahost", 80, params={"node": "n1"})
self.registry = registry
self.args = [service, url]
registry.register(service, url)
key = registry._node_key(service, "n2")
registry.etcd.write(key, ":".join((url.host, "81")))
res = registry.discovery(service)
registry.etcd.delete(key)
assert len(res) == 2
def test_discovery(self, registry):
service = 'test'
url = URL('locahost', 80, params={"node": 'n1'})
self.registry = registry
self.args = [service, url]
registry.register(service, url)
key = registry._node_key(service, 'n2')
registry.etcd.write(key, ':'.join((url.host, '81')))
res = registry.discovery(service)
registry.etcd.delete(key)
assert len(res) == 2
def test_watch(self, registry):
service = 'test_watch'
url = URL('locahost', 80, params={"node": 'n1'})
registry.register(service, url)
sleep(0.1)
def callback(res):
print('callback now')
assert res['action'] == 'delete'
registry.watch(service, callback)
sleep(0.1)
registry.deregister(service, url)
registry.beat_thread.kill()
sleep(0.1)
def test_watch(self, registry):
service = "test_watch"
url = URL("locahost", 80, params={"node": "n1"})
registry.register(service, url)
sleep(0.1)
def callback(res):
print("callback now")
assert res["action"] == "delete"
registry.watch(service, callback)
sleep(0.1)
registry.deregister(service, url)
registry.beat_thread.kill()
sleep(0.1)
def url():
return URL("127.0.0.1", 4399, "")
def parse_refer(self):
if not 'refer' in self.cfg:
raise ReferCfgError("refer config not exists")
rcfg = self.cfg['refer']
return URL(None, None, params=rcfg)
def parse_refer(self) -> URL:
if "refer" not in self.cfg:
raise ReferCfgError("refer config not exists")
rcfg = self.cfg["refer"]
return URL(None, None, params=rcfg)
def test_url():
url = URL("", "", "")
assert url.get_int_value("a", 1) == 1
url.set_param("a", -1)
assert url.get_positive_int_value("a", 3) == 3
assert url.get_int_value("a", 0) == -1
url.set_param("m.a", 3)
assert url.get_method_int_value("m", "a", 5) == 3
assert url.get_method_int_value("m", "b", 5) == 5
assert url.get_method_positive_int_value("m", "a", 5) == 3
assert url.get_method_positive_int_value("m", "b", 5) == 5
def deregister(self, service: str, url: URL) -> None:
n_key = self._node_key(service, url.get_param("node"))
logger.debug(f"deregister key: {n_key}")
self.etcd.delete(n_key)
# coding: utf-8
from __future__ import print_function
import pytest
from gevent import sleep
from doge.common.url import URL
from doge.registry.registry import DirectRegistry, EtcdRegistry
url = URL("127.0.0.1", 2379, params={"ttl": 10})
@pytest.fixture(scope="function")
def registry():
return EtcdRegistry(url)
class TestEtcdRegistry:
def teardown_method(self, method):
if hasattr(self, "registry"):
self.registry.deregister(*self.args)
self.registry.destroy()
del self.registry
del self.args
def test_register(self, registry):
service = "test"
url = URL("locahost", 80, params={"node": "n1"})
self.registry = registry
# coding: utf-8
import pytest
import gevent
from gevent import sleep
from doge.rpc.server import Server
from doge.rpc.context import Context
from doge.common.url import URL
from doge.rpc.client import Client
from doge.common.exceptions import RemoteError
url = URL("127.0.0.1", 4399, params={"name": "test", "node": "n1"})
rurl = URL("127.0.0.1", 2379, params={"ttl": 10})
context = Context(url, rurl)
class Sum(object):
def sum(self, x, y):
return x + y
@pytest.fixture(scope='module')
def server():
s = Server(context)
s.load(Sum)
g = gevent.spawn(s.run)
sleep(0.1)
yield s
g.kill()
s.registry.destroy()
def new_endpoint(k, v):
host, port = v.split(":")
url = URL(str(host), int(port), k)
return EndPoint(url)
def lb():
url = URL("127.0.0.1", 4399, "")
ep = EndPoint(url)
return RandomLB(url, [ep])
def new_endpoint(k: Union[int, str], v: str) -> EndPoint:
host, port = v.split(":")
url = URL(str(host), int(port), k)
return EndPoint(url)
