????
Your IP : 52.14.219.203
import acrobind
import acrort
import inspect
import os
import sys
import logging
def get_log_file():
return ""
def configure_logging():
log_file = get_log_file()
if log_file == "":
return
logger = logging.getLogger()
file_log_handler = logging.FileHandler(log_file)
logger.addHandler(file_log_handler)
def get_retention_specs(is_cloud):
file_name = inspect.getframeinfo(inspect.currentframe()).filename
dir_here = os.path.dirname(file_name)
sys.path.insert(0, dir_here)
if is_cloud:
from retention_specs import RETENTION_SPECS_CLOUD
return RETENTION_SPECS_CLOUD
else:
from retention_specs import RETENTION_SPECS_ONPREM
return RETENTION_SPECS_ONPREM
def get_objects_count(pattern, dml):
options = [('.Counter.CounterObjectTemplate.ID', 'guid', '936A68BE-4EE6-4AEB-B67F-1C2191CC9EAD'),
('.Counter.CounterObjectTemplate.ID^PrimaryKey', 'nil', None)]
count_result = dml.select1(acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=pattern), options=acrort.plain.Unit(flat=options)))
return count_result.CounterValue.ref
def fetch_value_by_name(obj, property_name):
for field in obj:
current_name = field[0]
if current_name == property_name:
property_value = field[1]
return property_value
return None
def is_root_id(activity_id):
return activity_id == '00000000-0000-0000-0000-000000000000'
def add_activity(activities, activity_id, parent_activity_id):
if activities.get(activity_id) is None:
activities.update({activity_id: set()})
if not is_root_id(parent_activity_id):
# The current activity is NOT a root, because has a parent
if activities.get(parent_activity_id) is None:
# The parent is not exist yet, lets create parent and add current activity as its child
activities.update({parent_activity_id: {activity_id}})
else:
# The parent is exist already, lets add current activity as its child
activities[parent_activity_id].add(activity_id)
def get_roots(activities):
result = set()
keys = activities.keys()
for activity_id in keys:
children = activities[activity_id]
if len(children) == 0:
result.add(activity_id)
return result
def collect_children(activities, activity_id):
children = activities.get(activity_id)
if children is None or len(children) == 0:
return set()
result = children.copy()
for child in children:
if child not in activities:
result.remove(child)
else:
tt = collect_children(activities, child)
result.update(tt)
return result
def traverse(activities, root_id, on_node):
children = activities.get(root_id)
if children is None or len(children) == 0:
on_node(root_id, 0)
return
on_node(root_id, 1)
for child in children.copy():
traverse(activities, child, on_node)
def clean_roots_and_tree(roots, activity_tree, root_id, sub_tree):
for activity_id in sub_tree:
if activity_id == root_id:
roots.remove(root_id)
if activity_id in activity_tree:
activity_tree.pop(activity_id,None)
else:
logging.getLogger().warning("activity_id {0} does not exists in activity_tree".format(activity_id))
def get_activities_specs(spec):
if spec["historical_order"] is True:
options = [('.SortingOptions.DmlTimeStamp', 'sqword', 0),
('.SortingOptions.DmlTimeStamp^Ascending', 'nil', None)]
activity_spec = acrort.dml.ViewSpec(pattern=acrort.plain.Unit(flat=spec["pattern"]),
options=acrort.plain.Unit(flat=options))
return activity_spec
def get_activities(connection, activity_spec):
activity_tree = dict()
roots = set()
activities = connection.dml.select(activity_spec)
for activity in activities:
activity_id = fetch_value_by_name(activity, 'ID')
if activity_id is None:
continue
get_activity_from_Root(activity_id, activity, activity_tree, roots)
get_activity_from_ParentProtectActivityID(activity_id, activity, activity_tree, roots)
return roots, activity_tree
def get_activity_from_ParentProtectActivityID(activity_id, activity, activity_tree, roots):
environment_value = fetch_value_by_name(activity, 'Environment')
if environment_value is None:
return
parent_activity_id = fetch_value_by_name(environment_value, 'ParentProtectActivityID')
if parent_activity_id is None:
return
activity_id = str(activity_id.ref)
parent_activity_id = str(parent_activity_id.ref)
add_activity(activity_tree, activity_id, parent_activity_id)
roots.add(parent_activity_id)
def get_activity_from_Root(activity_id, activity, activity_tree, roots):
property_value = fetch_value_by_name(activity, 'Origin')
if property_value is None:
return
parent_activity_id = fetch_value_by_name(property_value, 'ParentActivity')
if parent_activity_id is None:
return
activity_id = str(activity_id.ref)
parent_activity_id = str(parent_activity_id.ref)
add_activity(activity_tree, activity_id, parent_activity_id)
if is_root_id(parent_activity_id):
roots.add(activity_id)
def delete_activities(connection, activity_spec):
deleted_objects = 0
roots, activity_tree = get_activities(connection, activity_spec)
for root_id in roots.copy():
if root_id not in activity_tree:
continue
sub_tree = collect_children(activity_tree, root_id)
sub_tree.add(root_id)
deleted_activities = set()
if delete_activities_from_dml(connection, sub_tree):
deleted_activities = sub_tree
else:
# One or more activities could not be deleted.
# Try to delete activities one by one, traversing from the root to leaves.
def delete_and_collect_activity(activity_id, kind):
# token = "on_leaf" if kind == 0 else "on_node"
# logging.getLogger().warning("{0}({1})".format(token, activity_id))
if delete_activity_from_dml(connection, activity_id):
deleted_activities.add(activity_id)
traverse(activity_tree, root_id, delete_and_collect_activity)
clean_roots_and_tree(roots, activity_tree, root_id, deleted_activities)
deleted_objects += len(deleted_activities)
if len(activity_tree.keys()) > 0:
logging.getLogger().warning("Warning. Following activities are still retained {}".format(activity_tree.keys()))
return deleted_objects
def run_logic(connection, retention_specs):
deleted_objects = 0
# spec_index = 1
for spec in retention_specs:
# logging.getLogger().warning("spec{0}={1}".format(spec_index, spec))
# spec_index += 1
objects_limit = spec.get("objects_count_limit")
objects_count = get_objects_count(spec["pattern"], connection.dml)
need_to_delete = objects_count > objects_limit
if need_to_delete:
activity_spec = get_activities_specs(spec)
deleted_objects = delete_activities(connection, activity_spec)
# logging.getLogger().warning("deleted_objects {}".format(deleted_objects))
return deleted_objects
def delete_activity_from_dml(connection, activity_id):
try:
tt = acrobind.create_viewspec_by_is_and_guid_property('Tol::History::Plain::Activity', '.ID', activity_id)
connection.dml.delete(pattern=tt.pattern)
except:
logging.getLogger().warning("delete_activity_from_dml: Failed to delete activity {}".format(activity_id))
return False
return True
def delete_activities_from_dml(connection, activities):
try:
spec = acrobind.create_viewspec_by_is('Tol::History::Plain::Activity')
spec = acrobind.viewspec_apply_ids(spec, activities)
connection.dml.delete(pattern=spec.pattern)
except:
logging.getLogger().warning("delete_activities_from_dml: Failed to delete activities {}".format(activities))
return False
return True
def execute_retention(is_cloud, *args, **kw):
context = acrort.remoting.CommandContext(*args, **kw)
deleted_objects = run_logic(context.connection, get_retention_specs(is_cloud))
result = [('.DeletedObjectsCount', 'dword', deleted_objects)]
return acrort.plain.Unit(flat=result)
def execute_retention_cloud(*args, **kw):
configure_logging()
return execute_retention(True, *args, **kw)
def execute_retention_onprem(*args, **kw):
configure_logging()
return execute_retention(False, *args, **kw)