Synnefo

-Administration

    * Reconciliation process: On certain occasions, such as a Ganeti or

      RabbitMQ failure, the VM state in the system's database may differ from

      that in the Ganeti installation. The reconciliation process is designed

      to bring the system's database in sync with what Ganeti knows about

      each VM.

      The reconciliation process can be triggered for all VMs using the command

          ./manage.py reconcile --all

      It is advised, though not strictly necessary, to run the reconciliation

      process periodically, through cron. To avoid overloading the Ganeti

      master, the periodic reconciliation process takes a staggered approach

      to updating the VMs, which is configured through the following

      parameters:

        * The settings.py parameter: RECONCILIATION_MIN, which specifies the

        maximum time a VM can remain ``non-reconciled''. (default: 30 mins)

        * The --interval option to the reconcile command, which declares the

         interval time between reconciliation attempts (default: 1 min)

      On each invocation of the reconcile command, the system will trigger a

      reconciliation for ((num_all_vms/RECONCILIATION_MIN) * interval)

      machines. Obviously the less the interval value and the more the

      RECONCILIATION_MIN setting, the less load is going to be put on Ganeti.

from optparse import make_option

from django.core.management.base import BaseCommand

class Command(BaseCommand):

    option_list = BaseCommand.option_list +  (

         make_option('--all', action='store_true', dest='all_vms', default=False,

                     help='Run the reconciliation function for all VMs, now'),

         make_option('--interval', action='store', dest='interval', default=1,

                     help='Interval in minutes between reconciliations'),

    )

    def handle(self, all_vms = False, interval = 1, **options):

        all =  VirtualMachine.objects.all()

        if not all_vms:

            now = datetime.now()

            last_update = timedelta(minutes = settings.RECONCILIATION_MIN)

            not_updated = VirtualMachine.objects \

            to_update = ((all.count() / settings.RECONCILIATION_MIN) * interval)

        else:

            to_update = all.count()

            not_updated = all