innovagency.co.za - UnknownSec 403

upload mass deface mass delete console info server
name : amsctl.py
 import acrobind
import acrort
import collections
import csv
import datetime
import json
import operator
import os.path
import prettytable
import re
import subprocess
import sys
import time
import traceback


INSTANCE_TYPES = {
    1: 'TYPE_MACHINE',
    2: 'TYPE_DB',
    3: 'TYPE_SHAREPOINT',
    4: 'TYPE_VIRTUAL_MACHINE',
    5: 'TYPE_VIRTUAL_SERVER',
    6: 'TYPE_EXCHANGE',
    7: 'TYPE_VIRTUAL_CLUSTER',
    8: 'TYPE_VIRTUAL_APPLIANCE',
    9: 'TYPE_VIRTUAL_APPLICATION',
    10: 'TYPE_VIRTUAL_RESOURCE_POOL',
    11: 'TYPE_VIRTUAL_CENTER',
    12: 'TYPE_DATASTORE',
    13: 'TYPE_DATASTORE_CLUSTER',
    14: 'TYPE_MSSQL',
    15: 'TYPE_VIRTUAL_NETWORK',
    16: 'TYPE_VIRTUAL_FOLDER',
    17: 'TYPE_VIRTUAL_DATACENTER',
    18: 'TYPE_SMB_SHARED_FOLDER',
    19: 'TYPE_MSSQL_INSTANCE',
    20: 'TYPE_MSSQL_DATABASE',
    21: 'TYPE_MSSQL_DATABASE_FOLDER',
    22: 'TYPE_MSEXCHANGE_DATABASE',
    23: 'TYPE_MSEXCHANGE_STORAGE_GROUP',
    24: 'TYPE_MSEXCHANGE_MAILBOX',
}

BACKUP_STATUSES = {
    0: 'STATUS_BACKUP_UNKNOWN',
    1: 'STATUS_BACKUP_NONE',
    2: 'STATUS_BACKUP_SUCCEEDED',
    3: 'STATUS_BACKUP_WARNING',
    4: 'STATUS_BACKUP_FAILED'
}

BACKUP_STATES = {
    0: 'BACKUP_STATE_IDLE',
    1: 'BACKUP_STATE_RUNNING',
}

INSTANCE_STATUSES = {
    0: 'INSTANCE_STATUS_UNKNOWN',
    1: 'INSTANCE_STATUS_NONE',
    2: 'INSTANCE_STATUS_SUCCEEDED',
    3: 'INSTANCE_STATUS_WARNING',
    4: 'INSTANCE_STATUS_FAILED'
}

INSTANCE_STATES = {
    0: 'IDLE',
    0x01: 'INTERACTION_REQUIRED',
    0x02: 'CANCELLING',
    0x04: 'RUNNING_BACKUP',
    0x08: 'RUNNING_RECOVER',
    0x10: 'RUNNING_INSTALL',
    0x20: 'RUNNING_REBOOT',
    0x40: 'RUNNING_FAILBACK',
    0x80: 'RUNNING_TEST',
    0x100: 'RUNNING_FROM_IMAGE',
    0x200: 'RUNNING_FINALIZE',
    0x400: 'RUNNING_FAILOVER',
    0x800: 'RUNNING_REPLICATION',
}


Log = None
args = None


def format_backtrace(exception):
    exc_type, exc_value, exc_traceback = sys.exc_info()
    info = traceback.format_exception(exc_type, exc_value, exc_traceback)
    return ''.join(line for line in info)


def error_log(message):
    if Log:
        Log.write(message)
    else:
        print(message)


def print_bool_flag(flag):
    if flag is None:
      return '-'
    if not flag:
        return '-'
    return '+'


def get_optional(object, prop_name):
    val = None
    if prop_name in object:
        val = object[prop_name].ref
    return val


def describe_tenant(tenant, full_format=True):
    if tenant is None:
        return 'MISSING'

    if full_format:
        return '\'{0}\'(Name:\'{1}\', Locator: \'{2}\', Kind: \'{3}\')'.format(tenant.ID.ref if 'ID' in tenant else 'MISSING',\
            tenant.Name.ref if 'Name' in tenant else 'MISSING', tenant.Locator.ref if 'Locator' in tenant else 'MISSING',\
            tenant.Kind.ref if 'Kind' in tenant else 'MISSING')
    return '{}'.format(tenant.ID.ref if 'ID' in tenant else 'MISSING')


def get_tenant_string(object, full_format=True):
    if object is None or 'Tenant' not in object:
        return 'MISSING'

    return describe_tenant(object.Tenant, full_format)


def to_instance_state(state):
    if state == 0:
        return 'IDLE(0)'
    if state == 1:
        return 'RUNNING(1)'
    return 'UNKNOWN({})'.format(state)


def to_machine_status(status):
    if status == 0:
        return 'ONLINE'
    if status == 1:
        return 'OFFLINE'
    if status == 2:
        return 'FOREIGN'
    if status == 3:
        return 'EXPIRED'
    return 'UNKNOWN'


def drop_agent_connection(connection, host_id):
    try:
        argument = acrort.plain.Unit(flat=[('.ID', 'string', '{}'.format(host_id).upper())])
        activity_id = connection.tol.launch_command(command='651F1568-B113-479F-B578-A4167F9CA61B', argument=argument)
        Log.write('Waiting for command activity {} completion...'.format(activity_id), end='')
        result = connection.tol.get_result(activity_id)
        Log.write('done')
    except Exception as error:
        Log.write('Error: {}'.format(error))


def fix_item_protection_tenant(connection, ip_id, instance_id, host_id):
    print('Processing Gtob::Dto::ItemProtection with ID: {0}'.format(ip_id))
    print('Getting corresponding InstanceManagement::Instance with ID: {0}'.format(instance_id))
    (selected, instance) = acrobind.safe_select_object(connection, acrobind.create_viewspec_instance_by_id(instance_id))
    if selected and instance is None:
        print("Can't find instance with ID {0}, deleting wrong ItemProtection".format(instance_id))
        return
    print('Getting Msp::AMS::Dto::Machine for host ID: {0}'.format(host_id))

    msp_machine = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Msp::AMS::Dto::Machine', '.AgentID', '{}'.format(host_id)))
    #print('msp_machine: {0}'.format(msp_machine))
    if msp_machine is None:
        print("Can't find Msp::AMS::Dto::Machine for host {0}, skipping".format(host_id))
        return
    tenant_id = msp_machine['OwnerID'].ref
    print('Getting Tenants::HierarchyNode with ID: {0}'.format(tenant_id))
    tenant = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.ID', tenant_id))
    if tenant is None:
        print("Can't find Tenants::HierarchyNode with ID {0}, skipping".format(tenant_id))
        return
    print(tenant)
    #connection.dml.update(pattern=acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ItemProtection', '.ID', ip_id), diff={'Tenant': tenant})
    print('Gtob::Dto::ItemProtection with ID {0} is fixed.'.format(ip_id))


def fix_instance_tenant(connection, instance_id, host_id):
    print('Processing InstanceManagement::Instance with ID: {0}'.format(instance_id))
    print('Getting Msp::AMS::Dto::Machine for host ID: {0}'.format(host_id))
    msp_machine = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Msp::AMS::Dto::Machine', '.AgentID', '{}'.format(host_id)))
    #print('msp_machine: {0}'.format(msp_machine))
    if msp_machine is None:
        print("Can't find Msp::AMS::Dto::Machine for host {0}, skipping".format(host_id))
        return
    tenant_id = msp_machine['OwnerID'].ref
    print('Getting Tenants::HierarchyNode with ID: {0}'.format(tenant_id))
    tenant = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.ID', tenant_id))
    if tenant is None:
        print("Can't find Tenants::HierarchyNode with ID {0}, skipping".format(tenant_id))
        return
    print(tenant)
    #connection.dml.update(pattern=instance_spec(instance_id), diff={'Tenant': tenant})
    print('InstanceManagement::Instance with ID {0} is fixed.'.format(instance_id))


def fix_machine_tenant(connection, machine_id):
    print('Processing MachineManagement::Machine with ID: {0}'.format(machine_id))
    print('Getting Msp::AMS::Dto::Machine for host ID: {0}'.format(machine_id))
    msp_machine = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Msp::AMS::Dto::Machine', '.AgentID', '{}'.format(host_id)))
    #print('msp_machine: {0}'.format(msp_machine))
    if msp_machine is None:
        print("Can't find Msp::AMS::Dto::Machine for host {0}, skipping".format(machine_id))
        return False
    tenant_id = msp_machine['OwnerID'].ref
    print('Getting Tenants::HierarchyNode with ID: {0}'.format(tenant_id))
    tenant = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.ID', tenant_id))
    if tenant is None:
        print("Can't find Tenants::HierarchyNode with ID {0}, skipping".format(tenant_id))
        return False
    print(tenant)
    #connection.dml.update(pattern=acrobind.create_viewspec_by_is_and_guid_property('MachineManagement::Machine', '.ID', machine_id), diff={'Tenant': tenant})
    print('MachineManagement::Machine with ID {0} is fixed.'.format(machine_id))
    return True


def analyze_tenant(object):
    if 'Tenant' in object:
        locator = '-'
        if 'Locator' in object['Tenant']:
            locator = object.Tenant.Locator.ref
        return '\'{0}\'({1})'.format(object.Tenant.Name.ref, locator)
    return None


def wrap_safe_exec_result(result):
    if not result[0]:
        return 'UNKNOWN'
    return 'OK' if result[1] else 'MISSING'


def get_objects_count(connection, machine_id):
    spec = acrobind.create_viewspec_by_is_and_guid_property('Dml::Sync::Caching::Registration', '.__source_machine', str(machine_id))
    return acrobind.count_objects_by_spec(connection, spec)


def get_objects_count_2(connection, machine_id):
    return acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_guid_property('Dml::Sync::Caching::Registration', '.__source_machine', str(machine_id)))


def delete_objects_count(dml, machine_id):
    spec = acrobind.create_viewspec_by_is_and_guid_property('Dml::Sync::Caching::Registration', '.__source_machine', str(machine_id))
    dml.delete(pattern=spec.pattern)


def check_caching_registration(connection):
    print('Checking Dml::Sync::Caching::Registration')

    if args.machine_id is not None and args.machine_status is not None and args.machine_status == 0:


        print('Count: {0}'.format(get_objects_count(connection, args.machine_id)))

        objects = get_objects_count_2(connection, args.machine_id)
        print('Count2: {0}'.format(len(objects)))

        def caching_registration_spec(registration_id, machine_id):
            return acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is_and_guid_property('Dml::Sync::Caching::Registration', '.ID', registration_id), machine_id)

        object = acrobind.safe_select_object(connection, caching_registration_spec('CE030FCE-9241-400D-97C0-601610EDD186', args.machine_id))
        print('\tActivities: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('D0F82464-DD2F-4017-9745-DDEE4F44610A', args.machine_id))
        print('\tProtect command activities: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('8B94773D-6748-443B-8170-91426FD0EA98', args.machine_id))
        print('\tGtob::Protection::App::Machine: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('CC7554D7-62EA-4D57-8483-E6BFA12CDA72', args.machine_id))
        print('\tClusterManager::Cluster: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('D236945B-755A-4A79-A614-67BB674E011A', args.machine_id))
        print('\tGtob::Dto::Protection: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('54EB2BDC-1465-4C34-9C94-A08C843E6ED6', args.machine_id))
        print('\tGtob::Dto::ProtectionPlan: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('BFBFEE9D-551C-4737-BF43-06CB97B7FACA', args.machine_id))
        print('\tRunVmFromImage::VMResurrection: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('DE5FCF73-3A7E-4989-A869-CF61F509B0EB', args.machine_id))
        print('\tStatistics::Counters: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('B9D53478-4CB1-45C6-9EAF-91AB6DDD38CC', args.machine_id))
        print('\tReplication::Continuous::ProcessInfo: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('F47035AE-2057-4862-889A-40D6DADB7F9C', args.machine_id))
        print('\tLocal Gtob::Dto::ItemProtection: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('055F55CC-2F09-4FB8-A5E0-63EC1F186E0F', args.machine_id))
        print('\tCentralized Gtob::Dto::ItemProtection: {0}'.format(wrap_safe_exec_result(object)))

        object = acrobind.safe_select_object(connection, caching_registration_spec('323976BC-3CB2-4DD2-8736-9343A7B4C3DB', args.machine_id))
        print('\tLegacy Gtob::Dto::ItemProtection: {0}'.format(wrap_safe_exec_result(object)))

        objects = []
        #objects = acrobind.select_objects(connection, acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is('Gtob::Dto::ItemProtection'), args.machine_id))
        #objects = acrobind.select_objects(connection, acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is('InstanceManagement::Instance'), args.machine_id))
        #objects = acrobind.select_objects(connection, acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is('Gtob::Dto::Protection'), args.machine_id))
        #objects = acrobind.select_objects(connection, acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is('Gtob::Dto::ProtectionPlan'), args.machine_id))
        #objects = acrobind.select_objects(connection, acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.Environment.ProtectionPlanID', 'C3A38821-AF2D-05A0-21E2-23B2F5673916'), args.machine_id))
        for o in objects:
            print('--------------')
            print(o)

    elif args.machine_id is not None:
      print('Machine is OFFLINE.')
    else:
      print('No machine ID.')


def check_running_activities(connection, spec, machine_id=None):
    Log.write('Checking activities by spec: {0}'.format(spec.pattern))

    pattern1 = [
            ('^Is', 'string', 'Tol::History::Plain::Activity'),
            ('.Tenant.ID', 'string', '{}'.format(args.tenant_id)),
            ('.State', 'dword', 0),
            ('.State^Less', 'dword', 5)]
    spec1 = acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern1))

    local_count = acrobind.count_objects_by_spec(connection, spec)
    Log.write('AMS has \'{}\' activities.'.format(local_count))
    if local_count > 0:
        activities = acrobind.select_objects(connection, spec)
        list_activities(activities)

        if args.fix:
            print('Do you want to change state of these activities to completed?(y/n)?')
            if ask_user():
                for a in activities:
                    id_str = '{0}'.format(a.ID.ref)
                    pattern = [
                        ('', 'dword', 5),
                    ]
                    diff_unit={'State': acrort.plain.Unit(flat=pattern)}
                    connection.dml.update(pattern=acrobind.create_viewspec_by_is_and_guid_property('Tol::History::Plain::Activity', '.ID', id_str).pattern, diff=diff_unit)
                    print('Activity {} is fixed.'.format(id_str))
            else:
                print('skipped.')

    if machine_id:
        Log.write('Checking remote activities on agent \'{0}\'.'.format(machine_id))
        local_pattern = [
            ('^Is', 'string', 'Tol::History::Plain::Activity'),
            ('.State', 'dword', 0),
            ('.State^Less', 'dword', 5)]
        local_spec = acrort.dml.ViewSpec(acrort.plain.Unit(flat=local_pattern))
        remote_spec = acrobind.viewspec_apply_remote_host(local_spec, machine_id)
        count = acrobind.count_objects_by_spec(connection, remote_spec)
        Log.write('Agent \'{}\' has \'{}\' running activities.'.format(machine_id, count))
        if count > 0:
            activities = acrobind.select_objects(connection, remote_spec)
            list_activities(activities)


def list_activities(activities):
    table = prettytable.PrettyTable(["Name", "State", "ID", "Specific", "CommandID", "HostID"])
    table.align["Name"] = "l"
    table.padding_width = 1

    for a in activities:
        if args.extra:
            Log.write(a)
        name_str = '\'{0}\''.format(a.Name.ref)
        state_str = '{0}'.format(a.State.ref)
        id_str = '{0}'.format(a.ID.ref)
        command_id_str = '{0}'.format(a.Details.CommandID.ref)
        specific_id_str = '{0}'.format(a.Details.Specific.ref)
        host_id_str = acrobind.get_trait_value('Source', a)
        table.add_row([name_str, state_str, id_str, specific_id_str, command_id_str, host_id_str])
    Log.write(table.get_string(sortby="Name"))
    Log.write('')


def delete_plan_artifacts(connection, host_id, cplan_id):
    print('Do you want to cleanup synced Gtob::Dto::ProtectionPlan(y/n)?')
    if ask_user():
        connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', cplan_id).pattern)
        connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::CentralizedProtection', '.ID', cplan_id).pattern)
        connection.dml.delete(pattern=acrobind.viewspec_apply_source(acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', cplan_id), host_id).pattern)
        print('deleted.')
    else:
        print('skipped.')


    print('Do you want to cleanup legacy  Gtob::Dto::ItemProtection(y/n)?')
    if ask_user() and host_id:
        remote_ips_spec = acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ItemProtection', '.Plan', cplan_id), host_id)
        objects = acrobind.select_objects(connection, remote_ips_spec)
        for o in objects:
            print('--------------')
            print(o)

        connection.dml.delete(pattern=remote_ips_spec.pattern)
        print('deleted.')
    else:
        print('skipped.')


def origin_to_str(origin):
    if origin == 1:
        return 'L'
    if origin == 2:
        return 'C'
    if origin ==3:
        return 'D'
    return 'U'


def redeploy_plan(connection, plan_id):
    selection_state_spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Gct::SelectionState', '.ID', plan_id)
    selection_state = acrobind.select_object(connection, selection_state_spec)
    print("Deleting Gtob::Gct::SelectionState: {}".format(selection_state))
    connection.dml.delete(pattern=selection_state_spec.pattern)
    digest_spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ResourceDigest', '.ID', plan_id)
    digest = acrobind.select_object(connection, digest_spec)
    Log.write("Deleting Gtob::Dto::ResourceDigest: {}".format(digest))
    connection.dml.delete(pattern=digest_spec.pattern)
    deployment_request = [
      ('^Is', 'string', 'Gtob::Dto::AutomaticDeploymentRequest'),
      ('.ID', 'guid', plan_id),
      ('.ID^PrimaryKey', 'nil', None),
      ('.ID^AutomaticDeploymentRequest', 'nil', None),
      ('.InitiatedBy', 'string', 'infraview'),
      ('.Fails', 'array', [])
    ]
    #deployment_request_unit = acrort.plain.Unit(flat=deployment_request)
    #Log.write('Creating deployment request: {0}'.format(deployment_request_unit))
    #connection.dml.create(deployment_request_unit, mode=acrort.dml.CREATE_OR_REPLACE)

    Log.write('Running protect command for plan: {0}'.format(plan_id))
    plan = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', plan_id))
    tenant_connection = acrort.connectivity.Connection('ams', client_session_data = {'tenant_id': '{}'.format(plan.Tenant.ID.ref)})

    activity_id = tenant_connection.tol.launch_command(command='41830509-FCA4-4B3A-9978-3D00462DE006', argument=plan)

    result = None
    try:
        result = tenant_connection.tol.get_result(activity_id)
        tenant_connection.close()
    except acrort.Exception as ex:
        if acrort.common.interrupt_sentinel:
             tenant_connection.tol.cancel_activity(activity_id)
        Log.write('Protect canceled.')
        tenant_connection.close()
        raise


def fix_centralized_protection(connection, plan_id):
    Log.write('Creating missing Gtob::Dto::Centralized::ItemProtection object for plan \'{}\'...'.format(plan_id))
    spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::Centralized::ItemProtection', '.Centralized.PlanID', plan_id)
    protections = acrobind.select_objects(connection, spec)

    if not protections:
        Log.write('There are no Gtob::Dto::Centralized::ItemProtection objects for this plan')
        return

    affected_machines = []
    protected_instances = []

    for protection in protections:
        affected_machines.append([('', 'guid', protection.HostID.ref)])
        protected_instances.append(('.ProtectedInstances.{}'.format(protection.InstanceID.ref), 'dword', 1))

    centralized_protection = acrort.plain.Unit(flat=[
        ('.ActivationStatus', 'dword', 1),
        ('.AffectedMachines', 'array', affected_machines),
        ('.AffectedMachines^IsContainer', 'string', 'vector'),
        ('.AffectedMachinesCount', 'dword', 1),
        ('.CurrentFrame.BackupNumber', 'dword', 0),
        ('.CurrentFrame.LastStartTime', 'sqword', 0),
        ('.CurrentFrame.SchemeDeploymentID', 'string', ''),
        ('.CurrentFrame^Is', 'string', 'Gtob::Dto::BackupFrameData'),
        ('.Host', 'guid', '00000000-0000-0000-0000-000000000000'),
        ('.ID', 'guid', plan_id),
        ('.ID^PrimaryKey', 'nil', None),
        ('.ID^Protection', 'nil', None),
        ('.LastResult', 'dword', 0),
        ('.ManualStartNumber', 'dword', 0),
        ('.Origin', 'dword', 2),
        ('.Owner', 'string', 'root'),
        ('.PlanDeploymentState', 'dword', 0),
        ('.PlanID', 'guid', plan_id),
        ('.PlanID^ForeignKey', 'nil', None),
        *protected_instances,
        ('.Status', 'dword', 0),
        ('^Is', 'string', 'Gtob::Dto::CentralizedProtection'),
        ('^Is', 'string', 'Gtob::Dto::Protection'),
    ])
    connection.dml.create(centralized_protection)
    Log.write('Creating object:\n', centralized_protection)


def describe_plans(connection):
    Log.write('[---Checking plans---]')
    plans = None
    if args.plan_name:
        plans = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_like('Gtob::Dto::ProtectionPlan', '.Name', args.plan_name))
    if args.plan_id:
        plans = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', args.plan_id))

    check_plan_list_internal(connection, plans)

    if args.plan_id and args.change_owner:
        new_tenant = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.ID', args.change_owner))
        if new_tenant:
            diff = [
              ('^PackedDiff', 'nil', None),
              ('.DmlTimeStamp', 'sqword', 0),
              ('.DmlTimeStamp^Removed', 'nil', None),
            ]
            tenant_patch = new_tenant.merge(acrort.plain.Unit(flat=diff))
            new_owner_id = acrort.common.Guid(acrort.common.eval_md5('security-tenant-{}'.format(new_tenant.Locator.ref)))
            new_tenant_str = describe_tenant(new_tenant, full_format=True)
            plan = plans[0]
            p_tenant = get_tenant_string(plan, full_format=True)
            p_owner = get_optional(plan, "OwnerID")

            Log.write('Do you want to change owner of Gtob::Dto::ProtectionPlan from \'{0}({1})\' to \'{2}({3})\'?(y/n)'.format(p_tenant, p_owner, new_tenant_str, new_owner_id))
            if ask_user():
                owner_patch = acrort.plain.Unit({'OwnerID' : new_owner_id, 'Tenant' : tenant_patch})
                plan = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', args.plan_id))
                Log.write('Applying patch: {0}'.format(owner_patch))
                new_plan = plan.consolidate(owner_patch)
                connection.dml.create(new_plan, mode=acrort.dml.CREATE_OR_REPLACE)
                if args.extra:
                    Log.write(plan)
                Log.write('done')
        else:
            Log.write('Can\'t find tenant with ID \'{0}\''.format(args.change_owner))

    if args.plan_id and args.redeploy:
        Log.write('Do you want to redeploy Gtob::Dto::ProtectionPlan?(y/n)')
        if ask_user():
            result = redeploy_plan(connection, args.plan_id)
            Log.write(result)
            Log.write('done')

    if args.plan_id and args.fix:
        Log.write('Do you want to undeploy Gtob::Dto::ProtectionPlan?(y/n)')
        if ask_user():
            Log.write('Input host ID(for centralized plan leave it empty):')
            host_id = sys.stdin.readline()
            host_id = host_id.rstrip()

            cplan_id = None
            if not args.plan_id:
                Log.write('Input plan ID(empty ID will skip action):')
                cplan_id = sys.stdin.readline()
                cplan_id = cplan_id.rstrip()
            else:
                cplan_id = args.plan_id

            if cplan_id:
                check_plan = None
                if host_id:
                    check_plan = acrobind.select_object(connection, acrobind.viewspec_apply_source(acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', cplan_id), host_id))
                else:
                    check_plan = acrobind.select_object(connection, acrobind.create_viewspec_deployed_protection_plan_by_id(cplan_id))

                force_undeploy = False
                if not check_plan:
                    Log.write('Do you want to force undeploy?(y/n)')
                    if ask_user():
                        force_undeploy = True

                if check_plan or force_undeploy:
                    arg = acrort.common.Guid(cplan_id)
                    if args.extra:
                       Log.write(check_plan)
                    Log.write('Running unprotect')
                    if host_id:
                        activity_id = connection.tol.launch_command(command='C006D24E-E6ED-494a-9789-237CD3A814E7', argument=arg, target_machine=host_id)
                    else:
                        activity_id = connection.tol.launch_command(command='C006D24E-E6ED-494a-9789-237CD3A814E7', argument=arg)

                    try:
                        if host_id:
                            result = connection.tol.get_result(activity_id, target_machine=host_id)
                        else:
                            result = connection.tol.get_result(activity_id)
                    except acrort.Exception as ex:
                        if acrort.common.interrupt_sentinel:
                            if host_id:
                                connection.tol.cancel_activity(activity_id, target_machine=host_id)
                            else:
                                connection.tol.cancel_activity(activity_id)
                        Log.write('Unprotect canceled.')
                        delete_plan_artifacts(connection, host_id, cplan_id)
                        raise
                    Log.write(result)
                    Log.write('done')

                    delete_plan_artifacts(connection, host_id, cplan_id)
                else:
                    Log.write('Plan not found. Skipped.')

                    delete_plan_artifacts(connection, host_id, cplan_id)
            else:
                Log.write('skipped')
        else:
            Log.write('skipped')

    if args.plan_id and args.fix_centralized_protection:
        plan = plans[0]
        is_centralized = (plan.Origin.ref == 2)
        cprotection = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::CentralizedProtection', '.ID', args.plan_id))
        if cprotection:
            Log.write('Gtob::Dto::CentralizedProtection already exist')
        else:
            if not is_centralized:
                Log.write('Gtob::Dto::CentralizedProtection can be created for centralized plans only')
            else:
                Log.write('Do you want to create missing Gtob::Dto::CentralizedProtection?(y/n)')
                if ask_user():
                    fix_centralized_protection(connection, args.plan_id)
                    Log.write('done')


def list_tenants(connection):
    Log.write('[---List of tenants that matches \'{}\'---]'.format(args.tenant_name))
    objects = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_like('Tenants::HierarchyNode', '.Name', args.tenant_name))

    table = prettytable.PrettyTable(["Name", "ID", "Locator", "Kind"])
    table.align["Name"] = "l"
    table.padding_width = 1

    for o in objects:
        if args.extra:
            Log.write(o)
        o_name = '\'{0}\''.format(o.Name.ref)
        o_id_str = '{0}'.format(o.ID.ref)
        o_locator_str = '{0}'.format(o.Locator.ref)
        o_kind_str = '{0}'.format(o.Kind.ref)
        table.add_row([o_name, o_id_str, o_locator_str, o_kind_str])
    Log.write(table.get_string(sortby="Name"))
    Log.write('')


def handle_remove_object_request(connection, spec):
    if args.delete:
        print('Do you want to delete object by spec(y/n):\n\'{0}\'?'.format(spec.pattern))
        if ask_user():
            connection.dml.delete(pattern=spec.pattern)
            print('done')
        else:
            print('skipped')


def fix_centralized_protections(connection, plans):
    centralized_plan_found = False
    for plan in plans:
        try:
            # Process centralized plans onnly
            if plan.Origin.ref != 2:
                continue

            centralized_plan_found = True
            cprotection_spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::CentralizedProtection', '.ID', plan.ID.ref)
            cprotection = acrobind.select_object(connection, cprotection_spec)

            if cprotection:
                Log.write('Gtob::Dto::CentralizedProtection for plan \'{}\' already exists, skipping'.format(plan.ID.ref))
            else:
                fix_centralized_protection(connection, plan.ID.ref)
        except Exception as e:
            error_log(format_backtrace(e))

    if not centralized_plan_found:
        Log.write('There are no centralized plans for current account, nothing to fix')
    Log.write('done')


def check_plan_list(connection):
    Log.write('[---Checking plans---]')
    plans = []

    ids = [
'9248C82C-3848-430B-A74E-A2B3490112B9',
'DC5BB2CF-F645-43A1-9F6D-F77EAC8DABCA',
'099E59F7-856B-47D6-B6C6-87F61B25E907',
'F1EFC07B-B6F7-45A6-8B0B-439ADBBCD73E',
'74C6AFDB-682D-454F-BCCA-F36656EBF991',
'0FD9477E-69ED-42C8-B7BE-B7F25C76814A',
'29FE3C53-C0BB-47B4-87E7-269030FBF754',
'5B01139F-97CF-4957-969D-AFFBA5FB2A13',
'D7DF4A24-00BB-407F-9AA1-A54476953466',
'8434793F-9745-4855-A38F-53F8F42B6674',
'7D0F79F7-0551-4154-A463-D689514D14F6',
'C382E30D-66B2-41D9-A9EA-7AA4C08405F7',
'7D5EA15A-F928-441E-960F-CAE5EBE96603',
'C47E4AB4-9D37-41AF-9C1D-4681A96892CC',
'127F8D2C-A4B2-4FED-9A52-0EBBA608D25B',
'F77882CF-4E45-4A95-B3E8-6061E7BE5A98',
'60B724D9-B0A2-4916-91E7-C31C72D31DDE',
'03E1BBA6-1F6C-4446-926D-E5D997E412A6',
'4F8F9FCE-299D-4493-8E97-4F98299D15BD',
'25921214-FF3C-4A4B-BA0E-D50D2E994E9E',
'26FE004C-4773-4D9E-9F55-257D3F8E10FA',
'807BDBD3-DDD1-4EEB-BC99-5C6B63453BBD',
'99A1B1C0-089F-490F-8865-DE38A82CF5BC',
'88C98A57-0537-4F55-A5E9-E21E3999516D',
'19E90A70-1BAB-4929-8BB2-2038AF58F718',
'998EE36E-4973-496D-B8A2-B14AA3ECD526',
'1584C104-F6B1-42A4-A62B-D1B1DDB23330',
'34742B08-07EE-488D-BB8C-67CE062EDC67',
'EB333349-4FA2-4822-ADBC-59E129AD02A3',
'3D382519-9E62-42A4-A302-EB42AB493856',
'34D86CC4-76B8-43C2-B87B-F29D660A3F1F',
'CF9B8B40-9AA5-450A-8A50-6C8987733558',
'49791B80-D074-488D-9578-A8B4FC81F483',
'E65223EC-BDAB-4EE0-BA8A-55EDF94AC0D7',
'952B2C76-B4AF-4636-B845-EDA9E7322940',
'CF7BFC0C-F2D0-424D-A4EA-2E36EC5604B5',
'7547E6FF-AE84-4EB4-A57A-E9BCB51AE8E6',
'1E150441-5993-45CF-85DA-100738092AEC',
'05FAB142-3952-4DB0-83A4-8140FEFEF498',
'DC7A5FE6-0E4D-4906-A990-0E3EED7FEF0C',
'BDDF59BE-4CB7-46F4-9B28-29EC5F735394',
'29DBFE77-7B92-4AEE-9633-F7A4417AF560',
'7518FB93-56F0-418D-AC70-645D0A005302',
'F9FF7DA1-D21D-459F-8ABA-D1C51C93ED04',
'13215CC3-10C2-43A6-B773-CABEE0E9BA0C',
'730B3DA3-E118-4C1A-8C12-2F4F9D246C83',
'781AF1F6-0EC4-48CD-A717-B07CEF53CF1A',
'1E48C701-548C-4D7D-9B1D-3E06D99AA86E'
    ]
    for id in ids:
        pattern = [
          ('^Is', 'string', 'Gtob::Dto::ProtectionPlan'),
          ('.ID', 'guid', id)
        ]
        object = acrobind.select_object(connection, acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern)))
        if object is not None:
            plans.append(object)

    check_plan_list_internal(connection, plans)


def check_plan_list_internal(connection, plans):

    plan_table = prettytable.PrettyTable(["Index", "Name/Instance", "ID", "Agents", "Status", "Tenant"])
    plan_table.align["Name/Instance"] = "l"
    plan_table.align["Status"] = "l"
    plan_table.padding_width = 1

    is_centralized = False
    p_owner = None
    p_tenant = None
    p_id = None
    affected_machines_str = '-'
    affected_machines_ids_str = None
    centralized_plan_id_str = '-'
    cprotection = None


    index = 0
    for p in plans:
        if args.extra:
            Log.write(p)
        p_id = p.ID.ref
        p_id_str = '{0}'.format(p_id)
        p_origin = origin_to_str(p.Origin.ref)
        p_name = '\'{0}\'({1})'.format(p.Name.ref, p_origin)

        p_owner = get_optional(p, "OwnerID")

        if p.Origin.ref == 2: #'CENTRALIZED'
            is_centralized = True

            affected_machine_count = None
            cprotection = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::CentralizedProtection', '.ID', p_id))

            if not cprotection:
                Log.write('Missing centralized protection for plan \'{0}\'!'.format(p_id))
                continue

            if args.extra:
                print(cprotection)

            affected_machines_str = 'MISSING'
            if 'AffectedMachines' in cprotection:
                affected_machines_str = '{0}'.format(len(cprotection.AffectedMachines))

                for (number, affected_machine) in cprotection.AffectedMachines:
                    if affected_machines_ids_str:
                        affected_machines_ids_str = '{0}, {1}'.format(affected_machines_ids_str, affected_machine.ref)
                    else:
                        affected_machines_ids_str = '{0}'.format(affected_machine.ref)
        else:
            centralized_plan_id_str = '{0}'.format(p.CentralizedProtectionPlan.ref)

        p_source = ''
        for tname, tunit in p.traits:
            if tname == 'Source':
                p_source = '{0}'.format(tunit.ref)
                break

        p_tenant = get_tenant_string(p, full_format=True)
        t = get_tenant_string(p, full_format=False)


        items = []
        if is_centralized:
            items = check_cplan_related_item_protections(connection, p_id)
        else:
            items = check_plan_related_item_protections(connection, p_id)

        plan_table.add_row([index, p_name, p_id_str, affected_machines_str, '', t])
        index += 1
        for item in items:
            #item['lfi_status'] = None
            #item['lfi_result'] = None
            #item['lfi_time'] = None
            #item['ns_time'] = None
            #item['lsi_time'] = None
            #item['cpi'] = '-'
            #item['lpi'] = '-'
            #item['legacy_pi'] = '-'

            errors_string = ''
            errors_count = len(item['lfi_errors'])
            warnings_string = ''
            warnings_count = len(item['lfi_warnings'])
            is_ok = True
            for error in item['lfi_errors']:
                if errors_string != '':
                    errors_string += '\n{}'.format(errors_string)
                else:
                    errors_string = error

            for warning in item['lfi_warnings']:
                if warnings_string != '':
                    warnings_string += '\n{}'.format(warnings_string)
                else:
                    warnings_string = warning

            last_result = ''
            if errors_count > 0:
                last_result = 'E({}): {}'.format(errors_count, errors_string)
            if warnings_count > 0:
                if errors_count > 0:
                    last_result += '\n'
                last_result += 'W({}): {}'.format(warnings_count, warnings_string)

            if errors_count == 0 and warnings_count == 0:
                last_result = 'OK'
            elif args.parameter1 == 'id':
                last_result = 'E:{},W:{}'.format(errors_count, warnings_count)
            status = '{}\nLFT: {}\nNST: {}'.format(last_result, item['lfi_time'], item['ns_time'])
            #item_tenant_str = '{}({})'.format(item['tenant_id'], item['tenant_name'])
            item_tenant_str = '{}'.format(item['tenant_id'])

            plan_table.add_row([index, '  |- {}'.format(item['instance_id']), item['id'], item['host_id'], status, item_tenant_str])
            index += 1

    #Log.write(plan_table.get_string(sortby="Index", fields=["Name/Instance", "ID" "Agents", "Status", "Tenant"]))
    if args.parameter1 == 'id':
        Log.write(plan_table.get_string(sortby="Index", fields=["Name/Instance", "ID", "Agents", "Status", "Tenant"]))
    else:
        Log.write(plan_table.get_string(sortby="Index", fields=["Name/Instance", "Status", "Tenant"]))
    #print(plan_table)



def check_tenant(connection):
    Log.write('[---Checking tenant \'{}\'---]'.format(args.tenant_id))

    tenant_spec = acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.ID', args.tenant_id)
    t = acrobind.select_object(connection, tenant_spec)
    if args.extra:
        Log.write(t)

    if not t:
        Log.write('No such tenant.')
        return

    t_name = '\'{0}\'(ID:\'{1}\', Locator: \'{2}\', Kind: \'{3}\')'.format(t.Name.ref, t.ID.ref, t.Locator.ref, t.Kind.ref)
    Log.write('Tenant match: {0}'.format(t_name))

    handle_remove_object_request(connection, tenant_spec)

    if args.update:
        is_arr = [None, 'InstanceManagement::Instance', 'MachineManagement::Machine', 'Tol::History::Plain::Activity']
        base_pattern = [
            ('.Tenant.ID', 'string', t.ID.ref)
        ]
        raw_diff = acrort.plain.UnitDiff()
        raw_diff.add_patch('.Tenant.Name', t.Name.ref)
        for is_str in is_arr:
            pattern = base_pattern.copy()
            if is_str:
                pattern.append(('^Is', 'string', is_str))
            connection.dml.update(pattern=acrort.plain.Unit(flat=pattern), raw_diff=raw_diff)
        Log.write('All tenant sections is successfully updated.')

    if args.running_activities:
        pattern = [
            ('^Is', 'string', 'Tol::History::Plain::Activity'),
            ('.Tenant.ID', 'string', '{}'.format(args.tenant_id)),
            ('.State', 'dword', 0),
            ('.State^Less', 'dword', 5)]
        spec = acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern))
        check_running_activities(connection, spec)

    if args.machine_statistics:
        stat = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('MachineManagement::Statistics', '.Tenant.ID', args.tenant_id))
        Log.write(stat)

    msp_machine_table = prettytable.PrettyTable(["AgentID", "OwnerID", "IsEnabled", "PublicKey"])
    msp_machine_table.align["AgentID"] = "l"
    msp_machine_table.padding_width = 1

    machine_table = prettytable.PrettyTable(["Name", "ID", "Status", "InsideVirtual", "Tenant"])
    machine_table.align["Name"] = "l"
    machine_table.padding_width = 1

    plan_table = prettytable.PrettyTable(["Name", "ID", "Origin", "Source", "Tenant"])
    plan_table.align["Name"] = "l"
    plan_table.padding_width = 1

    tenants = []
    if t.Kind.ref != -1:
        Log.write('Checking subtenants of group...')
        pattern = [
            ('^Is', 'string', 'Tenants::HierarchyNode'),
            ('.Locator', 'string', ''),
            ('.Locator^DirectRelative', 'string', t.Locator.ref)
        ]
        tenants.extend(acrobind.select_objects(connection, acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern))))
    else:
        tenants.append(t)

    all_plans = []
    for t in tenants:
        if t.ID.ref != args.tenant_id:
            t_name = '\'{0}\'(ID:\'{1}\', Locator: \'{2}\', Kind: \'{3}\')'.format(t.Name.ref, t.ID.ref, t.Locator.ref, t.Kind.ref)
            Log.write('Subtenant: {0}'.format(t_name))

        msp_machines = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_string_property('Msp::AMS::Dto::Machine', '.OwnerID', t.ID.ref))
        machines = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_string_property('MachineManagement::Machine', '.Tenant.ID', t.ID.ref))
        plans = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_string_property('Gtob::Dto::ProtectionPlan', '.Tenant.ID', t.ID.ref))
        all_plans.extend(plans)

        add_tenant_description(connection, t, msp_machine_table, msp_machines, machine_table, machines, plan_table, plans)

    Log.write(msp_machine_table)
    Log.write('')
    Log.write(machine_table)
    Log.write('')
    Log.write(plan_table.get_string(sortby="Name"))
    Log.write('')

    if args.fix_centralized_protection:
        Log.write('Do you want to fix Gtob::Dto::CentralizedProtection objects for account and its children?(y/n)')
        if not ask_user():
            return
        fix_centralized_protections(connection, all_plans)

    if args.check_multitenancy:
        Log.write('Check virtual instances with mixed ownership...')
        instances = acrobind.select_objects(connection, acrobind.create_viewspec_by_is_and_string_property('InstanceManagement::Instance', '.Tenant.ID', t.ID.ref))

        if not instances:
            Log.write('Tenant doesn\'t have virtual instances')
            return

        all_vcenters = set()
        all_hosts = set()

        hosts_to_select = set()
        vcenters_to_select = set()

        already_selected = {instance.ID.ref for instance in instances}

        # Collect IDs of hosts and vcenters referened in virtual machines and servers
        for instance in instances:
            instance_id = instance.ID.ref
            instance_type = INSTANCE_TYPES.get(instance.Type.ref)

            if instance_type == 'TYPE_VIRTUAL_MACHINE':
                if instance.get_branch('.Parameters.Server', None) is not None:
                    host_id = instance.Parameters.Server[0].ref
                    if host_id not in already_selected:
                        hosts_to_select.add(host_id)
                    all_hosts.add(host_id)

            if instance_type == 'TYPE_VIRTUAL_SERVER':
                all_hosts.add(instance.ID.ref)
                if instance.get_branch('.Parameters.VirtualCenterUUID', None) is not None:
                    vcenter_id = instance.Parameters.VirtualCenterUUID[0].ref
                    if vcenter_id not in already_selected:
                        vcenters_to_select.add(vcenter_id)
                    all_vcenters.add(vcenter_id)

            if instance_type == 'TYPE_VIRTUAL_CENTER':
                all_vcenters.add(instance.ID.ref)

        def values_pattern(property, values):
            return [
                ('^Is', 'string', 'InstanceManagement::Instance'),
                (property, 'guid', '00000000-0000-0000-0000-000000000000'),
                (property + '^ValueIn', 'complex_trait', [
                    ('', 'array', [[('', 'guid', value)] for value in values])
                ]),
            ]

        def searchable_values_pattern(property, values):
            return [
                ('^Is', 'string', 'InstanceManagement::Instance'),
                (property, 'array', []),
                (property + '^HasIntersection', 'complex_trait', [
                    ('', 'array', [[('', 'string', str(value))] for value in values]),
                ])
            ]

        instances = []

        # Select all vcenters referenced by tenant hosts
        if vcenters_to_select:
            instances.extend(acrobind.select_objects(connection, acrobind.create_viewspec_by_pattern(values_pattern('.ID', vcenters_to_select))))
        # Select all hosts that have reference to all found vcenters
        if all_vcenters:
            pattern = searchable_values_pattern('.Parameters.VirtualCenterUUID', all_vcenters)
            hosts_by_vcenters = acrobind.select_objects(connection, acrobind.create_viewspec_by_pattern(pattern))

            for host in hosts_by_vcenters:
                host_id = host.ID.ref
                all_hosts.add(host_id)
                if host_id in hosts_to_select:
                    hosts_to_select.remove(host_id)

            instances.extend(hosts_by_vcenters)

        # Select all hosts referenced by tenant vms
        if hosts_to_select:
            instances.extend(acrobind.select_objects(connection, acrobind.create_viewspec_by_pattern(values_pattern('.ID', hosts_to_select))))
        # Select all vms that have reference to all found hosts
        if all_hosts:
            pattern = searchable_values_pattern('.Parameters.Server', all_hosts)
            vms = acrobind.select_objects(connection, acrobind.create_viewspec_by_pattern(pattern))
            instances.extend(vms)

        found = False
        for instance in instances:
            if instance.Tenant.ID.ref != args.tenant_id:
                if not found:
                    Log.write('List of virtual instances with mixed ownership:\n')
                    found = True
                Log.write('ID: %s' % instance.ID.ref)
                Log.write('Name: %s' % instance.FullPath.ref)
                Log.write('Type: %s' % INSTANCE_TYPES.get(instance.Type.ref))
                Log.write('Owner ID: %s' % instance.Tenant.ID.ref)
                Log.write('Owner Name: %s\n' % instance.Tenant.Name.ref)

        if not found:
            Log.write('All virtual instances belong to the same tenant')


def add_tenant_description(connection, t, msp_machine_table, msp_machines, machine_table, machines, plan_table, plans):
    for msp in msp_machines:
        if args.extra:
            print(msp)
        public_key = '{}'.format(msp.PublicKey.ref) if 'PublicKey' in msp else 'Missing'
        msp_machine_table.add_row(['{}'.format(msp.AgentID.ref), '{}'.format(msp.OwnerID.ref), '{}'.format(msp.IsEnabled.ref), public_key])

    for m in machines:
        if args.extra:
            Log.write(m)
        tenant_info = get_tenant_string(m, full_format=False)
        is_inside_virtual = ''
        if 'IsInsideVirtual' in m.Info:
            is_inside_virtual = '{}'.format(m.Info.IsInsideVirtual.ref)
        machine_table.add_row([m.Info.Name.ref, '{}'.format(m.ID.ref), to_machine_status(m.Status.ref), is_inside_virtual, tenant_info])

    for p in plans:
        if args.extra:
            Log.write(p)
        p_name = '\'{0}\''.format(p.Name.ref)
        p_id = p.ID.ref
        p_id_str = '{0}'.format(p_id)
        p_origin = origin_to_str(p.Origin.ref)
        p_source = ''
        for tname, tunit in p.traits:
            if tname == 'Source':
                p_source = '{0}'.format(tunit.ref)
                break

        t_name = get_tenant_string(p, full_format=False)
        plan_table.add_row([p_name, p_id_str, p_origin, p_source, t_name])


def quotas_reconcile(connection):
    def tail(file):
        while True:
            line = file.readline().strip()
            if not line:
                time.sleep(0.1)
                continue
            yield line

    def create_request():
        Log.write('Create request for quotas reconsiling.')
        request = acrort.plain.Unit(flat=[
            ('.Tenant.ID', 'string', args.tenant_id),
            ('.Tenant.ID^PrimaryKey', 'nil', None),
            ('.Tenant.ID^Type', 'string', 'Gtob::Protection::ResourceUsage::ForceAcquireRequest'),
            ('^Is', 'string', 'Gtob::Protection::ResourceUsage::ForceAcquireRequest')
        ])
        connection.dml.create(request)

    log_file = open('/var/lib/Acronis/AMS/logs/resource-usage.0.log')
    log_file.seek(0, 2)

    create_request()

    error_count = 0
    for line in tail(log_file):
        col = line.split(' ')
        if len(col) < 5:
            continue
        col[4] = ' '.join(col[4:])
        col = col[:5]

        reconcile_prefix = '[Reconcile'
        start_line = '[Reconcile] account: \'{}\'. Start.'.format(args.tenant_id)
        finish_line = '[Reconcile] account: \'{}\'. Finish.'.format(args.tenant_id)

        if col[4] == start_line:
            Log.write(' '.join([col[0], col[1], col[4]]))
        if reconcile_prefix in col[4] and col[3][0] == 'E':
            Log.write(' '.join([col[0], col[1], col[4]]))
            error_count += 1
        if col[4] == finish_line:
            Log.write(' '.join([col[0], col[1], col[4]]))
            break
    Log.write('\nScript finished. Error count: \'{}\''.format(error_count))


def list_machines(connection):
    print('[---List of machines that match name \'{}\'---]'.format(args.machine_name))
    machine_spec = acrobind.create_viewspec_by_is_and_like('MachineManagement::Machine', '.Info.Name', args.machine_name)
    machines = acrobind.select_objects(connection, machine_spec)

    table = prettytable.PrettyTable(["Name", "ID", "Tenant"])
    table.align["Name"] = "l"
    table.padding_width = 1

    for m in machines:
        if args.extra:
            Log.write(m)
        m_name = '\'{0}\''.format(m.Info.Name.ref)
        m_id = m.ID.ref
        m_id_str = '{0}'.format(m_id)
        t = get_tenant_string(m)
        table.add_row([m_name, m_id_str, t])
    Log.write(table.get_string(sortby="Name"))
    Log.write('')


def list_instances(connection):
    Log.write('[---List of instances that match name \'{}\'---]'.format(args.instance_name))
    spec = acrobind.create_viewspec_by_is_and_like('InstanceManagement::Instance', '.FullPath', args.instance_name)
    objects = acrobind.select_objects(connection, spec)
    list_instances_internal(connection, objects)


def list_instances_internal(connection, objects):

    for o in objects:
        table = prettytable.PrettyTable(["Name", "Value", ""])

        table.align["Name"] = "l"
        table.align["Value"] = "l"
        table.padding_width = 1
        if args.extra:
            Log.write(o)
        o_name = '\'{0}\''.format(str(get_optional(o, 'FullPath')))
        o_id_str = '{0}'.format(o.ID.ref)
        o_host_id_str = '{0}'.format(o.HostID.ref)
        o_state_str = to_instance_state(get_optional(o, 'State'))
        o_backup_state_str = to_instance_state(o.BackupState.ref)
        o_status = '{0}'.format(o.Status.ref)
        o_backup_status_str = '{0}'.format(o.BackupStatus.ref)
        o_inside_virtual_str = 'MISSING'
        if 'HostInfo' in o:
            o_inside_virtual_str = '{0}'.format(get_optional(o.HostInfo, "IsInsideVirtual"))
        availability_str = 'MISSING'
        if 'Availability' in o:
            availability_str = '{0}'.format(to_machine_status(o.Availability.ref))
        last_backup_str = '-'
        if 'LastBackup' in o:
            last_backup_str = describe_time(o.LastBackup.ref)
        last_backup_try_str = '-'
        if 'LastBackupTry' in o:
            last_backup_try_str = describe_time(o.LastBackupTry.ref)
        next_backup_time_str = '-'
        if 'NextBackupTime' in o and 'Time' in o.NextBackupTime:
            next_backup_time_str = describe_time(o.LastBackup.ref)
        t = get_tenant_string(o, full_format=False)
        table.add_row(['Name', o_name, ''])
        table.add_row(['ID', o_id_str, ''])
        table.add_row(['HostID', o_host_id_str, ''])
        table.add_row(['State', o_state_str, ''])
        table.add_row(['Status', o_status, ''])
        table.add_row(['State(Backup)', o_backup_state_str, ''])
        table.add_row(['Status(Backup)', o_backup_status_str, ''])
        table.add_row(['LastBackup', last_backup_str, ''])
        table.add_row(['LastBackupTry', last_backup_try_str, ''])
        table.add_row(['NextBackupTime', next_backup_time_str, ''])
        table.add_row(['Availability', availability_str, ''])
        table.add_row(['InsideVirtual', o_inside_virtual_str, ''])
        table.add_row(['Tenant', t, ''])

        Log.write(table)
        Log.write('')


def check_instance(connection):
    Log.write('Checking instance \'{}\'...'.format(args.instance_id))

    local_spec = acrobind.create_viewspec_by_is_and_guid_property('InstanceManagement::Instance', '.ID', args.instance_id)
    Log.write('AMS instance:')
    object = acrobind.select_object(connection, local_spec)
    if object is not None:
        list_instances_internal(connection, [object])
    else:
        Log.write('Not found')
        return

    spec = acrobind.viewspec_apply_remote_host(local_spec, object.HostID.ref)
    Log.write('Agent instance:')
    try:
        objects = acrobind.select_objects(connection, spec)
        list_instances_internal(connection, objects)
    except Exception as e:
        if args.extra:
            Log.write('Failed to get instance from agent: {}'.format(e))
        else:
            Log.write('Failed to get instance from agent')
    items = check_instance_related_item_protections(connection, args.instance_id)
    #TODO:
    print(items)


def check_machine(connection):
    if not args.delete and args.break_connection and args.machine_id:
        drop_agent_connection(connection, args.machine_id)

    Log.write('[---Check machine with id \'{}\'---]'.format(args.machine_id))
    machine_spec = acrobind.create_viewspec_by_is_and_guid_property('MachineManagement::Machine', '.ID', args.machine_id)
    machine = acrobind.select_object(connection, machine_spec)

    if not machine:
        Log.write('Not found.')
        #return

    if args.extra:
        Log.write(machine)

    msp_machine = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property('Msp::AMS::Dto::Machine', '.AgentID', '{}'.format(args.machine_id)))
    public_key = 'MISSING'
    is_enabled = 'MISSING'
    if msp_machine and 'PublicKey' in msp_machine:
        public_key = '{0}'.format(msp_machine.PublicKey.ref)
    if msp_machine and 'IsEnabled' in msp_machine:
        is_enabled = '{0}'.format(msp_machine.IsEnabled.ref)

    if args.extra:
        Log.write(msp_machine)

    machine_table = prettytable.PrettyTable(["Name", "Value", ""])

    machine_table.align["Name"] = "l"
    machine_table.align["Value"] = "l"
    machine_table.padding_width = 1

    name_str = '-'
    if machine and 'Info' in machine and 'Name' in machine.Info:
        name_str = '{}'.format(machine.Info.Name.ref)
    machine_table.add_row(['Name', name_str, ''])

    id_str = '-'
    if machine and 'ID' in machine:
        id_str = '{}'.format(machine.ID.ref)

    machine_table.add_row(['ID', id_str, ''])

    status_str = '-'
    if machine and 'Status' in machine:
        machine_statuses = {0: 'ONLINE (0)', 1: 'OFFLINE (1)'}
        if machine.Status.ref in machine_statuses:
            status_str = machine_statuses[machine.Status.ref]
        else:
            status_str = str(machine.Status.ref)

    machine_table.add_row(['Status', status_str, ''])
    machine_table.add_row(['PublicKey', public_key, ''])
    machine_table.add_row(['IsEnabled', is_enabled, ''])
    is_inside_virtual_str = '-'

    if machine and 'Info' in machine and 'IsInsideVirtual' in machine.Info:
        is_inside_virtual_str = '{}'.format(machine.Info.IsInsideVirtual.ref)

    machine_table.add_row(['IsInsideVirtual', is_inside_virtual_str, ''])
    machine_table.add_row(['Tenant', get_tenant_string(machine), ''])

    current_version = 'Unknown'
    try:
        if 'Info' in machine:
            current_version = machine.Info.Agents[0].Version.ref
    except:
        pass

    installed_agents = 'unknown'
    if machine and 'Info' in machine:
        if is_mobile_agent(machine.Info.Agents):
            installed_agents = 'mobile {}'.format(installed_agents)

        if is_ad_agent(machine.Info.Agents):
            installed_agents = 'ad {}'.format(installed_agents)

        if is_ati_agent(machine.Info.Agents):
            installed_agents = 'ati {}'.format(installed_agents)

        if is_win_agent(machine.Info.Agents):
            installed_agents = 'win {}'.format(installed_agents)

        if is_sql_agent(machine.Info.Agents):
            installed_agents = 'sql {}'.format(installed_agents)

        if is_esx_agent(machine.Info.Agents):
            installed_agents = 'esx {}'.format(installed_agents)

        if is_hyperv_agent(machine.Info.Agents):
            installed_agents = 'hyperv {}'.format(installed_agents)

        if is_exchange_agent(machine.Info.Agents):
            installed_agents = 'exchange {}'.format(installed_agents)

        if not installed_agents:
          Log.write(machine.Info.Agents)

    machine_table.add_row(['Current version', '{} | {}'.format(current_version, installed_agents), ''])

    update_desc = '-'
    if machine and 'UpdateState' in machine and 'UpdateIsAvailable' in machine.UpdateState:
        if machine.UpdateState.UpdateIsAvailable.ref:
            update_desc = '{}'.format(machine.UpdateState.UpdateVersion.ref)
    update_url = ''
    if machine and 'UpdateState' in machine and 'UpdateUrl' in machine.UpdateState:
        update_url = '{}'.format(machine.UpdateState.UpdateUrl.ref)
    machine_table.add_row(['Available update', '{}'.format(update_desc), update_url])
    Log.write(machine_table)

    if machine and 'Tenant' not in machine and args.fix:
        Log.write('Do you want to fix Tenant info for machine object with ID \'{0}\'(y/n)?'.format(args.machine_id))
        if ask_user():
            fix_machine_tenant(connection, args.machine_id)
            Log.write('done')
        else:
            Log.write('skipped')

    Log.write('Instances:')
    instances_spec = acrobind.create_viewspec_by_is_and_guid_property('InstanceManagement::Instance', '.HostID', args.machine_id)
    objects = acrobind.select_objects(connection, instances_spec)
    list_instances_internal(connection, objects)

    #check_caching_registration(connection)

    if args.running_activities:
        pattern = [
            ('^Is', 'string', 'Tol::History::Plain::Activity'),
            ('^Source', 'string', '{}'.format(args.machine_id)),
            ('.State', 'dword', 0),
            ('.State^Less', 'dword', 5)]
        spec = acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern))
        check_running_activities(connection, spec, args.machine_id)

    if args.reset_update:
        Log.write('Reseting update status for MachineManagement::Machine with ID {0}.'.format(args.machine_id))
        pattern = [
            ('.MachineIsProcessed', 'bool', False),
        ]
        diff_unit={'UpdateState': acrort.plain.Unit(flat=pattern)}
        #diff_unit={'Status': 1}
        connection.dml.update(pattern=acrobind.create_viewspec_by_is_and_guid_property('MachineManagement::Machine', '.ID', args.machine_id).pattern, diff=diff_unit)

    if args.delete:
        do_deletion(connection)


def ask_user():
    answer = sys.stdin.readline()
    if answer.startswith('y') or answer.startswith('Y'):
        return True
    else:
        return False

    return False

def wrap_error(error):
    if error == acrort.common.SUCCESS:
        return 'OK'
    return 'E'


def describe_time(time):
    return datetime.datetime.fromtimestamp(time).strftime('%Y-%m-%d %H:%M:%S')


def check_instance_related_item_protections(connection, instance_id):
    spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ItemProtection', '.InstanceID', instance_id)
    return check_item_protection_objects_internal(connection, spec)

def check_plan_related_item_protections(connection, plan_id):
    spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ItemProtection', '.Local.PlanID', plan_id)
    return check_item_protection_objects_internal(connection, spec)


def check_cplan_related_item_protections(connection, cplan_id):
    spec = acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ItemProtection', '.Centralized.PlanID', cplan_id)
    return check_item_protection_objects_internal(connection, spec)


def check_item_protection_objects_internal(connection, spec):
    ips = acrobind.select_objects(connection, spec)
    items = []
    if not (len(ips) > 0):
        return items

    for ip in ips:
        if args.extra:
            print(ip)

        item = {}
        item['tenant_id'] = get_tenant_string(ip, full_format=False)
        item['tenant'] = get_tenant_string(ip, full_format=True)
        item['tenant_name'] = ip.Tenant.Name.ref
        item['id'] = '{0}'.format(ip.ID.ref)
        item['instance_id'] = '{0}'.format(ip.InstanceID.ref)
        item['host_id'] = '-'
        if 'HostID' in ip:
            item['host_id'] = '{0}'.format(ip.HostID.ref)

        instance_spec = acrobind.create_viewspec_by_is_and_guid_property('InstanceManagement::Instance', '.ID', ip.InstanceID.ref)
        instance_spec = acrobind.viewspec_apply_mask(instance_spec, acrobind.create_mask3('.ID', '.FullPath', '.Type'))
        instance = acrobind.select_object(connection, instance_spec)
        if instance:
            #print(instance)
            item['instance_id'] = '{}({})'.format(instance.FullPath.ref, instance.Type.ref)

        item['lfi_status'] = None
        item['lfi_result'] = None
        item['lfi_result_full'] = None
        item['lfi_errors'] = []
        item['lfi_warnings'] = []
        item['lfi_time'] = None
        item['ns_time'] = None
        item['lsi_time'] = None
        item['cpi'] = '-'
        item['lpi'] = '-'
        item['legacy_pi'] = '-'

        if 'LastFinishInfo' in ip:
            item['lfi_status'] = '{0}'.format(ip.LastFinishInfo.Status.ref)
            item['lfi_result'] = '-'
            if 'CompletionResult' in ip.LastFinishInfo:
                item['lfi_result'] =  '{0}'.format(wrap_error(ip.LastFinishInfo.CompletionResult))
                item['lfi_result_full'] =  '{0}'.format(ip.LastFinishInfo.CompletionResult.ref)

            item['lfi_time'] =  '{0}'.format(describe_time(ip.LastFinishInfo.Time.ref))

            str_limit = 70
            if 'Errors' in ip.LastFinishInfo:
                for index, error in ip.LastFinishInfo.Errors:
                    full_error_str = '{}'.format(error.Error.ref)
                    last_error_pos = full_error_str.rfind('| error')
                    last_error_pos_2 = full_error_str.find('\n', last_error_pos)
                    error_str = full_error_str[last_error_pos:last_error_pos_2 if last_error_pos_2 - last_error_pos < str_limit else last_error_pos + str_limit]

                    last_function_pos = full_error_str.rfind('| $module:')
                    last_function_pos_2 = full_error_str.find('\n', last_function_pos)
                    function_str = full_error_str[last_function_pos:last_function_pos_2 if last_function_pos_2 - last_function_pos < str_limit else last_function_pos + str_limit]

                    #print(error_str)
                    #item['lfi_errors'].append('{}({})'.format(error_str, function_str))
                    item['lfi_errors'].append('{}'.format(error_str))

            if 'Warnings' in ip.LastFinishInfo:
                for index, warning in ip.LastFinishInfo.Warnings:
                    full_error_str = '{}'.format(warning.Error.ref)
                    last_error_pos = full_error_str.rfind('| error')
                    last_error_pos_2 = full_error_str.find('\n', last_error_pos)
                    error_str = full_error_str[last_error_pos:last_error_pos_2 if last_error_pos_2 - last_error_pos < str_limit else last_error_pos + str_limit]

                    last_function_pos = full_error_str.rfind('| $module:')
                    last_function_pos_2 = full_error_str.find('\n', last_function_pos)
                    function_str = full_error_str[last_function_pos:last_function_pos_2 if last_function_pos_2 - last_function_pos < str_limit else last_function_pos + str_limit]

                    #item['lfi_warnings'].append('{}({})'.format(error_str, function_str))
                    item['lfi_warnings'].append('{}'.format(error_str))

        if 'LastStartInfo' in ip and 'Time' in ip.LastStartInfo:
            item['lsi_time'] =  '{0}'.format(describe_time(ip.LastStartInfo.Time.ref))

        if 'NextBackupTime' in ip and 'Time' in ip.NextBackupTime:
            item['ns_time'] =  '{0}'.format(describe_time(ip.NextBackupTime.Time.ref))

        if 'Centralized' in ip:
            item['cpi'] = '{0}'.format(ip.Centralized.PlanID.ref)

        if 'Local' in ip:
            item['lpi'] = '{0}'.format(ip.Local.PlanID.ref)

        item['legacy_pi'] = '{0}'.format(ip.Plan.ref) if 'Plan' in ip else '-'

        items.append(item)
    return items


def do_deletion(connection):

    print('Do you want to delete MachineManagement::Machine related to this machine? (y/n)')
    if ask_user():
        connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_guid_property('MachineManagement::Machine', '.ID', args.machine_id).pattern)
        print('deleted.')
    else:
        print('skipped.')

    if args.instance_id:
        print('Do you want to delete all Gtob::Dto::ItemProtection related to this machine? (y/n)')
        if ask_user():
            connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ItemProtection', '.InstanceID', args.instance_id).pattern)
            print('deleted.')
        else:
            print('skipped.')

    print('Do you want to delete Msp::AMS::Dto::Machine related to this machine? (y/n)')
    if ask_user():
        connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_string_property('Msp::AMS::Dto::Machine', '.AgentID', '{}'.format(args.machine_id)).pattern)
        print('deleted.')
    else:
        print('skipped.')


    print('Do you want to delete all InstanceManagement::Instance objects related to this machine? (y/n)')
    if ask_user():
        connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_guid_property('InstanceManagement::InstanceAspect', '.Key.HostID', args.machine_id).pattern)
        connection.dml.delete(pattern=acrobind.create_viewspec_by_is_and_guid_property('InstanceManagement::Instance', '.HostID', args.machine_id).pattern)
        print('deleted.')
    else:
        print('skipped.')


def undeploy_local_plan(connection, pp_info, plan_id):
    try:
        host_id = pp_info[plan_id]['source']

        if not host_id:
            Log.write('Can\'t find host_id for plan {0}'.format(plan_id))
            return

        if 'status' in pp_info[plan_id] and pp_info[plan_id]['status'] != 0:
            Log.write('Can\'t undeploy plan {0} because agent ({1}) is OFFLINE'.format(plan_id, host_id))
            return

        Log.write('Trying to undeploy Gtob::Dto::ProtectionPlan ({0}) from host ({1})...'.format(plan_id, host_id), end='')

        arg = acrort.common.Guid(plan_id)
        if host_id:
            activity_id = connection.tol.launch_command(command='C006D24E-E6ED-494a-9789-237CD3A814E7', argument=arg, target_machine=host_id)
        else:
            activity_id = connection.tol.launch_command(command='C006D24E-E6ED-494a-9789-237CD3A814E7', argument=arg)

        try:
            if host_id:
                result = connection.tol.get_result(activity_id, target_machine=host_id)
            else:
                result = connection.tol.get_result(activity_id)
        except acrort.Exception as ex:
            if acrort.common.interrupt_sentinel:
                if host_id:
                    connection.tol.cancel_activity(activity_id, target_machine=host_id)
                else:
                    connection.tol.cancel_activity(activity_id)
            Log.write('canceled')
        Log.write('done')

        Log.write('Removing synced Gtob::Dto::ProtectionPlan ({0})...'.format(plan_id), end='')
        connection.dml.delete(pattern=acrobind.viewspec_apply_source(acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.ID', plan_id), host_id).pattern)
        Log.write('done')

        Log.write('Removing Gtob::Dto::ItemProtection from host({0})...'.format(host_id), end='')
        bytes_arg = None
        with open("a_injection.py", "rb") as tol_command:
            bytes_arg = acrort.common.Blob(bytes=tol_command.read())

        run_request = [
            ('.Script.Location', 'string', "attachment:a_injection.py?delete_legacy_item_protections"),
            ('.Script.Argument', 'string', plan_id),
            ('.Script.Body', 'blob', bytes_arg)
        ]
        request_unit = acrort.plain.Unit(flat=run_request)
        activity_id = connection.tol.launch_command(command=acrort.remoting.RUN_SCRIPT_COMMAND_ID_BUSINESS, argument=request_unit, target_machine=host_id)
        result = connection.tol.get_result(activity_id, target_machine=host_id)
        Log.write('done')
    except Exception as e:
        Log.write('Error: {0}'.format(e))


def _init_counters(connection, data_cache, entry_id, spec):
    entry_id_internal = '_{}'.format(entry_id)
    data_cache[entry_id_internal] = {}
    data_cache[entry_id_internal]['wrong'] = 0
    data_cache[entry_id_internal]['ok'] = 0
    data_cache[entry_id_internal]['total'] = acrobind.count_objects_by_spec(connection, spec)
    data_cache[entry_id_internal]['counter_reset'] = data_cache[entry_id_internal]['total'] / 10
    data_cache[entry_id_internal]['counter'] = data_cache[entry_id_internal]['counter_reset']


def _update_counters_and_file(data_cache, entry_id, filename, wrong_item_id, error_string):
    entry_id_internal = '_{}'.format(entry_id)

    if error_string:
        data_cache[entry_id_internal]['wrong'] = data_cache[entry_id_internal]['wrong'] + 1
        with open(filename, "a") as myfile:
            myfile.write('{0}: {1}\n'.format(wrong_item_id, error_string))
    else:
        data_cache[entry_id_internal]['ok'] = data_cache[entry_id_internal]['ok'] + 1
    data_cache[entry_id_internal]['counter'] = data_cache[entry_id_internal]['counter'] - 1

    if not data_cache['specific_tenant'] and data_cache[entry_id_internal]['counter'] <= 0:
        Log.write('-', end='')
        data_cache[entry_id_internal]['counter'] = data_cache[entry_id_internal]['counter_reset']


def _do_check(connection, data_cache, entry_id, filename, spec, callback):
    entry_id_internal = '_{}'.format(entry_id)
    with open(filename, "w") as myfile:
        myfile.truncate()
    if not data_cache['specific_tenant']:
        Log.write('[----------][{}]'.format(data_cache[entry_id_internal]['total']))
        Log.write('[', end='')
    else:
        Log.write('Objects count: {}'.format(data_cache[entry_id_internal]['total']))
    start = time.time()
    acrobind.enumerate_objects(connection, spec, callback, error_log)
    if not data_cache['specific_tenant']:
        Log.write('-]')
    Log.write('OK: {0} WRONG: {1}. Elapsed: {2:.2f} s'.format(data_cache[entry_id_internal]['ok'], data_cache[entry_id_internal]['wrong'], time.time() - start))


def check_tenants_consistency(connection, data_cache):
    data_cache['tenants'] = {}
    spec = acrobind.create_viewspec_by_is('Tenants::HierarchyNode')
    filename = 'amsctl_wrong_tenants.txt'
    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.ID', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)

    _init_counters(connection, data_cache, 'tenants', spec)

    def tenants_callback(connection, cache, file, object):
        tenant_id = '{0}'.format(object.ID.ref)

        parent_exists = False
        error_string = ''
        if 'ParentID' in object:
            parent_exists = True
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_parent_id_field')

        locator_exists = False
        if 'Locator' in object:
            locator_exists = True
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_locator')

        kind_exists = False
        if 'Kind' in object:
            kind_exists = True
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_kind')

        data_cache['tenants'][tenant_id] = {}
        data_cache['tenants'][tenant_id]['parent_exists'] = parent_exists
        data_cache['tenants'][tenant_id]['locator_exists'] = locator_exists
        data_cache['tenants'][tenant_id]['kind_exists'] = kind_exists
        data_cache['tenants'][tenant_id]['used'] = False

        _update_counters_and_file(data_cache, 'tenants', file, tenant_id, error_string)

    callback = lambda x: tenants_callback(connection, data_cache, filename, x)
    Log.write('Checking Tenants::HierarchyNode consistency. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'tenants', filename, spec, callback)


def check_orphan_msp_machines(connection, data_cache):
    data_cache['msp_machines'] = {}
    data_cache['to_delete']['msp_machines'] = []
    spec = acrobind.create_viewspec_by_is('Msp::AMS::Dto::Machine')
    filename = 'amsctl_wrong_msp_machines.txt'
    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.Owner', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)

    _init_counters(connection, data_cache, 'msp_machines', spec)

    spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask4('.AgentID', '.IsEnabled', '.OwnerID', '.PublicKey'))

    def msp_machine_callback(connection, cache, file, object):
        host_id_str = '{}'.format(object.AgentID.ref)
        cache['msp_machines'][host_id_str] = {}
        cache['msp_machines'][host_id_str]['used'] = False
        cache['msp_machines'][host_id_str]['public_key_exists'] = False
        cache['msp_machines'][host_id_str]['is_enabled'] = False
        cache['msp_machines'][host_id_str]['is_enabled_field_exists'] = False
        cache['msp_machines'][host_id_str]['owner_id'] = ''
        cache['msp_machines'][host_id_str]['owner_id_field_exists'] = False
        cache['msp_machines'][host_id_str]['owner_exists'] = False

        error_string = ''
        if 'PublicKey' in object:
            cache['msp_machines'][host_id_str]['public_key_exists'] = True
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_public_key')

        if 'IsEnabled' in object:
            cache['msp_machines'][host_id_str]['is_enabled_field_exists'] = True
            cache['msp_machines'][host_id_str]['is_enabled'] = object.IsEnabled.ref
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_is_enabled')

        if 'OwnerID' in object:
            cache['msp_machines'][host_id_str]['owner_id_field_exists'] = True
            cache['msp_machines'][host_id_str]['owner_id'] = object['OwnerID'].ref
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_owner_id')

        if cache['msp_machines'][host_id_str]['owner_id'] in data_cache['tenants']:
            data_cache['tenants'][cache['msp_machines'][host_id_str]['owner_id']]['used'] = True
            cache['msp_machines'][host_id_str]['owner_exists'] = True
        else:
            error_string = '{0} {1}'.format(error_string, 'no_owner(d)')
            data_cache['to_delete']['msp_machines'].append(host_id_str)

        _update_counters_and_file(data_cache, 'msp_machines', file, host_id_str, error_string)

    callback = lambda x: msp_machine_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan Msp::Agent::Dto::Machine. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'msp_machines', filename, spec, callback)


def is_mobile_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{AC127296-8E50-41DE-8EFE-853C4B5CD8A8}':
            return True
    return False


def is_ad_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{9F148D12-3653-478B-A039-239BE36950AB}':
            return True
    return False


def is_ati_agent(agent_info):
    for index, a in agent_info:
        agent_type_id = a.Id.ref
        if agent_type_id == '{8397FC51-C78E-4E26-9860-6A4A8622DF7C}':
            return True
        #Home agent have no Version AgentInfo and have empty Id in AgentInfo
        if len(agent_info) == 1 and agent_type_id == '':
            return True
        else:
            return False
    return False


def is_win_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{BA262882-C484-479A-8D07-B0EAC55CE27B}':
            return True
    return False

def is_sql_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{C293F7DD-9531-4916-9346-12B0F3BFCCAA}':
            return True
    return False

def is_esx_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{EC3CF038-C08A-4341-82DF-F75133705F63}':
            return True
    return False

def is_hyperv_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{87671A98-2B47-4D4C-98FB-490CA111E7A7}':
            return True
    return False

def is_exchange_agent(agent_info):
    for index, a in agent_info:
        if a.Id.ref == '{30BAF589-C02A-463F-AB37-5A9193375700}':
            return True
    return False


def check_if_tenant_is_valid(object, data_cache, item_type, item_id):
    tenant_id = '-'
    data_cache[item_type][item_id]['has_tenant'] = False

    error_string = ''
    if 'Tenant' in object:
        tenant_id = object.Tenant.ID.ref
        data_cache[item_type][item_id]['has_tenant'] = True
    else:
        error_string = '{0} {1}'.format(error_string, 'missing_tenant_field')

    data_cache[item_type][item_id]['tenant'] = tenant_id

    if data_cache['resolve_links']:
        data_cache[item_type][item_id]['has_existing_tenant'] = False
        if data_cache[item_type][item_id]['has_tenant']:
            if tenant_id in data_cache['tenants']:
                data_cache[item_type][item_id]['has_existing_tenant'] = True
            else:
                error_string = '{0} {1}'.format(error_string, 'no_tenant(d)')
                data_cache['to_delete'][item_type].append(item_id)
        else:
            data_cache[item_type][item_id]['has_existing_tenant'] = True
    return error_string


def check_orphan_agents(connection, data_cache):
    data_cache['agents'] = {}
    data_cache['to_delete']['agents'] = []
    spec = acrobind.create_viewspec_machines_by_role(0)
    filename = 'amsctl_wrong_agents.txt'
    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.Tenant.ID', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)

    _init_counters(connection, data_cache, 'agents', spec)

    spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask4('.ID', '.Role', '.Tenant', '.Info.Agents'))

    def agents_callback(connection, cache, file, object):
        id_str = '{}'.format(object.ID.ref)

        data_cache['agents'][id_str] = {}
        data_cache['agents'][id_str]['used'] = False
        data_cache['agents'][id_str]['has_existing_msp_machine'] = False

        error_string = ''
        #Mobile agents don't have Msp::Agent::Dto::Configuration
        if not is_mobile_agent(object.Info.Agents):
            if id_str in data_cache['msp_machines']:
                data_cache['agents'][id_str]['has_existing_msp_machine'] = True
                data_cache['msp_machines'][id_str]['used'] = True
            else:
                error_string = '{0} {1}'.format(error_string, 'no_msp_machine')

        tenant_error = check_if_tenant_is_valid(object, data_cache, 'agents', id_str)
        if tenant_error:
            error_string = '{0} {1}'.format(error_string, tenant_error)

        _update_counters_and_file(data_cache, 'agents', file, id_str, error_string)

    callback = lambda x: agents_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan MachineManagement::Machine. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'agents', filename, spec, callback)


def check_orphan_instances(connection, data_cache):
    data_cache['instances'] = {}
    data_cache['to_delete']['instances'] = []
    spec = acrobind.create_viewspec_by_is('InstanceManagement::Instance')
    filename = 'amsctl_wrong_instances.txt'
    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.Tenant.ID', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)
    _init_counters(connection, data_cache, 'instances', spec)

    spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask3('.ID', '.HostID', '.Tenant'))

    def instance_callback(connection, cache, file, object):
        id_str = '{}'.format(object.ID.ref)

        data_cache['instances'][id_str] = {}
        data_cache['instances'][id_str]['has_host_id'] = False
        data_cache['instances'][id_str]['host_id'] = '-'
        data_cache['instances'][id_str]['has_existing_host'] = False
        data_cache['instances'][id_str]['has_existing_tenant'] = False
        data_cache['instances'][id_str]['has_tenant'] = False
        data_cache['instances'][id_str]['is_deprecated'] = False

        error_string = ''

        if is_deprecated_vm_instance(id_str):
            error_string = '{0} {1}'.format(error_string, 'deprecated_vm_instance(d)')
            data_cache['instances'][id_str]['is_deprecated'] = True
            data_cache['to_delete']['instances'].append(id_str)
        else:
            if 'HostID' in object:
                data_cache['instances'][id_str]['has_host_id'] = False
                data_cache['instances'][id_str]['host_id'] = '{}'.format(object.HostID.ref)
            else:
                error_string = '{0} {1}'.format(error_string, 'missing_host_id_field')

            host_id_str = data_cache['instances'][id_str]['host_id']
            if host_id_str in data_cache['agents']:
                data_cache['instances'][id_str]['has_existing_host'] = True
                data_cache['agents'][host_id_str]['used'] = True
            else:
                error_string = '{0} {1}'.format(error_string, 'no_host')

            tenant_error = check_if_tenant_is_valid(object, data_cache, 'instances', id_str)
            if tenant_error:
                error_string = '{0} {1}'.format(error_string, tenant_error)

        _update_counters_and_file(data_cache, 'instances', file, id_str, error_string)

    callback = lambda x: instance_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan InstanceManagement::Instance. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'instances', filename, spec, callback)


def check_orphan_plans(connection, data_cache):
    data_cache['plans'] = {}
    data_cache['to_delete']['plans'] = []
    spec = acrobind.create_viewspec_by_is('Gtob::Dto::ProtectionPlan')
    filename = 'amsctl_wrong_plans.txt'

    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.Tenant.ID', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)

    _init_counters(connection, data_cache, 'plans', spec)

    spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask3('.ID', '.Origin', '.Tenant'))

    def plan_callback(connection, cache, file, object):
        id_str = '{}'.format(object.ID.ref)

        data_cache['plans'][id_str] = {}
        data_cache['plans'][id_str]['origin'] = '-'

        error_string = ''

        if 'Origin' in object:
            data_cache['plans'][id_str]['status'] = object.Origin.ref
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_origin_field')

        tenant_error = check_if_tenant_is_valid(object, data_cache, 'plans', id_str)
        if tenant_error:
            error_string = '{0} {1}'.format(error_string, tenant_error)

        _update_counters_and_file(data_cache, 'plans', file, id_str, error_string)

    callback = lambda x: plan_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan Gtob::Dto::ProtectionPlan. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'plans', filename, spec, callback)


def check_deployment_fact_consistency(connection, data_cache):
    data_cache['deployment_facts'] = {}
    data_cache['to_delete']['deployment_facts'] = []
    spec = acrobind.create_viewspec_by_is('Gtob::Protection::PlanDeploymentFact')
    filename = 'amsctl_wrong_deployment_facts.txt'

    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.PlanObject.Tenant.ID', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)

    _init_counters(connection, data_cache, 'deployment_facts', spec)

    spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask3('.ID', '.PlanObject.CentralizedProtectionPlan', '.PlanObject.Tenant'))

    def fact_callback(connection, cache, file, object):
        host_id_str = '{}'.format(object.ID.Host.ref)
        plan_id_str = '{}'.format(object.ID.Plan.ref)
        id_str = '{0}+{1}'.format(host_id_str, plan_id_str)

        data_cache['deployment_facts'][id_str] = {}
        data_cache['deployment_facts'][id_str]['plan'] = plan_id_str
        data_cache['deployment_facts'][id_str]['host'] = host_id_str
        data_cache['deployment_facts'][id_str]['need_redeploy'] = False
        data_cache['deployment_facts'][id_str]['exists'] = True

        source_id = acrobind.get_trait_value('Source', object)

        error_string = ''
        if source_id is None:
            error_string = '{0} {1}'.format(error_string, 'missing_source_trait')

        if source_id is not None and str(source_id) != host_id_str :
            error_string = '{0} {1}'.format(error_string, 'source_differes_from_host')

        if plan_id_str not in data_cache['plans']:
            error_string = '{0} {1}'.format(error_string, 'missing_plan(d)')
            data_cache['to_delete']['deployment_facts'].append(plan_id_str)

        if 'PlanObject' in object:
            tenant_error = check_if_tenant_is_valid(object.PlanObject, data_cache, 'deployment_facts', id_str)
            if tenant_error:
                error_string = '{0} {1}'.format(error_string, tenant_error)
        else:
            error_string = '{0} {1}'.format(error_string, 'missing_plan_object_field')

        _update_counters_and_file(data_cache, 'deployment_facts', file, id_str, error_string)

    callback = lambda x: fact_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan Gtob::Protection::PlanDeploymentFact. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'deployment_facts', filename, spec, callback)


def check_protections_consistency(connection, data_cache):
    if args.parameter1 is not None:
        Log.write('Can\'t calculate protection for specific tenant.')
        #return

    data_cache['protections'] = {}
    data_cache['to_delete']['protections'] = []
    spec = acrobind.create_viewspec_by_is('Gtob::Dto::CentralizedProtection')
    filename = 'amsctl_wrong_protections.txt'

    _init_counters(connection, data_cache, 'protections', spec)

    spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask2('.ID', '.AffectedMachines'))

    def protection_callback(connection, cache, file, object):
        id_str = '{}'.format(object.ID.ref)
        plan_id_str = id_str

        data_cache['protections'][id_str] = {}

        error_string = ''
        if plan_id_str not in data_cache['plans']:
            error_string = '{0} {1}'.format(error_string, 'missing_plan(d)')
            data_cache['to_delete']['protections'].append(id_str)
        else:
            for (number, affected_machine) in object.AffectedMachines:
                fact_id = '{0}+{1}'.format(affected_machine.ref, plan_id_str)

                no_fact = fact_id not in data_cache['deployment_facts']
                if no_fact:
                    error_string = '{0} {1}'.format(error_string, 'missing_deployment_fact')
                    data_cache['deployment_facts'][fact_id] = {}
                    data_cache['deployment_facts'][fact_id]['plan'] = plan_id_str
                    data_cache['deployment_facts'][fact_id]['host'] = affected_machine.ref
                    data_cache['deployment_facts'][fact_id]['exists'] = False

                    remote_spec = acrobind.viewspec_apply_remote_host(acrobind.create_viewspec_by_is_and_guid_property('Gtob::Dto::ProtectionPlan', '.CentralizedProtectionPlan', plan_id_str), affected_machine.ref)
                    remote_spec = acrobind.viewspec_apply_mask(remote_spec, acrobind.create_mask2('.ID', '.CentralizedProtectionPlan'))
                    (mms_plan_selected, mms_plan) = acrobind.safe_select_object(connection, remote_spec)
                    if mms_plan_selected:
                        if mms_plan is None:
                            error_string = '{0} {1}'.format(error_string, 'plan_missing_on_agent(r)')
                            data_cache['deployment_facts'][fact_id]['need_redeploy'] = True
                            data_cache['to_redeploy'].append(plan_id_str)
                    else:
                        if mms_plan is None:
                            error_string = '{0} {1}'.format(error_string, 'unknown_plan_state_on_agent')
                            data_cache['deployment_facts'][fact_id]['need_redeploy'] = True
                            data_cache['unknown_to_redeploy'].append(plan_id_str)

        _update_counters_and_file(data_cache, 'protections', file, id_str, error_string)

    callback = lambda x: protection_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan Gtob::Dto::CentralizedProtection. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'protections', filename, spec, callback)


def check_orphan_item_protections(connection, data_cache):
    data_cache['item_protections'] = {}
    data_cache['to_delete']['item_protections'] = []
    data_cache['item_protections']['stat'] = {}

    data_cache['item_protections']['stat']['is_legacy'] = 0
    data_cache['item_protections']['stat']['missing_tenant_field'] = 0
    data_cache['item_protections']['stat']['total'] = 0
    data_cache['item_protections']['stat']['error_item_type'] = 0
    data_cache['item_protections']['stat']['error_item_id'] = 0
    data_cache['item_protections']['stat']['local_item_protection'] = 0
    data_cache['item_protections']['stat']['missing_centralized'] = 0
    data_cache['item_protections']['stat']['missing_local'] = 0
    data_cache['item_protections']['stat']['missing_item_type'] = 0
    data_cache['item_protections']['stat']['missing_item_id'] = 0

    spec = acrobind.create_viewspec_by_is('Gtob::Dto::ItemProtection')
    filename = 'amsctl_wrong_item_protections.txt'

    def apply_limits(filename, spec):
        if args.parameter1 is not None:
            filename = '{0}_{1}'.format(args.parameter1, filename)
            limit_pattern = [
                ('.Tenant.ID', 'string', '{}'.format(args.parameter1))
            ]
            return filename, acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return filename, spec

    filename, spec = apply_limits(filename, spec)

    _init_counters(connection, data_cache, 'item_protections', spec)

    def ip_callback(connection, cache, file, object):
        id_str = '{}'.format(object.ID.ref)
        is_centralized = [unit.ref for name, unit in object.traits if unit.ref == "Gtob::Dto::Centralized::ItemProtection"]

        stat = data_cache['item_protections']['stat']
        data_cache['item_protections'][id_str] = {}
        data_cache['item_protections'][id_str]['cplan'] = '-'
        data_cache['item_protections'][id_str]['lplan'] = '-'

        error_string = ''

        stat['total'] = stat['total'] + 1

        is_legacy = False
        if 'Instance' in object:
            is_legacy = True
            stat['is_legacy'] = stat['is_legacy'] + 1

        tenant_id = ''
        tenant_error = check_if_tenant_is_valid(object, data_cache, 'item_protections', id_str)
        if tenant_error:
            error_string = '{0} {1}'.format(error_string, tenant_error)

        has_centralized = False
        if 'Centralized' in object:
            has_centralized = True

        has_local = False
        if 'Local' in object:
            has_local = True

        local_item_protection = False
        if 'LastStartInfo' in object and 'BackupFrame' in object.LastStartInfo:
            start_frame = object.LastStartInfo.BackupFrame.ref
            if start_frame.startswith('LOCAL'):
                local_item_protection = not is_centralized
                if local_item_protection:
                    stat['local_item_protection'] = stat['local_item_protection'] + 1

        item_type = get_optional(object, 'ItemType')
        wrong_item_type = False
        if 'ItemType' in object and item_type == 0:
            stat['error_item_type'] = stat['error_item_type']  + 1
            error_string = '{0} {1}'.format(error_string, 'error_item_type')

        item_id = get_optional(object, 'ItemID')

        if 'ItemID' in object and str(item_id) == '00000000-0000-0000-0000-000000000000':
            stat['error_item_id'] = stat['error_item_id']  + 1
            error_string = '{0} {1}'.format(error_string, 'error_item_id')
            data_cache['item_protections'][id_str]['wrong_item_id'] = True

        if cache['resolve_links']:
            if object is not None and 'Centralized' in object and 'PlanID' in object.Centralized:
                cplan_id = '{0}'.format(object.Centralized.PlanID.ref)
                data_cache['item_protections'][id_str]['cplan'] = cplan_id
                if cplan_id not in data_cache['plans']:
                    error_string = '{0} {1}'.format(error_string, 'link_to_missing_centralized_plan')

            if object is not None and 'Local' in object and 'PlanID' in object.Local:
                lplan_id = '{0}'.format(object.Local.PlanID.ref)
                data_cache['item_protections'][id_str]['lplan'] = lplan_id
                if lplan_id not in data_cache['plans']:
                    error_string = '{0} {1}'.format(error_string, 'link_to_missing_local_plan')

        if not is_legacy:
            if not has_local:
                any_problem_exists = True
                stat['missing_local'] = stat['missing_local'] + 1
                error_string = '{0} {1}'.format(error_string, 'missing_local')

            if not has_centralized and is_centralized:
                any_problem_exists = True
                stat['missing_centralized'] = stat['missing_centralized'] + 1
                error_string = '{0} {1}'.format(error_string, 'missing_centralized')

            if not local_item_protection and (item_type or item_id):
                if item_type is None:
                    stat['missing_item_type'] = stat['missing_item_type'] + 1
                    error_string = '{0} {1}'.format(error_string, 'missing_item_type')
                    any_problem_exists = True

                if item_id is None:
                    stat['missing_item_id'] = stat['missing_item_id'] + 1
                    error_string = '{0} {1}'.format(error_string, 'missing_item_id')
                    any_problem_exists = True

        #log_str = '{0}: {1}'.format(id_str, error_string)
        #if not cache['resolve_links']:
        #    log_str = '{0}\n{1}'.format(error_string, object)
        log_str = '{0}\n{1}'.format(error_string, object)
        _update_counters_and_file(data_cache, 'item_protections', file, id_str, error_string)

    callback = lambda x: ip_callback(connection, data_cache, filename, x)
    Log.write('Checking orphan Gtob::Dto::ItemProtection. Logging wrong item ids to \'{}\'.'.format(filename))
    _do_check(connection, data_cache, 'item_protections', filename, spec, callback)
    stat = data_cache['item_protections']['stat']
    for key in sorted(stat):
        Log.write('{0}: {1}'.format(key, stat[key]))


def _log_for_unused_objects(connection, cache, entry_id, filename):
    with open(filename, "w") as myfile:
        myfile.truncate()

    counter = 0
    for id, value in cache[entry_id].items():
        if not value['used']:
            counter = counter + 1
            with open(filename, "a") as myfile:
                myfile.write('{}\n'.format(id))
    Log.write('Unused {}: {}'.format(entry_id, counter))


def check_for_unused_objects(connection, cache):
    _log_for_unused_objects(connection, cache, 'tenants', 'amsctl_unused_tenants.txt')
    _log_for_unused_objects(connection, cache, 'msp_machines', 'amsctl_unused_msp_machines.txt')
    _log_for_unused_objects(connection, cache, 'agents', 'amsctl_unused_agents.txt')


def consistency_redeploy_plans(connection, ids):
    creation_time = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    log_file_name = 'amsctl_redeploy_{}.txt'.format(creation_time)
    Log.write('Plans to redeploy: {0}'.format(len(ids)))

    start = time.time()

    for plan_id in ids:
        Log.write('Redeploying \'{0}\''.format(plan_id))
        try:
            redeploy_plan(connection, plan_id)
        except Exception as error:
            Log.write('Skipping because of error: {0}'.format(error))

    Log.write('elapsed: {0:.2f} s.'.format(time.time() - start))

def delete_obsolete_data(connection, cache):
    creation_time = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    log_file_name = 'amsctl_deleted_objects_{}.txt'.format(creation_time)
    Log.write('Removing wrong objects...')

    start = time.time()
    def handle_ids(connection, spec, filename):

        def store_object(object, filename):
            with open(filename, "a") as myfile:
                myfile.write('{}\n'.format(object))

        callback = lambda x: store_object(x, filename)
        acrobind.enumerate_objects(connection, spec, callback, error_log)
        connection.dml.delete(pattern=spec.pattern)

    for type, ids in cache['to_delete'].items():
        Log.write('To delete \'{0}\': {1}'.format(type, len(ids)))

        if len(ids) <= 0:
            continue
        if type == 'agents':
            spec = acrobind.create_viewspec_by_is('MachineManagement::Machine')
            spec = acrobind.viewspec_apply_ids(spec, ids)
            handle_ids(connection, spec, log_file_name)

        if type == 'instances':
            spec = acrobind.create_viewspec_by_is('InstanceManagement::Instance')
            spec = acrobind.viewspec_apply_ids(spec, ids)
            handle_ids(connection, spec, log_file_name)
        if type == 'deployment_facts':
            spec = acrobind.create_viewspec_by_is('Gtob::Protection::PlanDeploymentFact')
            ids_pattern = []
            for id in ids:
                ids_pattern.append([('', 'guid', id)])

            pattern = [
                ('.ID.Plan', 'guid', '00000000-0000-0000-0000-000000000000'),
                ('.ID.Plan^ValueIn', 'complex_trait', [('', 'array', ids_pattern)]),
            ]
            spec = acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=pattern)), spec.options)
            handle_ids(connection, spec, log_file_name)
        if type == 'plans':
            spec = acrobind.create_viewspec_by_is('Gtob::Dto::ProtectionPlan')
            spec = acrobind.viewspec_apply_ids(spec, ids)
            handle_ids(connection, spec, log_file_name)
        if type == 'item_protections':
            spec = acrobind.create_viewspec_by_is('Gtob::Dto::ItemProtection')
            spec = acrobind.viewspec_apply_ids(spec, ids)
            handle_ids(connection, spec, log_file_name)
        if type == 'protections':
            spec = acrobind.create_viewspec_by_is('Gtob::Dto::CentralizedProtection')
            spec = acrobind.viewspec_apply_ids(spec, ids)
            handle_ids(connection, spec, log_file_name)
        if type == 'msp_machines':
            spec = acrobind.create_viewspec_by_is('Msp::AMS::Dto::Machine')

            ids_pattern = []
            for id in ids:
                ids_pattern.append([('', 'string', id)])

            pattern = [
                ('.AgentID', 'string', '00000000-0000-0000-0000-000000000000'),
                ('.AgentID^ValueIn', 'complex_trait', [('', 'array', ids_pattern)]),
            ]
            spec = acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=pattern)), spec.options)
            handle_ids(connection, spec, log_file_name)

    Log.write('elapsed: {0:.2f} s.'.format(time.time() - start))


def obsolete_data(connection):

    cache = {}
    cache['resolve_links'] = True
    cache['specific_tenant'] = False
    cache['to_delete'] = {}
    cache['to_redeploy'] = []
    cache['unknown_to_redeploy'] = []
    action = 'all'

    if args.parameter2 is not None and args.parameter2.startswith('ip'):
        action = 'item_protection_only'
        cache['resolve_links'] = False
    elif args.parameter2 is not None and args.parameter2.startswith('protection'):
        action = 'protection_plan_only'
        cache['resolve_links'] = False

    if args.parameter1 is not None:
        cache['specific_tenant'] = True

    Log.write('Action: {}'.format(action))
    Log.write('Resolve links between objects: {}'.format(cache['resolve_links']))

    if action in ['all']:
        check_tenants_consistency(connection, cache)
        check_orphan_msp_machines(connection, cache)
        check_orphan_agents(connection, cache)
        check_orphan_instances(connection, cache)

    if action in ['protection_plan_only', 'all']:
        check_orphan_plans(connection, cache)
        check_deployment_fact_consistency(connection, cache)
        check_protections_consistency(connection, cache)
    if action in ['item_protection_only', 'all']:
        check_orphan_item_protections(connection, cache)

    if action in ['all']:
        check_for_unused_objects(connection, cache)

    for type, ids in cache['to_delete'].items():
        Log.write('To delete \'{0}\': {1}'.format(type, len(ids)))
    Log.write('To redeploy: {0}'.format(len(cache['to_redeploy'])))
    Log.write('Unknown deployment status: {0}'.format(len(cache['unknown_to_redeploy'])))

    if args.fix:
        print('Do you want to redeploy wrong protection plans {0}? (y/n)'.format(len(cache['to_redeploy'])))
        if ask_user():
            consistency_redeploy_plans(connection, cache['to_redeploy'])
        print('Do you want to redeploy unknown protection plans {0}? (y/n)'.format(len(cache['unknown_to_redeploy'])))
        if ask_user():
            consistency_redeploy_plans(connection, cache['unknown_to_redeploy'])
    if args.delete:
        print('Do you want to delete obsolete data? (y/n)')
        if ask_user():
            delete_obsolete_data(connection, cache)


def init_agent_stat(stat):
    stat['by_version'] = {}
    stat['by_type'] = {}
    stat['by_type']['mac'] = {}
    stat['by_type']['lin'] = {}
    stat['by_type']['win'] = {}
    stat['by_type']['exc'] = {}
    stat['by_type']['vmw'] = {}
    stat['by_type']['mob'] = {}
    stat['by_type']['sql'] = {}
    stat['by_type']['oth'] = {}


def map_agent_type(id):
    if id == '':
        return 'Version'

    if id == '{BA262882-C484-479A-8D07-B0EAC55CE27B}':
        return 'Agent for Windows'

    if id == '{C293F7DD-9531-4916-9346-12B0F3BFCCAA}':
        return 'Agent for SQL'

    if id == '{AC127296-8E50-41DE-8EFE-853C4B5CD8A8}':
        return 'Agent for Mobile'

    if id == '{EC3CF038-C08A-4341-82DF-F75133705F63}':
        return 'Agent for VMware'

    if id == '{87671A98-2B47-4D4C-98FB-490CA111E7A7}':
        return 'Agent for Hyper-V'

    if id == '{30BAF589-C02A-463F-AB37-5A9193375700}':
        return 'Agent for Exchange'

    if id == '{CDC40814-3769-4D13-B222-629463D3F5CA}':
        return 'Agent for ESX (Appliance)'

    if id == '{09726067-5E56-4775-8D3B-FD9110BCAAD1}':
        return 'Agent for ARX single pass'

    if id == '{383CD411-7A5D-4658-B184-3B651A6E12BB}':
        return 'Agent for Online exchange agent'

    if id == '{9F148D12-3653-478B-A039-239BE36950AB}':
        return 'Agent for AD'

    if id == '{8397FC51-C78E-4E26-9860-6A4A8622DF7C}':
        return 'Agent for Home'

    return 'oth'


def increment_counter(stat, counter_name):
    if counter_name not in stat:
        stat[counter_name] = 1
        return
    stat[counter_name] += 1


def init_agents_info(data):
    data[map_agent_type('')] = ''
    data[map_agent_type('{BA262882-C484-479A-8D07-B0EAC55CE27B}')] = ''
    data[map_agent_type('{AC127296-8E50-41DE-8EFE-853C4B5CD8A8}')] = ''
    data[map_agent_type('{EC3CF038-C08A-4341-82DF-F75133705F63}')] = ''
    data[map_agent_type('{87671A98-2B47-4D4C-98FB-490CA111E7A7}')] = ''
    data[map_agent_type('{C293F7DD-9531-4916-9346-12B0F3BFCCAA}')] = ''
    data[map_agent_type('{30BAF589-C02A-463F-AB37-5A9193375700}')] = ''
    data[map_agent_type('{CDC40814-3769-4D13-B222-629463D3F5CA}')] = ''
    data[map_agent_type('{09726067-5E56-4775-8D3B-FD9110BCAAD1}')] = ''
    data[map_agent_type('{383CD411-7A5D-4658-B184-3B651A6E12BB}')] = ''
    data[map_agent_type('{9F148D12-3653-478B-A039-239BE36950AB}')] = ''
    #home
    data[map_agent_type('{8397FC51-C78E-4E26-9860-6A4A8622DF7C}')] = ''

def map_os_type(type):
    if type == 1:
        return 'Unknown'

    if type == 2:
        return 'Windows9x'

    if type == 3:
        return 'Windows'

    if type == 4:
        return 'Linux'

    if type == 5:
        return 'MacOs'

    return '{0}'.format(value)


def map_os_caps(value):
    result = []
    if value & 1:
        result.append('BOOTMEDIA')

    if value & 2:
        result.append('SERVER')

    if value & 4:
        result.append('APPLIANCE')

    if value & 8:
        result.append('LINUX_RAMDISK')

    if value & 16:
        result.append('HYPERV')

    if value & 32:
        result.append('DR_APPLIANCE')

    return '|'.join(result)


def map_architecture_edition(value):
    if value == 0:
        return 'UNKNOWN'

    if value == 1:
        return 'X86'

    if value == 2:
        return 'X64'

    return '{0}'.format(value)


def get_app_stat(info, host_id):
    if host_id not in info['apps']:
        info['apps'][host_id] = {}
        info['apps'][host_id]['exchange'] = {}
        info['apps'][host_id]['exchange']['2003'] = 0
        info['apps'][host_id]['exchange']['2007'] = 0
        info['apps'][host_id]['exchange']['2010'] = 0
        info['apps'][host_id]['exchange']['2013'] = 0
        info['apps'][host_id]['exchange']['-'] = 0
        info['apps'][host_id]['mssql'] = {}
        info['apps'][host_id]['mssql']['SQL Server 2005'] = 0
        info['apps'][host_id]['mssql']['SQL Server 2008'] = 0
        info['apps'][host_id]['mssql']['SQL Server 2008R2'] = 0
        info['apps'][host_id]['mssql']['SQL Server 2012'] = 0
        info['apps'][host_id]['mssql']['SQL Server 2014'] = 0
        info['apps'][host_id]['mssql']['SQL Server Unknown'] = 0

    return info['apps'][host_id]


def map_sql_server_version(version):
    if version.startswith('9.0'):
        return 'SQL Server 2005'
    if version.startswith('10.0'):
        return 'SQL Server 2008'
    if version.startswith('10.50'):
        return 'SQL Server 2008R2'
    if version.startswith('11.0'):
        return 'SQL Server 2012'
    if version.startswith('12.0'):
        return 'SQL Server 2014'
    return 'SQL Server Unknown'


def map_exchange_server_version(version):
    if version == '-':
        return 'Exchange Server Unknown'
    return 'Exchange Server {0}'.format(version)


def collect_summary_info(connection, info, object):
    is_online = (object.Status.ref == 0)
    is_mobile = is_mobile_agent(object.Info.Agents)
    is_ati = is_ati_agent(object.Info.Agents)

    info["total"]['total'] = info["total"]['total'] + 1
    if is_online:
        info["total"]['total_online'] = info["total"]['total_online'] + 1

    if is_mobile:
        info["total"]['mobile'] = info["total"]['mobile'] + 1
        if is_online:
            info["total"]['mobile_online'] = info["total"]['mobile_online'] + 1
    elif is_ati:
        info["total"]['home'] = info["total"]['home'] + 1
        if is_online:
            info["total"]['home_online'] = info["total"]['home_online'] + 1
    else:
        info['total']['abr'] = info['total']['abr'] + 1
        if is_online:
            info["total"]['abr_online'] = info["total"]['abr_online'] + 1


def collect_online_info(connection, info, object):
    is_mobile = is_mobile_agent(object.Info.Agents)
    is_ati = is_ati_agent(object.Info.Agents)

    info["total"]['total'] = info["total"]['total'] + 1

    if is_mobile:
        info["total"]['mobile'] = info["total"]['mobile'] + 1
    elif is_ati:
        info["total"]['home'] = info["total"]['home'] + 1
    else:
        info['total']['abr'] = info['total']['abr'] + 1


def process_agents(connection, info, object):
    agent_id = '{0}'.format(object.ID.ref)
    info[agent_id] = {}
    data = info[agent_id]

    tenant = ''
    if 'Tenant' in object:
        tenant = object.Tenant.Name.ref
    data['Tenant'] = tenant
    init_agents_info(data)

    is_online = (object.Status.ref == 0)
    is_mobile = is_mobile_agent(object.Info.Agents)
    is_ati = is_ati_agent(object.Info.Agents)

    def get_version(agents_info):
        for index, a in object.Info.Agents:
            version = a.Version.ref
            return version

    if is_mobile:
        agent_type = map_agent_type('{AC127296-8E50-41DE-8EFE-853C4B5CD8A8}')
        data[agent_type] = get_version(object.Info.Agents)
    elif is_ati:
        agent_type = map_agent_type('{8397FC51-C78E-4E26-9860-6A4A8622DF7C}')
        data[agent_type] = get_version(object.Info.Agents)
    else:
        for index, a in object.Info.Agents:
            version = a.Version.ref
            agent_type = map_agent_type(a.Id.ref)
            data[agent_type] = version

            if agent_type == 'oth':
                Log.write('UnknownType: {0}, {1}'.format(a.Name.ref, a.Id.ref))

    data['ProcessorArchitecture'] = object.Info.Architecture.ref
    #if 'Hardware' in object.Info:
    #    data['MemorySize'] = object.Info.Hardware.MemorySize.ref
    #    data['ProcessorFrequency'] = object.Info.Hardware.ProcessorFrequency.ref
    #    data['ProcessorName'] = object.Info.Hardware.ProcessorName.ref
    #else: #For Mobile
    #    data['MemorySize'] = '-'
    #    data['ProcessorFrequency'] = '-'
    #    data['ProcessorName'] = ''

    #data['Name'] = object.Info.Name.ref
    data['Status'] = object.Status.ref
    data['OSArchitectureEdition'] = map_architecture_edition(object.Info.OS.ArchitectureEdition.ref)
    data['OSName'] = object.Info.OS.Name.ref
    data['OSCaps'] = map_os_caps(object.Info.OS.OSCaps.ref)
    data['OSType'] = map_os_type(object.Info.OS.OSType.ref)
    data['OSVersionMajor'] = object.Info.OS.VersionMajor.ref
    data['OSVersionMinor'] = object.Info.OS.VersionMinor.ref
    if 'TimezoneOffsetInMinutes' in object.Info:
        data['TimezoneOffsetInMinutes'] = object.Info.TimezoneOffsetInMinutes.ref
    else: #For Mobile
        data['TimezoneOffsetInMinutes'] = '-'
    data['LastConnectionTime'] = '-'
    if 'LastConnectionTime' in object:
        data['LastConnectionTime'] = object.LastConnectionTime.ref

    if 'Tenant' in object:
        data['TenantName'] = object.Tenant.Name.ref
        data['TenantID'] = object.Tenant.ID.ref
        data['TenantLocator'] = object.Tenant.Locator.ref
    else:
        data['TenantName'] = '-'
        data['TenantID'] = '-'
        data['TenantLocator'] = '-'
    if 'UpdateState' in object:
        data['UpdateIsAvailable'] = object.UpdateState.UpdateVersion.ref
    else: #For Mobile
        data['UpdateIsAvailable'] = '-'

    app_stat = get_app_stat(info, agent_id)
    for app_version, count in app_stat['mssql'].items():
        data[app_version] = count
    for app_vesion, count in app_stat['exchange'].items():
        data[map_exchange_server_version(app_version)] = count


def print_agent_stat(stat):
    Log.write('By version:')
    sorted_items = sorted(stat['by_version'].items(), key=operator.itemgetter(1))
    sorted_items.reverse()
    for version, count in sorted_items:
        Log.write('\t{0}: {1}'.format(version, count))

    Log.write('By type:')
    for type, data in stat['by_type'].items():
        Log.write('\t{0}:'.format(type))
        sorted_items = sorted(data.items(), key=operator.itemgetter(1))
        sorted_items.reverse()
        for version, count in sorted_items:
            Log.write('\t\t{0}: {1}'.format(version, count))


def process_mssql_instances(connection, info, object):
    host_id = '{0}'.format(object.HostID.ref)
    stat = get_app_stat(info, host_id)
    if 'SqlServerVersion' not in object.Parameters:
        stat['mssql'][map_sql_server_version('-')] += 1
        return
    for index, value in object.Parameters.SqlServerVersion:
        #Log.write('Found mssql version \'{0}\''.format(value.ref))
        app_version = map_sql_server_version(value.ref)
        if app_version not in stat['mssql']:
            stat['mssql'][map_sql_server_version('-')] += 1
        else:
            stat['mssql'][app_version] += 1


def process_exchange_instances(connection, info, object):
    host_id = '{0}'.format(object.HostID.ref)
    stat = get_app_stat(info, host_id)
    #print(object)
    if 'ExchangeServerVersion' not in object.Parameters:
        stat['exchange']['-'] += 1
        return
    for index, value in object.Parameters.ExchangeServerVersion:
        #Log.write('Found exchange version \'{0}\''.format(value.ref))
        if value.ref not in stat['exchange']:
            stat['exchange']['-'] += 1
        else:
            stat['exchange'][value.ref] += 1


def collect_agents_statistics(connection):

    info = {}
    info['total'] = {}
    info['total']['home'] = 0
    info['total']['mobile'] = 0
    info['total']['abr'] = 0
    info['total']['total'] = 0
    info['apps'] = {}

    if args.parameter1 != 'summary' and args.parameter1 != 'online':
        #prefetch application instance info
        Log.write('Collecting information applications...')
        start = time.time()
        callback = lambda x: process_exchange_instances(connection, info, x)
        #INSTANCE_TYPE_EXCHANGE = 6,
        pattern = [
            ('^Is', 'string', 'InstanceManagement::Instance'),
            ('.Type', 'dword', 6),
        ]
        spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern))
        acrobind.enumerate_objects(connection, spec, callback, error_log)

        callback = lambda x: process_mssql_instances(connection, info, x)
        #INSTANCE_TYPE_MSSQL = 19,
        pattern = [
            ('^Is', 'string', 'InstanceManagement::Instance'),
            ('.Type', 'dword', 19),
        ]
        spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern))
        acrobind.enumerate_objects(connection, spec, callback, error_log)
        Log.write('done ({0:.2f} s)'.format(time.time() - start))

    #determine all agents type
    Log.write('Collecting information about agents...')
    start = time.time()
    spec = acrobind.create_viewspec_machines_by_role(0)

    if args.parameter1 == 'summary':
        info['total']['home_online'] = 0
        info['total']['mobile_online'] = 0
        info['total']['abr_online'] = 0
        info['total']['total_online'] = 0
        spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask3('.ID', '.Status', '.Info'))
        agents_callback = lambda x: collect_summary_info(connection, info, x)
    elif args.parameter1 == 'online':
        pattern = [
            ('^Is', 'string', 'MachineManagement::Machine'),
            ('.Info.Role', 'dword', 0),
            ('.Status', 'dword', 0),
        ]
        spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern))
        spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask3('.ID', '.Status', '.Info'))
        agents_callback = lambda x: collect_online_info(connection, info, x)
    else:
        info['total']['home_online'] = 0
        info['total']['mobile_online'] = 0
        info['total']['abr_online'] = 0
        info['total']['total_online'] = 0
        agents_callback = lambda x: process_agents(connection, info, x)

    acrobind.enumerate_objects(connection, spec, agents_callback, error_log)
    Log.write('done ({0:.2f} s)'.format(time.time() - start))

    if args.parameter1 == 'summary' or args.parameter1 == 'online':
        print(info['total'])
        return

    info.pop('apps', None)
    info.pop('total', None)
    print(json.dumps(info))
    #print_agent_stat(info)

    #for tenant, data in info['by_tenant'].items():
    #    Log.write("Tenant: {0}".format(tenant))
    #    print_agent_stat(data)


def map_usert_agent_type(id):

    if id == '{BA262882-C484-479A-8D07-B0EAC55CE27B}':
        return 'Workstation'

    if id == '{C293F7DD-9531-4916-9346-12B0F3BFCCAA}':
        return 'SQL'

    if id == '{AC127296-8E50-41DE-8EFE-853C4B5CD8A8}':
        return 'Mobile'

    if id == '{EC3CF038-C08A-4341-82DF-F75133705F63}':
        return 'VMware'

    if id == '{87671A98-2B47-4D4C-98FB-490CA111E7A7}':
        return 'Hyper-V'

    if id == '{30BAF589-C02A-463F-AB37-5A9193375700}':
        return 'Exchange'

    if id == '{CDC40814-3769-4D13-B222-629463D3F5CA}':
        return 'ESX (Appliance)'

    if id == '{09726067-5E56-4775-8D3B-FD9110BCAAD1}':
        return 'ARX single pass'

    if id == '{383CD411-7A5D-4658-B184-3B651A6E12BB}':
        return 'Online ARX'

    if id == '{9F148D12-3653-478B-A039-239BE36950AB}':
        return 'AD'

    if id == '{8397FC51-C78E-4E26-9860-6A4A8622DF7C}':
        return 'Home'

    if id == 'home':
        return 'Home'

    return 'unknown'

def init_users_info(data):
    data[map_usert_agent_type('{BA262882-C484-479A-8D07-B0EAC55CE27B}')] = {}
    data[map_usert_agent_type('{AC127296-8E50-41DE-8EFE-853C4B5CD8A8}')] = {}
    data[map_usert_agent_type('{EC3CF038-C08A-4341-82DF-F75133705F63}')] = {}
    data[map_usert_agent_type('{87671A98-2B47-4D4C-98FB-490CA111E7A7}')] = {}
    data[map_usert_agent_type('{C293F7DD-9531-4916-9346-12B0F3BFCCAA}')] = {}
    data[map_usert_agent_type('{30BAF589-C02A-463F-AB37-5A9193375700}')] = {}
    data[map_usert_agent_type('{CDC40814-3769-4D13-B222-629463D3F5CA}')] = {}
    data[map_usert_agent_type('{09726067-5E56-4775-8D3B-FD9110BCAAD1}')] = {}
    data[map_usert_agent_type('{383CD411-7A5D-4658-B184-3B651A6E12BB}')] = {}
    data[map_usert_agent_type('{9F148D12-3653-478B-A039-239BE36950AB}')] = {}
    data[map_usert_agent_type('home')] = {}
    data[map_usert_agent_type('unknown')] = {}


def process_users(connection, info, object):
    #print(object)
    #print(len(object.Info.Agents))

    if 'Tenant' not in object:
        #Log.write("Object without tenant info:\n{0}".format(object))
        return

    tenant_id = object.Tenant.ID.ref

    for index, a in object.Info.Agents:
        data = None
        agent_type = None
        #Home agent have no Version AgentInfo and have empty Id in AgentInfo
        if len(object.Info.Agents) == 1 and a.Id.ref == '':
            agent_type = map_usert_agent_type('home')
            #print('Home detected {0}'.format(object))
        elif a.Id.ref:
            agent_type = map_usert_agent_type(a.Id.ref)

        if not agent_type:
            continue

        data = info[agent_type]
        if data is None:
            Log.write('UnknownType: {0}, {1}'.format(a.Name.ref, a.Id.ref))
            print(agent_type)
            print(info)
            continue

        if tenant_id in data:
            #Log.write('Already calculated')
            return

        #Log.write(agent_type)
        data[tenant_id] = {}
        data[tenant_id]["ID"] = object.Tenant.ID.ref
        data[tenant_id]["Name"] = object.Tenant.Name.ref
        data[tenant_id]["Locator"] = object.Tenant.Locator.ref
        data[tenant_id]["ParentID"] = object.Tenant.ParentID.ref
        data[tenant_id]["Kind"] = object.Tenant.Kind.ref


def collect_users_info(connection):

    info = {}
    init_users_info(info)

    #determine all agents type
    Log.write('Collecting information about agents...')
    start = time.time()
    agents_callback = lambda x: process_users(connection, info, x)
    spec = acrobind.create_viewspec_machines_by_role(0)
    #spec = acrobind.viewspec_apply_mask(spec, acrobind.create_mask3('.ID', '.Tenant', '.Info.Agents', '.Info.OS'))
    acrobind.enumerate_objects(connection, spec, agents_callback, error_log)
    Log.write('done ({0:.2f} s)'.format(time.time() - start))
    print(json.dumps(info))


def process_autoupdate(connection, object, table):
    if args.extra:
        Log.write(object)

    if table:
        table.add_row(['{}'.format(object.Version.ref), '{}'.format(object.OS.ref), '{}'.format(object.Arch.ref), '{}'.format(object.Locale.ref), '{}'.format(object.BuildUrl.ref)])

    if args.fix:
        print('Do you want to delete this object(y/n)?')
        if ask_user():
            object_pattern = [
                ('^Is', 'string', 'AutoUpdate::Dto::Update'),
                ('.BuildUrl', 'string', object.BuildUrl.ref),
                ('.ID.ID', 'guid', object.ID.ID.ref),
                ('.ID.SequencedID', 'qword', object.ID.SequencedID.ref),
            ]
            connection.dml.delete(pattern=acrort.plain.Unit(flat=object_pattern))
            print('deleted.')
        else:
            print('skipped.')


def analyze_updates(connection):
    build_url = None
    if args.build_url:
        build_url = args.build_url

    update_id = None
    if args.update_id:
        update_id = args.update_id


    Log.write('Listing updates for build url {0} and update id {1}'.format(build_url if build_url else "All", update_id if update_id else "All"))

    table = prettytable.PrettyTable(["Version", "OS", "Arch", "Locale", "BuildUrl"])
    table.align["Version"] = "l"
    table.padding_width = 1
    callback = lambda x: process_autoupdate(connection, x, table)
    pattern = [
        ('^Is', 'string', 'AutoUpdate::Dto::Update'),
    ]
    if build_url:
        pattern.append(('.BuildUrl', 'string', build_url))
        pattern.append(('.BuildUrl^Like', 'string', '%{0}%'.format(build_url)))

    if update_id:
        pass
        #pattern.append(('.ID.ID', 'guid', update_id))

    spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern))
    acrobind.enumerate_objects(connection, spec, callback, error_log)
    print(table.get_string(sortby="Version"))
    print('')


def counter_mode(connection):
    statistics_views = {'machine-statistics': 'Statistics::Agents', 'backup-statistics': 'Statistics::Resources'}
    if args.count in statistics_views:
        stat = acrobind.select_object(connection, acrobind.create_viewspec_by_is_and_string_property(statistics_views[args.count], '.Tenant.ID', "all"))
        if not stat:
            Log.write("Failed to select statistics object.")
            return
        print(stat)
    else:
        Log.write("Trying to count objects: {}".format(args.count))
        count = acrobind.count_objects(connection, args.count)
        print("{0}: {1}".format(args.count, count))

#BEGIN --perf_stat analyze--
def get_perf_stat_folder():
    return os.path.join(acrort.fs.APPDATA_COMMON, acrort.common.BRAND_NAME, 'AMS', 'perf_stats')


def init_dml_perf_stat(stat, time_range):
    stat[time_range] = {}
    stat[time_range]['report_count_{}'.format(time_range)] = {}
    stat[time_range]['report_time_{}'.format(time_range)] = {}
    stat[time_range]['subscribe_create_count_{}'.format(time_range)] = {}
    stat[time_range]['subscribe_create_time_{}'.format(time_range)] = {}
    stat[time_range]['subscribe_delete_count_{}'.format(time_range)] = {}
    stat[time_range]['subscribe_delete_time_{}'.format(time_range)] = {}
    stat[time_range]['subscribe_update_count_{}'.format(time_range)] = {}
    stat[time_range]['subscribe_update_time_{}'.format(time_range)] = {}


def load_dml_stat(file_name, stat):
    with open(file_name, 'r') as csvfile:
        try:
            reader = csv.reader(csvfile, 'ams')
            for row in reader:
                stat[row[0]] = int(row[1])
        except Exception as error:
            Log.write('Failed to process stat file \'{0}\', reason: {1}.'.format(file_name, error))


def perf_stat():
    Log.write('DML perf stat')
    dml_perf_stat()


def dml_perf_stat():
    csv.register_dialect('ams', delimiter=';', skipinitialspace=True, quoting=csv.QUOTE_NONE)
    perf_folder = get_perf_stat_folder()
    stat = {}

    desc = {}
    init_dml_perf_stat(stat, 'total')
    init_dml_perf_stat(stat, '1_minute')

    for i in range(1, 10):
        core_id = '0_{}'.format(i)
        desc_file = '{0}/{1}_desc.log'.format(perf_folder, core_id)
        try:
            with open(desc_file, 'r') as csvfile:
                try:
                    reader = csv.reader(csvfile, 'ams')
                    for row in reader:
                        desc[row[0]] = '{}:{}'.format(row[2], row[1])
                except Exception as error:
                    Log.write('Failed to process file \'{0}\', reason: {1}.'.format(desc_file, error))

            for key, value in stat.items():
                for stat_id in value:
                    stat_file_name = '{0}/{1}_{2}.log'.format(perf_folder, stat_id, core_id)
                    load_dml_stat(stat_file_name, stat[key][stat_id])
        except Exception as error:
            Log.write('Failed to process file \'{0}\', reason: {1}. Skipping'.format(desc_file, error))


    for key, stat_pack in stat.items():
        table = prettytable.PrettyTable([key, "value", "file"])

        table.align[key] = "l"
        table.align["value"] = "l"
        table.align["file"] = "l"
        table.padding_width = 1

        last_minute_filter = 100
        total_minute_filter = 1000
        if args.parameter1 is not None:
            last_minute_filter = int(args.parameter1)

        if args.parameter2 is not None:
            total_minute_filter = int(args.parameter2)
        filter = last_minute_filter if key == '1_minute' else total_minute_filter
        for stat_id, state_value in stat_pack.items():
            sorted_stat = reversed(sorted(state_value.items(), key=lambda x:x[1]))
            top_str = ''
            column_name = stat_id
            for i, v in sorted_stat:
                if v > filter:
                    table.add_row([column_name, v, desc[i]])
                    column_name = ''

        Log.write(table)

#END --perf_stat analyze--


def dml_stat():
    Log.write('DML perf stat')
    csv.register_dialect('ams', delimiter=';', skipinitialspace=True, quoting=csv.QUOTE_NONE)
    perf_folder = get_perf_stat_folder()
    stat = {}
    stat['recent'] = {}
    stat['total'] = {}

    stat['result'] = {}
    stat['result']['recent'] = {}
    stat['result']['total'] = {}
    try:
        with open('dml_perf_last_1_minute.log', 'r') as csvfile:
            try:
                reader = csv.reader(csvfile, 'ams')
                for row in reader:
                    stat['recent'][int(row[0])] =  int(row[1])
            except Exception as error:
                Log.write('Failed to process file \'{0}\', reason: {1}.'.format('dml_perf_last_1_minute.log', error))

        with open('dml_perf_total.log', 'r') as csvfile:
            try:
                reader = csv.reader(csvfile, 'ams')
                for row in reader:
                    stat['total'][int(row[0])] =  int(row[1])
            except Exception as error:
                Log.write('Failed to process file \'{0}\', reason: {1}.'.format('dml_perf_total.log', error))
    except Exception as error:
        Log.write('Failed to process file, reason: {0}. Skipping'.format(error))

    def load_stat(stat, type):
        for key, value in stat[type].items():
            temp = key
            counter_id = temp % 100
            temp = temp // 100

            op_id = temp % 100
            temp = temp // 100

            core_id = temp % 100
            temp = temp // 100

            dispatcher_id = temp % 100
            counter_class = temp // 100

            if dispatcher_id not in stat['result'][type]:
                stat['result'][type][dispatcher_id] = {}
            dispatcher_stat = stat['result'][type][dispatcher_id]

            if counter_class > 1:
                core_id = core_id - 1

            if core_id not in dispatcher_stat:
                dispatcher_stat[core_id] = {}
            core_stat = dispatcher_stat[core_id]

            unified_key = key

            if counter_class > 1:
                unified_key = key % 10000000
                unified_key = 100000000 + dispatcher_id * 1000000 + core_id * 10000 + op_id * 100 + counter_id
                #continue
            #if key == 100000001:
            #    print(unified_key)

            if op_id not in core_stat:
                core_stat[op_id] = {}
                def init_op_stat(stat, op_id):
                    stat[op_id] = {}
                    stat[op_id]['key'] = unified_key
                    stat[op_id]['val'] = 0

                init_op_stat(core_stat[op_id], 0)
                init_op_stat(core_stat[op_id], 1)
                init_op_stat(core_stat[op_id], 2)
                init_op_stat(core_stat[op_id], 5)
                init_op_stat(core_stat[op_id], 6)

            op_stat = core_stat[op_id]

            c_id = (counter_class - 1)* 100 + counter_id
            if c_id not in op_stat:
                op_stat[c_id] = {}
                op_stat[c_id]['key'] = {}
                op_stat[c_id]['val'] = {}
            op_stat[c_id]['val'] = value
            op_stat[c_id]['key'] = unified_key

            #Log.write('{} - {}:{}:{}:{}'.format(key, dispatcher_id, core_id, op_id, counter_id))

    load_stat(stat, 'recent')
    load_stat(stat, 'total')

    table = prettytable.PrettyTable(['id', 'core + op', "calls=sucess+failed (time)", "calls=sucess+failed (time)", "avg_rate/cur_rate", "pending", "batch+sql+completion", "batch(elems)/register"])
    for dispatcher, dispatcher_stat in stat['result']['total'].items():
        for core_id, core_stat in dispatcher_stat.items():
            for op_id, op_stat in core_stat.items():

                op_name = ''
                if op_id == 0:
                    op_name = 'create'
                elif op_id == 1:
                    op_name = 'update'
                elif op_id == 2:
                    op_name = 'delete'
                elif op_id == 3:
                    op_name = 'tr'
                elif op_id == 4:
                    op_name = 'tu'
                elif op_id == 5:
                    op_name = 'report'
                elif op_id == 6:
                    op_name = 'subscribe'

                time_val = 0
                calls_val = 0
                s_calls_val = 0
                f_calls_val = 0
                p_calls_val = 0
                b_processing_time = '-'
                sql_exec_time = '-'
                completion_exec_time = '-'
                batch_count = '-'
                batch_elements = '-'
                register_counts = '-'

                key = 0
                for c_id, c_stat in op_stat.items():
                    key = c_stat['key']
                    if c_id == 0:
                        time_val = c_stat['val']
                    elif c_id == 1:
                        calls_val = c_stat['val']
                    elif c_id == 2:
                        s_calls_val = c_stat['val']
                    elif c_id == 3:
                        f_calls_val = c_stat['val']
                    elif c_id == 4:
                        p_calls_val = c_stat['val']
                    elif c_id == 100: #batch processing time
                        b_processing_time = c_stat['val']
                    elif c_id == 101: #sql execution  time
                        sql_exec_time = c_stat['val']
                    elif c_id == 102: #completion  time
                        completion_exec_time = c_stat['val']
                    elif c_id == 103: #batch count
                        batch_count = c_stat['val']
                    elif c_id == 104: #batch elements
                        batch_elements = c_stat['val']
                    elif c_id == 105: #register count
                        register_counts = c_stat['val']
                key = key // 100
                #print(key)
                #if key == 100000001:
                #    print(unified_key)
                cur_time_val = 0
                cur_calls_val = 0
                cur_s_calls_val = 0
                cur_f_calls_val = 0
                cur_p_calls_val = 0

                cur_b_processing_time = 0
                cur_sql_exec_time = 0
                cur_completion_exec_time = 0
                cur_batch_count = 0
                cur_batch_elements = 0
                cur_register_counts = 0

                if dispatcher in stat['result']['recent'] and core_id in stat['result']['recent'][dispatcher] and op_id in stat['result']['recent'][dispatcher][core_id]:
                    for c_id, c_stat in stat['result']['recent'][dispatcher][core_id][op_id].items():
                        if c_id == 0:
                            cur_time_val = c_stat['val']
                        elif c_id == 1:
                            cur_calls_val = c_stat['val']
                        elif c_id == 2:
                            cur_s_calls_val = c_stat['val']
                        elif c_id == 3:
                            cur_f_calls_val = c_stat['val']
                        elif c_id == 4:
                            cur_p_calls_val = c_stat['val']
                        elif c_id == 100: #batch processing time
                            cur_b_processing_time = c_stat['val']
                        elif c_id == 101: #sql execution  time
                            cur_sql_exec_time = c_stat['val']
                        elif c_id == 102: #completion  time
                            cur_completion_exec_time = c_stat['val']
                        elif c_id == 103: #batch count
                            cur_batch_count = c_stat['val']
                        elif c_id == 104: #batch elements
                            cur_batch_elements = c_stat['val']
                        elif c_id == 105: #register count
                            cur_register_counts = c_stat['val']
                cur_process_rate_val = 0
                cur_rate_val = 0
                if cur_time_val != '-' and cur_calls_val != '-' and cur_p_calls_val != '-' and cur_time_val != 0:
                    cur_process_rate_val = cur_calls_val
                    cur_rate_val = cur_p_calls_val + cur_calls_val
                rate = cur_rate_val - cur_process_rate_val
                rate_sgn = ''
                if rate > 0:
                    rate_sgn = '+'
                if rate < 0:
                    rate_sgn = '-'
                #Log.write('{}:{}:{} = {}'.format(dispatcher, core_id, op_name, val_str))

                table.add_row([key, '{:<2}:{:<2}:{:>10}'.format(dispatcher, core_id, op_name),\
                    '{:10} = {:8} + {:<4} ({:<8})'.format(calls_val, s_calls_val, f_calls_val, time_val), \
                    '{:5} = {:3} + {:<3} ({:<6})'.format(cur_calls_val, cur_s_calls_val, cur_f_calls_val, cur_time_val), \
                    '{:8.2f} / {:<8.2f}'.format(0 if time_val <= 0 else calls_val/time_val, 0 if cur_time_val <= 0 else cur_calls_val/cur_time_val), \
                    '{} ({}{})'.format(p_calls_val, rate_sgn, cur_p_calls_val), \
                    '{:1} + {:4} + {:<2}'.format(cur_b_processing_time, cur_sql_exec_time, cur_completion_exec_time), \
                    '{:4} ({:4}) / {:<2}'.format(cur_batch_count, cur_batch_elements, cur_register_counts) \
                    ])

    table.align['core + op'] = "l"
    table.align['time'] = "l"
    table.align['calls'] = "l"
    table.align['success'] = "l"
    table.align['failed'] = "l"
    table.align['rate'] = "l"
    table.align['pending'] = "l"
    table.padding_width = 1
    Log.write(table.get_string(sortby='id', reversesort=False))
    #print(table)
    return
    #continue
    table = prettytable.PrettyTable([key, "value", "file"])



    last_minute_filter = 100
    total_minute_filter = 1000
    if args.parameter1 is not None:
        last_minute_filter = int(args.parameter1)

    if args.parameter2 is not None:
        total_minute_filter = int(args.parameter2)
    filter = last_minute_filter if key == '1_minute' else total_minute_filter
    for stat_id, state_value in stat_pack.items():
        sorted_stat = reversed(sorted(state_value.items(), key=lambda x:x[1]))
        top_str = ''
        column_name = stat_id
        for i, v in sorted_stat:
            if v > filter:
                table.add_row([column_name, v, desc[i]])
                column_name = ''

    #Log.write(table)


#BEGIN --fix instance status--
def getEpochTime(hours_ago):
    ago = datetime.datetime.now() - datetime.timedelta(hours=hours_ago)
    return int(time.mktime(ago.timetuple()))


def fix_instances(connection):
    creation_time = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    Log.write('[FIX_INSTANCES]: {}'.format(creation_time))

    days = 1
    if args.parameter1:
        days = int(args.parameter1)

    hours = 24
    if args.parameter2:
        hours = int(args.parameter2)
    hours_ago = hours * days
    epochTime = getEpochTime(hours_ago)
    activities_pattern = [
        ('^Is', 'string', 'Tol::History::Plain::Activity'),
        ('.State', 'dword', 5),
        ('.Details.CommandID', 'guid', '8F01AC13-F59E-4851-9204-DE1FD77E36B4'),
        ('.Period.FinishTime', 'sqword', epochTime),
        ('.Period.FinishTime^Greater', 'sqword', epochTime)
    ]

    if args.fix_instances != 'all':
        activities_pattern.append(('.Tenant.ID', 'string', args.fix_instances))

    activities_options = [
        ('.Mask.ID', 'nil', None),
        ('.Mask.Details.CommandID', 'nil', None),
        ('.Mask.Environment.InstanceID', 'nil', None),
        ('.Mask.Environment.ProtectionPlanName', 'nil', None),
        ('.Mask.Tenant', 'nil', None)
    ]

    spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=activities_pattern), options=acrort.plain.Unit(flat=activities_options))
    cache = {}
    table = prettytable.PrettyTable(['id', 'plan', 'host', 'instance', 'tenant'])
    table.padding_width = 1

    def process_activity(connection, activity, cache, act_table):
        source_id = acrobind.get_trait_value('Source', activity)
        id = '{}'.format(activity.ID.ref)
        instance_id = '{}'.format(activity.Environment.InstanceID.ref)
        tenant_id = '{}'.format(activity.Tenant.ID.ref)
        plan_name = ''
        if 'ProtectionPlanName' in activity.Environment:
            plan_name = '{}'.format(activity.Environment.ProtectionPlanName.ref)
        cache[id] = {}
        cache[id]['host_id'] = source_id
        cache[id]['tenant_id'] = tenant_id
        cache[id]['instance_id'] = instance_id

        act_table.add_row([id, plan_name, source_id, instance_id, get_tenant_string(activity)])

    callback = lambda x: process_activity(connection, x, cache, table)
    acrobind.enumerate_objects(connection, spec, callback, error_log)
    if args.extra:
        Log.write(table)
    update_instance_state(connection, cache)


def drop_orphaned_machines(connection):
    locator = '/{}/'.format(args.tenant_id) if args.tenant_id else None
    tenant_locator_to_machines = collections.defaultdict(list)

    def collect_tenant_locators(object):
        Log.write('-', end='')
        tenant_locator_to_machines[object.Tenant.Locator.ref].append(object)

    def tenant_exists(locator):
        Log.write('-', end='')
        spec = acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.Locator', locator)
        return acrobind.count_objects_by_spec(connection, spec) > 0

    spec_m = acrobind.create_viewspec_by_is('MachineManagement::Machine')
    spec_m = acrobind.viewspec_apply_tenant_locator(spec_m, locator)
    mask = acrobind.create_mask2('.Info.Name', '.Tenant')

    Log.write('Collect all MachineManagement::Machine...')
    acrobind.enumerate_objects(connection, acrobind.viewspec_apply_mask(spec_m, mask), collect_tenant_locators, error_log)
    Log.write('\nFound {} tenants'.format(len(tenant_locator_to_machines)))

    Log.write('Search missed Tenants::HierarchyNode...')
    tenant_locator_to_machines = {k: v for k, v in tenant_locator_to_machines.items() if not tenant_exists(k)}

    Log.write('\nFound {} missed Tenants::HierarchyNode.'.format(len(tenant_locator_to_machines)))
    if not tenant_locator_to_machines:
        return

    table = prettytable.PrettyTable(['ID', 'Name', 'Tenant', 'Locator'])
    table.align = 'l'
    table.padding_width = 1
    for key, values in tenant_locator_to_machines.items():
        for v in values:
            tenant = v.get_branch('.Tenant', None)
            table.add_row([str(v.ID.ref), v.Info.Name.ref, tenant.ID.ref if 'ID' in tenant else '-', tenant.Locator.ref])

    Log.write('Orphaned machines:\n{}\nDelete entries?'.format(table.get_string(sortby='Locator')))
    if not ask_user():
        return

    for _, values in tenant_locator_to_machines.items():
        for v in values:
            Log.write('-', end='')
            connection.dml.delete(key=acrort.dml.get_object_key(acrort.plain.Unit(v)))
    Log.write('\nDone.')

    if not args.drop_orphaned_instances:
        Log.write('You deleted orphaned machines. Do you want to delete orphaned instances? (recommended)')
        if ask_user():
            drop_orphaned_instances(connection)

def drop_orphaned_instances(connection):
    host_id_to_keys = collections.defaultdict(list)
    locator = '/{}/'.format(args.tenant_id) if args.tenant_id else None

    def is_aspect(object):
        return acrobind.get_trait_value('Is', object) == 'InstanceManagement::InstanceAspect'

    def collect_host_ids(object):
        Log.write('-', end='')
        host_id = object.get_branch('.Key.HostID' if is_aspect(object) else '.HostID').ref
        host_id_to_keys[str(host_id)].append(object)

    def machine_exists(host_id):
        Log.write('-', end='')
        spec = acrobind.create_viewspec_by_is_and_id('MachineManagement::Machine', host_id)
        return acrobind.count_objects_by_spec(connection, spec) > 0

    spec_i = acrobind.create_viewspec_by_is('InstanceManagement::Instance')
    spec_i = acrobind.viewspec_apply_tenant_locator(spec_i, locator)
    spec_ia = acrobind.create_viewspec_by_is('InstanceManagement::InstanceAspect')
    spec_ia = acrobind.viewspec_apply_tenant_locator(spec_ia, locator)
    mask = acrobind.create_mask4('.HostID', '.FullPath', '.Type', '.Tenant')

    Log.write('Collect all InstanceManagement::Instance...')
    acrobind.enumerate_objects(connection, acrobind.viewspec_apply_mask(spec_i, mask), collect_host_ids, error_log)
    Log.write('\nCollect all InstanceManagement::InstanceAspect...')
    acrobind.enumerate_objects(connection, acrobind.viewspec_apply_mask(spec_ia, mask), collect_host_ids, error_log)
    Log.write('\nFound {} hosts'.format(len(host_id_to_keys)))

    Log.write('Search missed MachineManagement::Machine...')
    host_id_to_keys = {k: v for k, v in host_id_to_keys.items() if not machine_exists(k)}

    Log.write('\nFound {} missed MachineManagement::Machine.'.format(len(host_id_to_keys)))
    if not host_id_to_keys:
        return

    table = prettytable.PrettyTable(['HostID', 'Is', 'InstanceID', 'FullPath', 'Type', 'Tenant', 'Locator'])
    table.align = 'l'
    table.padding_width = 1
    for key, values in host_id_to_keys.items():
        for v in values:
            is_trait = acrobind.get_trait_value('Is', v)
            instance_id = str(v.get_branch('.Key.ID' if is_aspect(v) else '.ID').ref)
            tenant = v.get_branch('.Tenant', None)
            table.add_row([key, is_trait, instance_id, v.FullPath.ref, v.Type.ref, tenant.ID.ref if 'ID' in tenant else '-', tenant.Locator.ref])

    Log.write('Orphaned instances:\n{}\nDelete entries?'.format(table.get_string(sort_key=operator.itemgetter(0, 1))))
    if not ask_user():
        return

    for _, values in host_id_to_keys.items():
        for v in values:
            Log.write('-', end='')
            connection.dml.delete(key=acrort.dml.get_object_key(acrort.plain.Unit(v)))
    Log.write('\nDone.')


def update_instance_state(connection, data):
    Log.write('Fixing instance statuses for tenant: \'{}\'.'.format(args.fix_instances))

    mask = acrort.plain.Unit(flat=[
        ('.Mask.FullPath', 'nil', None),
        ('.Mask.Tenant', 'nil', None),
        ('.Mask.BackupState', 'nil', None),
        ('.Mask.BackupStatus', 'nil', None),
        ('.Mask.State', 'nil', None),
        ('.Mask.Status', 'nil', None),
        ('.Mask.Availability', 'nil', None),
        ('.Mask.LastBackup', 'nil', None),
        ('.Mask.LastBackupTry', 'nil', None),
        ('.Mask.NextBackupTime', 'nil', None)
    ])

    def set_ams_instance_availability(connection, ams_instance_spec, availability):
        diff = [
            ('', 'dword', availability),
        ]
        diff_unit={'Availability': acrort.plain.Unit(flat=diff)}
        connection.dml.update(pattern=ams_instance_spec.pattern, diff=diff_unit)

    def update_ams_instance_state(connection, ams_instance_spec, mms_instance, ams_instance, diff_next_start_time):
        status = mms_instance['Status']
        if (ams_instance.Status.ref == 1 and mms_instance.Status.ref == 1) or (ams_instance.Status.ref == 0 and mms_instance.Status.ref == 0):
            status = [
            ('', 'dword', 2)
            ]
            status = acrort.plain.Unit(flat=status)
        diff_unit={
        'BackupState': mms_instance['BackupState'],
        'BackupStatus': mms_instance['BackupStatus'],
        'State': mms_instance['State'],
        'Status': status,
        'LastBackup': mms_instance['LastBackup'],
        'LastBackupTry': mms_instance['LastBackupTry'],
        'NextBackupTime': diff_next_start_time,
        }
        Log.write('Applying patch:')
        for name, value in diff_unit.items():
            Log.write('{}: {}'.format(name, str(value)))

        connection.dml.update(pattern=ams_instance_spec.pattern, diff=diff_unit)

    #creation_time = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    #fixed_instances_log = 'fixed_instances_log_{}.txt'.format(creation_time)
    #with open(fixed_instances_log, "w") as myfile:
    #    myfile.truncate()

    processed_instances = []
    for activity_id, value in data.items():
        if value['instance_id'] in processed_instances:
            #Log.write('Skipping already processed instance \'{}\' on host \'{}\' (account \'{}\')'.format(value['instance_id'], value['host_id'], value['tenant_id']))
            continue
        else:
            processed_instances.append(value['instance_id'])
            Log.write('Checking instance \'{}\' on host \'{}\' (account \'{}\')'.format(value['instance_id'], value['host_id'], value['tenant_id']))

        ams_instance_spec = acrobind.create_viewspec_by_is_and_guid_property('InstanceManagement::Instance', '.ID', value['instance_id'])
        ams_instance_spec = acrobind.viewspec_apply_mask(ams_instance_spec, mask)

        ams_instance = acrobind.select_object(connection, ams_instance_spec)
        if ams_instance is None:
            Log.write('AMS doesn\'t have such instance. Skipping.')
            continue

        availability = 13
        if 'Availability' in ams_instance:
            availability = ams_instance.Availability.ref
        mms_instance_spec = acrobind.viewspec_apply_remote_host(ams_instance_spec, value['host_id'])
        mms_instance = None
        try:
            mms_instance = acrobind.select_object(connection, mms_instance_spec)
        except Exception as error:
            #Log.write('Couldn\'t get instance from host {}'.format(value['host_id']))
            if availability != 1:
                Log.write('Reseting Availability property for instance {} to 1.'.format(value['instance_id']))
                if args.fix:
                    set_ams_instance_availability(connection, ams_instance_spec, 1)
            continue

        #print(ams_instance)
        if mms_instance is None:
            Log.write('Instance {} is missing on host {}'.format(value['instance_id'], value['host_id']))
            continue

        if availability != 0:
            Log.write('Reseting Availability property for instance {} to 0.'.format(value['instance_id']))
            if args.fix:
                set_ams_instance_availability(connection, ams_instance_spec, 0)

        table = prettytable.PrettyTable(['Property', 'ams', 'mms', 'equal'])
        table.padding_width = 1
        def process_property(prop_name, ams_object, mms_object, table):
            ams_prop_state = None
            if prop_name in ams_object:
                ams_prop_state = ams_object[prop_name]
            mms_prop_state = None
            if prop_name in mms_object:
                mms_prop_state = mms_object[prop_name]

            equal = (ams_prop_state == mms_prop_state)
            ams_prop_state_str = '-'
            if ams_prop_state is not None and ams_prop_state.is_composite():
                ams_prop_state_str = '{}'.format(ams_prop_state)
            else:
                ams_prop_state_str = '{}'.format(ams_prop_state.ref)
            mms_prop_state_str = '-'
            if mms_prop_state is not None and mms_prop_state.is_composite():
                mms_prop_state_str = '{}'.format(mms_prop_state)
            else:
                mms_prop_state_str = '{}'.format(mms_prop_state.ref)
            table.add_row([prop_name, ams_prop_state_str, mms_prop_state_str, '+' if equal else '-'])
            return equal

        instance_name = ''
        tenant_str = get_tenant_string(ams_instance)
        if 'FullPath' in ams_instance:
            instance_name = ams_instance.FullPath.ref

        if 'FullPath' not in mms_instance or \
            'BackupState' not in mms_instance or \
            'BackupStatus' not in mms_instance or \
            'State' not in mms_instance or \
            'Status' not in mms_instance or \
            'LastBackup' not in mms_instance or \
            'LastBackupTry' not in mms_instance or \
            'NextBackupTime' not in mms_instance:
            Log.write('CORRUPTED MMS INSTANCE PROBLEM detected: {}, {}, {}'.format(value['instance_id'], instance_name, tenant_str))
            #print(mms_instance)
            continue

        instance_ok = True
        instance_ok = instance_ok and process_property('FullPath', ams_instance, mms_instance, table)
        instance_ok = instance_ok and process_property('BackupState', ams_instance, mms_instance, table)
        instance_ok = instance_ok and process_property('BackupStatus', ams_instance, mms_instance, table)
        instance_ok = instance_ok and process_property('State', ams_instance, mms_instance, table)
        instance_ok = instance_ok and process_property('Status', ams_instance, mms_instance, table)
        instance_ok = instance_ok and process_property('LastBackup', ams_instance, mms_instance, table)
        instance_ok = instance_ok and process_property('LastBackupTry', ams_instance, mms_instance, table)

        diff_next_start_time_unit = None
        if 'NextBackupTime' in mms_instance and 'Time' in mms_instance.NextBackupTime and mms_instance.NextBackupTime.Time.ref is not None:
            mms_next_start_time = mms_instance.NextBackupTime.Time.ref
            ams_next_start_time = 0
            if 'NextBackupTime' in ams_instance and 'Time' in ams_instance.NextBackupTime and ams_instance.NextBackupTime.Time.ref is not None:
                ams_next_start_time = ams_instance.NextBackupTime.Time.ref
                time_equal = (mms_next_start_time == ams_next_start_time)
                instance_ok = instance_ok and time_equal
                #print('{} {}'.format(mms_next_start_time, ams_next_start_time))
            else:
                #print('FALSE')
                time_equal = False
                instance_ok = False

            table.add_row(['NextStartTime', '{}'.format(ams_next_start_time), '{}'.format(mms_next_start_time), '+' if time_equal else '-'])
            diff_next_start_time = [
                ('.Time', 'sqword', mms_next_start_time),
                ('^Is', 'string', 'Gtob::Dto::NextExecutionTime')
            ]
            if 'Trigger' in mms_instance.NextBackupTime and mms_instance.NextBackupTime.Trigger.ref is not None:
                diff_next_start_time.append(('.Trigger', 'dword', mms_instance.NextBackupTime.Trigger.ref))
            diff_next_start_time_unit = acrort.plain.Unit(flat=diff_next_start_time)
        else:
            diff_next_start_time_unit = ams_instance.NextBackupTime

        if not instance_ok:
            Log.write('SYNC PROBLEM detected: {}, {}, {}'.format(value['instance_id'], instance_name, tenant_str))
            Log.write(table)
            if args.fix:
                update_ams_instance_state(connection, ams_instance_spec, mms_instance, ams_instance, diff_next_start_time_unit)
            #with open(fixed_instances_log, "a") as myfile:
            #    myfile.write('{}\n'.format(value['instance_id']))

        if instance_ok:
            if (ams_instance.Status.ref == 1 and mms_instance.Status.ref == 1) or (ams_instance.Status.ref == 0 and mms_instance.Status.ref == 0):
                Log.write('STATUS PROBLEM detected: {}, {}, {}'.format(value['instance_id'], instance_name, tenant_str))
                Log.write(table)
                if args.fix:
                    update_ams_instance_state(connection, ams_instance_spec, mms_instance, ams_instance, diff_next_start_time_unit)

        if 'LastBackup' in mms_instance and 'NextBackupTime' in mms_instance and 'Time' in mms_instance.NextBackupTime and mms_instance.NextBackupTime.Time.ref is not None:
            try:
                if mms_instance.LastBackup.ref > mms_instance.NextBackupTime.Time.ref:
                    Log.write('SCHEDULE PROBLEM detected: {}, {}, {}'.format(value['instance_id'], instance_name, tenant_str))
                    Log.write(table)
            except Exception as error:
                print(mms_instance.NextBackupTime)
                print(error)
#END --fix instance status--


def check_sync(connection):
    creation_time = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
    Log.write('[FIX_INSTANCES]: {}'.format(creation_time))

    agents_pattern = [
        ('^Is', 'string', 'MachineManagement::Machine'),
        ('.Info.Role', 'dword', 0),
        ('.Status', 'dword', 0)
    ]

    if args.check_sync != 'all':
        agents_pattern.append(('.Tenant.ID', 'string', args.check_sync))

    options = [
        ('.Mask.ID', 'nil', None),
        ('.Mask.Info.Name', 'nil', None),
        ('.Mask.Tenant', 'nil', None)
    ]

    spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=agents_pattern), options=acrort.plain.Unit(flat=options))

    processed_agents = []
    flag = False
    def process_agent(connection, cache, wait_flag, agent):
        #print(agent)
        host_id = agent.ID.ref
        if host_id in cache:
            Log.write('.', end='')
            wait_flag = True
            return
        else:
            if wait_flag:
                Log.write('.')
                wait_flag = False
            cache.append(host_id)

        name_str = '-'
        try:
            name_str = agent.Info.Name.ref
        except:
            pass

        if 'Tenant' not in agent:
            Log.write('MISSING tenant in {}, {}, {}'.format(name_str, host_id, get_tenant_string(agent)))
            return

        tenant_id = '{}'.format(agent.Tenant.ID.ref)
        #print(host_id)

        ams_activities_pattern = [
            ('^Is', 'string', 'Tol::History::Plain::Activity'),
            ('.State', 'dword', 5),
            #('^Source', 'string', '{}'.format(host_id)),
            ('.Details.MachineName', 'string', name_str),
            ('.Tenant.ID', 'string', tenant_id),
            ('.Details.Specific', 'string', 'Business'),
        ]

        agent_activities_pattern = [
            ('^Is', 'string', 'Tol::History::Plain::Activity'),
            ('.__source_machine', 'guid', agent.ID.ref),
            ('.State', 'dword', 5),
            ('.Details.Specific', 'string', 'Business'),
        ]

        options = [
            ('.SortingOptions.Period.FinishTime', 'sqword', 0),
            ('.SortingOptions.Period.FinishTime^Descending', 'nil', None),
            ('.LimitOptions', 'dword', 1),
            ('.Mask.ID', 'nil', None),
            ('.Mask.Tenant', 'nil', None),
            ('.Mask.Details.MachineName', 'nil', None),
            ('.Mask.Period.FinishTime', 'nil', None)
            ]

        ams_act_spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=ams_activities_pattern), options=acrort.plain.Unit(flat=options))
        mms_act_spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=agent_activities_pattern), options=acrort.plain.Unit(flat=options))

        ams_act = acrobind.select_object(connection, ams_act_spec)
        #print(ams_act)
        ams_act_time = 0
        if ams_act is not None and 'Period' in ams_act and 'FinishTime' in ams_act.Period:
            ams_act_time = ams_act.Period.FinishTime.ref

        mms_act = None
        try:
            mms_act = acrobind.select_object(connection, mms_act_spec)
        except Exception as error:
            #Log.write('Couldn\'t get instance from host {}'.format(value['host_id']))
            pass

        mms_act_time = 0
        if mms_act is not None and 'Period' in mms_act and 'FinishTime' in mms_act.Period:
            mms_act_time = mms_act.Period.FinishTime.ref

        if ams_act_time < mms_act_time:
            Log.write('NEED RESYNC: {}, {}, {}, {}, {}'.format(ams_act_time, mms_act_time, name_str, host_id, get_tenant_string(agent)))
            if args.fix:
                if args.parameter1:
                    psql_command = []
                    psql_command.append('psql')
                    psql_command.append('acronis_cms')
                    psql_command.append('-c')
                    psql_command.append('update attachedmachines set lastoperationid=1 where machineid=\'{}\''.format(host_id))
                    ret = subprocess.call(psql_command)
                    Log.write('Update last operation id: {}'.format(ret))

                drop_agent_connection(connection, host_id)
        else:
            Log.write('OK: {}, {}, {}, {}, {}'.format(ams_act_time, mms_act_time, name_str, host_id, get_tenant_string(agent)))

    callback = lambda x: process_agent(connection, processed_agents, flag, x)
    acrobind.enumerate_objects(connection, spec, callback, error_log)


def sync_monitor(connection):

    sync_monitor_for = args.sync_monitor
    names = {
      '7': 'Instance',
      '77': 'Aspect',
      '9': 'Machine',
      '15': 'Plan',
      '17': 'CentralizedItemProtection',
      '18': 'LocalItemProtection',
      '29': 'Activity',
      '101': 'Configuration',
      '102': 'Applications',
      '103': 'Cluster',
      '104': 'VmRessurection',
      '105': 'Archive',
      '106': 'Slice',
      '107': 'Vault',
      '108': 'Location',
      '109': 'Alert',
      '110': 'Notification',
      '111': 'Autoupdate',
      '112': 'Counter',
      '113': 'ProcessInfo',
      '114': 'UpgradeEvent11',
      '115': 'LocalPlan',
      '116': 'LocalProtectionObject',
      '117': 'Migration'
    }

    def format_epoch(x):
        if x is None:
            return 'Never'
        if x == 0:
            return 'Never'
        t = time.localtime(x)
        return time.strftime('%Y-%m-%d %H:%M:%S', t)

    def print_process_report(data):
        result = prettytable.PrettyTable(["ID", "Commits", "Reads", "RR", "Changed", "News", "Completions", "Objects", "Expired", "Fails"])
        result.align = "r"
        result.align["ID"] = "l"

        for x in data:
            is_summary = [unit.ref for name, unit in x.traits if unit.ref == "Sync::Replication::Monitoring::SummaryCounter"]
            if not is_summary and 'Processes' in x:
                for name, p in x.Processes:
                    if name in names:
                        session_id = '-'
                        if 'SessionID' in x:
                            session_id = str(x.SessionID.ref)
                        result.add_row([
                            "/{}/{}/{}".format(str(x.MachineID.ref), session_id, names[name]),
                            p.CommitCount.ref,
                            p.ReadCount.ref,
                            p.RemoteReadCount.ref,
                            format_epoch(p.SourceChanged.ref),
                            get_optional(p, 'ReadNewsCount'),
                            get_optional(p, 'CompletionCount'),
                            p.ObjectCount.ref,
                            get_optional(p, 'ExpiredObjectsCount'),
                            p.FailCount.ref
                        ])
        Log.write(result.get_string(sortby="ID", reversesort=False))

    def print_session_report(data):
        result = prettytable.PrettyTable(["ID", "StartTime", "InPackets", "InSize/K", "OutPackets", "OutSize/K",
                                          "Commits", "CommitTime", "Reads", "ReadTime", "RR", "RRTime",
                                          "Changed", "Recon", "Fails"])
        result.float_format["InSize/K"] = ".2"
        result.float_format["OutSize/K"] = ".2"
        result.align = "r"
        result.align["ID"] = "l"

        for x in data:
            is_summary = [unit.ref for name, unit in x.traits if unit.ref == "Sync::Replication::Monitoring::SummaryCounter"]
            if is_summary:
                result.add_row([
                    'Summary',
                    '-',
                    x.InCount.ref,
                    x.InSize.ref / 1024,
                    x.OutCount.ref,
                    x.OutSize.ref / 1024,
                    x.CommitCount.ref,
                    x.CommitTime.ref / 1000,
                    x.ReadCount.ref,
                    x.ReadTime.ref / 1000,
                    '-',
                    '-',
                    '-',
                    '-',
                    x.FailCount.ref
                ])
            else:
                result.add_row([
                    "/{}/{}".format(str(x.MachineID.ref), str(get_optional(x, 'SessionID'))),
                    format_epoch(get_optional(x, 'StartTime')),
                    x.InCount.ref,
                    x.InSize.ref / 1024,
                    x.OutCount.ref,
                    x.OutSize.ref / 1024,
                    x.CommitCount.ref,
                    x.CommitTime.ref / 1000,
                    x.ReadCount.ref,
                    x.ReadTime.ref / 1000,
                    get_optional(x, 'RemoteReadCount'),
                    '-' if get_optional(x, 'RemoteReadTime') is None else str(get_optional(x, 'RemoteReadTime') / 1000),
                    format_epoch(get_optional(x, 'Changed')),
                    get_optional(x, 'ReconcileTime'),
                    x.FailCount.ref
                ])

        Log.write(result.get_string(sortby="ID", reversesort=False))


    def apply_limits(spec):
        if args.parameter1 is not None and args.parameter2 is not None:
            limit_pattern = [
                ('.{0}'.format(args.parameter1), 'dword', int(args.parameter2))
            ]
            return acrort.dml.ViewSpec(spec.pattern.consolidate(acrort.plain.Unit(flat=limit_pattern)), spec.options)
        return spec


    if sync_monitor_for == 'summary':
        pattern = [
            ('^Is', 'string', 'Sync::Replication::Monitoring::Counter'),
            ('^Is', 'string', 'Sync::Replication::Monitoring::SummaryCounter')
        ]
        data = acrobind.select_objects(connection, apply_limits(acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern))))
        print_session_report(data)

    elif sync_monitor_for == 'all':
        spec = apply_limits(acrobind.create_viewspec_by_is('Sync::Replication::Monitoring::Counter'))
        print(spec.pattern)
        data = acrobind.select_objects(connection, spec)
        print_session_report(data)
        print_process_report(data)
    else:
        data = acrobind.select_objects(connection, apply_limits(acrobind.create_viewspec_by_is_and_guid_property('Sync::Replication::Monitoring::Counter', '.MachineID', sync_monitor_for)))
        print_session_report(data)
        print_process_report(data)


def is_deprecated_vm_instance(id):
    deprecated_ids = [
        '98259016-909E-48dd-A240-EE97209F545C',
        'E7F120F4-5479-4C91-AEA0-ACE049E8F4CC',
        '1052D468-8EA9-6C59-A0DB-9E56FC6A23C6',
        'ADFC498F-C6A4-AF0B-0476-277362346360',
        'B7A68552-D940-4781-B4CD-95F178DA7B2C'
    ]
    return id in deprecated_ids;


def check_deprecated_vms(connection):
    deprecated_ids = [
        '98259016-909E-48dd-A240-EE97209F545C',
        'E7F120F4-5479-4C91-AEA0-ACE049E8F4CC',
        '1052D468-8EA9-6C59-A0DB-9E56FC6A23C6',
        'ADFC498F-C6A4-AF0B-0476-277362346360',
        'B7A68552-D940-4781-B4CD-95F178DA7B2C'
    ]

    instances_spec = acrobind.create_viewspec_by_is('InstanceManagement::Instance')
    instances_spec = acrobind.viewspec_apply_ids(instances_spec, deprecated_ids)

    instance_aspects_spec = acrobind.create_viewspec_by_is('InstanceManagement::InstanceAspect')

    ids_pattern = []
    for id in deprecated_ids:
        ids_pattern.append([('', 'guid', id)])

    pattern = [
        ('.Key.ID', 'guid', '00000000-0000-0000-0000-000000000000'),
        ('.Key.ID^ValueIn', 'complex_trait', [('', 'array', ids_pattern)]),
    ]

    instance_aspects_spec = acrort.dml.ViewSpec(instance_aspects_spec.pattern.consolidate(acrort.plain.Unit(flat=pattern)), instance_aspects_spec.options)

    objects = acrobind.select_objects(connection, instances_spec)
    #dump instances
    for i in objects:
        Log.write(i)

    aspects = acrobind.select_objects(connection, instance_aspects_spec)
    for i in aspects:
        Log.write(i)

    if args.fix:
        Log.write('Removing deprecated aspects and instances...')
        start = time.time()
        connection.dml.delete(pattern=instance_aspects_spec.pattern)
        connection.dml.delete(pattern=instances_spec.pattern)
        Log.write('Elapsed: {0:.2f} s'.format(time.time() - start))


def check_status(connection_args):
    Log.write('')
    start = time.time()
    connection = acrort.connectivity.Connection(*connection_args)
    Log.write('Connection time: {0:.2f} s'.format(time.time() - start))

    table = prettytable.PrettyTable(["DB", "Connection Time (s)"])
    table.align["DB"] = "l"
    table.align["Connection Time (s)"] = "l"
    table.padding_width = 1

    def check_db_connection(connection, object, table):
        options = [('.LimitOptions', 'dword', 1)]
        start = time.time()
        spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=[('^Is', 'string', object)]), options=acrort.plain.Unit(flat=options))
        objects = acrobind.select_objects(connection, spec)
        table.add_row([object, '{0:.2f}'.format(time.time() - start)])

    check_db_connection(connection, 'Tenants::HierarchyNode', table)
    check_db_connection(connection, 'Gtob::Dto::ItemProtection', table)
    check_db_connection(connection, 'Tol::History::Plain::Activity', table)
    check_db_connection(connection, 'MachineManagement::Machine', table)
    check_db_connection(connection, 'InstanceManagement::Instance', table)
    check_db_connection(connection, 'Agent::Configuration', table)
    check_db_connection(connection, 'Tenant::Configuration', table)
    check_db_connection(connection, 'GroupManagement::Group', table)
    check_db_connection(connection, 'ArchiveManagement::Archive', table)
    check_db_connection(connection, 'Msp::AMS::Dto::Machine', table)

    Log.write(table.get_string(sortby="Connection Time (s)", reversesort=True))
    Log.write('')

    if args.extra:
        spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=[('^Is', 'string', 'Msp::Agent::Dto::Configuration')]))
        object = acrobind.select_object(connection, spec)
        table = prettytable.PrettyTable(["Name", "Value"])
        table.align["Name"] = "l"
        table.padding_width = 1
        table.add_row(["AgentID", str(get_optional(object, 'AgentID'))])
        table.add_row(["ZmqPublicKey", str(get_optional(object.Zmq, 'ZmqPublicKey'))])
        table.add_row(["Uplink", '{0}:{1}'.format(str(get_optional(object.Uplink.Address, 'Address')), str(get_optional(object.Uplink.Address, 'Port')))])
        Log.write(table.get_string(sortby="Name"))
        Log.write('')


def check_notifications():
    '''
    Print statistics about backup notifications
    '''
    def group(name, pattern):
        return '(?P<{}>{})'.format(name, pattern)


    def convert_date(date):
        return datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S:%f')


    def calculate_average(avg, current, count):
        if count == 1:
            return avg + current
        else:
            return avg * (count - 1) / count + current / count


    date_pattern = r'\d[\d-]+ \d[\d:]+'
    thread_id_pattern = r'\d+'
    level_pattern = r'[\w]\d+'

    log_header_pattern = '^{} {} {}:'.format(group('date', date_pattern), thread_id_pattern, level_pattern)

    guid_pattern = '[0-9A-F-]+'
    activity_header_pattern = r'\[Activity\] ID: {}'.format(group('activity_id', guid_pattern))

    start_string = 'Backup reports: processing completed activity:'
    end_string = 'Backup reports: MarkProcessedAndFlushActivities'

    activity_start_line = '{} {} {}'.format(log_header_pattern, start_string, activity_header_pattern)
    activity_end_line = '{} {} {}'.format(log_header_pattern, end_string, activity_header_pattern)

    log_file = os.path.join(acrort.fs.APPDATA_COMMON, acrort.common.BRAND_NAME, 'AMS', 'backup_notifications.0.log')

    with open(log_file, encoding='latin-1') as log:
        activities = {}
        durations = []

        avg_time = datetime.timedelta()
        completed_count = 0

        line_number = 0
        for line in log:
            line_number += 1
            r = re.search(activity_start_line, line)
            if r:
                activity_id = r.group('activity_id')
                activities[activity_id] = {'id': activity_id, 'start': convert_date(r.group('date'))}
            r = re.search(activity_end_line, line)
            if r:
                activity_id = r.group('activity_id')
                data = activities.get(activity_id)
                if data:
                    completed_count += 1
                    data['end'] = convert_date(r.group('date'))
                    data['duration'] = data['end'] - data['start']

                    avg_time = calculate_average(avg_time, data['duration'], completed_count)

                    durations.append(data)

        s = sorted(durations, key=lambda x: x['duration'])

        Log.write('Slowest processed activities:')
        for idx, record in enumerate(reversed(s[-5:])):
            Log.write(idx + 1, 'time:', str(record['duration']), ' activity:', record['id'])
        Log.write()

        Log.write('Fastest processed activities:')
        for idx, record in enumerate(s[:5]):
            Log.write(idx + 1, 'time:', str(record['duration']), ' activity:', record['id'])
        Log.write()

        Log.write('Average activity processing time:', avg_time)
        Log.write('Count of analysed activities: ', completed_count)


def delete_object(connection, args):
    spec = acrort.plain.Unit(flat=[('.ID', 'guid', args.delete_object)])
    connection.dml.delete(pattern=spec)


def fix_all_centralized_protections(connection):
    Log.write('Do you want to fix Gtob::Dto::CentralizedProtection objects for all tenants?(y/n)')
    if not ask_user():
        return

    plans_pattern = [
        ('^Is', 'string', 'Gtob::Dto::ProtectionPlan'),
        ('.Origin', 'dword', 2), # Centralized plans only
    ]

    options = [
        ('.Mask.ID', 'nil', None),
        ('.Mask.Origin', 'nil', None),
    ]

    spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=plans_pattern), options=acrort.plain.Unit(flat=options))

    plans = []
    acrobind.enumerate_objects(connection, spec, lambda x: plans.append(x), error_log)
    Log.write('Going to check {} plans'.format(len(plans)))

    fix_centralized_protections(connection, plans)


def report_all_instances(connection):
    Log.write(';'.join(['ID', 'BackupState', 'BackupStatus', 'FullPath', 'HostID', 'Mobile', 'AD', 'ATIH', 'BackupAgent', 'SQL', 'Exchange', 'ESX', 'Hyper-V', 'LastBackup', 'NextBackup', 'State', 'Status', 'Type']))

    pattern = acrort.plain.Unit(flat=[
        ('^Is', 'string', 'InstanceManagement::Instance'),
    ])
    options = acrort.plain.Unit(flat=[
        ('.Mask.ID', 'nil', None),
        ('.Mask.BackupState', 'nil', None),
        ('.Mask.BackupStatus', 'nil', None),
        ('.Mask.FullPath', 'nil', None),
        ('.Mask.HostID', 'nil', None),
        ('.Mask.LastBackup', 'nil', None),
        ('.Mask.NextBackupTime.Time', 'nil', None),
        ('.Mask.State', 'nil', None),
        ('.Mask.Status', 'nil', None),
        ('.Mask.Type', 'nil', None),
        ('.Mask.HostInfo.Agents', 'nil', None),
    ])
    spec = acrort.dml.ViewSpec(pattern, options)

    def print_instance(instance):
        is_esx = False
        is_hyperv = False
        is_mobile = False
        is_ad = False
        is_ati = False
        is_win = False
        is_sql = False
        is_exchange = False
        is_hyperv = False
        if 'HostInfo' in instance and 'Agents' in instance.HostInfo:
            is_mobile = is_mobile_agent(instance.HostInfo.Agents)
            is_ad = is_ad_agent(instance.HostInfo.Agents)
            is_ati = is_ati_agent(instance.HostInfo.Agents)
            is_win = is_win_agent(instance.HostInfo.Agents)
            is_sql = is_sql_agent(instance.HostInfo.Agents)
            is_exchange = is_exchange_agent(instance.HostInfo.Agents)
            is_esx = is_esx_agent(instance.HostInfo.Agents)
            is_hyperv = is_hyperv_agent(instance.HostInfo.Agents)

        last_backup_stamp = instance.LastBackup.ref if instance.LastBackup.ref else 0
        next_backup_stamp = instance.NextBackupTime.Time.ref if instance.NextBackupTime.Time.ref else 0

        record = [
            instance.ID.ref,
            BACKUP_STATES.get(instance.BackupState.ref),
            BACKUP_STATUSES.get(instance.BackupStatus.ref),
            instance.FullPath.ref,
            instance.HostID.ref,
            '+' if is_mobile else '-',
            '+' if is_ad else '-',
            '+' if is_ati else '-',
            '+' if is_win else '-',
            '+' if is_sql else '-',
            '+' if is_exchange else '-',
            '+' if is_esx else '-',
            '+' if is_hyperv else '-',
            datetime.datetime.utcfromtimestamp(last_backup_stamp),
            datetime.datetime.utcfromtimestamp(next_backup_stamp),
            INSTANCE_STATES.get(instance.State.ref) if 'State' in instance else None,
            INSTANCE_STATUSES.get(instance.Status.ref),
            INSTANCE_TYPES.get(instance.Type.ref),
        ]

        print(';'.join([str(field) for field in record]).encode('utf-8').strip())

    acrobind.enumerate_objects(connection, spec, print_instance, error_log)


def format_epoch(x):
    t = time.localtime(x)
    return time.strftime('%Y-%m-%d %H:%M:%S', t)


def collect_protections(connection, tenants):
    pattern = acrort.plain.Unit(flat=[
        ('^Is', 'string', 'Gtob::Dto::Centralized::ItemProtection'),
    ])
    options = acrort.plain.Unit(flat=[
        ('.Mask.ID', 'nil', None),
        ('.Mask.Centralized.PlanID', 'nil', None),
        ('.Mask.HostID', 'nil', None),
    ])
    spec = acrort.dml.ViewSpec(pattern, options)
    spec = acrobind.viewspec_apply_tenants(spec, tenants)
    stat = {}
    protections = [x for x in acrobind.dml_utils.enum_objects(connection, spec)]

    for x in protections:
        agent = ''

        if 'HostID' in x:
            agent = str(x.HostID.ref)
        else:
            for name, trait_value in x.traits:
                if 'name' == 'Source':
                    agent = str(trait_value.ref)

        if agent in stat:
            stat[agent] += 1
        else:
            stat[agent] = 1
    return stat


def collect_tenants(connection, tenants):
    pattern = [
        ('^Is', 'string', 'Tenants::HierarchyNode'),
    ]

    if tenants:
        ids_pattern = []
        for tenant_id in tenants:
            ids_pattern.append([('', 'string', tenant_id)])

        pattern.append(('.Tenant.ID', 'string', ''))
        pattern.append(('.Tenant.ID^ValueIn', 'complex_trait', [('', 'array', ids_pattern)]))

    options = acrort.plain.Unit(flat=[
        ('.Mask.ID', 'nil', None),
        ('.Mask.Name', 'nil', None),
        ('.Mask.Locator', 'nil', None),
        ('.Mask.Parent', 'nil', None),
    ])
    spec = acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern), options)
    tenants = { str(x.ID.ref): x for x in acrobind.dml_utils.enum_objects(connection, spec) }
    return { id: tenant.Name.ref for id, tenant in tenants.items() }


def collect_public_keys(connection, tenants):
    pattern = [
        ('^Is', 'string', 'Msp::AMS::Dto::Machine'),
    ]

    if tenants:
        ids_pattern = []
        for tenant_id in tenants:
            ids_pattern.append([('', 'string', tenant_id)])

        pattern.append(('.OwnerID', 'string', ''))
        pattern.append(('.OwnerID^ValueIn', 'complex_trait', [('', 'array', ids_pattern)]))

    options = acrort.plain.Unit(flat=[
        ('.Mask.AgentID', 'nil', None),
        ('.Mask.IsEnabled', 'nil', None),
        ('.Mask.OwnerID', 'nil', None),
        ('.Mask.PublicKey', 'nil', None),
        ('.Mask.LastSeenTime', 'nil', None),
    ])
    spec = acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern), options)
    return { str(x.AgentID.ref): x for x in acrobind.dml_utils.enum_objects(connection, spec)  }


def collect_offline_machines(connection, tenants):
    pattern = acrort.plain.Unit(flat=[
        ('^Is', 'string', 'MachineManagement::Machine'),
        ('.Info.Role', 'dword', 0),
    ])
    options = acrort.plain.Unit(flat=[
        ('.Mask.ID', 'nil', None),
        ('.Mask.Info.Agents', 'nil', None),
        ('.Mask.Info.Hardware.MemorySize', 'nil', None),
        ('.Mask.Info.Hardware.ProcessorName', 'nil', None),
        ('.Mask.Info.Hardware.ProcessorFrequency', 'nil', None),
        ('.Mask.Info.Name', 'nil', None),
        ('.Mask.Info.OS.ArchitectureEdition', 'nil', None),
        ('.Mask.Info.OS.Name', 'nil', None),
        ('.Mask.Info.OS.OSCaps', 'nil', None),
        ('.Mask.Info.OS.OSType', 'nil', None),
        ('.Mask.Info.OS.ProductType', 'nil', None),
        ('.Mask.Info.ResidentialAddresses', 'nil', None),
        ('.Mask.LastConnectionTime', 'nil', None),
        ('.Mask.MachineAddress', 'nil', None),
        ('.Mask.Status', 'nil', None),
        ('.Mask.Tenant', 'nil', None),
        ('.Mask.UpdateState.UpdateIsAvailable', 'nil', None)
    ])
    spec = acrort.dml.ViewSpec(pattern, options)
    spec = acrobind.viewspec_apply_tenants(spec, tenants)
    return { str(x.ID.ref): x for x in acrobind.dml_utils.enum_objects(connection, spec) }


def compare_numbers(lhs, rhs):
    if lhs > rhs:
        return 1
    elif lhs == rhs:
        return 0
    else:
        return -1


def compare_versions(lhs, rhs):
    major, minor, build = lhs.split('.')
    major2, minor2, build2 = rhs.split('.')
    if major == major2:
        if minor == minor2:
            return compare_numbers(build, build2)
        else:
            return compare_numbers(minor, minor2)
    return compare_numbers(major, major2)


def get_product_type(build_number):
    if len(build_number) <= 2:
        return "mobile"
    versions = build_number.split('.')
    if int(versions[0]) < 11:
        return "mobile"
    elif int(versions[0]) == 1:
        return "msp"
    elif int(versions[2]) < 100:
        return "home"
    else:
        return "msp"


def get_agent_version(machine):
    version = machine.Info.Agents[0].Version.ref
    for agent in machine.Info.Agents:
        agent = agent[1]
        agent_version = agent.Version.ref
        if agent_version.count('.') != 2:
            continue
        if compare_versions(agent_version, version) > 0:
            version = agent_version
    return version


def get_os_caps(value):
    if value & 4:
        return 'APPLIANCE'
    if value & 1:
        return 'BOOTMEDIA'
    if value & 8:
        return 'LINUX_RAMDISK'
    if value & 16:
        return 'HYPERV'
    if value & 32:
        return 'DR_APPLIANCE'
    if value & 2:
        return 'SERVER'
    return ''


def get_additional_info(value):
    if value & 2:
        return 'DOMAIN CONTROLLER'
    if value & 3:
        return 'SERVER'
    if value & 1:
        return 'WORKSTATION'
    return ""


def report_all_machines(connection):
    tenants = []
    if args.tenant_id:
        tenants.append(args.tenant_id)
        Log.write('Checking subtenants of {0}'.format(args.tenant_id))
        tenant_spec = acrobind.create_viewspec_by_is_and_string_property('Tenants::HierarchyNode', '.ID', args.tenant_id)
        t = acrobind.select_object(connection, tenant_spec)
        if t:
            pattern = [
                ('^Is', 'string', 'Tenants::HierarchyNode'),
                ('.Locator', 'string', ''),
                ('.Locator^DirectRelative', 'string', t.Locator.ref)
            ]
            tenants_objects = acrobind.select_objects(connection, acrort.dml.ViewSpec(acrort.plain.Unit(flat=pattern)))
            for ten in tenants_objects:
              tenants.append(ten.ID.ref)

    protections = collect_protections(connection, tenants)
    tenant_names = collect_tenants(connection, tenants)
    public_keys = collect_public_keys(connection, tenants)
    offline_machines = collect_offline_machines(connection, tenants)

    print(';'.join(["Account", "EUC", "AccountName", "AgentID", "MachineName", "IsEnabled", "PublicKey", "DmlTimeStamp", "OSName", "OS", "Architecture", "OSCaps", "OSInfo", "Memory",
      "ProcessorName", "ProcessorFrequency", "IP", "Build", "Product", "IsUpdateAvailable", "PlanCount", "LastConnectionTimeOld", "DaysOfflineOld", "LastConnectionTime", "DaysOffline", "Status"]))
    report = []
    for agent_id, machine in offline_machines.items():
        agent_version = get_agent_version(machine)
        product = get_product_type(agent_version)

        machine_name = machine.Info.Name.ref
        last_connection_time_old = 0
        sec_offline_old = 0
        if 'LastConnectionTime' in machine:
            last_connection_time_old = format_epoch(machine.LastConnectionTime.ref)
            sec_offline_old = int(time.time()) - machine.LastConnectionTime.ref

        if agent_id not in public_keys:
            continue
        key = public_keys.get(agent_id, None)
        if not key:
            print('Cannot find key for {}({})'.format(machine_name, agent_id))
            continue
        if 'OwnerID' in key:
            owner_id = str(key.OwnerID.ref)
        if 'Tenant' not in machine:
            print('Cannot find account for {}({}), owner={}, name={}'.format(machine_name, agent_id, owner_id, tenant_names.get(owner_id, 'Not found')))
            continue

        last_connection_time = 0
        sec_offline = 0
        if 'LastSeenTime' in key:
            last_connection_time = format_epoch(key.LastSeenTime.ref)
            sec_offline = int(time.time()) - key.LastSeenTime.ref

        stamp = key.DmlTimeStamp.ref
        if 'Status' in machine:
            is_offline = machine.Status.ref == 1
        else:
            is_offline = True
        is_enabled = key.IsEnabled.ref
        os = {1: "Unknown", 2: "Windows", 3: "Windows", 4: "Linux", 5: "MacOS"}[machine.Info.OS.OSType.ref]
        os_name = machine.Info.OS.Name.ref
        architecture = {0: "Unknown", 1: "x86", 2: "x64"}[machine.Info.OS.ArchitectureEdition.ref]
        os_caps = ""
        if 'OSCaps' in machine.Info.OS:
            os_caps = get_os_caps(machine.Info.OS.OSCaps.ref)
        os_info = ""
        if 'ProductType' in machine.Info.OS:
            os_info = get_additional_info(machine.Info.OS.ProductType.ref)
        memory = 0
        processor = ""
        if 'Hardware' in machine.Info:
            memory = round(machine.Info.Hardware.MemorySize.ref / 1024 / 1024)
            processor = machine.Info.Hardware.ProcessorName.ref
            frequency = machine.Info.Hardware.ProcessorFrequency.ref
        update_available = False
        if 'UpdateState' in machine:
            update_available = machine.UpdateState.UpdateIsAvailable.ref

        address = ','.join([y.ref for i, y in machine.Info.ResidentialAddresses])
        public_key = ''
        plan_count = protections.get(agent_id, 0)
        if 'PublicKey' in key:
            public_key = str(key.PublicKey.ref)

        account = machine.Tenant.Locator.ref
        account_name = tenant_names.get(machine.Tenant.ID.ref, 'Not found')
        euc_name = tenant_names.get(machine.Tenant.ParentID.ref, 'Not found')
        report.append([account, euc_name, account_name, agent_id, machine_name, is_enabled, public_key, stamp, os_name, os, architecture, os_caps, os_info, memory, processor,
            frequency, address, agent_version, product, update_available, plan_count, last_connection_time_old, round(sec_offline_old / 86400), last_connection_time, round(sec_offline / 86400), is_offline])
    for r in report:
        print(';'.join([str(c) for c in r]))


def main():
    parser = acrobind.CommandLineParser()
    parser.append_processor(acrobind.OutputArgumentsProcessor())
    parser.add_argument('--connection', nargs=3, metavar=('HOST', 'USERNAME', 'PASSWORD'))

    #resource specific options
    parser.add_argument('-mi', '--check-machine-id', dest='machine_id', help='Show info about machine by its ID and related instances.\
    Use \'-f\' option to enable fix mode. Use \'-ru\' for resetting \'MachineIsProcessed\' property. \
    Use \'-ra\' to list running activities. Use \'-br\' for dropping connection. \
    Example: \'acropsh -m amsctl -mi A8B415CD-3259-4E71-A38B-DE136FBCF6CE\'.', required=False)
    parser.add_argument('-mn', '--check-machine-name', dest='machine_name', help='List all machines that match provided name.\
    Example: \'acropsh -m amsctl -mn MyMachine\'.', required=False)
    parser.add_argument('-ru', '--reset-update', dest='reset_update', action='store_true', help='Reset \'MachineIsProcessed\' property for MachineManagement::Machine.\
    Can be used with \'-mi\' option only. Example: \'acropsh -m amsctl -mi A8B415CD-3259-4E71-A38B-DE136FBCF6CE -ru\'.', required=False)
    parser.add_argument('-ra', '--running-activities', dest='running_activities', action='store_true', help='List all running activities for tenant or machine if it is ONLINE.\
    Can be used with \'-mi\' option only. Example: \'acropsh -m amsctl -mi A8B415CD-3259-4E71-A38B-DE136FBCF6CE -ra\'.', required=False)
    parser.add_argument('-br', '--break-connection', dest='break_connection', action='store_true', help='Drop connection with agent if it is connected.\
    Can be used with \'-mi\' option only. Example: \'acropsh -m amsctl -mi A8B415CD-3259-4E71-A38B-DE136FBCF6CE -br\'.', required=False)
    parser.add_argument('-in', '--check-instance-name', dest='instance_name', help='List all instances that match provided name.', required=False)
    parser.add_argument('-ii', '--check-instance-id', dest='instance_id', help='Show info about instance by its ID ans applied protections.', required=False)
    parser.add_argument('-dom', '--drop-orphaned-machines', dest='drop_orphaned_machines', help='Remove machines without tenant.\
    Can be used with \'-ti\' option.', action='store_true', required=False)
    parser.add_argument('-doi', '--drop-orphaned-instances', dest='drop_orphaned_instances', help='Remove instances without host.\
    Can be used with \'-ti\' option.', action='store_true', required=False)

    #tenant specific options
    parser.add_argument('-ti', '--check-tenant-id', dest='tenant_id', help='Show info about specified tenant and its related objects.\
    Use \'-qr\' for recalculating quotas usage. Use \'-ms\' for showing statistics object for this tenant. Use \'-ra\' for running activities. Example: \'acropsh -m amsctl -ti 13456\'.', required=False)
    parser.add_argument('-tn', '--check-tenant-name', dest='tenant_name', help='List tenants that match specified name.', required=False)
    parser.add_argument('-qr', '--quotas-reconcile', dest='quotas_reconcile', action='store_true', help='Recalculate quotas for account.\
    Can be used with \'-ti\' only. Use \'all\' for reconcile quotas on all accounts. Example: \'acropsh -m amsctl -ti 13456 -qr\'.', required=False)
    parser.add_argument('-ms', '--machine-statistics', dest='machine_statistics', action='store_true', help='Show MachineManagement::Statistics for account.\
    Can be used with \'-ti\' only. Example: \'acropsh -m amsctl -ti 13456 -ms\'.', required=False)
    parser.add_argument('--check-multitenancy', dest='check_multitenancy', action='store_true', help='Check if tenant has virtual instances that belong to hosts of different tenant')
    parser.add_argument('-u', '--update', dest='update', action='store_true', help='Update section \'.Tenant\' in all dml objects by specified tenant')
    #plans specific options
    parser.add_argument('-pn', '--plan-name', dest='plan_name', help='List all protection plans that match specified name.', required=False)
    parser.add_argument('-pi', '--plan-id', dest='plan_id', help='Show info about protection plan and related item protections.\
    Use \'-r\' for protection plan redeployment.', required=False)
    parser.add_argument('-r', '--redeploy', dest='redeploy', action='store_true', help='Force protection plan redeployment.\
    Can be used only with \'-pi\' option. Example: \'acropsh -m amsctl -pi E9A35C00-388F-4522-AD07-981139D6F9A3 -r\'.', required=False)
    parser.add_argument('--check-plan-list', dest='check_plan_list', help='List all protection plans that match specified name.', required=False)

    # Option for both tenants and plans
    parser.add_argument('-fcp', '--fix-centralized-protection', dest='fix_centralized_protection', action='store_true', help='Create missing Gtob::Dto::CentralizedProtection object.\
    Can be used only with \'-pi\' and \'-ti\' options. Example: \'acropsh -m amsctl -pi E9A35C00-388F-4522-AD07-981139D6F9A3 -fcp\'.', required=False)
    parser.add_argument('-o', '--change-owner', dest='change_owner', help='Change owner of Gtob::Dto::CentralizedProtection object.\
    Can be used only with \'-pi\' option. Example: \'acropsh -m amsctl -pi E9A35C00-388F-4522-AD07-981139D6F9A3 -o 102665\'.', required=False)

    #common options
    parser.add_argument('-f', '--fix', dest='fix', action='store_true', help='Enable fix mode. Can be used with other options.', required=False)
    parser.add_argument('-d', '--delete', dest='delete', action='store_true', help='Enable delete mode (interactive). Can be used with other options.', required=False)
    parser.add_argument('-e', '--extra', dest='extra', action='store_true', help='Prints extra data. Can be used with other options.', required=False)

    #auto update
    parser.add_argument('-bu', '--build-url', dest='build_url', help='List auto update using build url', required=False)
    parser.add_argument('-ui', '--update-id', dest='update_id', help='List auto update using id', required=False)
    parser.add_argument('-lu', '--list-updates', dest='list_updates', action='store_true', help='List all auto updates', required=False)

    #misc options
    parser.add_argument('-p1', '--parameter1', dest='parameter1', help='Custom parameter that can be used with other options.', required=False)
    parser.add_argument('-p2', '--parameter2', dest='parameter2', help='Custom parameter that can be used with other options.', required=False)
    parser.add_argument('--fix-instances', dest='fix_instances', help='Check/Fix instances statuses for specified tenant or \'all\'. \
    It checks all recent activities for last 24 hours or time period specifid using \'p1\' and \'p2\' options.\
    Use \'--fix-instances all\' for all tenants.\
    Use \'-f\' for fixing. Use\'p1\' for specifing the amount of days and \'p2\' for hours.\
    Example: \'--fix-instances all -f -p1 2 -p2 13\'', required=False)
    parser.add_argument('--check-sync', dest='check_sync', help='Check/Fix sync statuses for machines of specified tenant or \'all\'. \
    It checks most recent activitiy on AMS side and most recent activity on MMS side. If theirs \'FinishTime\' isn\'t equal and \'-f\' specified \
    connection to MMS will be dropped and it will cause re-sync. Use \'p1\' with any value to drop connection to old agent (<=6.0).', required=False)
    parser.add_argument('--check-deprecated-vms', dest='check_deprecated_vms', action='store_true', help='Checks existence of deprecated virtual instances (aka Red hat KVM and etc).\
    Use \'-f\' to force deletion of deprecated instances.', required=False)
    parser.add_argument('-sm', '--sync-monitor', dest='sync_monitor', help='Show sync statistics. Show summary if \'summary\' is specified. Show all channels if \'all\' specified.\
    Show specific machine channels if machine ID is specified. Example: \'watch acropsh -m amsctl -sm E9A35C00-388F-4522-AD07-981139D6F9A3\'.', required=False)
    parser.add_argument('-ps', '--perf-stat', dest='perf_stat', action='store_true', help='Show aggregated DML performance statistics using data from \'SERVICE_HOME_DIR/perf_stat\' folder.', required=False)
    parser.add_argument('-ds', '--dml-stat', dest='dml_stat', action='store_true', help='Show aggregated DML performance statistics using data from \'SERVICE_HOME_DIR/perf_stat\' folder.', required=False)
    parser.add_argument('-od', '--obsolete-data', dest='obsolete_data', action='store_true', help='Analyze objects consistency. May take a lot of time if run for \'all\'.\
    Use \'-p1\' for checking objects of specific tenant . Use \'p2\' for specifing action: \'ip\' - only check item protections, \'protection\' or \'all\'.\
    Example: \'acropsh amsctl.py -od  -p1 92271\'.', required=False)
    parser.add_argument('-ai', '--agent-info', dest='agent_info', action='store_true', help='Collect agents statistics and outputs it as JSON.', required=False)
    parser.add_argument('-usi', '--user-info', dest='user_info', action='store_true', help='Collect info about users and outputs it as JSON.', required=False)
    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true', help='Disable output to stdout except result.', required=False)
    parser.add_argument('-c', '--count', dest='count', help='Count objects. Specify \'machine-statistics\' for machine statistics or \'backup-statistics\' for backup statistics, \
    otherwise tries to count objects assumes input as \'Is\' value.\
    Example: \'acropsh amsctl.py -c Gtob::Dto::ItemProtection\'.', required=False)
    parser.add_argument('-s', '--status', dest='check_status', action='store_true', help='Check AMS status.', required=False)
    parser.add_argument('-bn', '--backup-notifications', dest='backup_notifications', action='store_true', help='Show information about backup notifications', required=False)
    parser.add_argument('-do', '--delete-object', dest='delete_object', help='Delete object by ID', required=False)
    parser.add_argument('--fix-all-centralized-protections', dest='fix_all_centralized_protections', action='store_true', help='Create missing Gtob::Dto::CentralizedProtection objects \
    for all plans', required=False)
    parser.add_argument('--report-all-instances', dest='report_all_instances', action='store_true', help='Output information about all instances')
    parser.add_argument('--report-all-machines', dest='report_all_machines', action='store_true', help='Report offline machines')

    config = None
    try:
        config = parser.parse_arguments()
    except acrort.Exception as exception:
        error = exception.to_error()
        ret = error.to_exit_code()
        if ret == acrort.common.EXCEPTION_AWARE_RETURN_CODE:
            error.throw()
        return ret

    global args
    args = config['args']

    try:
        global Log
        if args.quiet:
            Log = acrobind.NullOutput()
        else:
            Log = acrobind.Output(config, end='\n')

        if args.perf_stat:
            perf_stat()
            return

        if args.dml_stat:
            dml_stat()
            return

        if args.backup_notifications:
            check_notifications()
            return

        if args.connection:
            hostname = args.connection[0]
            username = args.connection[1]
            password = args.connection[2]
            Log.write('Connecting to AMS \'{0}@{1}\' ...'.format(username, hostname), end='')
            connection_args = ('ams', hostname, (username, password))
        else:
            Log.write('Connecting to AMS locally...', end='')
            connection_args = ('ams', )

        if args.check_status:
            check_status(connection_args)
            return

        connection = acrort.connectivity.Connection(*connection_args, client_session_data={"identity_disabled": True})
        Log.write('done')

        if args.count:
            counter_mode(connection)
            return
        if args.list_updates or args.build_url or args.update_id:
            analyze_updates(connection)
            return
        if args.user_info:
            collect_users_info(connection)
            return
        if args.agent_info:
            collect_agents_statistics(connection)
            return
        if args.obsolete_data:
            obsolete_data(connection)
            return
        if args.report_all_machines:
            report_all_machines(connection)
            return
        if args.quotas_reconcile:
            quotas_reconcile(connection)
            return
        if args.drop_orphaned_machines:
            drop_orphaned_machines(connection)
            return
        if args.drop_orphaned_instances:
            drop_orphaned_instances(connection)
            return
        if args.tenant_id:
            check_tenant(connection)
            return
        if args.tenant_name:
            list_tenants(connection)
            return
        if args.check_plan_list:
            check_plan_list(connection)
            return
        if args.plan_name or args.plan_id:
            describe_plans(connection)
            return
        if args.machine_name:
            list_machines(connection)
            return
        if args.instance_name:
            list_instances(connection)
            return
        if args.fix_instances:
            fix_instances(connection)
            return
        if args.check_sync:
            check_sync(connection)
            return
        if args.sync_monitor:
            sync_monitor(connection)
            return
        if args.check_deprecated_vms:
            check_deprecated_vms(connection)
            return
        if args.delete_object:
            delete_object(connection, args)
            return
        if args.fix_all_centralized_protections:
            fix_all_centralized_protections(connection)
            return
        if args.report_all_instances:
            report_all_instances(connection)
            return
        if args.report_all_machines:
            report_all_machines(connection)
            return
        if args.instance_id:
            check_instance(connection)
        if args.machine_id:
            check_machine(connection)

    except Exception as e:
        error_log(format_backtrace(e))


if __name__ == '__main__':
    exit(acrobind.interruptable_safe_execute(main))
UnknownSec Shell
