Initial split into own package

Author: knikolla

README.md

@@ -1 +1,23 @@
-# coldfront-plugin-openstack
+# OpenStack Plugin
+
+## Configuration
+
+The OpenStack plugin is fired automatically for resources of type `OpenStack`.
+
+It expects the Resource to have the following attributes set:
+ * `OpenStack Auth URL` - the URL of the Keystone endpoint (omitting version
+   and ending slash)
+ * `OpenStack Domain for Projects` - The domain id that new projects will be
+   created in
+ * `OpenStack Domain for Users` - The domain id that new users will be created in
+ * `OpenStack Identity Provider` - The identity provider as configured in keystone
+ * `OpenStack Federation Protocol` - (defaults to openid) The federation protocol
+   used with the identity provider
+ * `OpenStack Role for User in Project` - (defaults to member) The role name of
+   the role that is assigned to the user on project creation
+
+Authentication is done using application credentials. The application credential
+is stored as the pair of environment variables in the form
+`OPENSTACK_{resource_name}_APPLICATION_CREDENTIAL_ID` and
+`OPENSTACK_{resource_name}_APPLICATION_CREDENTIAL_SECRET` where `{resource_name}`
+is the all name of the resource as all uppercase (with spaces and `-` replaced by `_`).

pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

requirements.txt

@@ -0,0 +1,6 @@
+git+https://github.com/ubccr/coldfront@7bc52c05ba1246b50c5fd5877d8e9184045042ab#egg=coldfront
+python-cinderclient  # TODO: Set version for OpenStack Clients
+python-keystoneclient
+python-memcached==1.59
+python-novaclient
+python-neutronclient

setup.cfg

@@ -0,0 +1,28 @@
+[metadata]
+name = coldfront_plugin_openstack
+version = 0.1.0
+author = Kristi Nikolla
+author_email = [email protected]
+description = OpenStack resource allocation plugin for ColdFront
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/knikolla/coldfront-plugin-openstack
+project_urls =
+    Bug Tracker = https://github.com/knikolla/coldfront-plugin-openstack/issues
+classifiers =
+    Programming Language :: Python :: 3
+    License :: OSI Approved :: MIT License
+    Operating System :: OS Independent
+
+[options]
+package_dir =
+    = src
+packages = find:
+python_requires = >=3.8
+
+[options.packages.find]
+where = src
+
+[options.entry_points]
+console_scripts =
+    coldfront-plugin-openstack = django:setup

src/coldfront_plugin_openstack/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'coldfront_plugin_openstack.apps.OpenStackConfig'

src/coldfront_plugin_openstack/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class OpenStackConfig(AppConfig):
+    name = 'coldfront_plugin_openstack'
+
+    def ready(self):
+        import coldfront_plugin_openstack.signals

src/coldfront_plugin_openstack/config.py

@@ -0,0 +1,6 @@
+from coldfront.config.base import INSTALLED_APPS
+from coldfront.config.env import ENV
+
+INSTALLED_APPS += [
+    'coldfront_plugin_openstack',
+]

src/coldfront_plugin_openstack/management/commands/__init__.py

@@ -0,0 +1,75 @@
+from django.core.management.base import BaseCommand
+from django.core.management import call_command
+
+from coldfront.core.resource.models import (Resource,
+                                            ResourceAttribute,
+                                            ResourceAttributeType,
+                                            ResourceType)
+
+
+class Command(BaseCommand):
+    help = 'Create OpenStack resource'
+
+    def add_arguments(self, parser):
+        parser.add_argument('--name', type=str, required=True,
+                            help='Name of OpenStack resource')
+        parser.add_argument('--auth-url', type=str, required=True,
+                            help='URL of the OpenStack Identity Endpoint')
+        parser.add_argument('--users-domain', type=str, default='default',
+                            help='Domain ID to create users')
+        parser.add_argument('--projects-domain', type=str, default='default',
+                            help='Domain ID to create projects')
+        parser.add_argument('--idp', type=str, required=True,
+                            help='Identity provider configured in OpenStack')
+        parser.add_argument('--protocol', type=str, default='openid',
+                            help='Federation protocol (default: openid)')
+        parser.add_argument('--role', type=str, default='member',
+                            help='Role for user when added to project (default: member)')
+
+    def handle(self, *args, **options):
+        openstack = Resource.objects.get_or_create(
+            resource_type=ResourceType.objects.get(name='OpenStack'),
+            parent_resource=None,
+            name=options['name'],
+            description='OpenStack test cloud environment',
+            is_available=True,
+            is_public=True,
+            is_allocatable=True
+        )
+
+        resource_models.ResourceAttribute.objects.get_or_create(
+            resource_attribute_type=ResourceAttributeType.objects.get(
+                name='OpenStack Auth URL'),
+            resource=openstack,
+            value=options['auth-url']
+        )
+        ResourceAttribute.objects.get_or_create(
+            resource_attribute_type=ResourceAttributeType.objects.get(
+                name='OpenStack Domain for Projects'),
+            resource=openstack,
+            value=options['projects-domain']
+        )
+        ResourceAttribute.objects.get_or_create(
+            resource_attribute_type=ResourceAttributeType.objects.get(
+                name='OpenStack Domain for Users'),
+            resource=openstack,
+            value=options['users-domain']
+        )
+        ResourceAttribute.objects.get_or_create(
+            resource_attribute_type=ResourceAttributeType.objects.get(
+                name='OpenStack Identity Provider'),
+            resource=openstack,
+            value=options['idp']
+        )
+        ResourceAttribute.objects.get_or_create(
+            resource_attribute_type=ResourceAttributeType.objects.get(
+                name='OpenStack Federation Protocol'),
+            resource=openstack,
+            value=options['protocol']
+        )
+        ResourceAttribute.objects.get_or_create(
+            resource_attribute_type=ResourceAttributeType.objects.get(
+                name='OpenStack Role for User in Project'),
+            resource=openstack,
+            value=options['role']
+        )

src/coldfront_plugin_openstack/management/commands/add_openstack_resource.py

@@ -0,0 +1,49 @@
+from django.core.management.base import BaseCommand
+from django.core.management import call_command
+
+from coldfront.core.allocation import models as allocation_models
+from coldfront.core.resource import models as resource_models
+
+
+class Command(BaseCommand):
+    help = 'Add default OpenStack allocation related choices'
+
+    def register_allocation_attributes(self):
+        for name, attribute_type, has_usage, is_private in (
+                ('OpenStack Compute Instance Quota', 'Int', False, False),
+                ('OpenStack Compute RAM Quota', 'Int', False, False),
+                ('OpenStack Compute vCPU Quota', 'Int', False, False),
+                ('OpenStack Project ID', 'Text', False, False),
+                ('OpenStack Project Name', 'Text', False, False),
+        ):
+            allocation_models.AllocationAttributeType.objects.get_or_create(
+                name=name,
+                attribute_type=allocation_models.AttributeType.objects.get(
+                    name=attribute_type),
+                has_usage=has_usage,
+                is_private=is_private
+            )
+
+    def register_resource_attributes(self):
+        for resource_attribute_type, attribute_type in (
+            ('OpenStack Auth URL', 'Text'),
+            ('OpenStack Domain for Projects', 'Text'),
+            ('OpenStack Domain for Users', 'Text'),
+            ('OpenStack Federation Protocol', 'Text'),
+            ('OpenStack Identity Provider', 'Text'),
+            ('OpenStack Role for User in Project', 'Text'),
+        ):
+            resource_models.ResourceAttributeType.objects.get_or_create(
+                name=resource_attribute_type,
+                attribute_type=resource_models.AttributeType.objects.get(
+                    name=attribute_type)
+            )
+
+    def register_resource_type(self):
+        resource_models.ResourceType.objects.get_or_create(
+            name='OpenStack', description='OpenStack Cloud')
+
+    def handle(self, *args, **options):
+        self.register_resource_type()
+        self.register_resource_attributes()
+        self.register_allocation_attributes()

src/coldfront_plugin_openstack/management/commands/register_openstack_attributes.py

@@ -0,0 +1,38 @@
+from django.dispatch import receiver
+
+from coldfront_plugin_openstack.tasks import (activate_allocation,
+                                              add_user_to_allocation,
+                                              disable_allocation,
+                                              remove_user_from_allocation)
+from coldfront.core.allocation.signals import (allocation_activate,
+                                               allocation_activate_user,
+                                               allocation_disable,
+                                               allocation_remove_user)
+
+
+@receiver(allocation_activate)
+def activate_allocation_receiver(sender, **kwargs):
+    allocation_pk = kwargs.get('allocation_pk')
+    # TODO: Async implementation
+    activate_allocation(allocation_pk)
+
+
+@receiver(allocation_disable)
+def allocation_disable_receiver(sender, **kwargs):
+    allocation_pk = kwargs.get('allocation_pk')
+    # TODO: Async implementation
+    disable_allocation(allocation_pk)
+
+
+@receiver(allocation_activate_user)
+def activate_allocation_user_receiver(sender, **kwargs):
+    allocation_user_pk = kwargs.get('allocation_user_pk')
+    # TODO: Async implementation
+    add_user_to_allocation(allocation_user_pk)
+
+
+@receiver(allocation_remove_user)
+def allocation_remove_user_receiver(sender, **kwargs):
+    allocation_user_pk = kwargs.get('allocation_user_pk')
+    # TODO: Async implementation
+    remove_user_from_allocation(allocation_user_pk)