def find_or_make_instance_for_instance_tag(self, service_instance):
instance_tag = self.get_instance_tag(service_instance)
instance = self.find_instance_for_instance_tag(instance_tag)
if instance:
if instance.no_sync:
# if no_sync is still set, then perhaps we failed while saving it and need to retry.
self.save_instance(service_instance, instance)
return instance
desired_image = self.get_image(service_instance)
desired_flavor = self.get_flavor(service_instance)
slice = service_instance.owner.slices.first()
(node, parent) = LeastLoadedNodeScheduler(slice, label=None).pick()
assert (slice is not None)
assert (node is not None)
assert (desired_image is not None)
assert (service_instance.creator is not None)
assert (node.site_deployment.deployment is not None)
assert (desired_image is not None)
instance = Instance(slice=slice,
node=node,
image=desired_image,
creator=service_instance.creator,
deployment=node.site_deployment.deployment,
flavor=desired_flavor,
isolation=slice.default_isolation,
parent=parent)
self.save_instance(service_instance, instance)
return instance
def manage_container(self, tenant):
if tenant.deleted:
return
if tenant.instance is None:
if not tenant.owner.slices.count():
raise SynchronizerConfigurationError(
"The service has no slices")
new_instance_created = False
slice = [
s for s in tenant.owner.slices.all()
if tenant.slice_name in s.name
]
slice = slice[0]
desired_image = slice.default_image
flavor = slice.default_flavor
if not flavor:
flavors = Flavor.objects.filter(name="m1.small")
if not flavors:
raise SynchronizerConfigurationError("No m1.small flavor")
flavor = flavors[0]
if slice.default_isolation == "container_vm":
raise Exception("Not implemented")
else:
(node, parent) = LeastLoadedNodeScheduler(slice).pick()
assert (slice is not None)
assert (node is not None)
assert (desired_image is not None)
assert (tenant.creator is not None)
assert (node.site_deployment.deployment is not None)
assert (flavor is not None)
try:
instance = Instance(slice=slice,
node=node,
image=desired_image,
creator=tenant.creator,
deployment=node.site_deployment.deployment,
flavor=flavor,
isolation=slice.default_isolation,
parent=parent)
self.save_instance(instance)
new_instance_created = True
tenant.instance = instance
tenant.save()
except:
# NOTE: We don't have transactional support, so if the synchronizer crashes and exits after
# creating the instance, but before adding it to the tenant, then we will leave an
# orphaned instance.
if new_instance_created:
instance.delete()
def find_or_make_instance_for_s_tag(self, service_instance):
instance = self.find_instance_for_s_tag(service_instance.volt.s_tag)
if instance:
if instance.no_sync:
# if no_sync is still set, then perhaps we failed while saving it and need to retry.
self.save_instance(service_instance, instance)
return instance
desired_image = self.get_image(service_instance)
flavors = Flavor.objects.filter(name="m1.small")
if not flavors:
raise SynchronizerConfigurationError("No m1.small flavor")
slice = service_instance.owner.slices.first()
(node, parent) = LeastLoadedNodeScheduler(
slice,
label=self.get_vsg_service(service_instance).node_label).pick()
assert (slice is not None)
assert (node is not None)
assert (desired_image is not None)
assert (node.site_deployment.deployment is not None)
assert (desired_image is not None)
assert (service_instance.volt)
assert (service_instance.volt.subscriber)
assert (service_instance.volt.subscriber.creator)
instance = Instance(slice=slice,
node=node,
image=desired_image,
creator=service_instance.volt.subscriber.creator,
deployment=node.site_deployment.deployment,
flavor=flavors[0],
isolation=slice.default_isolation,
parent=parent)
self.save_instance(service_instance, instance)
return instance
