def _create_fake_infrastructure_and_flavor():
with flavorsync.app.app_context():
manager = DatabaseManager()
flavor = util.create_secondary_example_flavor()
manager.register_infrastructure(flavor.nodes[0])
manager.create_flavor(flavor)
return flavor.id
def __init__(self):
self.database_manager = DatabaseManager()
class FlavorSynchronizer():
def __init__(self):
self.database_manager = DatabaseManager()
##############
#Management of the completed lifecycle of the flavors, including private, public and promoted flavors
#That should be only possible if all the management is done using this API, if the different regions don't use it,
#it will be complicated to maintain the coherence.
#Hence, this part is not finished and tested, since we have not centralized this management.
#########
def register_infrastructure(self, infrastructure):
self.database_manager.register_infrastructure(infrastructure)
def unregister_infrastructure(self, name):
self.database_manager.unregister_infrastructure(name)
def get_flavors(self, public, promoted):
flavors = self._get_public_flavors(public, promoted)
flavor_collection = FlavorCollection(flavors)
if not public and not promoted:
private_flavors = self._get_private_flavors()
self._remove_duplicated_flavors(flavors, private_flavors)
flavor_collection.extend(private_flavors)
return flavor_collection
def get_flavors_region(self, region):
private_flavors = self._get_private_flavors()
return flavor_collection
def create_flavor(self, flavor):
f = self._create_private_flavor(flavor)
return f
def get_flavor(self, flavor_id):
try:
flavor = self._get_public_flavor(flavor_id)
except FlavorNotFoundExceptionError:
flavor = self._get_private_flavor(flavor_id)
return flavor
def publish_or_promote_flavor(self, flavor_id, modified_flavor):
self._check_well_formed_publishing_conditions(modified_flavor)
current_flavor = self.get_flavor(flavor_id)
self._check_publishing_conditions(current_flavor, modified_flavor)
self._publish_or_promote_flavor(current_flavor, modified_flavor)
return current_flavor
def add_node_to_flavor(self, flavor_id, modified_flavor):
current_flavor = self.get_flavor(flavor_id)
self._create_private_flavor(current_flavor)
self.database_manager.add_node_to_flavor(current_flavor,
modified_flavor.nodes)
return current_flavor
def delete_flavor(self, flavor_id):
flavor = self.get_flavor(flavor_id)
self._delete_private_flavor(flavor.id)
if flavor.public:
self._delete_node_in_flavor(flavor)
def is_node_included(self, region):
return self._exist_node(region)
def get_nodes(self):
return self._get_nodes()
#########
#########
##############
#Management of the promoted flavors, which are not related with the private flavors.
#This part has been integrated with the DashFI.
#########
def get_public_flavor(self, flavor_id):
try:
flavor = self._get_public_flavor(flavor_id)
except FlavorNotFoundExceptionError:
flavor = None
return flavor
def create_promoted_flavor(self, flavor):
#this method only manage the promoted flavors. Hence, it is responsible to force the promoted attribute.
flavor.promoted = True
flavor.public = True
if not flavor.id:
flavor.id = str(uuid4())
print (flavor)
print (flavor.id)
f = self._publish_flavor(flavor)
return f
def delete_promoted_flavor(self, flavor_id):
#If the promoted flavor has nodes associated an error raised, since it is not allowed to remove promote flavors with nodes.
#If you only manage promoted flavors, it shouldn't happen,
#nevertheless if you are managing the complete life cycle, the flavor cannot be deleted if it has nodes associated.
self.database_manager.delete_flavor(flavor_id)
#########
#########
#########
#Manage only the private flavors for the different regions.
#This part has been integrated with the DashFI.
#########
def get_region_flavors(self, region):
private_flavors = self._get_private_region_flavors(region)
return private_flavors
def get_region_flavor(self, region, flavor_id):
try:
flavor = self._get_private_region_flavor(region, flavor_id)
except FlavorNotFoundExceptionError:
flavor = None
return flavor
def create_region_flavor(self, region, flavor):
f = self._create_private_region_flavor(region, flavor)
return f
def delete_region_flavor(self, region, flavor_id):
self._delete_private_region_flavor(region, flavor_id)
########
########
########
##Common and private methods
########
def _get_public_flavors(self, public, promoted):
return self.database_manager.get_flavors(public, promoted)
def _exist_node(self, region):
infrastructure = self.database_manager.get_infrastructure(region)
if infrastructure is None:
return False
else:
return True
def _get_nodes(self):
infrastructures = self.database_manager.get_infrastructures()
infrastructure_collection = InfrastructureCollection(infrastructures)
return infrastructure_collection
#with token of KeyStone
def _get_private_region_flavors(self, region):
token = session['token_keystone']
infrastructure = self.database_manager.get_infrastructure(region)
openstack_manager = OpenStackManager(region, token)
openstack_flavors = openstack_manager.get_flavors()
#TODO review how to manage the infrastructure to be aligned with the data base definition.
return FlavorCollection.from_openstack_flavor_list(openstack_flavors, infrastructure)
def _get_private_region_flavor(self, region, flavor_id):
token = session['token_keystone']
infrastructure = self.database_manager.get_infrastructure(region)
openstack_manager = OpenStackManager(region, token)
openstack_flavor = openstack_manager.get_flavor(flavor_id)
return Flavor.from_openstack_flavor(openstack_flavor, infrastructure)
def _create_private_region_flavor(self, region, flavor):
token = session['token_keystone']
infrastructure = self.database_manager.get_infrastructure(region)
openstack_manager = OpenStackManager(region, token)
created_flavor = openstack_manager.create_flavor(flavor)
return Flavor.from_openstack_flavor(created_flavor, infrastructure)
def _delete_private_region_flavor(self, region, flavor_id):
token = session['token_keystone']
infrastructure = self.database_manager.get_infrastructure(region)
openstack_manager = OpenStackManager(region, token)
openstack_manager.delete_flavor(flavor_id)
#without Keystone token
def _get_private_flavors(self):
infrastructure = self.database_manager.get_infrastructure('Mordor')
openstack_manager = OpenStackManager(infrastructure)
openstack_flavors = openstack_manager.get_flavors()
return FlavorCollection.from_openstack_flavor_list(openstack_flavors, infrastructure)
def _create_private_flavor(self, flavor):
infrastructure = self.database_manager.get_infrastructure('Mordor')
openstack_manager = OpenStackManager(infrastructure)
created_flavor = openstack_manager.create_flavor(flavor)
return Flavor.from_openstack_flavor(created_flavor, infrastructure)
def _publish_flavor(self, flavor):
f = self.database_manager.create_flavor(flavor)
return f
def _get_private_flavor(self, flavor_id):
infrastructure = self.database_manager.get_infrastructure('Mordor')
openstack_manager = OpenStackManager(infrastructure)
openstack_flavor = openstack_manager.get_flavor(flavor_id)
return Flavor.from_openstack_flavor(openstack_flavor, infrastructure)
def _get_public_flavor(self, flavor_id):
return self.database_manager.get_flavor(flavor_id)
def _delete_private_flavor(self, flavor_id):
infrastructure = self.database_manager.get_infrastructure('Mordor')
openstack_manager = OpenStackManager(infrastructure)
openstack_manager.delete_flavor(flavor_id)
def _delete_node_in_flavor(self, flavor):
infrastructure = self.database_manager.get_infrastructure('Mordor')
self.database_manager.delete_node_in_flavor(flavor, infrastructure)
def _check_well_formed_publishing_conditions(self, flavor):
if flavor.promoted and flavor.public is not None and not flavor.public:
raise PromotedNotPublicFlavorBadRequestError()
def _check_publishing_conditions(self, current_flavor, modified_flavor):
if (modified_flavor.public is not None
and current_flavor.public
and not modified_flavor.public
or current_flavor.promoted and not modified_flavor.promoted):
raise UnpublishUnpromotedFlavorError()
def _publish_or_promote_flavor(self, current_flavor, modified_flavor):
if modified_flavor.public:
current_flavor.public = modified_flavor.public
if modified_flavor.promoted is not None:
current_flavor.promoted = modified_flavor.promoted
current_flavor = self._publish_flavor(current_flavor)
elif modified_flavor.promoted:
current_flavor = self.database_manager.promote_flavor(current_flavor)
return current_flavor
def _is_openstack_flavor(self, flavor):
return flavor is None
def _remove_duplicated_flavors(self, public_flavors, private_flavors):
for public_flavor in public_flavors:
for private_flavor in private_flavors.flavors:
if private_flavor.id in public_flavor.id:
private_flavors.flavors.remove(private_flavor)
class AuthManager():
def __init__(self):
self.db_manager = DatabaseManager()
def get_tenant_info(self):
return self.db_manager.get_infrastructure()
