from waldur_core.logging.loggers import EventLogger, event_logger
class OpenStackPackageLogger(EventLogger):
tenant = 'openstack.Tenant'
service_settings = 'structure.ServiceSettings'
package_template_name = basestring
class Meta:
event_types = ('openstack_package_created',
'openstack_package_deleted')
event_groups = {
'customers': event_types,
'packages': event_types,
'debug_only': event_types
}
nullable_fields = ('service_settings', )
event_logger.register('openstack_package', OpenStackPackageLogger)
resource = models.Instance
class Meta:
event_types = (
'resource_backup_creation_scheduled',
'resource_backup_creation_succeeded',
'resource_backup_creation_failed',
'resource_backup_restoration_scheduled',
'resource_backup_restoration_succeeded',
'resource_backup_restoration_failed',
'resource_backup_deletion_scheduled',
'resource_backup_deletion_succeeded',
'resource_backup_deletion_failed',
'resource_backup_schedule_creation_succeeded',
'resource_backup_schedule_update_succeeded',
'resource_backup_schedule_deletion_succeeded',
'resource_backup_schedule_activated',
'resource_backup_schedule_deactivated',
)
@staticmethod
def get_scopes(event_context):
return ResourceActionEventLogger.get_scopes(event_context)
event_logger.register('openstack_resource_action', ResourceActionEventLogger)
event_logger.register('openstack_backup_schedule', BackupScheduleEventLogger)
event_logger.register('openstack_snapshot_schedule',
SnapshotScheduleEventLogger)
event_logger.register('openstack_backup', BackupEventLogger)
class Meta:
event_types = ('token_created', )
@staticmethod
def get_scopes(event_context):
return {event_context['affected_user']}
class SshPublicKeyEventLogger(EventLogger):
ssh_key = SshPublicKey
user = User
class Meta:
event_types = ('ssh_key_creation_succeeded',
'ssh_key_deletion_succeeded')
event_groups = {
'ssh': event_types,
'users': event_types,
}
@staticmethod
def get_scopes(event_context):
return {event_context['user']}
event_logger.register('auth', AuthEventLogger)
event_logger.register('user', UserEventLogger)
event_logger.register('sshkey', SshPublicKeyEventLogger)
event_logger.register('token', TokenEventLogger)
class Meta:
event_types = (
'marketplace_component_usage_created',
'marketplace_component_usage_updated',
)
@staticmethod
def get_scopes(event_context):
usage = event_context['usage']
resource = usage.resource
project = Project.all_objects.get(id=resource.project_id)
return {resource, project, project.customer}
event_logger.register('marketplace_order', MarketplaceOrderLogger)
event_logger.register('marketplace_resource', MarketplaceResourceLogger)
event_logger.register('marketplace_component_usage',
MarketplaceComponentUsageLogger)
def log_order_created(order):
event_logger.marketplace_order.info(
'Marketplace order has been created.',
event_type='marketplace_order_created',
event_context={'order': order},
)
def log_order_approved(order):
event_logger.marketplace_order.info(
from waldur_core.logging.loggers import EventLogger, event_logger
from waldur_mastermind.marketplace.models import Resource
class BookingEventLogger(EventLogger):
resource = Resource
class Meta:
event_types = ('device_booking_is_accepted', )
@staticmethod
def get_scopes(event_context):
resource = event_context['resource']
return {resource, resource.project, resource.project.customer}
event_logger.register('waldur_booking', BookingEventLogger)
}
class FloatingIPLogger(EventLogger):
floating_ip = 'openstack.FloatingIP'
class Meta:
event_types = (
'openstack_floating_ip_attached',
'openstack_floating_ip_detached',
)
event_groups = {
'resources': event_types,
}
@staticmethod
def get_scopes(event_context):
floating_ip = event_context['floating_ip']
port = event_context['port']
return {floating_ip, floating_ip.tenant, port}
event_logger.register('openstack_tenant_quota', TenantQuotaLogger)
event_logger.register('openstack_router', RouterLogger)
event_logger.register('openstack_network', NetworkLogger)
event_logger.register('openstack_subnet', SubNetLogger)
event_logger.register('openstack_security_group', SecurityGroupLogger)
event_logger.register('openstack_security_group_rule', SecurityGroupRuleLogger)
event_logger.register('openstack_port', PortLogger)
event_logger.register('openstack_floating_ip', FloatingIPLogger)
'marketplace_resource_update_succeeded',
'marketplace_resource_update_failed',
'marketplace_resource_terminate_requested',
'marketplace_resource_terminate_succeeded',
'marketplace_resource_terminate_failed',
'marketplace_resource_update_limits_succeeded',
'marketplace_resource_update_limits_failed',
)
@staticmethod
def get_scopes(event_context):
resource = event_context['resource']
return {resource, resource.project, resource.project.customer}
event_logger.register('marketplace_order', MarketplaceOrderLogger)
event_logger.register('marketplace_resource', MarketplaceResourceLogger)
def log_order_created(order):
event_logger.marketplace_order.info(
'Marketplace order has been created.',
event_type='marketplace_order_created',
event_context={'order': order},
)
def log_order_approved(order):
event_logger.marketplace_order.info(
'Marketplace order has been approved.',
event_type='marketplace_order_approved',
'invoice_update_succeeded',
'invoice_creation_succeeded',
)
event_groups = {'invoices': event_types}
@staticmethod
def get_scopes(event_context):
invoice = event_context['invoice']
return {invoice.customer}
class PaymentEventLogger(EventLogger):
payment = Payment
class Meta:
event_types = (
'payment_creation_succeeded',
'payment_approval_succeeded',
'payment_cancel_succeeded',
)
event_groups = {'payments': event_types}
@staticmethod
def get_scopes(event_context):
payment = event_context['payment']
return {payment.customer}
event_logger.register('paypal_invoice', InvoiceEventLogger)
event_logger.register('paypal_payment', PaymentEventLogger)
from waldur_core.logging.loggers import EventLogger, event_logger
class InvoiceLogger(EventLogger):
month = int
year = int
customer = 'structure.Customer'
class Meta:
event_types = ('invoice_created', 'invoice_paid', 'invoice_canceled')
event_groups = {
'customers': event_types,
'invoices': event_types,
}
event_logger.register('invoice', InvoiceLogger)
)
event_groups = {
'support': event_types,
}
@staticmethod
def get_scopes(event_context):
offering = event_context['offering']
project = Project.all_objects.get(
id=offering.project_id
) # handle case when project is already deleted
return {offering, project, project.customer}
class OfferingBackendIDEventLogger(EventLogger):
full_name = str
old_backend_id = str
new_backend_id = str
class Meta:
event_types = ('offering_backend_id_changed',)
event_groups = {
'support': event_types,
}
event_logger.register('waldur_issue', IssueEventLogger)
event_logger.register('waldur_attachment', AttachmentEventLogger)
event_logger.register('waldur_offering', OfferingEventLogger)
event_logger.register('waldur_offering_backend_id', OfferingBackendIDEventLogger)
from . import models
class IssueEventLogger(EventLogger):
issue = models.Issue
class Meta:
event_types = ('issue_deletion_succeeded', 'issue_update_succeeded',
'issue_creation_succeeded')
event_groups = {
'support': event_types,
}
class OfferingEventLogger(EventLogger):
offering = models.Offering
class Meta:
event_types = (
'offering_created',
'offering_deleted',
'offering_state_changed',
)
event_groups = {
'support': event_types,
}
event_logger.register('waldur_issue', IssueEventLogger)
event_logger.register('waldur_offering', OfferingEventLogger)
from waldur_core.core.models import User
from waldur_core.logging.loggers import EventLogger, event_logger
class Saml2AuthEventLogger(EventLogger):
user = User
class Meta:
event_types = ('auth_logged_in_with_saml2',
'auth_logged_out_with_saml2')
event_groups = {'users': event_types}
event_logger.register('saml2_auth', Saml2AuthEventLogger)
from waldur_core.logging.loggers import EventLogger, event_logger
class TenantQuotaLogger(EventLogger):
quota = 'quotas.Quota'
tenant = 'openstack.Tenant'
limit = float
old_limit = float
class Meta:
event_types = ('openstack_tenant_quota_limit_updated', )
event_groups = {
'resources': event_types,
}
@staticmethod
def get_scopes(event_context):
tenant = event_context['tenant']
project = tenant.service_project_link.project
return {tenant, project, project.customer}
event_logger.register('openstack_tenant_quota', TenantQuotaLogger)
from waldur_core.logging.loggers import EventLogger, event_logger
class DropletResizeEventLogger(EventLogger):
droplet = 'waldur_digitalocean.Droplet'
size = 'waldur_digitalocean.Size'
class Meta:
event_types = ('droplet_resize_scheduled', 'droplet_resize_succeeded')
@staticmethod
def get_scopes(event_context):
resource = event_context['droplet']
project = resource.project
return {resource, project, project.customer}
event_logger.register('droplet_resize', DropletResizeEventLogger)
class MarketplaceOfferingUserEventLogger(EventLogger):
offering_user = models.OfferingUser
class Meta:
event_types = (
'marketplace_offering_user_created',
'marketplace_offering_user_deleted',
)
event_groups = {
'users': event_types,
}
event_logger.register('marketplace_order', MarketplaceOrderLogger)
event_logger.register('marketplace_resource', MarketplaceResourceLogger)
event_logger.register('marketplace_component_usage',
MarketplaceComponentUsageLogger)
event_logger.register('marketplace_offering_permission',
MarketplaceOfferingPermissionEventLogger)
event_logger.register('marketplace_offering_user',
MarketplaceOfferingUserEventLogger)
def log_order_created(order):
event_logger.marketplace_order.info(
'Marketplace order has been created.',
event_type='marketplace_order_created',
event_context={'order': order},
)
from django.contrib.auth import get_user_model
from waldur_core.logging.loggers import EventLogger, event_logger
User = get_user_model()
provider_event_type_mapping = {
'smartid.ee': 'auth_logged_in_with_smartid_ee',
'tara': 'auth_logged_in_with_tara',
'keycloak': 'auth_logged_in_with_keycloak',
'eduteams': 'auth_logged_in_with_eduteams',
}
class SocialEventLogger(EventLogger):
provider = str
user = User
class Meta:
event_types = provider_event_type_mapping.values()
event_groups = {'users': event_types}
@staticmethod
def get_scopes(event_context):
return {event_context['user']}
event_logger.register('auth_social', SocialEventLogger)
from waldur_core.logging.loggers import EventLogger, event_logger
from waldur_core.structure.models import Customer, Project
class PriceEstimateEventLogger(EventLogger):
class Meta:
event_types = ('project_price_limit_updated', 'customer_price_limit_updated')
event_groups = {
'projects': ['project_price_limit_updated'],
'customers': ['customer_price_limit_updated'],
}
@staticmethod
def get_scopes(event_context):
scope = event_context['scope']
if isinstance(scope, Project):
return {scope, scope.customer}
elif isinstance(scope, Customer):
return {scope}
else:
return set()
event_logger.register('price_estimate', PriceEstimateEventLogger)
from waldur_core.core.models import User
from waldur_core.logging.loggers import EventLogger, event_logger
class FreeIPAEventLogger(EventLogger):
user = User
username = str
class Meta:
event_types = (
'freeipa_profile_created',
'freeipa_profile_deleted',
'freeipa_profile_enabled',
'freeipa_profile_disabled',
)
event_groups = {'users': event_types}
@staticmethod
def get_scopes(event_context):
return {event_context['user']}
event_logger.register('freeipa', FreeIPAEventLogger)
from django.contrib.auth import get_user_model
from waldur_core.logging.loggers import EventLogger, event_logger
User = get_user_model()
class OpenIDEventLogger(EventLogger):
user = User
class Meta:
event_types = ('auth_logged_in_with_openid',)
event_groups = {'users': event_types}
event_logger.register('auth_openid', OpenIDEventLogger)
event_types = (
'resource_start_scheduled',
'resource_start_succeeded',
'resource_start_failed',
'resource_stop_scheduled',
'resource_stop_succeeded',
'resource_stop_failed',
'resource_restart_scheduled',
'resource_restart_succeeded',
'resource_restart_failed',
'resource_creation_scheduled',
'resource_creation_succeeded',
'resource_creation_failed',
'resource_import_succeeded',
'resource_update_succeeded',
'resource_deletion_scheduled',
'resource_deletion_succeeded',
'resource_deletion_failed',
)
event_groups = {
'resources': event_types,
}
event_logger.register('customer_role', CustomerRoleEventLogger)
event_logger.register('project_role', ProjectRoleEventLogger)
event_logger.register('user_organization', UserOrganizationEventLogger)
event_logger.register('customer', CustomerEventLogger)
event_logger.register('project', ProjectEventLogger)
event_logger.register('resource', ResourceEventLogger)
'invoice_paid',
'invoice_canceled',
'payment_created',
'payment_removed',
)
event_groups = {
'customers': event_types,
'invoices': event_types,
}
@staticmethod
def get_scopes(event_context):
return {event_context['customer']}
event_logger.register('invoice', InvoiceLogger)
class PaymentLogger(EventLogger):
amount = decimal.Decimal
customer = 'structure.Customer'
class Meta:
event_types = (
'payment_added',
'payment_removed',
)
event_groups = {
'customers': event_types,
}
def get_scopes(event_context):
attachment = event_context['attachment']
return get_issue_scopes(attachment.issue)
class OfferingEventLogger(EventLogger):
offering = models.Offering
class Meta:
event_types = (
'offering_created',
'offering_deleted',
'offering_state_changed',
)
event_groups = {
'support': event_types,
}
@staticmethod
def get_scopes(event_context):
offering = event_context['offering']
project = Project.all_objects.get(
id=offering.project_id
) # handle case when project is already deleted
return {offering, project, project.customer}
event_logger.register('waldur_issue', IssueEventLogger)
event_logger.register('waldur_attachment', AttachmentEventLogger)
event_logger.register('waldur_offering', OfferingEventLogger)
from waldur_core.logging.loggers import EventLogger, event_logger
from .models import Issue, Comment
class IssueEventLogger(EventLogger):
issue = Issue
class Meta:
event_types = ('issue_deletion_succeeded', 'issue_update_succeeded',
'issue_creation_succeeded')
event_groups = {'jira': event_types}
class CommentEventLogger(EventLogger):
comment = Comment
class Meta:
event_types = ('comment_deletion_succeeded',
'comment_update_succeeded',
'comment_creation_succeeded')
event_groups = {'jira': event_types}
event_logger.register('jira_issue', IssueEventLogger)
event_logger.register('jira_comment', CommentEventLogger)
'resource_stop_succeeded',
'resource_stop_failed',
'resource_restart_scheduled',
'resource_restart_succeeded',
'resource_restart_failed',
'resource_creation_scheduled',
'resource_creation_succeeded',
'resource_creation_failed',
'resource_import_succeeded',
'resource_update_succeeded',
'resource_deletion_scheduled',
'resource_deletion_succeeded',
'resource_deletion_failed',
)
event_groups = {
'resources': event_types,
}
@staticmethod
def get_scopes(event_context):
resource = event_context['resource']
project = models.Project.all_objects.get(id=resource.project_id)
return {resource, project, project.customer}
event_logger.register('customer_role', CustomerRoleEventLogger)
event_logger.register('project_role', ProjectRoleEventLogger)
event_logger.register('customer', CustomerEventLogger)
event_logger.register('project', ProjectEventLogger)
event_logger.register('resource', ResourceEventLogger)
from . import models
class ExpertRequestEventLogger(EventLogger):
expert_request = models.ExpertRequest
class Meta:
event_types = (
'expert_request_created',
'expert_request_activated',
'expert_request_cancelled',
'expert_request_completed',
)
event_groups = {
'experts': event_types,
}
class ExpertBidEventLogger(EventLogger):
expert_bid = models.ExpertBid
class Meta:
event_types = ('expert_bid_created', )
event_groups = {
'experts': event_types,
}
event_logger.register('waldur_expert_request', ExpertRequestEventLogger)
event_logger.register('waldur_expert_bid', ExpertBidEventLogger)