????
Your IP : 18.220.134.161
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))