Gecko [ www.omxrelocation.in ]

Name	Size	Permission
agents.py	36.7 KB	-rw-r--r--
amsctl.py	202.84 KB	-rw-r--r--
cep.py	26.85 KB	-rw-r--r--
change_machine_id.py	18.65 KB	-rw-r--r--
cleanup_backups.py	17.44 KB	-rw-r--r--
dmldump.py	1.61 KB	-rw-r--r--
gtobview.py	16.08 KB	-rw-r--r--
manage_creds.py	2.21 KB	-rw-r--r--
multi_mms.py	12.17 KB	-rw-r--r--
register_mms.py	1.88 KB	-rw-r--r--
set_logging.py	6.97 KB	-rw-r--r--
stdspecs.zip	13.63 KB	-rw-r--r--

Code Editor : agents.py

# -*- coding: utf-8 -*-

import os
import time

import argparse
import csv
import datetime
import json
import logging
import logging.handlers
import requests

now = datetime.datetime.now()

TITLE = """Install or update the agents in bulk."""
TIMEOUT = 10
LOG_FILENAME = 'agents.{}.log'.format(now.strftime('%y%m%d%H%M%S'))
LOG_FORMAT = "%(asctime)s - %(filename)s - %(levelname)s - %(message)s"
CRED_FIELDNAMES = ['hostname', 'username', 'password', 'unit']

IN_ENCODING = 'utf-8-sig'
OUT_ENCODING = 'utf-8'
STDOUT_FALLBACK_ENCODING = 'utf-8'

logger = logging.getLogger(__file__)

parser = None
params = None

_URL = None
_HEADERS = None

def safe_print(msg):
    """Usual print, but detect and workaround stdout encoding errors."""
    try:
        print(msg)
    except UnicodeEncodeError:
        print(str(msg).encode(STDOUT_FALLBACK_ENCODING))

def _init_logging():
    logger.setLevel(logging.DEBUG)
    # create file handler which logs even debug messages
    fh = logging.FileHandler(LOG_FILENAME, encoding=OUT_ENCODING)
    fh.setLevel(logging.DEBUG)
    # create console handler with a higher log level
    ch = logging.StreamHandler()
    ch.setLevel(logging.ERROR)
    # formatter
    fmt = logging.Formatter(LOG_FORMAT)
    fh.setFormatter(fmt)
    ch.setFormatter(fmt)
    # add the handlers to the logger
    logger.addHandler(fh)
    logger.addHandler(ch)

def _logging(method, msg, verbose=False, prefix=None):
    if verbose:
        if prefix:
            msg = prefix + msg
        safe_print(msg)
    method(msg)

def do(method, uri, payload=None):
    """Common function to make HTTP request."""
    url = _URL + uri

if payload is None:
        log_payload = '""'
    elif 'password' in payload:
        log_payload = payload.copy()
        log_payload['password'] = '***'
    else:
        log_payload = payload

logger.debug('URL: %s %s', method.__name__.upper(), url)
    logger.debug('PAYLOAD: %s', log_payload)

try:
        response = method(url, data=json.dumps(payload), headers=_HEADERS)
    except requests.exceptions.ConnectionError as err:
        _logging(logger.error, err)
        exit(1)

logger.debug('RESPONSE: %s %s', response, response.content)
    try:
        content = response.json()
    except json.decoder.JSONDecodeError:
        content = response.text

return response.status_code, content

class _TenantsHierarchy:
    # Information about all organizational units (aka tenants) accessible
    # by current user.
    #
    # Although all the tenants in the system form a tree, it may happen that
    # current user sees only several branches of this global tree. What he sees
    # is a set of several trees.

class Error(Exception):
        # TenantsTree-related exceptions
        def __init__(self, tenant_locator, err_msg, error_level=0):
            self._tenant_locator = tenant_locator
            self._err_msg = err_msg
            self._error_level = error_level

def __str__(self):
            return 'Error processing Organization Unit "{}": {}'.format(
                self._tenant_locator, self._err_msg)

def __init__(self, root_tenants_guids, tenant_names, subtenants):
        # Fetch information about all the available organizational units
        # Arguments:
        # - subtenants: {tenant_guid: [subtenant_guid, ]}
        self._root_tenants_guids = root_tenants_guids
        self._tenants_names = tenant_names  # {guid: name}

self._tenants_parents = {  # {tenant_guid: parent_tenant_guid}
            t_guid: None
            for t_guid in self._root_tenants_guids
        }
        for tenant, children in subtenants.items():
            for subtenant in children:
                assert subtenant not in self._tenants_parents, (
                    "Tenant {} has more than one parent: {} and {}".format(
                        subtenant, tenant, self._tenants_parents[subtenant])
                )
                self._tenants_parents[subtenant] = tenant

self._subtenants_by_name = {  # {tenant_guid: {subtenant_name: subtenant_guid}}
            tenant: {
                self._tenants_names[subtenant_guid]: subtenant_guid
                for subtenant_guid in children
            }
            for tenant, children in subtenants.items()
        }
        self._root_tenants_by_name = {}  # {root_tenant_name: [guid, ]}
                                         # Because root tenant names can duplicate
        for root_guid in self._root_tenants_guids:
            name = self._tenants_names[root_guid]
            self._root_tenants_by_name.setdefault(name, []).append(root_guid)

self._tenant_to_guid_cache = {}  # cached results

@classmethod
    def read_tenants_tree(cls, session):
        """_TenantsHierarchy constructor. (information is fatched from AMS)."""

tenants_names = {}
        subtenants = {}

# get current (default) tenant info
        status_code, response = do(session.get, "/api/gateway/session")
        assert status_code == 200, "Can't get organization units list"
        default_tenant_id = response['current_tenant']

# get list of all possible root tenants
        status_code, response = do(
            session.get, "/api/account_server/users/self/access_policies")
        assert status_code == 200, "Can't get organization units list"
        potential_root_tenants = set(item.get('tenant_id') for item in response['items'])

potential_root_tenants.add(default_tenant_id)

for root_tenant_guid in potential_root_tenants:
            # depth-first-search all available tenants
            tenants_stack = [[root_tenant_guid, ], ]
            positions = [0,  ]

while tenants_stack:
                if positions[-1] >= len(tenants_stack[-1]):
                    tenants_stack.pop()
                    positions.pop()
                    continue

cur_guid = tenants_stack[-1][positions[-1]]
                positions[-1] += 1

if cur_guid in tenants_names:
                    # this tenant was processed previously.
                    # the situation is possible if one of potential root tenants is
                    # actually a child of another one.
                    continue

# get tenant properties
                status_code, response = do(
                    session.get, "/api/account_server/tenants/{}".format(cur_guid))
                assert status_code == 200, "Can't get tenant details"

tenants_names[cur_guid] = response['name']

# get children
                status_code, response = do(
                    session.get,
                    "/api/account_server/tenants/{}/children".format(cur_guid))
                assert status_code == 200, "Can't get tenant's children"

cur_subtenants = response['items']
                subtenants[cur_guid] = cur_subtenants

if cur_subtenants:
                    tenants_stack.append(cur_subtenants)
                    positions.append(0)

# leave only really root tenants
        all_subtenants = set(
            tenant_guid
            for _, subtenants_list in subtenants.items()
            for tenant_guid in subtenants_list)

root_tenants_guids = [x for x in potential_root_tenants - all_subtenants]
        root_tenants_guids.sort()

assert root_tenants_guids, "Can't get root organization unit(s)"

return cls(root_tenants_guids, tenants_names, subtenants)

def find_tenant_by_name(self, tenant_locator):
        """Get tenant guid by tenant name or path.

tenant_locator may be:
        - full tenant path ("Organization/Unit Number 1/some subtenant")
        - just name of the tenant without path (ok, if there are no
          name duplicates.)
        - tenant's guid (in this case it is returned as is)
        """

if tenant_locator not in self._tenant_to_guid_cache:
            try:
                guid = self._find_tenant_by_name(tenant_locator)
                self._tenant_to_guid_cache[tenant_locator] = guid
            except self.Error as err:
                self._tenant_to_guid_cache[tenant_locator] = err

result = self._tenant_to_guid_cache[tenant_locator]
        if isinstance(result, self.Error):
            raise result

return result

def _find_tenant_by_name(self, tenant_locator):
        # helper for find_tenant_by_name method.

path_chunks = self._split_tenant_path(tenant_locator)

if len(path_chunks) == 1:
            # it's not a path, but just a tenant name
            tenant_name = path_chunks[0]
            if tenant_name in self._tenants_names:
                return tenant_name  # it's not a name but tenant's guid.
            guids = self._find_tenants_by_name(tenant_name)
            if not guids:
                raise self.Error(
                    tenant_locator,
                    'Organization Unit "{}" not found'.format(tenant_name))
            elif len(guids) == 1:
                # fine, single match!
                return guids[0]
            else:
                raise self.Error(
                    tenant_locator,
                    'Ambiguous Organization Unit name "{}". '
                    'It corresponds to units: {}. '
                    'To avoid ambiguity specify full '
                    'Organization Unit path.'.format(tenant_name, guids))

# need to find tenant by path

# skip first and last empty chunks - corresponding to optional "/" in the
        # start or end of locator.
        if not path_chunks[0]:
            path_chunks.pop(0)
        if not path_chunks[-1]:
            path_chunks.pop()

if not path_chunks:
            raise self.Error(tenant_locator, "Invalid unit locator")  # looks like single slash

# find the apropriate root tenant(s)
        root_chunk = path_chunks[0]
        if root_chunk in self._root_tenants_guids:
            # this is not a name of root chunk, but guid
            roots_to_check = [root_chunk, ]
        else:
            roots_to_check = self._root_tenants_by_name.get(root_chunk)

if not roots_to_check:
            err_msg = '"{}" is not a root Organization Unit.'.format(root_chunk)
            raise self.Error(tenant_locator, err_msg)

problems_by_root = []  # [error, ]
        for current_root_guid in roots_to_check:
            try:
                return self._find_tenant_by_path(current_root_guid, path_chunks)
            except self.Error as err:
                err._tenant_locator = tenant_locator
                problems_by_root.append(err)

# We tried to look for the tenant starting from each appropriate tenant and
        # all the attempts failed. But only one error should be reported. Let's report
        # the 'deepest' error.
        error_to_report = problems_by_root[0]
        for err in problems_by_root:
            if err._error_level > error_to_report._error_level:
                error_to_report = err

raise error_to_report

def _find_tenant_by_path(self, root_guid, path_chunks):
        # ["path", "to", "tenant"] -> tenant_guid
        #
        # Search starting from the specified root tenant.
        # It is supposed (but not verified) that the first element of path
        # corresponds to the root_guid.

cur_tenant_guid = root_guid
        current_depth = 0
        for cur_tenant_name in path_chunks[1:]:
            current_depth += 1
            next_tenant_guid = None
            if cur_tenant_name in self._tenants_names:
                # this is actually not a name, but guid
                # just need to check it is really a child of current tenant
                if self._tenants_parents[cur_tenant_name] == cur_tenant_guid:
                    next_tenant_guid = cur_tenant_name
            else:
                next_tenant_guid = self._subtenants_by_name[cur_tenant_guid].get(cur_tenant_name)

if not next_tenant_guid:
                # child tenant was not found!
                err_msg = (
                    '"{}" is not a child of "{}" Organization Unit. '
                    'List of existing children: {}').format(
                        cur_tenant_name,
                        self._make_full_tenant_name(cur_tenant_guid),
                        self._get_subtenants_names(cur_tenant_guid)
                    )
                raise self.Error("", err_msg, current_depth)

cur_tenant_guid = next_tenant_guid

if not cur_tenant_guid:
            raise self.Error("", "Invalid unit locator")

return cur_tenant_guid

def _find_tenants_by_name(self, tenant_name):
        # tenant_name (not full path!) -> list of tenants guids
        return [
            guid
            for guid, name in self._tenants_names.items()
            if tenant_name == name]

def _make_full_tenant_name(self, tenant_guid):
        # tenant_guid -> "Organization/Unit 1/SubUnit5"
        cur_tenant_guid = tenant_guid
        unit_names = []
        while cur_tenant_guid:
            unit_names.append(self._tenants_names[cur_tenant_guid])
            cur_tenant_guid = self._tenants_parents[cur_tenant_guid]

unit_names = [
            name if "/" not in name else '"name"'
            for name in reversed(unit_names)]

return "/".join(name for name in unit_names)

def _get_subtenants_names(self, tenant_guid):
        # returns list of all the parents of specified tenant
        return [
            self._tenants_names[guid]
            for guid, parent_guid in self._tenants_parents.items()
            if parent_guid == tenant_guid]

@staticmethod
    def _split_tenant_path(tenant_locator):
        # "path/to/unit" -> "path"; "to"; "unit"

# fixme: support escape characters
        return tenant_locator.split("/")

def create(session):
    """Establish the web session."""
    payload = {
        'machine': params.ams,
        'username': params.username,
        'password': params.password,
        'remember': False,
        'type': 'ams',
        'NonRequiredParams': ['username', 'password'],
    }
    msg = 'Establish a web session for {}'.format(params.username)
    _logging(logger.info, msg, params.verbose)
    status_code, response = do(session.post, '/api/ams/session', payload)
    if status_code != 200:
        msg = 'Connection to AMS failed: {}.'.format(params.ams)
        _logging(logger.debug, msg, verbose=True)
        exit(2)
    return response

def lola_register(session, hostname, username, password, action):
    """Returns entry_id as a string."""
    uri = '/api/ams/user_profiles/current/credentials'
    payload = {
        'address': hostname,
        'userName': username,
        'password': password,
        'category': action,
        'temporary': True
    }
    msg = 'Set the credentials for {} into LOLA'.format(username)
    _logging(logger.info, msg, params.verbose)
    return do(session.post, uri, payload)

def make_subscription(session):
    """Creates a subscription."""
    msg = 'Create a subscription'
    _logging(logger.info, msg, params.verbose)
    return do(session.post, '/api/subscriptions')

def get_subscription(session, subscription_id):
    """Gets a content of the subsription."""
    uri = '/api/subscriptions/{}'.format(subscription_id)
    payload = {
        'timeout': TIMEOUT,
        'action': 'pop',
    }
    msg = 'Check the subscription {}.'.format(subscription_id)
    _logging(logger.info, msg, params.verbose)
    return do(session.post, uri, payload)

def bind_activity(session, activity_id, subscription_id):
    """Binds the activity with the subscription."""
    uri = '/api/ams/activities/{}?isRootActivity=true&subscriptionId={}'
    uri = uri.format(activity_id, subscription_id)
    msg = 'Bind the activity {} on the subscription {}.'.format(activity_id, subscription_id)
    _logging(logger.info, msg, params.verbose)
    return do(session.get, uri)

def install_agent_win(session, hostname, unit_id, subscription_id):
    """Returns activity_id as a string."""
    payload = {
        'subscriptionId': subscription_id,
        'operationId': hostname,
        'machines': [
            {
                'address': hostname,
                'agents': [
                    'agentForWindows',
                ],
                'registrationAddress': params.ams,
                'tenantId': unit_id,
                'NonRequiredParams': [],
            }
        ],
        'NonRequiredParams': [],
    }
    msg = 'Install agent on {}'.format(hostname)
    _logging(logger.info, msg, params.verbose)
    return do(session.post, '/api/ams/infrastructure/agents', payload)

def host_list():
    reader = csv.DictReader(params.agents, fieldnames=CRED_FIELDNAMES,
                            delimiter=' ', restkey='_unexpected', skipinitialspace=True)
    for n, line in enumerate(reader):
        if n == 0:
            if all(line.get(col_name) in (col_name, None) for col_name in CRED_FIELDNAMES):
                # this is a header line
                continue

hostname = line['hostname']
        username = params.use_username if params.use_username else line['username']
        password = params.use_password if params.use_password else line['password']
        org_unit = params.use_unit if params.use_unit else line['unit']

if not hostname:
            # empty string - ignore
            continue

if hostname and hostname.startswith('#'):
            # this is a comment
            continue

if n == 0 and "," in hostname:
            raise Exception(
                "Hostname '{}' contains comma character and is invalid. "
                "Make sure the input file is space-delimited.".format(hostname))

if username is None:
            raise Exception("Username is not specified for host '{}'".format(hostname))

if password is None:
            raise Exception("Password is not specified for host '{}'".format(hostname))

if '_unexpected' in line:
            raise Exception(
                "Information for host '{0}' contains unexpected trailing characters:\n{1}\n\n"
                "Make sure values containig spaces are enclosed into double quotes.".format(
                    hostname, line['_unexpected']))

yield hostname, username, password, org_unit

def get_agent_ids(session):
    msg = 'Get information about agents'
    _logging(logger.info, msg, params.verbose)
    return do(session.get, '/api/ams/infrastructure/agents')

def update_agent(session, username, password, agent_id):
    """Run update of agents.

:param session: The web session object.
    :param username: Agent's username.
    :param password: Agent's password.
    :param agent_ids: The agents' ID.
    """

payload = {
        'credentials': {
            'userName': username,
            'password': password,
        },
        'machinesIds': [agent_id],
    }
    msg = 'Update agent: {}.'.format(agent_id)
    _logging(logger.info, msg, params.verbose)
    return do(session.post, '/api/ams/resource_operations/run_auto_update', payload)

class ReportedActivityState:
    # activity properties (as reported by wcs subscription)
    def __init__(self, activity_id, title, state, status, progress,
                 problem_effect, problem_cause):
        self.activity_id = activity_id
        self.title = title
        self.state = state
        self.status = status
        self.progress = progress
        self.problem_effect = problem_effect  # populated in case of failure
        self.problem_cause = problem_cause    #

def __str__(self):
        fmt = "[{} {}]: {}"
        if self.state == 'completed':
            if self.status == 'ok':
                msg = "Completed with status {}".format(self.status)
            else:
                msg = "Completed with status {}: {}: {}".format(
                    self.status,
                    self.problem_effect or "unknown effect",
                    self.problem_cause or "unknown cause")
        else:
            msg = "State {}; Progress {}".format(self.state, self.progress)
        return fmt.format(self.activity_id, self.title, msg)

@classmethod
    def from_subscr_item(cls, subscr_item):
        # item received through wcs subscription -> ActivitiState (or None)
        data = subscr_item.get('data')
        if not data:
            return None

activity_id = subscr_item.get('key') or data.get('id')
        if not activity_id:
            return None # this item does not correspond to activity

return ReportedActivityState(
            activity_id,
            data.get('title', '- unknown -'),
            data.get('state'),
            data.get('status'),
            data.get('progress'),
            cls._get_by_path(data, 'completionResult/effect'),
            cls._get_by_path(data, 'completionResult/cause'),
        )

@staticmethod
    def _get_by_path(o, path):
        # parser helper
        if not isinstance(path, list):
            path = path.split('/')
        node, tail = path[0], path[1:]
        value = o.get(node)
        return _get_by_path(value, tail) if isinstance(value, dict) else value

class ActivitiesMonitor:
    # Monitors state of activities associated with install/update operations

def __init__(self):
        self.activity2host = {}  # all registered activities
        self.session = None
        self.subscription_id = None

self.waiting_activities = set()
        self.activities_problems = {}

def register_activity(self, host_id, activity_id):
        assert not self.is_started()
        self.activity2host[activity_id] = host_id

def is_started(self):
        return self.session is not None

def start(self, session):
        assert not self.is_started()
        self.session = session

# New subscription should be created for activities monitoring.
        # The subscription created when starting install/upgrade operations
        # may be expired by now.
        _code, data = make_subscription(session)
        if not isinstance(data, dict):
            raise RuntimeError("Can't create subscription for activities monitor")
        self.subscription_id = data['id']

# bind all the registered activities to subscription to get updates when
        # activity state changes
        for activity_id in self.activity2host:

status_code, sub_response = bind_activity(self.session, activity_id, self.subscription_id)
            if status_code != 200:
                logger.error(
                    "Activity binding faild {} (for {})",
                    activity_id,
                    self.activity2host[activity_id])
                self.activities_problems[activity_id] = "Failed to trace status"
                continue

self.waiting_activities.add(activity_id)

# response may contain activity status
            activity = ReportedActivityState.from_subscr_item(sub_response)
            if activity:
                self._process_activity_update(activity)

def _get_activities_updates(self):
        # yield ReportedActivityState objects for updated activities
        assert self.is_started()
        status_code, response = get_subscription(self.session, self.subscription_id)
        if status_code != 200:
            return

for subscr_item in response:
            activity = ReportedActivityState.from_subscr_item(subscr_item)
            if activity:
                yield activity

def _process_activity_update(self, activity):
        # process ReportedActivityState
        if activity.activity_id not in self.activity2host:
            logger.debug("Unknown activity %s encountered", activity.activity_id)
            return

if activity.state == 'completed':
            try:
                self.waiting_activities.remove(activity.activity_id)
            except KeyError:
                logger.debug("Unexpected completed activity %s", activity.activity_id)

if activity.status == 'ok':
                _logging(logger.info, self._make_activity_descr(activity), verbose=True)
            else:
                msg = self._make_activity_descr(activity)
                self.activities_problems[activity.activity_id] = msg
                _logging(logger.error, msg, verbose=True)
            return

# activity is not completed yet. Just log current status
        logger.debug(self._make_activity_descr(activity))

def check_updates(self):
        # returns if all the activities completed
        for activity in self._get_activities_updates():
            self._process_activity_update(activity)

def _make_activity_descr(self, activity):
        return "{} {}".format(self.activity2host.get(activity.activity_id, "- ?? -"),
                              str(activity))

def all_completed(self):
        return not self.waiting_activities

def problems_detected(self):
        return len(self.activities_problems) > 0

def install(session, subscription_id):
    activities_monitor = ActivitiesMonitor()
    tenants_set = None  # will be initialized on demand

failures = {}  # {hostname: problem_descr}

for hostname, username, password, org_unit in host_list():

if org_unit:
            if tenants_set is None:
                tenants_set = _TenantsHierarchy.read_tenants_tree(session)
            try:
                org_unit = tenants_set.find_tenant_by_name(org_unit)
            except _TenantsHierarchy.Error as err:
                failures[hostname] = "Invalid organization unit {} specified".format(org_unit)
                _logging(logger.error, str(err), params.verbose)
                continue

status_code, response = lola_register(session, hostname, username, password, 'windows_remote_install')
        if not status_code == 200:
            msg = 'Lola register {} failed.'.format(hostname)
            failures[hostname] = msg
            _logging(logger.error, msg, params.verbose)
            continue

status_code, response = install_agent_win(session, hostname, org_unit, subscription_id)
        if not status_code == 200:
            msg = 'Install on {} failed.'.format(hostname)
            failures[hostname] = msg
            _logging(logger.error, msg, params.verbose)
            continue

activity_id = response.get('reminst_result', {}).get('activity_id', None)

if activity_id:
            # some remote installation really happens
            _logging(logger.info,
                     'Hostname[{}] -> Activity[{}]'.format(hostname, activity_id),
                     verbose=True)
            activities_monitor.register_activity(hostname, activity_id)

if not params.wait:
        return True

safe_print('Waiting...')
    activities_monitor.start(session)
    while not activities_monitor.all_completed():
        time.sleep(TIMEOUT)
        activities_monitor.check_updates()
        num_waiting = len(activities_monitor.waiting_activities)
        _logging(logger.debug,
                 "Waiting for {} {}...".format(
                     num_waiting,
                     "activity" if num_waiting == 1 else "activities"),
                 params.verbose)

problems_detected = failures or activities_monitor.problems_detected()

return not problems_detected

def update(session, subscription_id):
    activities_monitor = ActivitiesMonitor()
    status_code, response = get_agent_ids(session)
    if not status_code == 200:
        msg = 'Get agent ids for {} failed.'.format(params.ams)
        logger.error(msg)
        raise RuntimeError(msg)

agents_map = {}

creds = {hostname: (username, password)
             for hostname, username, password, _org_unit in host_list()}

for item in response['data']:
        ip = item['Attributes']['ResidentialAddresses'][0]
        name = item['Attributes']['Name'].lower()
		
        try:
            installed_version = item['Attributes']['Agents'][0]['Version']
        except:
            installed_version = None

if item['Attributes']['Status'] and installed_version and installed_version >= "12":
            # Skip update of offline agents (Status: 0 - online, 1 - offline)
            # Agents of old version should be upgraded even if they are reported offline.
            msg = 'Agent on {} is offline. Skipping...'.format(ip)
            _logging(logger.info, msg, verbose=True)
            continue
        if not item['Attributes']['UpdateIsAvailable']:
            msg = 'No update will be applied for agent on {}. Skipping...'.format(ip)
            _logging(logger.info, msg, verbose=True)
            continue

update_version = item['Attributes'].get('UpdateVersion', None)
        if update_version and update_version == installed_version:
            msg = 'Agent on {} is up to date. Skipping...'.format(ip)
            _logging(logger.info, msg, verbose=True)
            continue

local_id = item['ID']['LocalID']
        if ip not in creds and name.lower() not in creds:
            msg = 'No record for agent on {} in the credentials file. Skipping...'.format(ip)
            _logging(logger.info, msg, verbose=True, prefix='\t')
            continue

username, password = creds[ip] if ip in creds else creds[name]
			
        agent_info = {
            'machine_id': local_id,
            'name': item['DisplayedName'],
            'ip': ip,
            'username': username,
            'password': password,
        }
        agents_map[local_id] = agent_info
        msg = 'Agent on {} will be updated!'.format(ip)
        _logging(logger.info, msg, verbose=True)

if len(agents_map) == 0:
        msg = 'Nothing to update!'
        _logging(logger.info, msg, verbose=True)
        return True

for agent_id, agent_info in agents_map.items():
        status_code, response = update_agent(
            session, agent_info['username'], agent_info['password'], agent_id)

if not params.wait:
            continue

for info in response['data']:
            agent_id = info['machine_id']
            activity_id = info['activity_id']

activities_monitor.register_activity(agent_id, activity_id)

if not params.wait:
        return True

safe_print('Waiting...')
    activities_monitor.start(session)
    while not activities_monitor.all_completed():
        time.sleep(TIMEOUT)
        activities_monitor.check_updates()
        _logging(logger.debug,
                 "Waiting for {} {}...".format(
                     num_waiting,
                     "activity" if num_waiting == 1 else "activities"),
                 params.verbose)

return not activities_monitor.problems_detected()

TPL_MACHINE = 'hostname="{}", username="{}", password="{}"'

def main():
    _init_logging()

global _URL, _HEADERS
    _URL = 'http://{}:{}'.format(params.ams, params.port)
    _HEADERS = {
        'content-type': 'application/json',
        'Origin': _URL,
    }

with requests.Session() as session:
        data = create(session)

if params.list:
            status_code, response = get_agent_ids(session)
            if not status_code == 200:
                msg = 'Get agent ids for {} failed.'.format(params.ams)
                logger.error(msg)
                raise RuntimeError(msg)

if params.dump:
                writer = csv.DictWriter(params.dump, fieldnames=CRED_FIELDNAMES, delimiter=' ')
                writer.writeheader()

unique_hostnames = set()
            for item in response['data']:
                attributes = item['Attributes']
                for agent in attributes['Agents']:
                    if agent['Name']:
                        ip_address = attributes['ResidentialAddresses'][0]
                        data = {
                            'version': agent['Version'],
                            'ip': ip_address,
                            'name': attributes['Name'],
                            'title': agent['Name'],
                        }
                        safe_print('{name}\t{ip}\t{title}\t{version}'.format(**data))
                        if params.dump:
                            if ip_address in unique_hostnames:
                                continue
                            unique_hostnames.add(ip_address)
                            writer.writerow({
                                'hostname': ip_address,
                                'username': params.dump_username,
                                'password': params.dump_password
                            })
            if params.dump:
                tpl = '-----\nThe agents list was dumped to "{}" file in CSV format.'
                safe_print(tpl.format(params.dump.name))
            return

status_code, data = make_subscription(session)
        if not isinstance(data, dict):
            raise RuntimeError('See log file.')

subscription_id = data.get('id')

if params.install:
            install(session, subscription_id)
        elif params.update:
            update(session, subscription_id)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=TITLE)
    parser.add_argument('-v', '--verbose', help='Make this script verbose.',
                        action='store_true', default=False)

ams_group = parser.add_argument_group('connection')
    ams_group.add_argument('-a', '--ams', required=True,
                           help='AMS\' IP address or hostname.')
    ams_group.add_argument('-p', '--port', help='AMS\' port.', default=9877)
    ams_group.add_argument('--username', help='AMS\' username.', required=True)
    ams_group.add_argument('--password', help='AMS\' password.', required=True)

main_group = parser.add_argument_group('install or update')
    group = main_group.add_mutually_exclusive_group()
    group.add_argument('-i', '--install', action='store_true',
                       default=False, help='Do install.')
    group.add_argument('-u', '--update', action='store_true',
                       default=False, help='Do update.')

main_group.add_argument('--agents', type=argparse.FileType('r', encoding=IN_ENCODING),
                            help='Space-delimited CSV file containing list of hostnames and credentials. '
                            'Used for both install and update operations. '
                            'Each line should contain hostname, username and password in this order.')
    main_group.add_argument('--use_username',
                            help='Default username for agents, has a priority over file.')
    main_group.add_argument('--use_password',
                            help='Default password for agents, has a priority over file.')
    main_group.add_argument('--use_unit',
                            help='Default organization unit for installing agents, '
                            'has a priority over file. Ignored by "update" command')
    main_group.add_argument('--wait', help='Waiting until complete.',
                            action='store_true', default=False)

listing_group = parser.add_argument_group('agent listing')
    listing_group.add_argument('-l', '--list', help='Listing the agents with versions.',
                               action='store_true', default=False)
    listing_group.add_argument('--dump', nargs='?',
                               type=argparse.FileType('w', encoding=OUT_ENCODING),
                               help='Dump agents to file, dump_agent.csv by default.',
                               const='dump_agent.csv')
    listing_group.add_argument('--dump_username', default='Administrator',
                               help='Default username for agents')
    listing_group.add_argument('--dump_password', default='top_secret_password',
                               help='Default password for agents')
    params = parser.parse_args()

if not any([params.list, params.install, params.update]):
        safe_print('\nPlease specify one of the following commands: --install, --update, --list')
        parser.print_help()
        os.sys.exit(1)

if (params.install or params.update) and not params.agents:
        safe_print('\nPlease, provide credentials information with --agent option.')
        safe_print('You may generate the appropriate file with -l option. See below...\n')
        parser.print_help()
        os.sys.exit(2)

main()

${this.title}

Code Editor : agents.py