def start_service(self, service_definition_as_json, swarm_network):
"""
RPC method for starting a service in background on the worker
:param service_definition_as_json: Service definition as JSON
:param swarm_network: Network name
:return: True when the service has been started successfully
"""
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
docker_interface_object = docker_interface.DockerInterface()
llogger.debug("Run container: %s in background",
service_definition_as_json)
service_definition = jsonpickle.decode(service_definition_as_json)
try:
container = docker_interface_object.run_container_in_background(
service_definition, self._remote_logger, self._swarm_uuid,
self._uuid, swarm_network)
container.service_definition = service_definition
self._container_list.append(container)
return True
except DockerException as e:
llogger.exception(
e, "Error while starting service " + service_definition.tag)
return False
def join_docker_swarm(self, master_address, join_token):
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
docker_interface_object = docker_interface.DockerInterface()
try:
docker_interface_object.join_docker_swarm(master_address,
self._interface,
join_token)
except DockerException:
raise RuntimeError(traceback.format_exc())
def create_docker_network(self):
"""
Create a new Docker network
:return: List of Networks
"""
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
docker_interface_object = docker_interface.DockerInterface()
network = docker_interface_object.create_network(
network_name=self.swarm.uuid)
llogger.debug("Network created: %s", jsonpickle.encode(network.attrs))
return network.attrs.get("Name")
def create_new_swarm(self, new_master, predefined_uuid=None):
"""
Factory method for creating a new swarm
:param new_master: Object of the new master
:param predefined_uuid: Predefined UUID of the swarm
:return: Object of the new swarm
"""
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
docker_interface_object = docker_interface.DockerInterface()
docker_interface_object.init_docker_swarm(new_master.interface)
self.swarm = swarm.Swarm(predefined_uuid, new_master)
return self.swarm
def register_worker_in_swarm(self, swarm_uuid, new_worker):
"""
Register a new worker at the swarm
:param swarm_uuid: The UUID of the swarm
:param new_worker: Object of the new worker
:return:
"""
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
llogger.debug("Add worker: " + str(new_worker) + " to swarm: " +
swarm_uuid)
self.swarm.add_worker_to_list(new_worker)
dio = docker_interface.DockerInterface()
if new_worker.advertise_address != self.swarm.master.advertise_address:
new_worker.join_docker_swarm(self.swarm.advertise_address,
dio.get_join_token())
def get_remaining_image_download_size(self, image_tag):
"""
RPC method for checking if the service image is available on the worker
:param image_tag: name of the image
:return: size of image if it needs to be downloaded, otherwise 0
"""
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
img_size = 0
try:
docker_interface_object = docker_interface.DockerInterface()
img_size = docker_interface_object.get_image_size(image_tag)
except DockerException as e:
llogger.exception(e, "Unable to get remaining image download size")
pass
if img_size < 0:
return 0
return img_size
def check_hardware(self, service_definition_as_json):
"""
RPC method for checking the hardware capabilities of the worker for a specific service
:param service_definition_as_json: Service definition as JSON
:return: 1, when all hardware requirements have been met, otherwise 0
"""
llogger = local_logger.LocalLogger()
llogger.log_method_call(self.__class__.__name__,
sys._getframe().f_code.co_name)
service_definition = jsonpickle.decode(service_definition_as_json)
docker_interface_object = docker_interface.DockerInterface()
volume_vector = docker_interface_object.check_volumes(
service_definition)
llogger.debug("Vector of volume check: %s", volume_vector)
device_vector = docker_interface_object.check_devices(
service_definition)
llogger.debug("Vector of device check: %s", device_vector)
hardware_vector = volume_vector + device_vector
llogger.debug("Vector of hardware check: %s", hardware_vector)
if all(x == 1 for x in hardware_vector) or hardware_vector == []:
return 1
else:
return 0