def closing(cls, name, addr, use_mock_etcd):
clnt = None
with cls.ETCD_CLIENT_POOL_LOCK:
if (name in cls.ETCD_CLIENT_POOL
and len(cls.ETCD_CLIENT_POOL[name]) > 0):
clnt = cls.ETCD_CLIENT_POOL[name][0]
cls.ETCD_CLIENT_POOL[name] = cls.ETCD_CLIENT_POOL[name][1:]
if clnt is None:
try:
if use_mock_etcd:
clnt = mock_etcd.MockEtcdClient(addr[0], addr[1])
else:
clnt = etcd3.client(host=addr[0], port=addr[1])
except Exception as e:
clnt.close()
raise e
try:
yield clnt
except Exception as e:
clnt.close()
raise e
else:
with cls.ETCD_CLIENT_POOL_LOCK:
if cls.ETCD_CLIENT_POOL_DESTORY:
clnt.close()
else:
if name not in cls.ETCD_CLIENT_POOL:
cls.ETCD_CLIENT_POOL[name] = [clnt]
else:
cls.ETCD_CLIENT_POOL[name].append(clnt)
def etcd(self):
etcd = etcd3.client()
yield etcd
etcd.disarm_alarm()
for m in etcd.members:
if m.active_alarms:
etcd.disarm_alarm(m.id)
def main():
etcd_client = etcd3.client()
versions = {}
for node in db.get_nodes():
versions.setdefault(node.get('version', 'unknown'), 0)
versions[node.get('version', 'unknown')] += 1
print('Deployed versions:')
for version in sorted(versions):
print(' - %s: %s' % (version, versions[version]))
print()
min_version = None
if not versions:
min_version = '0.2'
elif 'unknown' in versions:
min_version = '0.2'
else:
min_version = sorted(versions)[0]
print('Minimum version is %s' % min_version)
elems = min_version.split('.')
major = int(elems[0])
minor = int(elems[1])
if major == 0:
if minor == 2:
clean_events_mesh_operations(etcd_client)
def registry_factory(self) -> Etcd3Client:
if self.server == None:
raise RegistryError("load etcd server error")
address = self.server.address
if address:
return etcd3.client(host=address.split(",")[0].split(":")[0], port=int(address.split(",")[0].split(":")[1]))
else:
raise RegistryError("load etcd server error")
def __init__(self, host, port, path_prefix):
self.log = structlog.get_logger()
self._etcd = etcd3.client(host=host, port=port)
self.host = host
self.port = port
self._path_prefix = path_prefix
self.retries = 0
def main():
f = open("config.json", "r")
data = json.loads(f.read())
f.close()
etcd = etcd3.client(host='localhost', port=2379)
for k, v in data.items():
etcd.put(k, json.dumps(v))
def etcd3_client(client_params):
try:
etcd = etcd3.client(**client_params)
etcd.status()
except Exception as exp:
raise AnsibleLookupError('Cannot connect to etcd cluster: %s' %
(to_native(exp)))
return etcd
def _etcd_client(conf):
# TODO(jaypipes): Cache etcd3 client connections?
client = etcd3.client(
host=conf.etcd_host,
port=conf.etcd_port,
timeout=conf.etcd_connect_timeout,
)
return client
def main():
module = AnsibleModule(
argument_spec=dict(
key=dict(),
id=dict(type=int),
host=dict(default="localhost"),
port=dict(type=int, default=2379),
user=dict(default=None),
password=dict(default=None, no_log=True),
get_value=dict(type=bool),
get_status=dict(type=bool),
get_lease_status=dict(type=bool),
),
required_together=[["user", "password"]],
required_if=(
("get_value", True, ["key"]),
("get_lease_status", True, ["id"]),
),
)
etcd = etcd3.client(
host=module.params["host"],
port=module.params["port"],
user=module.params["user"],
password=module.params["password"],
)
try:
if module.params["get_value"]:
resp = etcd.get(module.params["key"])
module.exit_json(value=resp[0].decode("utf-8"))
elif module.params["get_status"]:
resp = etcd.status()
module.exit_json(
status={
"db_size": resp.db_size,
"version": resp.version,
"raft_index": resp.raft_index,
"leader": {
"id": resp.leader.id,
"name": resp.leader.name
},
})
elif module.params["get_lease_status"]:
resp = etcd.get_lease_info(module.params["id"])
module.exit_json(
lease_status={
"ttl": resp.TTL,
"granted_ttl": resp.grantedTTL,
"keys": [k.decode("utf-8") for k in resp.keys],
})
else:
module.fail_json(msg="unknown parameters")
except Exception as error:
module.fail_json(msg=error)
finally:
etcd.close()
def __config_via_etcd():
ETCD_PORT = os.getenv('ETCD_PORT', 2379)
try:
etcd = etcd3.client(host=os.getenv('ETCD_HOST'), port=ETCD_PORT)
for variable in VARIABLES:
config[variable] = str(
etcd.get(f'que-vemos:{variable}')[0], 'utf-8')
except:
__config_via_dotenv()
def __init__(self, server, name):
import etcd3
srv, port = server.split(':')
self.etcd = etcd3.client(host=srv, port=port)
self.prefix = "/paddle/" + name
self.node_prefix = self.prefix + '/nodes'
self.np_path = self.prefix + '/np'
def __init__(self):
grpc_options = [
('grpc.max_receive_message_length', 100 * 1024 * 1024),
('grpc.max_send_message_length', 100 * 1024 * 1024),
]
self.client = etcd3.client(grpc_options=grpc_options)
# TODO: test client.
self.fds = [None] * 1024
self.logger = logging.getLogger('etcdfs')
def main():
args = getargs()
etcd_client = etcd3.client(host=args.etcd_host, port=args.etcd_port)
redis_client = redis.StrictRedis(host=args.redis_host,
port=args.redis_port,
db=args.redis_db)
migrate(args.source_root_prefix, etcd_client, redis_client, args.dry_run)
return 0
def __enter__(self):
self._logger.info('watching key range {}/*'.format(self._base_prefix))
self._client = etcd3.client(host=self._host)
self._watch_id = self._client.add_watch_prefix_callback(
key_prefix=self._base_prefix + '/',
callback=self._on_event,
)
for val, metadata in self._client.get_prefix(key_prefix=self._base_prefix):
self._update_key(metadata.key, val, metadata.version)
def make_agent_app(config):
from chipmunks.agent import Agent
etcd3_config = pack_etcd_config(config)
etcd3_cli = etcd3.client(**etcd3_config)
docker_params = pack_docker_config(config)
docker_cli = docker.DockerClient(timeout=60, version=None, **docker_params)
return Agent(docker_cli, etcd3_cli)
def __init__(self, confFile="%s/.etcd3.conf" % os.environ['HOME']):
if oct(os.stat(confFile).st_mode)[-3:] != "600":
print(
"Config file: %s Must be 600 UNIX rights in order to be used."
% confFile,
file=sys.stderr)
os._exit(1)
self.configfile = confFile
self.config = configparser.ConfigParser()
self.config.read(confFile)
if 'user' in self.config['server'].keys():
self.etcd = etcd3.client(
host=self.config['server']['host'],
port=int(self.config['server']['port']),
user=self.config['server']['user'],
password=self.config['server']['password'])
else:
self.etcd = etcd3.client(host=self.config['server']['host'],
port=int(self.config['server']['port']))
def __init__(self, data):
(host, port, user, password,
timeout) = unpack(data, ('host', 'localhost'), ('port', 2379), 'user',
'password', 'timeout')
self.store = etcd3.client(host=host,
port=port,
timeout=timeout,
user=user,
password=password)
def __init__(self,
host: str,
port: int,
dry_run: bool = False,
owner_id: str = 'skyreg'):
self._owner_id = owner_id
self._dry_run = dry_run
self._etcd = etcd3.client(host, port)
if not self._dry_run:
self._etcd.get('/')
def connect_etcd_cluster(host,
port,
ca_cert=None,
cert_key=None,
cert_cert=None):
return etcd3.client(host=host,
port=port,
ca_cert=ca_cert,
cert_key=cert_key,
cert_cert=cert_cert)
def _default_client(self):
etcd_service = urlparse(self.kv_url)
if self.kv_password:
return etcd3.client(
host=str(etcd_service.hostname),
port=etcd_service.port,
user=self.kv_username,
password=self.kv_password,
ca_cert=self.etcd_client_ca_cert,
cert_cert=self.etcd_client_cert_crt,
cert_key=self.etcd_client_cert_key,
)
return etcd3.client(
host=str(etcd_service.hostname),
port=etcd_service.port,
ca_cert=self.etcd_client_ca_cert,
cert_cert=self.etcd_client_cert_crt,
cert_key=self.etcd_client_cert_key,
)
def main(server_name):
client = etcd3.client(host="localhost", port=2379)
while True:
is_leader, lease = leader_election(client, server_name)
if is_leader:
print("I am the leader.")
on_leadership_gained(lease)
else:
print("I am a follower.")
wait_for_next_election(client)
def test_watch_timeout_on_establishment(self, etcd):
foo_etcd = etcd3.client(timeout=3)
def slow_watch_mock(*args, **kwargs):
time.sleep(4)
foo_etcd.watcher._watch_stub.Watch = slow_watch_mock # noqa
with pytest.raises(etcd3.exceptions.WatchTimedOut):
foo_etcd.watch('foo')
def change_domain(request, id):
if request.method == 'GET':
result = Domain.objects.filter(id=id).values('id', 'zone', 'host',
'type', 'data', 'ttl')
domain_type = Domain.dns_type_choice
domain_zone = Domain.dns_zone_choice
return render(
request, 'domain/domain_change.html', {
'result': result,
'domain_type': domain_type,
'domain_zone': domain_zone
})
else:
dns_upform = DomainValidForm(request.POST)
if dns_upform.is_valid():
try:
zone = request.POST.get('zone')
host = dns_upform.cleaned_data['host']
type = dns_upform.cleaned_data['type']
data = dns_upform.cleaned_data['data']
### 更新数据(数据库)
UpObj = Domain.objects.filter(id=id).update(
zone=zone,
host=host,
type=type,
data=data,
ttl='60',
update_datetime=timezone.now())
### 更新解析(Etcd)
etcd = etcd3.client(host='39.107.46.39', port=12379)
# Etcd存储路径
etcd_path = '/bind/named/named.linux-testing.com'
domain_path = etcd_path + '/domain/'
serial_path = etcd_path + '/serial/number'
# 删除旧域名
oldhost = request.POST.get('oldhost')
etcd.delete(domain_path + oldhost)
# 添加新域名
record = '%-20s IN A %-2s' % (host, data)
etcd.put(domain_path + host, record)
# 获取DNS序列号(每次更新+1)
number = etcd.get(serial_path)
number = number[0].decode(encoding='utf-8')
serial = int(number) + 1
# 更新DNS序列号
etcd.put(serial_path, str(serial))
return HttpResponse('success')
except Exception as err:
return HttpResponse(err)
else:
dns_form = DomainValidForm()
def __init__(self, member_id, parsed_url, options):
super(Etcd3Driver, self).__init__(member_id, parsed_url, options)
host = parsed_url.hostname or self.DEFAULT_HOST
port = parsed_url.port or self.DEFAULT_PORT
options = utils.collapse(options)
timeout = int(options.get('timeout', self.DEFAULT_TIMEOUT))
self.client = etcd3.client(host=host, port=port, timeout=timeout)
self.lock_timeout = int(options.get('lock_timeout', timeout))
self.membership_timeout = int(options.get(
'membership_timeout', timeout))
self._acquired_locks = set()
def test_user_pwd_auth(self, auth_mock):
auth_resp_mock = mock.MagicMock()
auth_resp_mock.token = 'foo'
auth_mock.Authenticate = auth_resp_mock
self._enable_auth_in_etcd()
# Create a client using username and password auth
client = etcd3.client(user='******', password='******')
assert client.call_credentials is not None
self._disable_auth_in_etcd()
def _start(self):
self.etcdclient = etcd3.client(
host=self.host,
port=self.port,
grpc_options={
"grpc.max_send_message_length": -1,
"grpc.max_receive_message_length": -1,
}.items(),
)
self.etcdclient.status()
threading.Thread(target=self._deliver, daemon=True).start()
def session(self):
if self._session is None:
logger.info('Connect to etcd:{0}:{1}'.format(
self.etcd_ip, self.etcd_port))
self._session = etcd3.client(host=self.etcd_ip,
port=self.etcd_port,
ca_cert=self.ca_crt,
cert_key=self.peer_key,
cert_cert=self.peer_crt)
return self._session
def make_chips_app(config):
from chipmunks.chips import Chipmunks
etcd3_config = pack_etcd_config(config)
etcd3_cli = etcd3.client(**etcd3_config)
nginx_config = {
'configuration_path': config.get('nginx.config_path'),
'nginx_pid_file': config.get('nginx.pid_path')
}
key_prefix = config.get('chipmunks.prefix', '/chipmunks/')
return Chipmunks(etcd3_cli, nginx_config, key_prefix)
def __init__(self, client_config, resource_config=None, logger=None):
self.client_config = client_config
self.logger = logger
self.connection = etcd3.client(**client_config)
self.config = resource_config or {}
self.name = self.config.get('name') \
if 'name' in self.config \
else None
self.resource_id = self.config.get('id', None) \
if 'id' in self.config \
else uuid4()
def etcd_client():
"""
Creates an etcd client instance with connection
:return: returns an etcd client instance
"""
host = os.environ.get('ETCD_HOST')
port = os.environ.get('ETCD_PORT')
etcd = etcd3.client(host=host, port=port)
return etcd
def __init__(self, member_id, parsed_url, options):
super(Etcd3Driver, self).__init__(member_id, parsed_url, options)
host = parsed_url.hostname or self.DEFAULT_HOST
port = parsed_url.port or self.DEFAULT_PORT
options = utils.collapse(options)
timeout = int(options.get('timeout', self.DEFAULT_TIMEOUT))
self.client = etcd3.client(host=host, port=port, timeout=timeout)
self.lock_timeout = int(options.get('lock_timeout', timeout))
self.membership_timeout = int(
options.get('membership_timeout', timeout))
self._acquired_locks = set()
def __init__(self, masterGraph, hubHost):
self.etcd = etcd3.client(host=hubHost, port=9022)
self.masterGraph = masterGraph
self.hubHost = hubHost
self.configGraph = ConjunctiveGraph()
self.boards = []
self.etcPrefix = 'pi/'
self.reread()
deferToThread(self.watchEtcd)
def gets(self):
client = etcd3.client(host=self.etcd_url, port=self.port)
client.get_prefix()
return_dict = {}
for shardid in self.shardsinfo:
assign_dict = {}
v3_prefix = os.path.join(self.prefix, str(self.shardsinfo[shardid]['gid']),self.type_module, str(shardid))
#print v3_prefix
gid = str(self.shardsinfo[shardid]['gid'])
for v3_kv in client.get_prefix(v3_prefix, sort_order=None, sort_target='key'):
#print v3_kv[1].key, v3_kv[0]
assign_dict[v3_kv[1].key.split('/')[-1]] = v3_kv[0]
default_prefix = os.path.join(self.prefix, gid, 'default')
for default_kv in client.get_prefix(default_prefix, sort_order=None, sort_target='key'):
#print default_kv[1].key, default_kv[0]
assign_dict[default_kv[1].key.split('/')[-1]] = default_kv[0]
return_dict[shardid] = assign_dict
return return_dict
def regist_api_etcd(api_version, m_key,m_value):
if api_version == 'v2':
try:
requests.put('http://%s:2379/%s/keys%s' % (etcdhost, etcd_api_version, m_key), data={'value': m_value})
except requests.exceptions.ConnectionError as e:
print 'Line %s Error Check Address: %s' % (sys._getframe().f_lineno, etcdhost)
exit(7)
elif api_version == 'v3':
try:
import etcd3
client = etcd3.client(host=etcdhost, port=2379)
client.put(m_key, m_value)
except AttributeError as e:
print 'Line %s Please check the address %s' % (sys._getframe().f_lineno,etcdhost)
exit(7)
except ImportError as e:
print 'Line %s Make sure install etcd3 module' %(sys._getframe().f_lineno)
exit(7)
except Exception as e:
print 'Line %s Error can not write key to etcd' % sys._getframe().f_lineno
exit(7)
def __init__(self,
host='127.0.0.1',
port=2379,
ca_cert=None,
cert_key=None,
cert_cert=None,
timeout=None,
user=None,
password=None,
grpc_options=None,
on_change=lambda e: None):
ConManBase.__init__(self)
self.on_change = on_change
self.client = etcd3.client(
host=host,
port=port,
ca_cert=ca_cert,
cert_key=cert_key,
cert_cert=cert_cert,
timeout=timeout,
user=user,
password=password,
grpc_options=grpc_options,
)
def run_module():
# define the available arguments/parameters that a user can pass to
# the module
module_args = dict(
key=dict(type='str', required=True),
value=dict(type='str', required=True),
host=dict(type='str', default='localhost'),
port=dict(type='int', default=2379),
state=dict(type='str', required=True, choices=['present', 'absent']),
)
# seed the result dict in the object
# we primarily care about changed and state
# change is if this module effectively modified the target
# state will include any data that you want your module to pass back
# for consumption, for example, in a subsequent task
result = dict(
changed=False,
)
# the AnsibleModule object will be our abstraction working with Ansible
# this includes instantiation, a couple of common attr would be the
# args/params passed to the execution, as well as if the module
# supports check mode
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=True
)
result['key'] = module.params.get('key')
if not etcd_found:
module.fail_json(msg="the python etcd3 module is required")
allowed_keys = ['host', 'port', 'ca_cert', 'cert_key', 'cert_cert',
'timeout', 'user', 'password']
# TODO(evrardjp): Move this back to a dict comprehension when python 2.7 is
# the minimum supported version
# client_params = {key: value for key, value in module.params.items() if key in allowed_keys}
client_params = dict()
for key, value in module.params.items():
if key in allowed_keys:
client_params[key] = value
try:
etcd = etcd3.client(**client_params)
except Exception as exp:
module.fail_json(msg='Cannot connect to etcd cluster: %s' % (to_native(exp)),
exception=traceback.format_exc())
try:
cluster_value = etcd.get(module.params['key'])
except Exception as exp:
module.fail_json(msg='Cannot reach data: %s' % (to_native(exp)),
exception=traceback.format_exc())
# Make the cluster_value[0] a string for string comparisons
result['old_value'] = to_native(cluster_value[0])
if module.params['state'] == 'absent':
if cluster_value[0] is not None:
if module.check_mode:
result['changed'] = True
else:
try:
etcd.delete(module.params['key'])
except Exception as exp:
module.fail_json(msg='Cannot delete %s: %s' % (module.params['key'], to_native(exp)),
exception=traceback.format_exc())
else:
result['changed'] = True
elif module.params['state'] == 'present':
if result['old_value'] != module.params['value']:
if module.check_mode:
result['changed'] = True
else:
try:
etcd.put(module.params['key'], module.params['value'])
except Exception as exp:
module.fail_json(msg='Cannot add or edit key %s: %s' % (module.params['key'], to_native(exp)),
exception=traceback.format_exc())
else:
result['changed'] = True
else:
module.fail_json(msg="State not recognized")
# manipulate or modify the state as needed (this is going to be the
# part where your module will do what it needs to do)
# during the execution of the module, if there is an exception or a
# conditional state that effectively causes a failure, run
# AnsibleModule.fail_json() to pass in the message and the result
# in the event of a successful module execution, you will want to
# simple AnsibleModule.exit_json(), passing the key/value results
module.exit_json(**result)
def etcd_put():
import etcd3
etcd = etcd3.client(host='127.0.0.1')
etcd.put('/foo', 'bar')
return "GET /etcd/put"
def etcd_get():
import etcd3
etcd = etcd3.client(host='127.0.0.1')
etcd.get('/foo')
return "GET /etcd/get"
import etcd3
from apisvc.common.config import CONFIG
_host = host = CONFIG['APISVC_DB_HOST']
_client = etcd3.client(host=_host)
# ===================================== #
# #
# ca management #
# #
# ===================================== #
def get_ca():
value, key = _client.get('/apisvc/ca')
return value, key
def get_ca_pem(target):
value, key = _client.get('/apisvc/ca/{0}'.format(target))
return value, key
# ===================================== #
# #
# node management #
# #
# ===================================== #
from __future__ import division
import sys
import etcd3
from twisted.python.filepath import FilePath
etcd = etcd3.client(host='bang6', port=9022)
prefix, = sys.argv[1:]
def main():
existing = set(md.key for v, md in etcd.get_prefix(prefix))
written = set()
root = FilePath('config')
print 'reading at %s' % root
for f in root.walk():
if f.isfile() and f.path.endswith('.n3'):
n3 = f.getContent()
key = prefix + b'/'.join(f.segmentsFrom(root))
etcd.put(key, n3)
written.add(key)
print 'wrote %s' % key
for k in existing - written:
etcd.delete(k)
print 'removed %s' % k
main()
