def map_sync_inputs(self, controller_image):
swarm_manager_url = controller_image.controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
input_fields = {
'swarm_manager_address':
swarm_manager_address,
'docker_registry_port':
docker_registry_port,
'image_file_path':
controller_image.image.path,
'image_dir':
os.path.dirname(controller_image.image.path),
'image_name':
controller_image.image.name,
'image_tag':
controller_image.image.tag,
'delete':
False,
'ansible_tag':
'%s@%s' %
(controller_image.image.name, controller_image.controller.name
) # name of ansible playbook
}
slog.info("input_fields: %s" % str(input_fields))
return input_fields
def map_delete_inputs(self, controller_network):
# make sure to not delete a shared network
"""
if (controller_network.network.template.shared_network_name or controller_network.network.template.shared_network_id):
return
"""
swarm_manager_url = controller_network.controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
try:
slice = controller_network.network.owner
except:
raise Exception('Could not get slice for Network %s' %
controller_network.network.name)
network_name = controller_network.network.name
#subnet_name = '%s-%d'%(network_name,controller_network.pk)
cidr = controller_network.subnet
network_fields = {
'swarm_manager_address':
swarm_manager_address,
'network_name':
network_name,
'ansible_tag':
'%s-%s@%s' % (network_name, slice.slicename,
controller_network.controller.name),
'delete':
True
}
return network_fields
def chk_svc_exist(self, instance, swarm_manager_address):
duplicated_flag = False
try:
instance_name = '%s-%s-%d' % (instance.slice.service.name,
instance.slice.name, instance.id)
slog.debug("Service name to chkeck: %s" % instance_name)
import docker
docker_api_base_url = "tcp://%s:4243" % swarm_manager_address
slog.debug("Docker API Base URL: %s" % docker_api_base_url)
my_client = docker.DockerClient(base_url=docker_api_base_url)
swarm_svc = my_client.services.get(instance_name)
slog.debug("swarm_svc.id : %s" % swarm_svc.id)
slog.debug("swarm_svc.name : %s" % swarm_svc.name)
slog.debug("swarm_svc.attrs : %s" % swarm_svc.attrs)
except Exception as ex:
slog.error("Exception: %s %s %s" %
(type(ex), str(ex), ex.args))
slog.error("%s" % str(traceback.format_exc()))
slog.info(
"There is no duplicated service name, I would create new service (%s)"
% instance_name)
duplicated_flag = False
else:
slog.info("There is duplicated service name (%s)" % instance_name)
duplicated_flag = True
return duplicated_flag
def delete_record(self, controller_slice_privilege):
controller_register = json.loads(
controller_slice_privilege.controller.backend_register)
slog.info("controller_register: %s" % controller_register)
if (controller_register.get('disabled', False)):
raise InnocuousException(
'Controller %s is disabled' %
controller_slice_privilege.controller.name)
def map_sync_outputs(self, controller_site_privilege, res):
# results is an array in which each element corresponds to an
# "ok" string received per operation. If we get as many oks as
# the number of operations we issued, that means a grand success.
# Otherwise, the number of oks tell us which operation failed.
slog.info("res: %s" % res)
controller_site_privilege.role_id = res[0]['id']
controller_site_privilege.save()
def alloc_gateway(self, subnet):
# given a CIDR, allocate a default gateway using the .1 address within the subnet.
# 10.123.0.0/24 --> 10.123.0.1
# 207.141.192.128/28 --> 207.141.192.129
(network, bits) = subnet.split("/")
network = network.strip()
bits = int(bits.strip())
netmask = (~(pow(2, 32 - bits) - 1) & 0xFFFFFFFF)
ip = struct.unpack("!L", socket.inet_aton(network))[0]
ip = ip & netmask | 1
slog.info("subnet: %s gateway: %s" % (subnet, ip))
return socket.inet_ntoa(struct.pack("!L", ip))
def map_sync_inputs(self, controller_user):
slog.debug("controller user: %r" % controller_user)
if not controller_user.controller.admin_user:
slog.info("controller %r has no admin_user, skipping" %
controller_user.controller)
return
# All users will have at least the 'user' role at their home site/tenant.
# We must also check if the user should have the admin role
roles = ['user']
# setup user home site roles at controller
if not controller_user.user.site:
raise Exception('Siteless user %s' % controller_user.user.email)
else:
swarm_manager_url = controller_user.controller.auth_url
slog.info("swarm_manager_url: %s" % swarm_manager_url)
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
user_fields = {
'swarm_manager_address':
swarm_manager_address,
'admin_user':
controller_user.controller.admin_user,
'ansible_tag':
'%s@%s' %
(controller_user.user.email.replace('@', '-at-'),
controller_user.controller.name) # name of ansible playbook
}
slog.info("user_fields: %s" % user_fields)
return user_fields
def sync_record(self, role):
slog.info("role: %r" % role)
slog.info("role.enacted: %s" % role.enacted)
if not role.enacted:
controllers = Controller.objects.all()
slog.info("controllers: %s" % controllers)
for controller in controllers:
slog.info("controller: %s" % controller)
role.save()
def map_delete_inputs(self, instance):
try:
controller_register = json.loads(
instance.node.site_deployment.controller.backend_register)
slog.debug("controller_register: %s" % controller_register)
if (controller_register.get('disabled', False)):
slog.info('Controller %s is disabled' %
instance.node.site_deployment.controller.name)
raise InnocuousException(
'Controller %s is disabled' %
instance.node.site_deployment.controller.name)
instance_name = '%s-%s-%d' % (instance.slice.service.name,
instance.slice.name, instance.id)
slog.debug("instance_name: %s" % instance_name)
controller = instance.node.site_deployment.controller
slog.debug("controller: %s" % controller)
swarm_manager_url = controller.auth_url
slog.debug("swarm_manager_url: %s" % swarm_manager_url)
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.debug(
"swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
host_volume_path = "/opt/xos/instance_volume/%s" % instance.id
slog.debug("host_volume_path: %s" % host_volume_path)
input = {
'swarm_manager_address': swarm_manager_address,
'swarm_service_name': instance_name,
'host_volume_path': host_volume_path,
'ansible_tag': instance_name,
'delete': True
}
return input
except Exception as ex:
slog.error("Exception: %s %s %s" %
(type(ex), str(ex), ex.args))
slog.error("%s" % str(traceback.format_exc()))
def fetch_pending(self, deletion=False):
slog.info("begin fetch_pending(%s)" % deletion)
objs = super(SyncInstances, self).fetch_pending(deletion)
slog.info("objs: %s" % objs)
objs = [x for x in objs if x.isolation == "vm"]
slog.info("vm objs: %s" % objs)
return objs
def map_sync_inputs(self, controller_network):
# make sure to not sync a shared network
slog.debug("controller_network: %s" % str(controller_network))
slog.debug("controller_network.subnet: %s" % controller_network.subnet)
slog.debug("controller_network.network_id: %s" %
controller_network.network_id)
slog.debug("controller_network.network.name: %s" %
controller_network.network.name)
slog.debug(
"controller_network.network.template.shared_network_name: %s" %
controller_network.network.template.shared_network_name)
slog.debug(
"controller_network.network.template.shared_network_id : %s" %
controller_network.network.template.shared_network_id)
# If shared_network_name is kuryr/libnetwork2:latest --> then, discard following if-statement.
"""
if (controller_network.network.template.shared_network_name or controller_network.network.template.shared_network_id):
if controller_network.network.template.shared_network_name.__contains__("kuryr"):
slog.debug("This is kuryr network")
else:
slog.debug("SyncStep.SYNC_WITHOUT_RUNNING: %s" % str(SyncStep.SYNC_WITHOUT_RUNNING))
return SyncStep.SYNC_WITHOUT_RUNNING
"""
slog.debug("network owner: %s creator: %s" %
(controller_network.network.owner,
controller_network.network.owner.creator))
if controller_network.network.owner and controller_network.network.owner.creator:
return self.save_controller_network(controller_network)
else:
slog.info("I could not create network controller information %s" %
controller_network)
raise Exception('I could not create network controller %s' %
controller_network)
def delete_record(self, controller_site_privilege):
controller_register = json.loads(controller_site_privilege.controller.backend_register)
slog.info("controller_register: %s" % controller_register)
if (controller_register.get('disabled',False)):
slog.info("Controller %s is disabled" % controller_site_privilege.controller.name)
raise InnocuousException('Controller %s is disabled'%controller_site_privilege.controller.name)
slog.info("Nothing to do on Swarm cluster")
pass
def fetch_pending(self, deleted=False):
lobjs = super(SyncControllerSites, self).fetch_pending(deleted)
slog.info("lobjs: %r" % lobjs)
slog.info("deleted: %s" % deleted)
if not deleted:
# filter out objects with null controllers
lobjs = [x for x in lobjs if x.controller]
slog.info("lobjs: %r" % lobjs)
return lobjs
def map_delete_inputs(self, controller_slice):
slog.info("controller_slice: %r" % controller_slice)
controller_users = ControllerUser.objects.filter(
user_id=controller_slice.slice.creator.id,
controller_id=controller_slice.controller.id)
slog.info(
"controller_slice.slice.creator.id: %s controller_slice.controller.id: %s"
% (controller_slice.slice.creator.id,
controller_slice.controller.id))
if not controller_users:
slog.info("slice createor %s has not accout at controller %s" %
(controller_slice.slice.creator,
controller_slice.controller.name))
raise Exception(
"slice createor %s has not accout at controller %s" %
(controller_slice.slice.creator,
controller_slice.controller.name))
else:
controller_user = controller_users[0]
swarm_manager_url = controller_slice.controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
tenant_fields = {
'swarm_manager_address':
swarm_manager_address,
'admin_user':
controller_slice.controller.admin_user,
'ansible_tag':
'%s@%s' %
(controller_slice.slice.name, controller_slice.controller.name),
'delete':
True
}
slog.info("tenant_fields: %s" % tenant_fields)
return tenant_fields
def map_delete_inputs(self, controller_image):
try:
controller_register = json.loads(
instance.node.site_deployment.controller.backend_register)
slog.debug("controller_register: %s" % controller_register)
if (controller_register.get('disabled', False)):
slog.info('Controller %s is disabled' %
instance.node.site_deployment.controller.name)
raise InnocuousException(
'Controller %s is disabled' %
instance.node.site_deployment.controller.name)
swarm_manager_url = controller_image.controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
input_fields = {
'swarm_manager_address':
swarm_manager_address,
'docker_registry_port':
docker_registry_port,
'image_file_path':
controller_image.image.path,
'image_dir':
os.path.dirname(controller_image.image.path),
'image_name':
controller_image.image.name,
'image_tag':
controller_image.image.tag,
'delete':
True,
'ansible_tag':
'%s@%s' %
(controller_image.image.name, controller_image.controller.name
) # name of ansible playbook
}
slog.info("input_fields: %s" % str(input_fields))
return input_fields
except Exception as ex:
slog.error("Exception: %s %s %s" %
(type(ex), str(ex), ex.args))
slog.error("%s" % str(traceback.format_exc()))
def update_instance_with_ssh(self, inst_id):
try:
import subprocess
import shlex
new_inst = Instance.objects.get(id=inst_id)
controller = new_inst.node.site_deployment.controller
swarm_manager_url = controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
volume_mount_opt = "--mount-add type=bind,src=/opt/xos/instance_volume/%s,dst=%s" % (
new_inst.id, new_inst.volumes)
## DOCKER SERVICE UPDATE
ssh_cmd = "ssh root@%s docker service update --force %s %s" % (
swarm_manager_address, volume_mount_opt,
new_inst.instance_name)
slog.debug("SSH CMD: %s" % ssh_cmd)
popen = subprocess.Popen(ssh_cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
(stdoutdata, stderrdata) = popen.communicate()
slog.debug("popen result: %s etc data: %s" %
(stdoutdata, stderrdata))
## DOCKER SERVICE STATUS
ssh_cmd = "ssh root@%s docker service ps %s" % (
swarm_manager_address, new_inst.instance_name)
slog.debug("SSH CMD: %s" % ssh_cmd)
popen = subprocess.Popen(ssh_cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
(stdoutdata, stderrdata) = popen.communicate()
slog.debug("popen result: %s etc data: %s" %
(stdoutdata, stderrdata))
except Exception as ex:
slog.info("Exception: %s %s %s" % (type(ex), str(ex), ex.args))
slog.info("%s" % str(traceback.format_exc()))
return 0
def chk_net_exist(self, controller_network, swarm_manager_address):
duplicated_flag = False
try:
slog.debug("network_name to check: %s" %
controller_network.network.name)
import docker
docker_api_base_url = "tcp://%s:4243" % swarm_manager_address
slog.info("Docker API Base URL: %s" % docker_api_base_url)
my_client = docker.DockerClient(base_url=docker_api_base_url)
net = my_client.networks.get(controller_network.network.name)
slog.debug("network.id : %s" % net.id)
slog.debug("network.name : %s" % net.name)
slog.debug("network.attrs[IPAM][Config] : %s" %
net.attrs['IPAM']['Config'])
slog.debug("network.attrs : %s" % net.attrs)
except Exception as ex:
slog.info("Exception: %s" % str(ex.args))
slog.info("Exception: %s" % str(ex))
duplicated_flag = False # There is no same network.
else:
duplicated_flag = True # There is same network.
slog.debug("network duplicated_flag: %s" % duplicated_flag)
return duplicated_flag
def map_sync_inputs(self, controller_site):
swarm_manager_url = controller_site.controller.auth_url
slog.info("swarm_manager_url: %s" % swarm_manager_url)
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
input_fields = {
'swarm_manager_address':
swarm_manager_address,
'admin_user':
controller_site.controller.admin_user,
'ansible_tag':
'%s@%s' %
(controller_site.site.login_base,
controller_site.controller.name), # name of ansible playbook
'tenant_description':
controller_site.site.name
}
slog.info("input_fields: %s" % input_fields)
return input_fields
def map_sync_outputs(self, instance, res):
try:
slog.info("ansible playbook ressult: %s" % str(res))
slog.info("ansible playbook ressult[3][stdout]: %s" %
str(res[3]['stdout']))
res_stdout = res[3]['stdout']
json_content = json.loads(res_stdout)
slog.info("json_content: %s" % str(json_content))
instance.instance_id = json_content[0]['Spec']["Name"]
slog.info("instance.instance_id: %s" % str(instance.instance_id))
instance.instance_uuid = json_content[0]['ID']
slog.info("instance.instance_uuid: %s" %
str(instance.instance_uuid))
controller = instance.node.site_deployment.controller
swarm_manager_url = controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
try:
instance.ip = socket.gethostbyname(swarm_manager_address)
except Exception, e:
slog.info(str(e))
slog.info("hostname(%s) resolution fail" %
swarm_manager_address)
pass
instance.instance_name = self.instance_name
instance.save()
def delete_record(self, controller_user):
slog.info("Nothing to delete (%r)" % controller_user)
pass
def sync_record(self, role):
slog.info("SyncImages:: role: %r" % role)
# nothing to do
pass
def map_sync_inputs(self, controller_site_privilege):
slog.info("begin map_sync_input()")
controller_register = json.loads(controller_site_privilege.controller.backend_register)
if not controller_site_privilege.controller.admin_user:
slog.info("controller %r has no admin_user, skipping" % controller_site_privilege.controller)
return
roles = [controller_site_privilege.site_privilege.role.role]
slog.info("roles: %s" % roles)
# setup user home site roles at controller
if not controller_site_privilege.site_privilege.user.site:
slog.info("Siteless user %s" % controller_site_privilege.site_privilege.user.email)
raise Exception('Siteless user %s'%controller_site_privilege.site_privilege.user.email)
else:
swarm_manager_url = controller_site_privilege.controller.auth_url
slog.info("swarm_manager_url: %s" % swarm_manager_url)
(swarm_manager_address, docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" % (
swarm_manager_address,
docker_registry_port))
user_fields = {
'swarm_manager_address' : swarm_manager_address,
'name': controller_site_privilege.site_privilege.user.email,
'admin_user': controller_site_privilege.controller.admin_user,
'ansible_tag':'%s@%s' % (
controller_site_privilege.site_privilege.user.email.replace('@','-at-'),
controller_site_privilege.controller.name)
}
slog.info("user_fields: %s" % user_fields)
return user_fields
def map_sync_inputs(self, controller_slice):
slog.info("sync'ing slice controller %s" % controller_slice)
if not controller_slice.controller.admin_user:
slog.info("controller %r has no admin_user, skipping" %
controller_slice.controller)
return
slog.info(
"controller_slice.slice.creator.id: %s controller_slice.controller.id: %s"
% (controller_slice.slice.creator.id,
controller_slice.controller.id))
controller_users = ControllerUser.objects.filter(
user_id=controller_slice.slice.creator.id,
controller_id=controller_slice.controller.id)
if not controller_users:
slog.info("slice createor %s has not accout at controller %s" %
(controller_slice.slice.creator,
controller_slice.controller.name))
raise Exception(
"slice createor %s has not accout at controller %s" %
(controller_slice.slice.creator,
controller_slice.controller.name))
else:
controller_user = controller_users[0]
max_instances = int(controller_slice.slice.max_instances)
slog.info("controller_slice.slice.max_instances: %s" %
controller_slice.slice.max_instances)
swarm_manager_url = controller_slice.controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
tenant_fields = {
'swarm_manager_address':
swarm_manager_address,
'admin_user':
controller_slice.controller.admin_user,
'ansible_tag':
'%s@%s' %
(controller_slice.slice.name, controller_slice.controller.name)
}
slog.info("tenant_fields: %s" % tenant_fields)
return tenant_fields
def map_sync_inputs(self, instance):
try:
slog.debug("instance: %s slice: %s" %
(instance, instance.slice.name))
controller = instance.node.site_deployment.controller
swarm_manager_url = controller.auth_url
slog.info("swarm_manager_url: %s" % swarm_manager_url)
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
## if instance.instance_uuid is not None,
## then This method will update the instance with new configuration.
swarm_service_update_flag = False
if instance.instance_uuid is not None:
if len(instance.instance_uuid) > 2:
swarm_service_update_flag = True
# check if this service is created already on swarm cluster.
duplicated_flag = self.chk_svc_exist(instance,
swarm_manager_address)
if duplicated_flag is True:
swarm_service_update_flag = True
## To get volume information
slog.debug("slice.mount_data_sets: %s" %
instance.slice.mount_data_sets)
mount_dest_path = "/usr/local/etc"
if len(instance.slice.mount_data_sets) < 2:
slog.debug("instance.slice.mount_data_sets(%s) is too short" %
instance.slice.mount_data_sets)
else:
mount_dest_path = instance.slice.mount_data_sets
slog.debug("volume mount destination path: %s" % mount_dest_path)
## set options for volume mounting
## (example) --mount type=bind,src=/opt/xos/instance_volume/1,dst=/usr/local/etc/haproxy
volume_mount_opt = " "
if swarm_service_update_flag is True:
volume_mount_opt = "--mount-add type=bind,src=/opt/xos/instance_volume/%s,dst=%s" % (
instance.id, mount_dest_path)
else:
volume_mount_opt = "--mount type=bind,src=/opt/xos/instance_volume/%s,dst=%s" % (
instance.id, mount_dest_path)
slog.debug("volume_mount_opt: %s" % volume_mount_opt)
host_volume_path = "/opt/xos/instance_volume/%s" % instance.id
slog.debug("host_volume_path: %s" % host_volume_path)
# sanity check - make sure model_policy for slice has run
if ((not instance.slice.policed)
or (instance.slice.policed < instance.slice.updated)):
slog.info(
"Instance %s waiting on Slice %s to execute model policies"
% (instance, instance.slice.name))
raise DeferredException(
"Instance %s waiting on Slice %s to execute model policies"
% (instance, instance.slice.name))
# sanity check - make sure model_policy for all slice networks have run
networks = instance.slice.ownedNetworks.all()
slog.debug("network list for slice of this instance(%s): %s" %
(instance.name, str(networks)))
for network in instance.slice.ownedNetworks.all():
slog.info("instance: %s network of slice(%s): %s" %
(instance.name, instance.slice.name, network.name))
if ((not network.policed)
or (network.policed < network.updated)):
slog.info(
"Instance %s waiting on Network %s to execute model policies"
% (instance, network.name))
raise DeferredException(
"Instance %s waiting on Network %s to execute model policies"
% (instance, network.name))
slog.debug("Model Policy checking is done successfully.")
swarm_network = ""
for network in networks:
slog.debug("networkd.id: %s(%s, %s) controller.id: %s" %
(network.id, network.name, network.subnet,
instance.node.site_deployment.controller.id))
if not ControllerNetwork.objects.filter(
network_id=network.id,
controller_id=instance.node.site_deployment.controller.
id).exists():
raise DeferredException(
"Instance %s Private Network %s lacks ControllerNetwork object"
% (instance, network.name))
swarm_network += " --network %s " % network.name
slog.debug("swarm_network: %s" % swarm_network)
image_name = None
controller_images = instance.image.controllerimages.all()
controller_images = [
x for x in controller_images if x.controller_id ==
instance.node.site_deployment.controller.id
]
if controller_images:
image_name = controller_images[0].image.name
slog.info("using image from ControllerImage object: " +
str(image_name))
host_filter = instance.node.name.strip()
slog.info("instance.node.name: %s" % instance.node.name)
instance_name = '%s-%s-%d' % (instance.slice.service.name,
instance.slice.name, instance.id)
slog.info(
"service name: %s instance.slice.name: %s instance.id: %s instance_name: %s"
% (instance.slice.service.name, instance.slice.name,
instance.id, instance_name))
self.instance_name = instance_name
input_fields = {
'swarm_manager_address': swarm_manager_address,
'swarm_service_name': instance_name,
'network_name': swarm_network,
'replicas': "--replicas 1",
'restart_condition':
"--restart-condition any --restart-delay 9s ",
'volume': volume_mount_opt,
'host_volume_path': host_volume_path,
'docker_registry_port': docker_registry_port,
'image_name': instance.image.name,
'image_tag': instance.image.tag,
'ansible_tag': instance_name,
'delete': False,
'update': swarm_service_update_flag
}
slog.info("input_fields: %s" % input_fields)
if swarm_service_update_flag is False:
slog.info(
"swarm_service_update_flag is %s, so I will update once more"
% swarm_service_update_flag)
try:
my_thr = threading.Thread(target=self.update_instance,
args=(instance, ))
my_thr.start()
except Exception as ex:
slog.error("Exception: %s %s %s" %
(type(ex), str(ex), ex.args))
slog.error("%s" % str(traceback.format_exc()))
return input_fields
except Exception as ex:
slog.error("Exception: %s %s %s" %
(type(ex), str(ex), ex.args))
slog.error("%s" % str(traceback.format_exc()))
def map_sync_inputs(self, controller_slice_privilege):
slog.info("controller_slice_privilege: %r" %
controller_slice_privilege)
if not controller_slice_privilege.controller.admin_user:
slog.info("controller %r has no admin_user, skipping" %
controller_slice_privilege.controller)
return
template = os_template_env.get_template('sync_controller_users.yaml')
slog.info("sync_controller_users.yaml --> template: %s" % template)
roles = [controller_slice_privilege.slice_privilege.role.role]
# setup user home slice roles at controller
if not controller_slice_privilege.slice_privilege.user.site:
slog.info('Sliceless user %s' %
controller_slice_privilege.slice_privilege.user.email)
raise Exception(
'Sliceless user %s' %
controller_slice_privilege.slice_privilege.user.email)
else:
swarm_manager_url = controller_slice_privilege.controller.auth_url
slog.info("swarm_manager_url: %s" % swarm_manager_url)
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
user_fields = {
'swarm_manager_address':
swarm_manager_address,
'admin_user':
controller_slice_privilege.controller.admin_user,
'ansible_tag':
'%s@%s@%s' %
(controller_slice_privilege.slice_privilege.user.email.replace(
'@', '-at-'),
controller_slice_privilege.slice_privilege.slice.name,
controller_slice_privilege.controller.name)
}
slog.info("user_fields: %s" % user_fields)
return user_fields
def update_instance(self, instance):
slog.info(
"[THREAD] instance_name: %s Thread: %s instance.updated: %s" %
(instance.instance_name, threading.current_thread().name,
instance.updated))
time.sleep(10)
try:
inst_id = instance.id
slog.debug("[THREAD] inst_id : %s" % inst_id)
old_update = 0
for idx in range(1, 100, 1):
slog.debug("[THREAD] idx: %s" % idx)
new_inst = Instance.objects.get(id=inst_id)
if old_update == 0:
old_update = new_inst.updated
slog.debug("[THREAD] updated(old) : %s" % time.strftime(
"%Y-%m-%d %H:%M:%S", time.gmtime(old_update)))
if (new_inst.volumes is not None) and (new_inst.instance_name
is not None):
if (len(new_inst.volumes) > 2) and (len(
new_inst.instance_name) > 2):
slog.debug("[THREAD] instance_name : %s (%s)" %
(new_inst.instance_name,
len(new_inst.instance_name)))
slog.debug("[THREAD] volumes : %s (%s)" %
(new_inst.volumes, len(new_inst.volumes)))
"""
if idx == 1:
self.update_instance_with_ssh(inst_id)
"""
new_inst.numberCores = idx
new_inst.updated = time.time()
slog.debug(
"[THREAD] updated to renew : %s (%s)" %
(time.strftime("%Y-%m-%d %H:%M:%S",
time.gmtime(new_inst.updated)),
new_inst.updated))
new_inst.save(update_fields=['updated', 'numberCores'])
time.sleep(1)
clone_inst = Instance.objects.get(id=inst_id)
clone_inst.save(update_fields=['numberCores'])
slog.debug(
"[THREAD] updated : %s (%s)" %
(time.strftime("%Y-%m-%d %H:%M:%S",
time.gmtime(clone_inst.updated)),
clone_inst.updated))
if clone_inst.updated == old_update:
slog.debug(
"[THREAD] updated date was not changed. Nothing is executed. Waiting 5 seconds."
)
time.sleep(5)
else:
slog.debug(
"[THREAD] updated date was changed. Swarm synchronizer will run ansible"
)
return
except Exception as ex:
slog.error("Exception: %s %s %s" %
(type(ex), str(ex), ex.args))
slog.error("%s" % str(traceback.format_exc()))
def save_controller_network(self, controller_network):
network_name = controller_network.network.name
#subnet_name = '%s-%d'%(network_name, controller_network.pk)
#slog.info("network_name: %s subnet_name: %s" % (network_name, subnet_name))
if controller_network.subnet and controller_network.subnet.strip():
# If a subnet is already specified (pass in by the creator), then
# use that rather than auto-generating one.
cidr = controller_network.subnet.strip()
slog.info("subnet CIDR_MS : %s" % cidr)
else:
cidr = self.alloc_subnet(controller_network.pk)
slog.info("subnet CIDR_AMS: %s" % cidr)
if controller_network.network.start_ip and controller_network.network.start_ip.strip(
):
start_ip = controller_network.network.start_ip.strip()
# FIXME: this assignment(gateway=start_ip) is temporary code.
# I would add a attribute gateway on core_network model.
controller_network.gateway = start_ip
else:
start_ip = None
controller_network.gateway = self.alloc_gateway(cidr)
if controller_network.network.end_ip and controller_network.network.end_ip.strip(
):
end_ip = controller_network.network.end_ip.strip()
else:
end_ip = None
slog.info("Start IP Address: %s End IP Address: %s" %
(start_ip, end_ip))
self.cidr = cidr
slice = controller_network.network.owner
opt_driver = "--driver=overlay" # default driver for swarm
opt_ipam_driver = " "
opt_ipam_neutron_opt = " "
if controller_network.network.template.shared_network_name is not None:
if controller_network.network.template.shared_network_name.__contains__(
"kuryr"):
opt_driver = "--driver=%s" % controller_network.network.template.shared_network_name
opt_ipam_driver = "--ipam-driver=%s" % controller_network.network.template.shared_network_name
opt_ipam_neutron_opt = "--ipam-opt=neutron.pool.uuid=%s -o neutron.pool.uuid=%s -o neutron.net.name=%s" % (
controller_network.network.labels,
controller_network.network.labels,
controller_network.network.name)
swarm_manager_url = controller_network.controller.auth_url
(swarm_manager_address,
docker_registry_port) = swarm_manager_url.split(':')
slog.info("swarm_manager_address: %s docker_registry_port: %s" %
(swarm_manager_address, docker_registry_port))
# check if this controller network is created already on swarm cluster.
duplicated_flag = self.chk_net_exist(controller_network,
swarm_manager_address)
network_fields = {
'swarm_manager_address':
swarm_manager_address,
'network_name':
network_name,
#'subnet_name': subnet_name,
'ansible_tag':
'%s-%s@%s' % (network_name, slice.slicename,
controller_network.controller.name),
'opt_driver':
opt_driver,
'opt_ipam_driver':
opt_ipam_driver,
'opt_ipam_neutron_opt':
opt_ipam_neutron_opt,
'opt_subnet':
"--subnet=%s" % cidr,
'opt_gateway':
"--gateway=%s" % controller_network.gateway,
'start_ip':
start_ip,
'end_ip':
end_ip,
'duplicated':
duplicated_flag,
'delete':
False
}
slog.info("network_fields: %s" % network_fields)
return network_fields
def map_sync_outputs(self, controller_slice_privilege, res):
slog.info("res: %s" % res)
controller_slice_privilege.role_id = res[0]['id']
controller_slice_privilege.save()
