def test_setup_environment(self):
service = self._start_service() # type: ConsulDockerisedService
service.setup_environment()
consul_client = Consul()
self._test_client(consul_client)
def get_client() -> Client:
return NomadClient(Consul())
def _redo_consul_connection(self):
self._consul = Consul(host=self.host, port=self.port)
def __init__(self):
self.cns: Consul = Consul()
self.kv = ConsulKVBasic(cns=self.cns)
def __init__(self, host, port, path_prefix):
self._consul = Consul(host=host, port=port)
self._path_prefix = path_prefix
self._cache = {}
def __init__(self, store_loc, store_path, delim='>'):
KvStore.__init__(self, store_loc, store_path, delim)
self.c = Consul()
self._payload = ConsulKvPayload(self.c, self._delim)
def __init__(self):
self.settings = {
k: v
for k, v in os.environ.items()
if k.isupper() and k.startswith("CN_CONFIG_CONSUL_")
}
self.settings.setdefault(
"CN_CONFIG_CONSUL_HOST",
"localhost",
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_PORT",
8500,
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_CONSISTENCY",
"stale",
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_SCHEME",
"http",
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_VERIFY",
False,
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_CACERT_FILE",
"/etc/certs/consul_ca.crt",
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_CERT_FILE",
"/etc/certs/consul_client.crt",
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_KEY_FILE",
"/etc/certs/consul_client.key",
)
self.settings.setdefault(
"CN_CONFIG_CONSUL_TOKEN_FILE",
"/etc/certs/consul_token",
)
self.settings.setdefault("CN_CONFIG_CONSUL_NAMESPACE", "jans")
self.prefix = f"{self.settings['CN_CONFIG_CONSUL_NAMESPACE']}/config/"
cert, verify = self._verify_cert(
self.settings["CN_CONFIG_CONSUL_SCHEME"],
self.settings["CN_CONFIG_CONSUL_VERIFY"],
self.settings["CN_CONFIG_CONSUL_CACERT_FILE"],
self.settings["CN_CONFIG_CONSUL_CERT_FILE"],
self.settings["CN_CONFIG_CONSUL_KEY_FILE"],
)
self._request_warning(self.settings["CN_CONFIG_CONSUL_SCHEME"], verify)
self.client = Consul(
host=self.settings["CN_CONFIG_CONSUL_HOST"],
port=self.settings["CN_CONFIG_CONSUL_PORT"],
token=self._token_from_file(
self.settings["CN_CONFIG_CONSUL_TOKEN_FILE"]),
scheme=self.settings["CN_CONFIG_CONSUL_SCHEME"],
consistency=self.settings["CN_CONFIG_CONSUL_CONSISTENCY"],
verify=verify,
cert=cert,
)
def init_client(self):
if self.consulClient is None:
self.consulClient = Consul(host=self.host)
# pylint: disable=redefined-outer-name
import time
import pytest
from consul import Consul
from consul_docker_autosync import __version__
from consul_docker_autosync.autosync import sync
consul = Consul()
@pytest.fixture
def sync_wrapper(docker, consul):
return lambda: sync(docker, consul)
def test_syncs_containers_with_labels(sync_wrapper, start_container):
container = start_container()
sync_wrapper()
services = consul.agent.services()
assert len(services) == 1
service = services["rafa-benitez"]
assert service["Service"] == "rafa-benitez"
assert service["Port"] == 8000
assert service["Meta"] == {"container_id": container.id}
def test_ignores_containers_without_labels(sync_wrapper, start_container):
start_container(labels={})
sync_wrapper()
zipkin_exporter = zipkin.ZipkinSpanExporter(
service_name="image-service",
# host_name="localhost",
# port=9411,
# endpoint='/api/v2/spans'
)
trace.get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(zipkin_exporter))
tracer = trace.get_tracer(__name__)
app = FastAPI()
client = httpx.AsyncClient()
consul = Consul(host='172.22.0.21', port=8500)
@app.on_event("startup")
async def startup_event():
service = Consul.Agent.Service(consul.agent)
service.register("FastAPI", port=3002)
@app.on_event("shutdown")
def shutdown_event():
service = Consul.Agent.Service(consul.agent)
service.deregister("FastAPI")
@app.get("/")
def setUp(self) -> None:
self.consul = Consul()
from functools import reduce
import os
class EnvironmentVariableNotFound(Exception):
"""
"""
# what if consul_host = [], IndexError... ?
consul_host = os.getenv('CONSUL_HOST')
if consul_host is None:
raise EnvironmentVariableNotFound('CONSUL_HOST should not be empty.')
consul_client = Consul(host=consul_host, port=8500, scheme='http')
consul_members = consul_client.agent.members()
def consul_role(acc, val):
"""
:param acc: Accumulator to list addresses
:param val: list item
:return: list of consul servers
"""
try:
if val['Tags']['role'] == 'consul':
acc.append(val['Addr'])
return acc
except AttributeError:
pass
_help = '<hostname>:<port> of Voltha simulated adapter backend for ' \
'testing (default={})'.format(
defs['voltha_sim_rest_endpoint'])
parser.add_argument('-s',
'--sim-rest-endpoint',
action='store',
default=defs['voltha_sim_rest_endpoint'],
help=_help)
args = parser.parse_args()
if args.lookup:
host = args.consul.split(':')[0].strip()
port = int(args.consul.split(':')[1].strip())
consul = Consul(host=host, port=port)
_, services = consul.catalog.service('voltha-grpc')
if not services:
print('No voltha-grpc service registered in consul; exiting')
sys.exit(1)
args.grpc_endpoint = '{}:{}'.format(services[0]['ServiceAddress'],
services[0]['ServicePort'])
_, services = consul.catalog.service('voltha-sim-rest')
if not services:
print('No voltha-sim-rest service registered in consul; exiting')
sys.exit(1)
args.sim_rest_endpoint = '{}:{}'.format(services[0]['ServiceAddress'],
services[0]['ServicePort'])
def cli(verbose, consul, consul_port, check_triggers, check_uptime, dryrun, maintenance_reason, ignore_global_stop_flag,
ignore_node_disabled, ignore_failed_checks, check_holidays, post_reboot_wait_until_healthy, lazy_consul_checks,
ensure_config, set_global_stop_flag, set_local_stop_flag):
"""Reboot Manager
Default values of parameteres are environment variables (if set)
"""
logsetup(verbose)
con = Consul(host=consul, port=int(consul_port))
hostname = socket.gethostname().split(".")[0]
if ensure_config:
if ensure_configuration(con, hostname, dryrun):
LOG.warning("Created default configuration, "
"since it was missing or invalid. Exit.")
else:
LOG.debug("Did not create default configuration, "
"since there already was one. Exit.")
sys.exit(0)
if set_global_stop_flag:
do_set_global_stop_flag(con, set_global_stop_flag)
sys.exit(0)
if set_local_stop_flag:
do_set_local_stop_flag(con, hostname)
sys.exit(0)
if not config_is_present_and_valid(con, hostname):
LOG.error("The configuration of this node (%s) seems to be missing. "
"Exit." % hostname)
sys.exit(EXIT_CONFIGURATION_IS_MISSING)
flags = {"check_triggers": check_triggers,
"check_uptime": check_uptime,
"dryrun": dryrun,
"maintenance_reason": maintenance_reason,
"ignore_global_stop_flag": ignore_global_stop_flag,
"ignore_node_disabled": ignore_node_disabled,
"ignore_failed_checks": ignore_failed_checks,
"check_holidays": check_holidays,
"lazy_consul_checks": lazy_consul_checks}
check_consul_cluster(con, ignore_failed_checks)
consul_lock = Lock(con, "service/rebootmgr/lock")
try:
# Try to get Lock without waiting
if not consul_lock.acquire(blocking=False):
LOG.error("Could not get consul lock. Exit.")
sys.exit(EXIT_CONSUL_LOCK_FAILED)
reboot_in_progress = check_reboot_in_progress(con)
if reboot_in_progress:
if reboot_in_progress.startswith(hostname):
# We are in post_reboot state
post_reboot_state(con, consul_lock, hostname, flags, post_reboot_wait_until_healthy)
sys.exit(0)
# Another node has the lock
else:
LOG.info("Another Node %s is rebooting. Exit." % reboot_in_progress)
sys.exit(EXIT_CONSUL_LOCK_FAILED)
# consul-key reboot_in_progress does not exist
# we are free to reboot
else:
# We are in pre_reboot state
pre_reboot_state(con, consul_lock, hostname, flags)
if not dryrun:
# Set a consul maintenance, which creates a 15 maintenance window in Zabbix
con.agent.maintenance(True, maintenance_reason)
LOG.warning("Reboot now ...")
try:
# NOTE(sneubauer): Reboot after 1 minutes. This was added
# for the MachineDB reboot task, so it can report success
# to the API before the actual reboot happens.
subprocess.run(["shutdown", "-r", "+1"], check=True)
except Exception as e:
LOG.error("Could not run reboot")
LOG.error("Remove consul key service/rebootmgr/reboot_in_progress")
con.kv.delete("service/rebootmgr/reboot_in_progress")
raise e
finally:
consul_lock.release()
def __init__(self):
# collects all env vars prefixed with `GLUU_CONFIG_CONSUL_`,
# for example `GLUU_CONFIG_CONSUL_HOST=localhost`
self.settings = {
k: v for k, v in os.environ.iteritems()
if k.isupper() and k.startswith("GLUU_CONFIG_CONSUL_")
}
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_HOST",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_HOST", "localhost"),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_PORT",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_PORT", 8500),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_CONSISTENCY",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_CONSISTENCY", "stale"),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_SCHEME",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_SCHEME", "http"),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_VERIFY",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_VERIFY", False),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_CACERT_FILE",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_CACERT_FILE",
"/etc/certs/consul_ca.crt"),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_CERT_FILE",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_CERT_FILE",
"/etc/certs/consul_client.crt"),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_KEY_FILE",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_KEY_FILE",
"/etc/certs/consul_client.key"),
)
self.settings.setdefault(
"GLUU_CONFIG_CONSUL_TOKEN_FILE",
# backward-compat with Gluu Server v3.1.4
os.environ.get("GLUU_CONSUL_TOKEN_FILE", "/etc/certs/consul_token"),
)
self.prefix = "gluu/config/"
token = None
cert = None
verify = False
if os.path.isfile(self.settings["GLUU_CONFIG_CONSUL_TOKEN_FILE"]):
with open(self.settings["GLUU_CONFIG_CONSUL_TOKEN_FILE"]) as fr:
token = fr.read().strip()
if self.settings["GLUU_CONFIG_CONSUL_SCHEME"] == "https":
verify = as_boolean(self.settings["GLUU_CONFIG_CONSUL_VERIFY"])
# verify using CA cert (if any)
if all([verify,
os.path.isfile(self.settings["GLUU_CONFIG_CONSUL_CACERT_FILE"])]):
verify = self.settings["GLUU_CONFIG_CONSUL_CACERT_FILE"]
if all([os.path.isfile(self.settings["GLUU_CONFIG_CONSUL_CERT_FILE"]),
os.path.isfile(self.settings["GLUU_CONFIG_CONSUL_KEY_FILE"])]):
cert = (self.settings["GLUU_CONFIG_CONSUL_CERT_FILE"],
self.settings["GLUU_CONFIG_CONSUL_KEY_FILE"])
self._request_warning(self.settings["GLUU_CONFIG_CONSUL_SCHEME"], verify)
self.client = Consul(
host=self.settings["GLUU_CONFIG_CONSUL_HOST"],
port=self.settings["GLUU_CONFIG_CONSUL_PORT"],
token=token,
scheme=self.settings["GLUU_CONFIG_CONSUL_SCHEME"],
consistency=self.settings["GLUU_CONFIG_CONSUL_CONSISTENCY"],
verify=verify,
cert=cert,
)
def __init__(self, raw_client: Optional[Consul] = None):
self.cns: Consul = raw_client or Consul()
self.kv = KVAdapter(cns=self.cns)
self.catalog = CatalogAdapter(cns=self.cns)
def __init__(self, cns: Optional[Consul] = None):
self.cns = cns or Consul()
#!/usr/bin/env python
'''
Copyright (C) 2019 Maged Mokhtar <mmokhtar <at> petasan.org>
Copyright (C) 2019 PetaSAN www.petasan.org
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU Affero General Public License
as published by the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
'''
from consul import Consul
node_name = input("Enter Node Name: ")
con = Consul()
con.kv.put(node_name, node_name)
