def test_hung_processes(self):
ps_output = [{
'id': 58002,
'type': 'core'
}, {
'id': 58003,
'type': 'agent'
}]
stdout = MagicMock()
stderr = MagicMock()
mock_os_kill = MagicMock()
mock_time_sleep = MagicMock()
mock_find_pids = MagicMock(return_value=ps_output)
with patch('os.kill', mock_os_kill), \
patch('time.sleep', mock_time_sleep), \
patch('conductr_cli.sandbox_common.find_pids', mock_find_pids):
logging_setup.configure_logging(MagicMock(**self.default_args),
stdout, stderr)
sandbox_stop_jvm.stop(MagicMock(**self.default_args))
self.assertEqual(
headline('Stopping ConductR') + '\n', self.output(stdout))
self.assertEqual(
strip_margin(
as_error(
"""|Error: ConductR core pid 58002 could not be stopped
|Error: ConductR agent pid 58003 could not be stopped
|Error: Please stop the processes manually
|""")), self.output(stderr))
mock_os_kill.assert_has_calls(
[call(58002, signal.SIGTERM),
call(58003, signal.SIGTERM)])
def start(self):
if major_version(self.image_version) == 1:
pass
else:
log = logging.getLogger(__name__)
log.info(
headline(
'Starting logging feature based on elasticsearch and kibana'
))
log.info(
'conductr-kibana bundle is packaged as a Docker image. Checking Docker requirements..'
)
docker.validate_docker_vm(docker.vm_type())
log.info('Docker is installed and configured correctly.')
elasticsearch = select_bintray_uri('conductr-elasticsearch',
self.version_args)
log.info('Deploying bundle %s..' % elasticsearch['bundle'])
elasticsearch_load_command = ['load', elasticsearch['bundle'], '--disable-instructions'] + \
parse_offline_mode_arg(self.offline_mode)
conduct_main.run(elasticsearch_load_command,
configure_logging=False)
conduct_main.run(
['run', elasticsearch['name'], '--disable-instructions'],
configure_logging=False)
kibana = select_bintray_uri('conductr-kibana', self.version_args)
log.info('Deploying bundle %s..' % kibana['bundle'])
kibana_load_command = ['load', kibana['bundle'], '--disable-instructions'] + \
parse_offline_mode_arg(self.offline_mode)
conduct_main.run(kibana_load_command, configure_logging=False)
conduct_main.run([
'run', kibana['name'], '--disable-instructions',
'--wait-timeout', '600'
],
configure_logging=False)
def stop(args):
"""
Stops the existing ConductR core and agent processes.
This is done by interrogating the output of the ps, looking for java process which is running of the sandbox image.
directory.
:param args: args parsed from the input arguments
"""
log = logging.getLogger(__name__)
core_info, agent_info = sandbox_common.resolve_conductr_info(
args.image_dir)
pids_info = sandbox_common.find_pids(core_info['extraction_dir'],
agent_info['extraction_dir'])
if pids_info:
log.info(headline('Stopping ConductR'))
killed_pids_info, hung_pids_info = kill_processes(
core_info, agent_info, pids_info)
if hung_pids_info:
for hung_pid_info in hung_pids_info:
log.error('ConductR {} pid {} could not be stopped'.format(
hung_pid_info['type'], hung_pid_info['id']))
log.error('Please stop the processes manually')
return False
else:
log.info('ConductR has been successfully stopped')
return True
else:
return True
def start_proxy(nr_of_containers):
log = logging.getLogger(__name__)
bundle_name = 'conductr-haproxy'
configuration_name = 'conductr-haproxy-dev-mode'
log.info(headline('Starting HAProxy'))
log.info('Deploying bundle {} with configuration {}'.format(bundle_name, configuration_name))
conduct_main.run(['load', bundle_name, configuration_name, '--disable-instructions'], configure_logging=False)
conduct_main.run(['run', bundle_name, '--scale', str(nr_of_containers), '--disable-instructions'], configure_logging=False)
def stop(args):
"""`sandbox stop` command"""
log = logging.getLogger(__name__)
running_containers = sandbox_common.resolve_running_docker_containers()
if running_containers:
log.info(headline('Stopping ConductR'))
terminal.docker_rm(running_containers)
def start(self):
if major_version(self.image_version) == 1:
pass
else:
log = logging.getLogger(__name__)
log.info(headline('Starting logging feature based on eslite'))
eslite = select_bintray_uri('eslite', self.version_args)
log.info('Deploying bundle %s..' % eslite['bundle'])
conduct_main.run(['load', eslite['bundle'], '--disable-instructions'], configure_logging=False)
conduct_main.run(['run', eslite['name'], '--disable-instructions'], configure_logging=False)
def start(self):
if major_version(self.image_version) == 1:
pass
else:
log = logging.getLogger(__name__)
log.info(headline('Starting visualization feature'))
visualizer = select_bintray_uri('visualizer', self.version_args)
log.info('Deploying bundle %s..' % visualizer['bundle'])
conduct_main.run(['load', visualizer['bundle'], '--disable-instructions'], configure_logging=False)
conduct_main.run(['run', visualizer['name'], '--disable-instructions'], configure_logging=False)
def print_result(container_names, is_started, no_wait, wait_timeout, image_version):
if not no_wait:
log = logging.getLogger(__name__)
if is_started:
log.info(headline('Summary'))
log.info('ConductR has been started')
plural_string = 's' if len(container_names) > 1 else ''
log.info('Check resource consumption of Docker container{} that run the ConductR node{} with:'
.format(plural_string, plural_string))
log.info(' docker stats {}'.format(' '.join(container_names)))
log.info('Check current bundle status with:')
log.info(' conduct info')
if major_version(image_version) != 1:
log.info('Bundle status:')
conduct_main.run(['info'], configure_logging=False)
else:
log.info(headline('Summary'))
log.error('ConductR has not been started within {} seconds.'.format(wait_timeout))
log.error('Set the env CONDUCTR_SANDBOX_WAIT_RETRY_INTERVAL to increase the wait timeout.')
def start(self):
log = logging.getLogger(__name__)
log.info(headline('Starting monitoring feature'))
bundle_repo = ''
if self.version_args and self.version_args[0] == 'snapshot':
bundle_repo = 'lightbend/commercial-monitoring/'
grafana = select_bintray_uri('cinnamon-grafana', self.version_args, bundle_repo)
log.info('Deploying bundle %s..' % grafana['bundle'])
conduct_main.run(['load', grafana['bundle'], '--disable-instructions'], configure_logging=False)
conduct_main.run(['run', grafana['name'], '--disable-instructions'], configure_logging=False)
def test_success(self):
stdout = MagicMock()
containers = ['cond-0', 'cond-1']
with patch('conductr_cli.sandbox_common.resolve_running_docker_containers', return_value=containers), \
patch('conductr_cli.terminal.docker_rm') as mock_docker_rm:
logging_setup.configure_logging(MagicMock(**self.default_args), stdout)
sandbox_stop.stop(MagicMock(**self.default_args))
self.assertEqual(headline('Stopping ConductR') + '\n', self.output(stdout))
mock_docker_rm.assert_called_once_with(containers)
def log_run_attempt(args, run_result, is_started, wait_timeout):
container_names = run_result.container_names
if not args.no_wait:
log = logging.getLogger(__name__)
if is_started:
log.info(headline('Summary'))
log.info('ConductR has been started')
plural_string = 's' if len(container_names) > 1 else ''
log.info(
'Check resource consumption of Docker container{} that run the ConductR node{} with:'
.format(plural_string, plural_string))
log.info(' docker stats {}'.format(' '.join(container_names)))
log.info('Check current bundle status with:')
log.info(' conduct info')
else:
log.info(headline('Summary'))
log.error(
'ConductR has not been started within {} seconds.'.format(
wait_timeout))
log.error(
'Set the env CONDUCTR_SANDBOX_WAIT_RETRY_INTERVAL to increase the wait timeout.'
)
def start(self):
if major_version(self.image_version) == 1:
pass
else:
log = logging.getLogger(__name__)
log.info(headline('Starting logging feature based on eslite'))
eslite = select_bintray_uri('eslite', self.version_args)
log.info('Deploying bundle %s..' % eslite['bundle'])
load_command = ['load', eslite['bundle'], '--disable-instructions'] + \
parse_offline_mode_arg(self.offline_mode)
conduct_main.run(load_command, configure_logging=False)
conduct_main.run(['run', eslite['name'], '--disable-instructions'],
configure_logging=False)
def log_run_attempt(args, run_result, is_started, wait_timeout):
"""
Logs the run attempt. This method will be called after the completion of run method and when all the features has
been started.
:param args: args parsed from the input arguments
:param run_result: the result from calling sandbox_run_jvm.run() - instance of sandbox_run_jvm.SandboxRunResult
:param is_started: sets to true if sandbox is started
:param wait_timeout: the amount of timeout waiting for sandbox to be started
:return:
"""
log = logging.getLogger(__name__)
if not args.no_wait:
if is_started:
log.info(headline('Summary'))
log.info('ConductR has been started:')
nr_instance_core = len(run_result.core_pids)
plural_core = 's' if nr_instance_core > 1 else ''
log.info(' core: {} instance{}'.format(nr_instance_core,
plural_core))
nr_instance_agent = len(run_result.agent_pids)
plural_agents = 's' if nr_instance_agent > 1 else ''
log.info(' agent: {} instance{}'.format(nr_instance_agent,
plural_agents))
log.info('Check current bundle status with:')
log.info(' conduct info')
conduct_main.run(['info', '--host', run_result.host],
configure_logging=False)
else:
log.info(headline('Summary'))
log.error(
'ConductR has not been started within {} seconds.'.format(
wait_timeout))
log.error(
'Set the env CONDUCTR_SANDBOX_WAIT_RETRY_INTERVAL to increase the wait timeout.'
)
def start(self):
if major_version(self.image_version) == 1:
pass
else:
log = logging.getLogger(__name__)
log.info(headline('Starting logging feature based on elasticsearch and kibana'))
elasticsearch = select_bintray_uri('conductr-elasticsearch', self.version_args)
log.info('Deploying bundle %s..' % elasticsearch['bundle'])
conduct_main.run(['load', elasticsearch['bundle'], '--disable-instructions'], configure_logging=False)
conduct_main.run(['run', elasticsearch['name'], '--disable-instructions'], configure_logging=False)
kibana = select_bintray_uri('conductr-kibana', self.version_args)
log.info('Deploying bundle %s..' % kibana['bundle'])
conduct_main.run(['load', kibana['bundle'], '--disable-instructions'], configure_logging=False)
conduct_main.run(['run', kibana['name'], '--disable-instructions'], configure_logging=False)
def stop_proxy():
log = logging.getLogger(__name__)
try:
running_container = get_running_haproxy()
if running_container:
log.info(headline('Stopping HAProxy'))
is_docker_present()
terminal.docker_rm([DEFAULT_SANDBOX_PROXY_CONTAINER_NAME])
log.info('HAProxy has been successfully stopped')
return True
except (AttributeError, CalledProcessError):
# Fail silently as these errors will be raised if Docker is not installed or Docker environment is not
# configured properly.
return False
def stop(args):
log = logging.getLogger(__name__)
running_containers = sandbox_common.resolve_running_docker_containers()
if running_containers:
log.info(headline('Stopping ConductR'))
try:
terminal.docker_rm(running_containers)
log.info('ConductR has been successfully stopped')
return True
except (AttributeError, CalledProcessError):
log.error(
'ConductR containers could not be stopped pid 58002 could not be stopped'
)
log.error('Please stop the Docker containers manually')
return False
else:
return True
def start(self):
log = logging.getLogger(__name__)
log.info(headline('Starting monitoring feature'))
bundle_repo = 'lightbend/commercial-monitoring/' if self.version_args and self.version_args[0] == 'snapshot' \
else ''
bundle_name = 'cinnamon-grafana' if major_version(
self.image_version) == 1 else 'cinnamon-grafana-docker'
grafana = select_bintray_uri(bundle_name, self.version_args,
bundle_repo)
log.info('Deploying bundle %s..' % grafana['bundle'])
load_command = ['load', grafana['bundle'], '--disable-instructions'] + \
parse_offline_mode_arg(self.offline_mode)
conduct_main.run(load_command, configure_logging=False)
conduct_main.run([
'run', grafana['name'], '--disable-instructions', '--wait-timeout',
'600'
],
configure_logging=False)
def run(args, features):
"""
Starts the ConductR core and agent.
:param args: args parsed from the input arguments
:param features: list of features which are specified via -f switch.
This is only relevant for Docker based sandbox since the features decides what port to expose
:return: SandboxRunResult
"""
nr_of_core_instances, nr_of_agent_instances = instance_count(
args.image_version, args.nr_of_instances)
validate_jvm_support()
validate_64bit_support()
sandbox_stop.stop(args)
log = logging.getLogger(__name__)
log.info(headline('Starting ConductR'))
bind_addrs = find_bind_addrs(
max(nr_of_core_instances, nr_of_agent_instances), args.addr_range)
core_extracted_dir, agent_extracted_dir = obtain_sandbox_image(
args.image_dir, args.image_version, args.offline_mode)
core_addrs = bind_addrs[0:nr_of_core_instances]
core_pids = start_core_instances(core_extracted_dir, core_addrs,
args.conductr_roles, features,
args.log_level)
agent_addrs = bind_addrs[0:nr_of_agent_instances]
agent_pids = start_agent_instances(agent_extracted_dir,
bind_addrs[0:nr_of_agent_instances],
core_addrs, args.conductr_roles,
features, args.log_level)
return SandboxRunResult(core_pids, core_addrs, agent_pids, agent_addrs)
def start_nodes(args, features):
container_names = []
log = logging.getLogger(__name__)
log.info(headline('Starting ConductR'))
ports = collect_ports(args, features)
conductr_args = flatten([feature.conductr_args() for feature in features])
conductr_features = flatten([feature.conductr_feature_envs() for feature in features])
feature_conductr_roles = flatten([feature.conductr_roles() for feature in features])
for i in range(args.nr_of_containers):
container_name = '{prefix}{nr}'.format(prefix=CONDUCTR_NAME_PREFIX, nr=i)
container_names.append(container_name)
# Display the ports on the command line. Only if the user specifies a certain feature, then
# the corresponding port will be displayed when running 'sandbox run' or 'sandbox debug'
if ports:
host_ip = host.resolve_ip_by_vm_type(args.vm_type)
ports_desc = ' exposing ' + ', '.join(['{}:{}'.format(host_ip, map_port(i, port))
for port in sorted(ports)])
else:
ports_desc = ''
log.info('Starting container {container}{port_desc}..'.format(container=container_name,
port_desc=ports_desc))
cond0_ip = inspect_cond0_ip() if i > 0 else None
conductr_container_roles = resolve_conductr_roles_by_container(args.conductr_roles, feature_conductr_roles, i)
run_conductr_cmd(
i,
args.nr_of_containers,
container_name,
cond0_ip,
args.envs,
'{image}:{version}'.format(image=args.image, version=args.image_version),
args.log_level,
ports,
args.bundle_http_port,
conductr_features,
conductr_container_roles,
conductr_args
)
return container_names
def start_docker_instance(proxy_bind_addr, proxy_ports):
log = logging.getLogger(__name__)
log.info(headline('Starting HAProxy'))
docker_image = terminal.docker_images(HAPROXY_DOCKER_IMAGE)
if not docker_image:
log.info('Pulling docker image {}'.format(HAPROXY_DOCKER_IMAGE))
terminal.docker_pull(HAPROXY_DOCKER_IMAGE)
all_proxy_ports = []
all_proxy_ports.extend(DEFAULT_PROXY_PORTS)
all_proxy_ports.extend(proxy_ports)
all_proxy_ports = sorted(all_proxy_ports)
port_args = []
for port in all_proxy_ports:
port_args.append('-p')
port_args.append('{}:{}:{}'.format(proxy_bind_addr.exploded, port, port))
docker_args = ['-d', '--name', DEFAULT_SANDBOX_PROXY_CONTAINER_NAME] + port_args + \
['-v', '{}:/usr/local/etc/haproxy:ro'.format(HAPROXY_CFG_DIR)]
log.info('Exposing the following ports {}'.format(all_proxy_ports))
terminal.docker_run(docker_args, HAPROXY_DOCKER_IMAGE, positional_args=[])
def start_nodes(args, nr_of_containers, features):
container_names = []
log = logging.getLogger(__name__)
log.info(headline('Starting ConductR'))
ports = collect_ports(args, features)
conductr_args = flatten([feature.conductr_args() for feature in features])
conductr_features = flatten(
[feature.conductr_feature_envs() for feature in features])
feature_conductr_roles = flatten(
[feature.conductr_roles() for feature in features])
for i in range(nr_of_containers):
container_name = '{prefix}{nr}'.format(prefix=CONDUCTR_NAME_PREFIX,
nr=i)
container_names.append(container_name)
# Display the ports on the command line. Only if the user specifies a certain feature, then
# the corresponding port will be displayed when running 'sandbox run' or 'sandbox debug'
if ports:
host_ip = host.DOCKER_IP
ports_desc = ' exposing ' + ', '.join([
'{}:{}'.format(host_ip, map_port(i, port))
for port in sorted(ports)
])
else:
ports_desc = ''
log.info('Starting container {container}{port_desc}..'.format(
container=container_name, port_desc=ports_desc))
cond0_ip = inspect_cond0_ip() if i > 0 else None
conductr_container_roles = sandbox_common.resolve_conductr_roles_by_instance(
args.conductr_roles, feature_conductr_roles, i)
run_conductr_cmd(
i, nr_of_containers, container_name, cond0_ip, args.envs,
'{image}:{version}'.format(image=args.image,
version=args.image_version),
args.log_level, ports, args.bundle_http_port, conductr_features,
conductr_container_roles, conductr_args)
return container_names
