Gecko [ www.omxrelocation.in ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
auto_update.py	2.84 KB	-rw-r--r--
protect.py	408 B	-rw-r--r--
retention.py	8.86 KB	-rw-r--r--
retention_specs.py	1.25 KB	-rw-r--r--
run_tool.py	817 B	-rw-r--r--
staging.py	732 B	-rw-r--r--

Code Editor : retention.py

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)

${this.title}

Code Editor : retention.py