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)