def _add_running_services_at_startup():
wait_for_consul_ready()
try:
ship_ip, ship_name = get_ship_ip_and_name()
containers_saved_in_kv = get_local_services_from_kv_store()
sleep(10)
all_services = consul_query('agent/services')
if 'consul' in all_services:
del all_services['consul']
for service_id, service_dict in six.iteritems(all_services):
if ':' in service_id:
continue
if service_dict['Service'] == 'armada':
continue
key = create_consul_services_key(ship_name,
service_dict['Service'],
service_id)
if not containers_saved_in_kv or key not in containers_saved_in_kv:
save_container(ship_name,
service_id,
'started',
ship_ip=ship_ip)
get_logger().info(
'Added running service: {}'.format(service_id))
except Exception:
get_logger().exception('Unable to add running services.')
def _load_containers_to_kv_store(saved_containers_path):
wait_for_consul_ready()
try:
ship_ip, ship_name = get_ship_ip_and_name()
saved_containers = _load_saved_containers_parameters(saved_containers_path)
_load_from_dict(saved_containers, ship_name, ship_ip)
except:
get_logger().exception('Unable to load from %s', saved_containers_path)
def recover_saved_containers_from_parameters(saved_containers):
wait_for_consul_ready()
try:
ship_ip, ship_name = get_ship_ip_and_name()
_load_from_dict(saved_containers, ship_name, ship_ip)
except Exception as e:
get_logger().exception(e)
containers_to_be_recovered = recover_containers_from_kv_store()
return containers_to_be_recovered
def on_post(self, req, resp, microservice_id):
try:
input_json = req.json
container_id = microservice_id.split(':')[0]
microservice_name = input_json['microservice_name']
microservice_data = {
'microservice_id':
microservice_id,
'microservice_name':
microservice_name,
'single_active_instance':
bool(input_json.get('single_active_instance')),
'container_created_timestamp':
input_json['container_created_timestamp'],
'microservice_port':
local_port_to_external_port(
container_id, input_json['microservice_local_port']),
}
microservice_tags = []
if input_json.get('microservice_env'):
microservice_tags.append('env:{}'.format(
input_json['microservice_env']))
if input_json.get('microservice_app_id'):
microservice_tags.append('app_id:{}'.format(
input_json['microservice_app_id']))
if microservice_tags:
microservice_data['microservice_tags'] = microservice_tags
microservice_version = input_json.get('microservice_version')
register_service_in_consul(microservice_data)
if microservice_version and microservice_name != 'armada' and not is_subservice(
microservice_name):
ship_ip, ship_name = get_ship_ip_and_name()
save_container(ship_name,
container_id,
status='started',
start_timestamp=str(
input_json['container_created_timestamp']),
ship_ip=ship_ip)
update_service_dict(ship_name, microservice_name, container_id,
'microservice_version',
microservice_version)
resp.json = microservice_data
except Exception as e:
logging.exception(e)
resp.json = {
'error': 'Could not register service: {}'.format(repr(e))
}
resp.status = falcon.HTTP_400
def _start_container(self, long_container_id):
docker_api = docker_client.api(timeout=30)
docker_api.start(long_container_id)
service_endpoints = {}
service_ip, ship_name = get_ship_ip_and_name()
docker_inspect = docker_api.inspect_container(long_container_id)
container_id = shorten_container_id(long_container_id)
save_container(ship_name,
container_id,
status='started',
ship_ip=service_ip)
for container_port, host_address in docker_inspect['NetworkSettings'][
'Ports'].items():
service_endpoints['{0}:{1}'.format(
service_ip, host_address[0]['HostPort'])] = container_port
return service_endpoints
def on_post(self, req, resp):
try:
microservice_data = req.json
register_service_in_consul(microservice_data)
result = {'microservice_data': microservice_data}
ship_ip, ship_name = get_ship_ip_and_name()
microservice_id = microservice_data['microservice_id']
container_id = microservice_id.split(':')[0]
if not is_subservice(microservice_data['microservice_name']):
save_container(
ship_name,
container_id,
status='started',
start_timestamp=str(
microservice_data['container_created_timestamp']),
ship_ip=ship_ip)
except Exception as e:
return self.status_exception(resp, 'Could not register service.',
e)
return self.status_ok(resp, {'result': result})
def get_local_services_from_kv_store():
ship_ip, ship_name = get_ship_ip_and_name()
if ship_name == ship_ip:
return get_services_by_ship(ship_name)
return get_services_by_ship(ship_name) + get_services_by_ship(ship_ip)
