databaseinfra.plan = databaseinfra.engine.engine_type.default_plan LOG.warning("No plan specified, using default plan (%s) for engine %s" % (databaseinfra, databaseinfra.engine)) @receiver(pre_save, sender=Plan) def plan_pre_save(sender, **kwargs): """ plan pre save databaseinfra is a plan object and not an implementation from DatabaseInfra's model """ plan = kwargs.get('instance') LOG.debug("plan pre-save triggered") if plan.is_default: LOG.debug("looking for other plans marked as default (they will be marked as false) with engine type %s" % plan.engine_type) if plan.id: plans = Plan.objects.filter(is_default=True, engine_type=plan.engine_type).exclude(id=plan.id) else: plans = Plan.objects.filter(is_default=True, engine_type=plan.engine_type) if plans: with transaction.commit_on_success(): for plan in plans: LOG.info("marking plan %s(%s) attr is_default to False" % (plan, plan.engine_type)) plan.is_default = False plan.save(update_fields=['is_default']) else: LOG.debug("No plan found") simple_audit.register(EngineType, Engine, Plan, PlanAttribute, DatabaseInfra, Instance)
LOG.warning("configuration %s not found" % name) return None except Exception, e: LOG.warning( "ops.. could not retrieve configuration value for %s: %s" % (name, e)) return None @receiver([post_save, post_delete], sender=Configuration) def clear_configuration_cache(sender, **kwargs): configuration = kwargs.get("instance") LOG.info('Clearing configuration for name=%s', configuration.name) configuration.clear_cache() simple_audit.register(Configuration) class CeleryHealthCheck(BaseModel): last_update = models.DateTimeField() @classmethod def set_last_update(cls): obj, created = cls.objects.get_or_create( pk=1, defaults={'last_update': datetime.datetime.now()}) obj.last_update = datetime.datetime.now() obj.save() @classmethod def get_healthcheck_string(cls): celery_healthcheck_threshold_seconds = Configuration.get_by_name_as_int(
groups = Group.objects.filter(name__in=ldap_groups).exclude( user__username=user.username).order_by("name") LOG.info("LDAP's team created in the system and not set to user %s: %s" % (user, groups)) group = None if groups: group = groups[0] user.groups.add(group) LOG.info("group %s added to user %s" % (groups[0], user)) LOG.debug("User %s groups: %s after" % (user, user.groups.all())) return group simple_audit.register(Team, AccountUser, Role) ########################################################################## # SIGNALS ########################################################################## # all role name should start with role_ def user_post_save_wrapper(kwargs={}): user = kwargs.get('instance') created = kwargs.get('created') if created: LOG.debug("new user %s created" % user) user.is_active = True user.is_staff = True user.save() # notify new user create
groups = Group.objects.filter(name__in=ldap_groups).exclude( user__username=user.username).order_by("name") LOG.info("LDAP's team created in the system and not set to user %s: %s" % (user, groups)) group = None if groups: group = groups[0] user.groups.add(group) LOG.info("group %s added to user %s" % (groups[0], user)) LOG.debug("User %s groups: %s after" % (user, user.groups.all())) return group simple_audit.register(Team, AccountUser, Role, Organization) ########################################################################## # SIGNALS ########################################################################## # all role name should start with role_ def user_post_save_wrapper(kwargs={}): user = kwargs.get('instance') created = kwargs.get('created') if created: LOG.debug("new user %s created" % user) user.is_active = True user.is_staff = True user.save() # notify new user create
parameter_name = models.CharField(verbose_name=_(" Parameter name"), null=False, blank=False, max_length=100,) function_name = models.CharField(verbose_name=_(" Function name"), null=False, blank=False, max_length=100, choices=(_get_registered_functions())) maintenance = models.ForeignKey(Maintenance, related_name="maintenance_params",) def __unicode__(self): return "{} - {}".format(self.parameter_name, self.function_name) class Meta: permissions = ( ("view_maintenance_parameters", "Can view maintenance parameters"), ) simple_audit.register(Maintenance) simple_audit.register(HostMaintenance) simple_audit.register(MaintenanceParameters) ######### # SIGNALS# ######### @receiver(pre_delete, sender=Maintenance) def maintenance_pre_delete(sender, **kwargs): """ maintenance pre delete signal. Revoke scheduled task and remove its HostMaintenance objects """ maintenance = kwargs.get("instance")
ldap_groups = find_ldap_groups_from_user(username=user.username) groups = Group.objects.filter(name__in=ldap_groups).exclude( user__username=user.username).order_by("name") LOG.info( "LDAP's team created in the system and not set to user %s: %s" % (user, groups)) group = None if groups: group = groups[0] user.groups.add(group) LOG.info("group %s added to user %s" % (groups[0], user)) LOG.debug("User %s groups: %s after" % (user, user.groups.all())) return group simple_audit.register(Team, AccountUser, Role) ########################################################################## # SIGNALS ########################################################################## # all role name should start with role_ def user_post_save_wrapper(kwargs={}): user = kwargs.get('instance') created = kwargs.get('created') if created: LOG.debug("new user %s created" % user) user.is_active = True user.is_staff = True user.save() # notify new user create
""" email = models.EmailField(verbose_name='email address', max_length=255, unique=True) is_active = models.BooleanField(default=True) is_staff = models.BooleanField(default=True) organization = models.ForeignKey(Organization, blank=True, default=None, null=True) objects = CustomUserManager() USERNAME_FIELD = 'email' REQUIRED_FILEDS = [] def __str__(self): return self.email def get_full_name(self): return self.email def get_short_name(self): return self.email simple_audit.register(CustomUser) simple_audit.register(Organization) simple_audit.register(Team) simple_audit.register(Teammate)
class FilerMigrate(DatabaseMaintenanceTask): task = models.ForeignKey( TaskHistory, verbose_name="Task History", null=False, related_name="filer_migrate" ) original_export_id = models.CharField(max_length=200, null=False) database = models.ForeignKey( Database, verbose_name="Database", null=False, unique=False, related_name="filer_migrate" ) def __unicode__(self): return "Migrate filer" simple_audit.register(Maintenance) simple_audit.register(HostMaintenance) simple_audit.register(MaintenanceParameters) simple_audit.register(DatabaseUpgrade) simple_audit.register(DatabaseResize) simple_audit.register(DatabaseChangeParameter) simple_audit.register(DatabaseConfigureSSL) simple_audit.register(HostMigrate) simple_audit.register(DatabaseMigrate) ######### # SIGNALS# ######### @receiver(pre_delete, sender=Maintenance)
import resources.user_type import resources.practices import resources.position import resources.type_of_fire import resources.reset_password import resources.results import resources.progress import resources.results_zone import resources.logs import resources.image_repository import resources.report_repository simple_audit.register(resources.account.Account, resources.city.City, resources.custom_practices.CustomPractices, resources.company.Company, resources.grade.Grade, resources.military_grade.MilitaryGrade, resources.target_resource.Target, resources.lesson.Lesson, resources.program_practice.ProgramPractice, resources.user_type.UserType, resources.practices.Practices, resources.position.Position, resources.type_of_fire.TypeOfFire, resources.reset_password.ResetPassword, resources.results.Results, resources.results_zone.ResultsZone, resources.squadron.Squadron, )
try: hosts = scheduled_tasks.keys() except Exception as e: LOG.info("Could not retrieve celery scheduled tasks: {}".format(e)) return False for host in hosts: try: scheduled_tasks = scheduled_tasks[host] except TypeError: LOG.warn("There are no scheduled tasks") LOG.info(scheduled_tasks) continue for task in scheduled_tasks: if task['request']['id'] == self.celery_task_id: return True return False simple_audit.register(DatabaseFlipperFoxMigration, DatabaseFlipperFoxMigrationDetail) @receiver(pre_delete, sender=DatabaseFlipperFoxMigrationDetail) def flipperfox_migration_detail_pre_delete(sender, **kwargs): detail = kwargs.get("instance") LOG.debug("flipperfoxmigration pre-delete triggered") control.revoke(task_id=detail.celery_task_id)
class CloudStackPack(BaseModel): offering = models.ForeignKey('CloudStackOffering', related_name="cs_offering_packs") engine_type = models.ForeignKey('physical.EngineType', verbose_name=_("Engine Type"), related_name='cs_packs') name = models.CharField(verbose_name=_("Name"), max_length=100, help_text="Cloud Stack Pack Name") def __unicode__(self): return "%s" % (self.name) @property def get_region(self): return self.offering.region @property def get_environment(self): return self.offering.region.environment simple_audit.register(PlanAttr) simple_audit.register(HostAttr) simple_audit.register(DatabaseInfraAttr) simple_audit.register(CloudStackBundle) simple_audit.register(CloudStackOffering) simple_audit.register(LastUsedBundle) simple_audit.register(CloudStackRegion) simple_audit.register(DatabaseInfraOffering) simple_audit.register(CloudStackPack) simple_audit.register(BundleGroup) simple_audit.register(OfferingGroup)
class Message(models.Model): title = models.CharField(max_length=50, blank=False) text = models.TextField(blank=False) def __unicode__(self): return self.text class Owner(models.Model): name = models.CharField(max_length=50, blank=False) def __unicode__(self): return self.name class VirtualMachine(models.Model): name = models.CharField(max_length=50, blank=False) cpus = models.IntegerField() owner = models.ForeignKey(Owner) so = models.CharField(max_length=100, blank=False) started = models.BooleanField() def __unicode__(self): return self.name simple_audit.register(Message, Owner, VirtualMachine, User, Pizza, Topping)
import simple_audit import logging from django.db import models from django.core.exceptions import ValidationError from django.utils.translation import ugettext_lazy as _ from django.dispatch import receiver from util.models import BaseModel LOG = logging.getLogger(__name__) class Bind(BaseModel): service_name = models.CharField(verbose_name=_("Service Name"), max_length=200) service_hostname = models.CharField(verbose_name=_("Service Hostname"), max_length=200, null=True, blank=True) databaseinfra = models.ForeignKey('physical.DatabaseInfra', related_name="binds", on_delete=models.PROTECT, null=True, blank=True) def __unicode__(self): return "%s" % self.service_name simple_audit.register(Bind)
ldap_groups = find_ldap_groups_from_user(username=user.username) groups = Group.objects.filter(name__in=ldap_groups).exclude( user__username=user.username).order_by("name") LOG.info( "LDAP's team created in the system and not set to user %s: %s" % (user, groups)) group = None if groups: group = groups[0] user.groups.add(group) LOG.info("group %s added to user %s" % (groups[0], user)) LOG.debug("User %s groups: %s after" % (user, user.groups.all())) return group simple_audit.register(Team, AccountUser, Role, Organization) ########################################################################## # SIGNALS ########################################################################## # all role name should start with role_ def user_post_save_wrapper(kwargs={}): user = kwargs.get('instance') created = kwargs.get('created') if created: LOG.debug("new user %s created" % user) user.is_active = True user.is_staff = True user.save() # notify new user create
def get(self, request): simple_audit.register() return Response({"d": 22})
database = models.ForeignKey(Database, verbose_name="Database", null=False, unique=False, related_name="set_not_require_ssl") task = models.ForeignKey(TaskHistory, verbose_name="Task History", null=False, unique=False, related_name="database_ssl_not_require") def __unicode__(self): return "{} set SSL Not Required".format(self.database.name) simple_audit.register(Maintenance) simple_audit.register(HostMaintenance) simple_audit.register(MaintenanceParameters) simple_audit.register(DatabaseUpgrade) simple_audit.register(DatabaseResize) simple_audit.register(DatabaseChangeParameter) simple_audit.register(DatabaseConfigureSSL) simple_audit.register(HostMigrate) simple_audit.register(DatabaseMigrate) simple_audit.register(DatabaseUpgradePatch) simple_audit.register(TaskSchedule) simple_audit.register(RestartDatabase) simple_audit.register(DatabaseChangePersistence) simple_audit.register(DatabaseSetSSLRequired) simple_audit.register(DatabaseSetSSLNotRequired)
parameter_name = models.CharField(verbose_name=_(" Parameter name"), null=False, blank=False, max_length=100,) function_name = models.CharField(verbose_name=_(" Function name"), null=False, blank=False, max_length=100,choices=(_get_registered_functions())) maintenance = models.ForeignKey(Maintenance, related_name="maintenance_params",) def __unicode__(self): return "{} - {}".format(self.parameter_name, self.function_name) class Meta: permissions = ( ("view_maintenance_parameters", "Can view maintenance parameters"), ) simple_audit.register(Maintenance) simple_audit.register(HostMaintenance) simple_audit.register(MaintenanceParameters) ######### # SIGNALS# ######### @receiver(pre_delete, sender=Maintenance) def maintenance_pre_delete(sender, **kwargs): """ maintenance pre delete signal. Revoke scheduled task and remove its HostMaintenance objects """
@receiver(pre_save, sender=Credential) def credential_pre_save(sender, **kwargs): credential = kwargs.get('instance') #slugify user credential.user = slugify(credential.user) if credential.id: saved_object = Credential.objects.get(id=credential.id) if credential.user != saved_object.user: raise AttributeError(_("Attribute user cannot be edited")) if credential.database != saved_object.database: raise AttributeError(_("Attribute database cannot be edited")) @receiver(pre_save, sender=Project) def project_pre_save(sender, **kwargs): instance = kwargs.get('instance') instance.slug = slugify(instance.name) class NoDatabaseInfraCapacity(Exception): """ There isn't databaseinfra capable to support a new database with this plan """ pass simple_audit.register(Project, Database, Credential)
from django.db import models import simple_audit class Project(models.Model): name = models.CharField(max_length=30, unique=True) class Job(models.Model): name = models.CharField(max_length=30, unique=True) project = models.ForeignKey(Project, related_name='jobs') simple_audit.register(Project, Job)
# -*- coding: utf-8 -*- from __future__ import absolute_import, unicode_literals import simple_audit import logging from django.db import models from django.core.exceptions import ValidationError from django.utils.translation import ugettext_lazy as _ from django.dispatch import receiver from util.models import BaseModel LOG = logging.getLogger(__name__) class Bind(BaseModel): service_name = models.CharField( verbose_name=_("Service Name"), max_length=200) service_hostname = models.CharField( verbose_name=_("Service Hostname"), max_length=200, null=True, blank=True) databaseinfra = models.ForeignKey( 'physical.DatabaseInfra', related_name="binds", on_delete=models.PROTECT, null=True, blank=True) def __unicode__(self): return "%s" % self.service_name simple_audit.register(Bind)
from backup.models import Snapshot import datetime instance = kwargs.get('instance') LOG.debug("instance %s pre-delete" % (instance)) snapshots = Snapshot.objects.filter( instance=instance, purge_at__isnull=True) for snapshot in snapshots: LOG.debug("Setting snapshopt %s purge_at time" % (snapshot)) snapshot.purge_at = datetime.datetime.now() snapshot.save() LOG.debug("instance pre-delete triggered") @receiver(post_save, sender=DatabaseInfra) def databaseinfra_post_save(sender, **kwargs): """ databaseinfra post save """ databaseinfra = kwargs.get('instance') LOG.debug("databaseinfra post-save triggered") LOG.debug("databaseinfra %s endpoint: %s" % (databaseinfra, databaseinfra.endpoint)) simple_audit.register( EngineType, Engine, Plan, PlanAttribute, DatabaseInfra, Instance)
scheduled_tasks = inspect.scheduled() try: hosts = scheduled_tasks.keys() except Exception as e: LOG.info("Could not retrieve celery scheduled tasks: {}".format(e)) return False for host in hosts: try: scheduled_tasks = scheduled_tasks[host] except TypeError: LOG.warn("There are no scheduled tasks") LOG.info(scheduled_tasks) continue for task in scheduled_tasks: if task['request']['id'] == self.celery_task_id: return True return False simple_audit.register(DatabaseRegionMigration, DatabaseRegionMigrationDetail) @receiver(pre_delete, sender=DatabaseRegionMigrationDetail) def region_migration_detail_pre_delete(sender, **kwargs): detail = kwargs.get("instance") LOG.debug("regionmigration pre-delete triggered") control.revoke(task_id=detail.celery_task_id)
class Message(models.Model): title = models.CharField(max_length=50, blank=False) text = models.TextField(blank=False) def __unicode__(self): return self.text class Owner(models.Model): name = models.CharField(max_length=50, blank=False) def __unicode__(self): return self.name class VirtualMachine(models.Model): name = models.CharField(max_length=50, blank=False) cpus = models.IntegerField() owner = models.ForeignKey(Owner) so = models.CharField(max_length=100, blank=False) started = models.BooleanField() def __unicode__(self): return self.name simple_audit.register(Message, Owner, VirtualMachine, User)
class UpdateSsl(DatabaseMaintenanceTask): task = models.ForeignKey( TaskHistory, verbose_name="Task History", null=False, related_name="update_ssl_manager" ) database = models.ForeignKey( Database, verbose_name="Database", null=False, unique=False, related_name="update_ssl_manager" ) def __unicode__(self): return "Update SSL for {}".format(self.database) simple_audit.register(Maintenance) simple_audit.register(HostMaintenance) simple_audit.register(MaintenanceParameters) simple_audit.register(DatabaseUpgrade) simple_audit.register(DatabaseResize) simple_audit.register(DatabaseChangeParameter) simple_audit.register(DatabaseConfigureSSL) simple_audit.register(HostMigrate) simple_audit.register(DatabaseMigrate) simple_audit.register(DatabaseUpgradePatch) ######### # SIGNALS# #########
from django.db import models import simple_audit class Plan(models.Model): name = models.CharField(max_length=255) fixed_cost = models.DecimalField(max_digits=8, decimal_places=2, default=25.0) user_cost = models.DecimalField(max_digits=8, decimal_places=2, default=2.0) max_users = models.IntegerField(default=0) teams = models.BooleanField(default=False) simple_audit.register(Plan)
self.__update_final_status(self.ERROR) @property def is_status_error(self): return self.status == self.ERROR def save(self, *args, **kwargs): super(DatabaseUpgrade, self).save(*args, **kwargs) older_upgrades = DatabaseUpgrade.objects.filter( database=self.database, source_plan=self.source_plan).exclude(id=self.id) older_upgrades.update(can_do_retry=False) simple_audit.register(Maintenance) simple_audit.register(HostMaintenance) simple_audit.register(MaintenanceParameters) simple_audit.register(DatabaseUpgrade) ######### # SIGNALS# ######### @receiver(pre_delete, sender=Maintenance) def maintenance_pre_delete(sender, **kwargs): """ maintenance pre delete signal. Revoke scheduled task and remove its HostMaintenance objects """
if len(parameter_query) < 1: raise Exception('No parameters available') return { parameter['name'].split(group_name + '_')[1]: parameter['value'] for parameter in parameter_query } except Exception as e: LOG.warning( "ops.. could not retrieve parameters values for group %s: %s" % (group_name, e)) return {} class Parameter(BaseModel): name = models.CharField(verbose_name=_("Parameter name"), max_length=100) value = models.CharField(verbose_name=_("Parameter value"), max_length=255) description = models.CharField( verbose_name=_("Description"), max_length=255, null=True, blank=True ) credential = models.ForeignKey( Credential, related_name="credential_parameters" ) class Meta: unique_together = ( ('credential', 'name'), ) simple_audit.register(Credential, CredentialType, Parameter)
LOG.debug("slugfying database's name for %s" % database.name) database.name = slugify(database.name) @receiver(pre_save, sender=Credential) def credential_pre_save(sender, **kwargs): credential = kwargs.get('instance') if credential.id: saved_object = Credential.objects.get(id=credential.id) if credential.user != saved_object.user: raise AttributeError(_("Attribute user cannot be edited")) if credential.database != saved_object.database: raise AttributeError(_("Attribute database cannot be edited")) @receiver(pre_save, sender=Project) def project_pre_save(sender, **kwargs): instance = kwargs.get('instance') instance.slug = slugify(instance.name) class NoDatabaseInfraCapacity(Exception): """ There isn't databaseinfra capable to support a new database with this plan """ pass simple_audit.register(Project, Database, Credential)
Each user can be linked to organization. """ email = models.EmailField( verbose_name = 'email address', max_length = 255, unique = True ) is_active = models.BooleanField(default=True) is_staff = models.BooleanField(default=True) organization = models.ForeignKey(Organization, blank=True, default=None, null=True) objects = CustomUserManager() USERNAME_FIELD = 'email' REQUIRED_FILEDS = [] def __str__(self): return self.email def get_full_name(self): return self.email def get_short_name(self): return self.email simple_audit.register(CustomUser) simple_audit.register(Organization) simple_audit.register(Team) simple_audit.register(Teammate)