def setUp(self):
manager.register(
offering_type='TEST_TYPE',
create_resource_processor=utils.TestCreateProcessor,
)
self.service_settings = structure_factories.ServiceSettingsFactory(
type='Test', shared=True)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace_support import PLUGIN_NAME
from waldur_mastermind.support import models as support_models
from . import handlers, processor
signals.post_save.connect(
handlers.create_support_template,
sender=marketplace_models.Offering,
dispatch_uid='waldur_mastermind.marketpace_support.create_support_template',
)
signals.post_save.connect(
handlers.change_order_item_state,
sender=support_models.Offering,
dispatch_uid='waldur_mastermind.marketpace_support.order_item_set_state_done',
)
signals.post_save.connect(
handlers.create_support_plan,
sender=marketplace_models.Plan,
dispatch_uid='waldur_mastermind.marketpace_support.create_support_plan',
)
manager.register(PLUGIN_NAME, processor.process_support)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace import models as marketplace_models
from . import (
PLUGIN_NAME,
processors,
utils,
handlers,
registrators as booking_registrators,
)
manager.register(
offering_type=PLUGIN_NAME,
create_resource_processor=processors.BookingCreateProcessor,
delete_resource_processor=processors.BookingDeleteProcessor,
change_attributes_for_view=utils.change_attributes_for_view,
enable_usage_notifications=True,
)
booking_registrators.BookingRegistrator.connect()
signals.post_save.connect(
handlers.update_google_calendar_name_if_offering_name_has_been_changed,
sender=marketplace_models.Offering,
dispatch_uid='waldur_mastermind.booking.handlers.update_google_calendar_name',
)
def ready(self):
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace_packages import PLUGIN_NAME
from waldur_openstack.openstack import models as openstack_models
from . import handlers, processor
signals.post_save.connect(
handlers.create_template_for_plan,
sender=marketplace_models.Plan,
dispatch_uid='waldur_mastermind.marketpace_packages.'
'create_template_for_plan',
)
signals.post_save.connect(
handlers.change_order_item_state,
sender=openstack_models.Tenant,
dispatch_uid='waldur_mastermind.marketpace_packages.'
'change_order_item_state',
)
manager.register(offering_type=PLUGIN_NAME,
processor=processor.process_order_item,
validator=processor.validate_order_item,
components=dict(ram='RAM', cores='Cores', storage='Storage'))
def ready(self):
from waldur_core.structure import signals as structure_signals
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace.plugins import manager, Component
from waldur_rancher.apps import RancherConfig
from waldur_rancher import models as rancher_models
from . import handlers, PLUGIN_NAME, processors
USAGE = marketplace_models.OfferingComponent.BillingTypes.USAGE
manager.register(
offering_type=PLUGIN_NAME,
create_resource_processor=processors.RancherCreateProcessor,
delete_resource_processor=processors.RancherDeleteProcessor,
components=(Component(type='node',
name='K8S node',
measured_unit='',
billing_type=USAGE), ),
service_type=RancherConfig.service_name,
resource_model=rancher_models.Cluster,
)
marketplace_handlers.connect_resource_metadata_handlers(
rancher_models.Cluster)
marketplace_handlers.connect_resource_handlers(rancher_models.Cluster)
structure_signals.resource_imported.connect(
handlers.create_marketplace_resource_for_imported_cluster,
sender=rancher_models.Cluster,
dispatch_uid='waldur_mastermind.marketpace_rancher.'
'create_resource_for_imported_cluster',
)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace_support import PLUGIN_NAME
from waldur_mastermind.support import models as support_models
from . import handlers, processor
signals.post_save.connect(
handlers.create_support_template,
sender=marketplace_models.Offering,
dispatch_uid=
'waldur_mastermind.marketpace_support.create_support_template',
)
signals.post_save.connect(
handlers.change_order_item_state,
sender=support_models.Offering,
dispatch_uid=
'waldur_mastermind.marketpace_support.change_order_item_state',
)
signals.pre_delete.connect(
handlers.terminate_resource,
sender=support_models.Offering,
dispatch_uid=
'waldur_mastermind.marketpace_support.terminate_resource',
)
signals.post_save.connect(
handlers.create_support_plan,
sender=marketplace_models.Plan,
dispatch_uid=
'waldur_mastermind.marketpace_support.create_support_plan',
)
signals.post_save.connect(
handlers.change_offering_state,
sender=support_models.Issue,
dispatch_uid=
'waldur_mastermind.marketpace_support.change_offering_state',
)
signals.post_save.connect(
handlers.update_order_item_if_issue_was_complete,
sender=support_models.Issue,
dispatch_uid=
'waldur_mastermind.marketpace_support.update_order_item_if_issue_was_complete',
)
manager.register(
PLUGIN_NAME,
create_resource_processor=processor.CreateRequestProcessor,
update_resource_processor=processor.UpdateRequestProcessor,
delete_resource_processor=processor.DeleteRequestProcessor)
marketplace_handlers.connect_resource_metadata_handlers(
support_models.Offering)
def ready(self):
from waldur_core.structure import signals as structure_signals
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace.plugins import manager, Component
from waldur_rancher.apps import RancherConfig
from waldur_rancher import models as rancher_models
from . import handlers, PLUGIN_NAME, processors, registrators
registrators.RancherRegistrator.connect()
USAGE = marketplace_models.OfferingComponent.BillingTypes.USAGE
manager.register(
offering_type=PLUGIN_NAME,
create_resource_processor=processors.RancherCreateProcessor,
delete_resource_processor=processors.RancherDeleteProcessor,
components=(Component(
type='node',
name='K8S node',
measured_unit='nodes',
billing_type=USAGE,
), ),
service_type=RancherConfig.service_name,
get_importable_resources_backend_method='get_importable_clusters',
import_resource_backend_method='import_cluster',
)
marketplace_handlers.connect_resource_metadata_handlers(
rancher_models.Cluster)
marketplace_handlers.connect_resource_handlers(rancher_models.Cluster)
structure_signals.resource_imported.connect(
handlers.create_marketplace_resource_for_imported_cluster,
sender=rancher_models.Cluster,
dispatch_uid='waldur_mastermind.marketplace_rancher.'
'create_resource_for_imported_cluster',
)
signals.post_save.connect(
handlers.update_node_usage,
sender=rancher_models.Node,
dispatch_uid=
'waldur_mastermind.marketplace_rancher.update_node_usage',
)
signals.post_save.connect(
handlers.create_offering_user_for_rancher_user,
sender=rancher_models.RancherUser,
dispatch_uid=
'waldur_mastermind.marketplace_rancher.create_offering_user_for_rancher_user',
)
signals.pre_delete.connect(
handlers.drop_offering_user_for_rancher_user,
sender=rancher_models.RancherUser,
dispatch_uid=
'waldur_mastermind.marketplace_rancher.drop_offering_user_for_rancher_user',
)
def ready(self):
from waldur_mastermind.marketplace.plugins import Component
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.invoices import registrators
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_vmware import models as vmware_models
from waldur_vmware import signals as vmware_signals
from waldur_vmware.apps import VMwareConfig
from . import handlers, registrators as vmware_registrators, processors, VIRTUAL_MACHINE_TYPE
resource_models = (
vmware_models.VirtualMachine,
)
marketplace_handlers.connect_resource_handlers(*resource_models)
marketplace_handlers.connect_resource_metadata_handlers(*resource_models)
USAGE = marketplace_models.OfferingComponent.BillingTypes.USAGE
manager.register(offering_type=VIRTUAL_MACHINE_TYPE,
create_resource_processor=processors.VirtualMachineCreateProcessor,
service_type=VMwareConfig.service_name,
components=(
Component(type='cpu', name='CPU', measured_unit='vCPU', billing_type=USAGE),
# Price is stored per GiB but size is stored per MiB
# therefore we need to divide size by factor when price estimate is calculated.
Component(type='ram', name='RAM', measured_unit='GB', billing_type=USAGE, factor=1024),
Component(type='disk', name='Disk', measured_unit='GB', billing_type=USAGE, factor=1024),
))
registrators.RegistrationManager.add_registrator(
vmware_models.VirtualMachine,
vmware_registrators.VirtualMachineRegistrator
)
vmware_signals.vm_created.connect(
handlers.add_new_vm_to_invoice,
dispatch_uid='marketplace_vmware.handlers.add_new_vm_to_invoice',
)
signals.pre_delete.connect(
handlers.terminate_invoice_when_vm_deleted,
sender=vmware_models.VirtualMachine,
dispatch_uid='marketplace_vmware.handlers.terminate_invoice_when_vm_deleted',
)
vmware_signals.vm_updated.connect(
handlers.create_invoice_item_when_vm_is_updated,
dispatch_uid='marketplace_vmware.handlers.create_invoice_item_when_vm_is_updated',
)
vmware_signals.vm_updated.connect(
handlers.update_marketplace_resource_limits_when_vm_is_updated,
dispatch_uid='marketplace_vmware.handlers.'
'update_marketplace_resource_limits_when_vm_is_updated',
)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from . import PLUGIN_NAME, processors
manager.register(
offering_type=PLUGIN_NAME,
create_resource_processor=processors.BookingCreateProcessor,
delete_resource_processor=processors.BookingDeleteProcessor)
def ready(self):
from waldur_azure import models as azure_models
from waldur_azure.apps import AzureConfig
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_core.structure import signals as structure_signals
from . import handlers, processors, VIRTUAL_MACHINE_TYPE, SQL_SERVER_TYPE
resource_models = (
azure_models.VirtualMachine,
azure_models.SQLServer,
azure_models.SQLDatabase,
)
marketplace_handlers.connect_resource_handlers(*resource_models)
marketplace_handlers.connect_resource_metadata_handlers(
*resource_models)
signals.post_save.connect(
handlers.synchronize_nic,
sender=azure_models.NetworkInterface,
dispatch_uid='waldur_mastermind.marketplace_azure.synchronize_nic',
)
signals.post_save.connect(
handlers.synchronize_public_ip,
sender=azure_models.PublicIP,
dispatch_uid=
'waldur_mastermind.marketplace_azure.synchronize_public_ip',
)
manager.register(
offering_type=VIRTUAL_MACHINE_TYPE,
create_resource_processor=processors.VirtualMachineCreateProcessor,
delete_resource_processor=processors.VirtualMachineDeleteProcessor,
service_type=AzureConfig.service_name,
get_importable_resources_backend_method=
'get_importable_virtual_machines',
import_resource_backend_method='import_virtual_machine',
)
manager.register(
offering_type=SQL_SERVER_TYPE,
create_resource_processor=processors.SQLServerCreateProcessor,
delete_resource_processor=processors.SQLServerDeleteProcessor,
service_type=AzureConfig.service_name,
)
structure_signals.resource_imported.connect(
handlers.create_marketplace_resource_for_imported_resources,
sender=azure_models.VirtualMachine,
dispatch_uid='waldur_mastermind.marketplace_azure.'
'create_resource_for_imported_vm',
)
def setUp(self):
init_args = []
self.init_args = init_args
class NewInstanceSerializer(structure_test_serializers.NewInstanceSerializer):
def __init__(self, *args, **kwargs):
init_args.extend([self, args, kwargs])
super(NewInstanceSerializer, self).__init__(*args, **kwargs)
class Meta(structure_test_serializers.NewInstanceSerializer.Meta):
fields = (
structure_test_serializers.NewInstanceSerializer.Meta.fields
+ ('cores',)
)
class TestNewInstanceViewSet(structure_test_views.TestNewInstanceViewSet):
serializer_class = NewInstanceSerializer
class TestNewInstanceCreateProcessor(utils.TestCreateProcessor):
viewset = TestNewInstanceViewSet
fields = ['name', 'cores']
manager.register(
offering_type='TEST_TYPE',
create_resource_processor=TestNewInstanceCreateProcessor,
)
self.service_settings = structure_factories.ServiceSettingsFactory(type='Test')
self.fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=self.fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=self.fixture.project
)
self.offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
type='TEST_TYPE',
scope=self.service_settings,
)
structure_models.Project.add_quota_field(
name='test_cpu_count',
quota_field=TotalQuotaField(
target_models=[test_models.TestNewInstance],
path_to_scope='service_project_link.project',
target_field='cores',
),
)
quotas_models.Quota.objects.update_or_create(
name='test_cpu_count',
content_type=ContentType.objects.get_for_model(self.fixture.project),
object_id=self.fixture.project.id,
defaults={'limit': 1},
)
def ready(self):
from waldur_mastermind.marketplace.plugins import Component, manager
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace_slurm import PLUGIN_NAME
from waldur_slurm import models as slurm_models
from waldur_slurm.apps import SlurmConfig
from . import handlers, processor
signals.post_save.connect(
handlers.create_slurm_package,
sender=marketplace_models.PlanComponent,
dispatch_uid=
'waldur_mastermind.marketpace_slurm.create_slurm_package',
)
signals.post_save.connect(
handlers.create_slurm_usage,
sender=slurm_models.AllocationUsage,
dispatch_uid=
'waldur_mastermind.marketpace_slurm.create_slurm_usage',
)
signals.post_save.connect(
handlers.update_component_quota,
sender=slurm_models.Allocation,
dispatch_uid=
'waldur_mastermind.marketpace_slurm.update_component_quota',
)
marketplace_handlers.connect_resource_handlers(slurm_models.Allocation)
marketplace_handlers.connect_resource_metadata_handlers(
slurm_models.Allocation)
USAGE = marketplace_models.OfferingComponent.BillingTypes.USAGE
manager.register(
PLUGIN_NAME,
create_resource_processor=processor.CreateAllocationProcessor,
delete_resource_processor=processor.DeleteAllocationProcessor,
components=(
Component(type='cpu',
name='CPU',
measured_unit='hours',
billing_type=USAGE),
Component(type='gpu',
name='GPU',
measured_unit='hours',
billing_type=USAGE),
Component(type='ram',
name='RAM',
measured_unit='GB',
billing_type=USAGE),
),
service_type=SlurmConfig.service_name)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from . import PLUGIN_NAME, processors, utils
manager.register(
offering_type=PLUGIN_NAME,
create_resource_processor=processors.BookingCreateProcessor,
delete_resource_processor=processors.BookingDeleteProcessor,
change_attributes_for_view=utils.change_attributes_for_view,
)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from . import PLUGIN_NAME, processors, registrators as script_registrators
manager.register(
offering_type=PLUGIN_NAME,
create_resource_processor=processors.CreateProcessor,
update_resource_processor=processors.UpdateProcessor,
delete_resource_processor=processors.DeleteProcessor,
)
script_registrators.ScriptRegistrator.connect()
def setUp(self):
manager.register(offering_type='TEST_TYPE',
create_resource_processor=utils.TestCreateProcessor)
self.service_settings = structure_factories.ServiceSettingsFactory(
type='Test')
self.fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=self.fixture.customer)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=self.fixture.project)
self.offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
type='TEST_TYPE',
scope=self.service_settings)
def setUp(self):
manager.register(
offering_type='TEST_TYPE',
create_resource_processor=utils.TestCreateProcessor,
can_update_limits=True,
)
self.service_settings = structure_factories.ServiceSettingsFactory(
type='Test', shared=True)
self.fixture = fixtures.ProjectFixture()
self.offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
type='TEST_TYPE',
scope=self.service_settings,
)
def ready(self):
from waldur_mastermind.marketplace.plugins import Component, manager
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace_slurm import PLUGIN_NAME
from waldur_slurm import models as slurm_models
from waldur_core.structure import models as structure_models
from . import handlers, processor
signals.post_save.connect(
handlers.create_slurm_package,
sender=marketplace_models.PlanComponent,
dispatch_uid='waldur_mastermind.marketpace_slurm.create_slurm_package',
)
signals.post_save.connect(
handlers.create_slurm_usage,
sender=slurm_models.AllocationUsage,
dispatch_uid='waldur_mastermind.marketpace_slurm.create_slurm_usage',
)
signals.post_save.connect(
handlers.update_component_quota,
sender=slurm_models.Allocation,
dispatch_uid='waldur_mastermind.marketpace_slurm.update_component_quota',
)
signals.post_save.connect(
handlers.change_order_item_state,
sender=slurm_models.Allocation,
dispatch_uid='waldur_mastermind.marketpace_slurm.change_order_item_state',
)
signals.pre_delete.connect(
handlers.terminate_resource,
sender=slurm_models.Allocation,
dispatch_uid='waldur_mastermind.marketpace_slurm.terminate_resource',
)
USAGE = marketplace_models.OfferingComponent.BillingTypes.USAGE
manager.register(PLUGIN_NAME,
create_resource_processor=processor.CreateResourceProcessor,
delete_resource_processor=processor.DeleteResourceProcessor,
scope_model=structure_models.ServiceSettings,
components=(
Component(type='cpu', name='CPU', measured_unit='hours', billing_type=USAGE),
Component(type='gpu', name='GPU', measured_unit='hours', billing_type=USAGE),
Component(type='ram', name='RAM', measured_unit='GB', billing_type=USAGE),
))
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace_support import PLUGIN_NAME
from waldur_mastermind.support import models as support_models
from . import handlers, processor
signals.post_save.connect(
handlers.create_support_template,
sender=marketplace_models.Offering,
dispatch_uid='waldur_mastermind.marketpace_support.create_support_template',
)
signals.post_save.connect(
handlers.change_order_item_state,
sender=support_models.Offering,
dispatch_uid='waldur_mastermind.marketpace_support.order_item_set_state_done',
)
signals.pre_delete.connect(
handlers.terminate_resource,
sender=support_models.Offering,
dispatch_uid='waldur_mastermind.marketpace_support.terminate_resource',
)
signals.post_save.connect(
handlers.create_support_plan,
sender=marketplace_models.Plan,
dispatch_uid='waldur_mastermind.marketpace_support.create_support_plan',
)
signals.post_save.connect(
handlers.offering_set_state_ok,
sender=support_models.Issue,
dispatch_uid='waldur_mastermind.marketpace_support.offering_set_state_ok',
)
manager.register(PLUGIN_NAME,
create_resource_processor=processor.CreateResourceProcessor,
delete_resource_processor=processor.DeleteResourceProcessor,
scope_model=support_models.Offering)
def ready(self):
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace_support import PLUGIN_NAME
from waldur_mastermind.support import models as support_models
from waldur_core.core import signals as core_signals
from waldur_mastermind.marketplace import serializers as marketplace_serializers
from waldur_mastermind.marketplace_support.serializers import add_issue
from . import handlers, processor, registrators
registrators.SupportRegistrator.connect()
signals.post_save.connect(
handlers.update_order_item_if_issue_was_complete,
sender=support_models.Issue,
dispatch_uid=
'waldur_mastermind.marketplace_support.update_order_item_if_issue_was_complete',
)
signals.post_save.connect(
handlers.notify_about_request_based_item_creation,
sender=support_models.Issue,
dispatch_uid=
'waldur_mastermind.marketplace_support.notify_about_request_based_item_creation',
)
manager.register(
PLUGIN_NAME,
create_resource_processor=processor.CreateRequestProcessor,
update_resource_processor=processor.UpdateRequestProcessor,
delete_resource_processor=processor.DeleteRequestProcessor,
can_terminate_order_item=True,
enable_usage_notifications=True,
enable_remote_support=True,
can_update_limits=True,
)
core_signals.pre_serializer_fields.connect(
sender=marketplace_serializers.OrderItemDetailsSerializer,
receiver=add_issue,
)
def ready(self):
from waldur_core.quotas import models as quota_models
from waldur_core.structure import models as structure_models
from waldur_core.structure import signals as structure_signals
from waldur_openstack.openstack import models as openstack_models
from waldur_openstack.openstack.apps import OpenStackConfig
from waldur_openstack.openstack_tenant import models as tenant_models
from waldur_mastermind.invoices import registrators
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace import filters as marketplace_filters
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace import signals as marketplace_signals
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace.plugins import Component
from waldur_mastermind.marketplace_openstack.registrators import MarketplaceItemRegistrator
from waldur_mastermind.packages import models as package_models
from . import (filters, handlers, processors, INSTANCE_TYPE,
VOLUME_TYPE, PACKAGE_TYPE, RAM_TYPE, CORES_TYPE,
STORAGE_TYPE, AVAILABLE_LIMITS)
marketplace_filters.ExternalOfferingFilterBackend.register(
filters.VpcExternalFilter())
signals.post_save.connect(
handlers.create_offering_from_tenant,
sender=openstack_models.Tenant,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.create_offering_from_tenant',
)
signals.pre_delete.connect(
handlers.archive_offering,
sender=structure_models.ServiceSettings,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.archive_offering',
)
resource_models = (tenant_models.Instance, tenant_models.Volume,
openstack_models.Tenant)
marketplace_handlers.connect_resource_metadata_handlers(
*resource_models)
marketplace_handlers.connect_resource_handlers(*resource_models)
signals.post_save.connect(
handlers.create_template_for_plan,
sender=marketplace_models.Plan,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.create_template_for_plan',
)
signals.post_save.connect(
handlers.update_template_for_plan,
sender=marketplace_models.Plan,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.update_template_for_plan',
)
signals.post_save.connect(
handlers.update_plan_for_template,
sender=package_models.PackageTemplate,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.update_plan_for_template',
)
signals.post_save.connect(
handlers.synchronize_plan_component,
sender=marketplace_models.PlanComponent,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_plan_component',
)
FIXED = marketplace_models.OfferingComponent.BillingTypes.FIXED
manager.register(
offering_type=PACKAGE_TYPE,
create_resource_processor=processors.PackageCreateProcessor,
update_resource_processor=processors.PackageUpdateProcessor,
delete_resource_processor=processors.PackageDeleteProcessor,
components=(
Component(type=CORES_TYPE,
name='Cores',
measured_unit='cores',
billing_type=FIXED),
# Price is stored per GiB but size is stored per MiB
# therefore we need to divide size by factor when price estimate is calculated.
Component(type=RAM_TYPE,
name='RAM',
measured_unit='GB',
billing_type=FIXED,
factor=1024),
Component(type=STORAGE_TYPE,
name='Storage',
measured_unit='GB',
billing_type=FIXED,
factor=1024),
),
service_type=OpenStackConfig.service_name,
secret_attributes=get_secret_attributes,
available_limits=AVAILABLE_LIMITS,
resource_model=openstack_models.Tenant)
manager.register(
offering_type=INSTANCE_TYPE,
create_resource_processor=processors.InstanceCreateProcessor,
delete_resource_processor=processors.InstanceDeleteProcessor)
manager.register(
offering_type=VOLUME_TYPE,
create_resource_processor=processors.VolumeCreateProcessor,
delete_resource_processor=processors.VolumeDeleteProcessor)
signals.post_save.connect(
handlers.synchronize_volume_metadata,
sender=tenant_models.Volume,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_volume_metadata',
)
signals.post_save.connect(
handlers.synchronize_instance_metadata,
sender=tenant_models.Instance,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_instance_metadata',
)
signals.post_save.connect(
handlers.synchronize_internal_ips,
sender=tenant_models.InternalIP,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_internal_ips',
)
signals.post_save.connect(
handlers.synchronize_floating_ips,
sender=tenant_models.FloatingIP,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_floating_ips',
)
signals.post_delete.connect(
handlers.synchronize_internal_ips_on_delete,
sender=tenant_models.InternalIP,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_internal_ips_on_delete',
)
signals.post_delete.connect(
handlers.synchronize_floating_ips_on_delete,
sender=tenant_models.FloatingIP,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_floating_ips_on_delete',
)
signals.post_save.connect(
handlers.create_resource_of_volume_if_instance_created,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketpace_openstack.'
'create_resource_of_volume_if_instance_created',
)
for model in [
tenant_models.Instance, tenant_models.Volume,
openstack_models.Tenant
]:
structure_signals.resource_imported.connect(
handlers.create_marketplace_resource_for_imported_resources,
sender=model,
dispatch_uid='waldur_mastermind.marketpace_openstack.'
'create_resource_for_imported_%s' % model,
)
signals.post_save.connect(
handlers.import_resource_metadata_when_resource_is_created,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketpace_openstack.'
'import_resource_metadata_when_resource_is_created',
)
signals.post_save.connect(
handlers.update_openstack_tenant_usages,
sender=quota_models.Quota,
dispatch_uid='waldur_mastermind.marketpace_openstack.'
'update_openstack_tenant_usages',
)
registrators.RegistrationManager.add_registrator(
marketplace_models.Resource,
MarketplaceItemRegistrator,
)
marketplace_signals.resource_creation_succeeded.connect(
handlers.update_invoice_when_resource_is_created,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketplace.'
'update_invoice_when_resource_is_created',
)
marketplace_signals.limit_update_succeeded.connect(
handlers.update_invoice_when_resource_is_updated,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketplace.'
'update_invoice_when_resource_is_updated',
)
marketplace_signals.resource_deletion_succeeded.connect(
handlers.update_invoice_when_resource_is_deleted,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketplace.'
'update_invoice_when_resource_is_deleted',
)
def ready(self):
from waldur_core.structure import models as structure_models
from waldur_openstack.openstack import models as openstack_models
from waldur_openstack.openstack.apps import OpenStackConfig
from waldur_openstack.openstack_tenant import models as tenant_models
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace.plugins import Component
from . import (
handlers,
processors,
INSTANCE_TYPE,
VOLUME_TYPE,
PACKAGE_TYPE,
RAM_TYPE,
CORES_TYPE,
STORAGE_TYPE,
)
signals.post_save.connect(
handlers.create_offering_from_tenant,
sender=openstack_models.Tenant,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.create_offering_from_tenant',
)
signals.pre_delete.connect(
handlers.archive_offering,
sender=structure_models.ServiceSettings,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.archive_offering',
)
resource_models = (tenant_models.Instance, tenant_models.Volume,
openstack_models.Tenant)
marketplace_handlers.connect_resource_metadata_handlers(
*resource_models)
marketplace_handlers.connect_resource_handlers(*resource_models)
signals.post_save.connect(
handlers.create_template_for_plan,
sender=marketplace_models.Plan,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.create_template_for_plan',
)
signals.post_save.connect(
handlers.synchronize_plan_component,
sender=marketplace_models.PlanComponent,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_plan_component',
)
FIXED = marketplace_models.OfferingComponent.BillingTypes.FIXED
manager.register(
offering_type=PACKAGE_TYPE,
create_resource_processor=processors.PackageCreateProcessor,
update_resource_processor=processors.PackageUpdateProcessor,
delete_resource_processor=processors.PackageDeleteProcessor,
components=(
Component(type=RAM_TYPE,
name='RAM',
measured_unit='GB',
billing_type=FIXED),
Component(type=CORES_TYPE,
name='Cores',
measured_unit='cores',
billing_type=FIXED),
Component(type=STORAGE_TYPE,
name='Storage',
measured_unit='GB',
billing_type=FIXED),
),
service_type=OpenStackConfig.service_name)
manager.register(
offering_type=INSTANCE_TYPE,
create_resource_processor=processors.InstanceCreateProcessor,
delete_resource_processor=processors.InstanceDeleteProcessor)
manager.register(
offering_type=VOLUME_TYPE,
create_resource_processor=processors.VolumeCreateProcessor,
delete_resource_processor=processors.VolumeDeleteProcessor)
signals.post_save.connect(
handlers.synchronize_volume_metadata,
sender=tenant_models.Volume,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_volume_metadata',
)
signals.post_save.connect(
handlers.synchronize_instance_metadata,
sender=tenant_models.Instance,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_instance_metadata',
)
signals.post_save.connect(
handlers.synchronize_internal_ips,
sender=tenant_models.InternalIP,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_internal_ips',
)
signals.post_save.connect(
handlers.synchronize_floating_ips,
sender=tenant_models.FloatingIP,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_floating_ips',
)
def ready(self):
from waldur_core.quotas import models as quota_models
from waldur_core.structure import models as structure_models
from waldur_core.structure import signals as structure_signals
from waldur_openstack.openstack import models as openstack_models
from waldur_openstack.openstack import signals as openstack_signals
from waldur_openstack.openstack.apps import OpenStackConfig
from waldur_openstack.openstack_tenant import (
models as tenant_models,
executors as tenant_executors,
)
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace import filters as marketplace_filters
from waldur_mastermind.marketplace import handlers as marketplace_handlers
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace.plugins import Component
from waldur_mastermind.marketplace_openstack.registrators import (
OpenStackRegistrator, )
from . import (
filters,
handlers,
processors,
INSTANCE_TYPE,
VOLUME_TYPE,
TENANT_TYPE,
RAM_TYPE,
CORES_TYPE,
STORAGE_TYPE,
AVAILABLE_LIMITS,
)
marketplace_filters.ExternalOfferingFilterBackend.register(
filters.VpcExternalFilter())
signals.post_save.connect(
handlers.create_offering_from_tenant,
sender=openstack_models.Tenant,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.create_offering_from_tenant',
)
signals.pre_delete.connect(
handlers.archive_offering,
sender=structure_models.ServiceSettings,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.archive_offering',
)
resource_models = (
tenant_models.Instance,
tenant_models.Volume,
openstack_models.Tenant,
)
marketplace_handlers.connect_resource_metadata_handlers(
*resource_models)
marketplace_handlers.connect_resource_handlers(*resource_models)
LIMIT = marketplace_models.OfferingComponent.BillingTypes.LIMIT
manager.register(
offering_type=TENANT_TYPE,
create_resource_processor=processors.TenantCreateProcessor,
update_resource_processor=processors.TenantUpdateProcessor,
delete_resource_processor=processors.TenantDeleteProcessor,
components=(
Component(
type=CORES_TYPE,
name='Cores',
measured_unit='cores',
billing_type=LIMIT,
),
# Price is stored per GiB but size is stored per MiB
# therefore we need to divide size by factor when price estimate is calculated.
Component(
type=RAM_TYPE,
name='RAM',
measured_unit='GB',
billing_type=LIMIT,
factor=1024,
),
Component(
type=STORAGE_TYPE,
name='Storage',
measured_unit='GB',
billing_type=LIMIT,
factor=1024,
),
),
service_type=OpenStackConfig.service_name,
secret_attributes=get_secret_attributes,
components_filter=components_filter,
available_limits=AVAILABLE_LIMITS,
can_update_limits=True,
get_importable_resources_backend_method='get_importable_tenants',
import_resource_backend_method='import_tenant',
)
manager.register(
offering_type=INSTANCE_TYPE,
create_resource_processor=processors.InstanceCreateProcessor,
delete_resource_processor=processors.InstanceDeleteProcessor,
get_importable_resources_backend_method='get_importable_instances',
import_resource_backend_method='import_instance',
import_resource_executor=tenant_executors.InstancePullExecutor,
)
manager.register(
offering_type=VOLUME_TYPE,
create_resource_processor=processors.VolumeCreateProcessor,
delete_resource_processor=processors.VolumeDeleteProcessor,
get_importable_resources_backend_method='get_importable_volumes',
import_resource_backend_method='import_volume',
)
signals.post_save.connect(
handlers.synchronize_volume_metadata,
sender=tenant_models.Volume,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_volume_metadata',
)
signals.post_save.connect(
handlers.synchronize_tenant_name,
sender=openstack_models.Tenant,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_tenant_name',
)
signals.post_save.connect(
handlers.synchronize_instance_name,
sender=tenant_models.Instance,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_instance_name',
)
signals.post_save.connect(
handlers.synchronize_instance_after_pull,
sender=tenant_models.Instance,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_instance_after_pull',
)
signals.post_save.connect(
handlers.synchronize_internal_ips,
sender=tenant_models.InternalIP,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_internal_ips',
)
signals.post_save.connect(
handlers.synchronize_floating_ips,
sender=tenant_models.FloatingIP,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_floating_ips',
)
signals.post_delete.connect(
handlers.synchronize_internal_ips_on_delete,
sender=tenant_models.InternalIP,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_internal_ips_on_delete',
)
signals.post_delete.connect(
handlers.synchronize_floating_ips_on_delete,
sender=tenant_models.FloatingIP,
dispatch_uid=
'waldur_mastermind.marketplace_openstack.synchronize_floating_ips_on_delete',
)
signals.post_save.connect(
handlers.create_resource_of_volume_if_instance_created,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'create_resource_of_volume_if_instance_created',
)
for model in [
tenant_models.Instance,
tenant_models.Volume,
openstack_models.Tenant,
]:
structure_signals.resource_imported.connect(
handlers.create_marketplace_resource_for_imported_resources,
sender=model,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'create_resource_for_imported_%s' % model,
)
signals.post_save.connect(
handlers.import_resource_metadata_when_resource_is_created,
sender=marketplace_models.Resource,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'import_resource_metadata_when_resource_is_created',
)
signals.post_save.connect(
handlers.update_openstack_tenant_usages,
sender=quota_models.Quota,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'update_openstack_tenant_usages',
)
OpenStackRegistrator.connect()
signals.post_save.connect(
handlers.create_offering_component_for_volume_type,
sender=openstack_models.VolumeType,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'create_offering_component_for_volume_type',
)
signals.post_delete.connect(
handlers.delete_offering_component_for_volume_type,
sender=openstack_models.VolumeType,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'delete_offering_component_for_volume_type',
)
signals.post_save.connect(
handlers.synchronize_limits_when_storage_mode_is_switched,
sender=marketplace_models.Offering,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'synchronize_limits_when_storage_mode_is_switched',
)
structure_signals.resource_imported.connect(
handlers.import_instances_and_volumes_if_tenant_has_been_imported,
sender=openstack_models.Tenant,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'import_instances_and_volumes_if_tenant_has_been_imported',
)
openstack_signals.tenant_pull_succeeded.connect(
handlers.import_instances_and_volumes_if_tenant_has_been_imported,
sender=openstack_models.Tenant,
dispatch_uid='waldur_mastermind.marketplace_openstack.'
'import_instances_and_volumes_if_tenant_has_been_imported_if_tenant_has_been_pulled',
)
def ready(self):
from waldur_core.structure import models as structure_models
from waldur_openstack.openstack import models as openstack_models
from waldur_openstack.openstack_tenant import models as tenant_models
from waldur_mastermind.marketplace import models as marketplace_models
from waldur_mastermind.marketplace.plugins import manager
from waldur_mastermind.marketplace.plugins import Component
from . import handlers, processors, INSTANCE_TYPE, VOLUME_TYPE, PACKAGE_TYPE
signals.post_save.connect(
handlers.create_offering_from_tenant,
sender=openstack_models.Tenant,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.create_offering_from_tenant',
)
signals.pre_delete.connect(
handlers.archive_offering,
sender=structure_models.ServiceSettings,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.archive_offering',
)
for index, model in enumerate(
(openstack_models.Tenant, tenant_models.Instance,
tenant_models.Volume)):
signals.post_save.connect(
handlers.change_order_item_state,
sender=model,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.change_order_item_state_%s'
% index,
)
signals.pre_delete.connect(
handlers.terminate_resource,
sender=model,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.terminate_resource_%s'
% index,
)
signals.post_save.connect(
handlers.create_template_for_plan,
sender=marketplace_models.Plan,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.create_template_for_plan',
)
signals.post_save.connect(
handlers.synchronize_plan_component,
sender=marketplace_models.PlanComponent,
dispatch_uid=
'waldur_mastermind.marketpace_openstack.synchronize_plan_component',
)
FIXED = marketplace_models.OfferingComponent.BillingTypes.FIXED
manager.register(
offering_type=PACKAGE_TYPE,
create_resource_processor=processors.PackageCreateProcessor,
update_resource_processor=processors.PackageUpdateProcessor,
delete_resource_processor=processors.PackageDeleteProcessor,
components=(
Component(type='ram',
name='RAM',
measured_unit='GB',
billing_type=FIXED),
Component(type='cores',
name='Cores',
measured_unit='cores',
billing_type=FIXED),
Component(type='storage',
name='Storage',
measured_unit='GB',
billing_type=FIXED),
),
scope_model=structure_models.ServiceSettings)
manager.register(
offering_type=INSTANCE_TYPE,
create_resource_processor=processors.InstanceCreateProcessor,
delete_resource_processor=processors.InstanceDeleteProcessor,
scope_model=structure_models.ServiceSettings)
manager.register(
offering_type=VOLUME_TYPE,
create_resource_processor=processors.VolumeCreateProcessor,
delete_resource_processor=processors.VolumeDeleteProcessor,
scope_model=structure_models.ServiceSettings)
