GIF89a=( �' 7IAXKgNgYvYx\%wh&h}t�h%�s%x�}9�R��&�0%� (�.��5�SD��&�a)�x5��;ͣ*ȡ&ղ)ׯ7׵<ѻ4�3�H֧KͯT��Y�aq��q��F� !� ' !� NETSCAPE2.0 , =( ��pH,�Ȥr�l:xШtJ�Z�جv��z��xL.:��z�n���|N�����~�������& !�0`9R�}��"�"a:S�~x��������g���E�������R���E����B�� ��ȸ��D���"�Ů� �H��L��D٫D�B�����D���T���H �G��A R�ڐ |�� ٭&��E8�S�kG�A�px�a��� R2XB��E8I���6X�:vT)�~��q�賥��"F~%x� � 4#Z�0O|-4Bs�X:= Q� Sal��yXJ`GȦ|s h��K3l7�B|�$'7Jީܪ0!��D�n=�P� ����0`�R�lj����v>���5 �.69�ϸd�����nlv�9��f{���Pbx �l5}�p� ��� �3a���I�O����!ܾ���i��9��#��)p�a ޽ �{�)vm��%D~ 6f��s}Œ�D�W E�`!� �&L8x� �ܝ{)x`X/>�}m��R�*|`D�=�_ ^�5 !_&'a�O�7�c��`DCx`�¥�9�Y�F���`?��"� �n@`�} lď��@4>�d S �v�xN��"@~d��=�g�s~G��� ���ud &p8Q�)ƫlXD����A~H�ySun�j���k*D�LH�] ��C"J��Xb~ʪwSt}6K,��q�S:9ت:���l�@�`�� �.۬�t9�S�[:��=`9N����{¿�A !R�:���6��x�0�_ �;������^���#����!����U���;0L1�����p% A��U̬ݵ��%�S��!���~`�G���� ���=4�np�3���������u�u�ٮ|%2�I��r�#0��J``8�@S@5� ���^`8E�]�.�S���7 � �0�j S�D� z���i�S�����!���l��w9*�D�I�nEX��� &A�Go�Qf��F��;���}�J����F5��Q|���X��T��y���]� o ��C=��:���PB@ D׽S�(>�C�x}`��xJЬ�۠��p+eE0`�}`A �/NE�� �9@��� H�7�!%B0`�l*��!8 2�%� �:�1�0E��ux%nP1�!�C)�P81l�ɸF#Ƭ{����B0>�� �b�`��O3��()yRpb��E.ZD8�H@% �Rx+%���c� ���f��b�d�`F�"8�XH"��-�|1�6iI, 2�$+](A*j� QT�o0.�U�`�R�}`�SN����yae�����b��o~ S)�y�@��3 �tT�0�&�+~L�f"�-|�~��>!�v��~�\Q1)}@�}h#aP72�"�$ !� " , =( &7IAXG]KgNgYvYxR"k\%w]'}h}t�h%�g+�s%r.m3ax3�x�}9��&��+�!7�0%� (�.�SD��&��;�"&ײ)׻4��6�K� �@pH,�Ȥr�l:xШtJ�Z�جv��z��xL.:��z�n���|N�����~�������& !�0`9R�}��"�"a:S�~x��������g �� E �� �������E �´��C���ǶR��D��"Ʒ�ʱH��M��GڬD�B����D��T����G���C�C� l&�~:'�tU�6ɹ#��)�'�.6�&��Ȼ K(8p0N�?!�2"��NIJX>R��OM '��2�*x�>#n� �@<[:�I�f ��T���Cdb��[�}E�5MBo��@�`@��tW-3 �x�B���jI�&E�9[T&$��ﯧ&"s��ȳ����dc�UUρ#���ldj?����`\}���u|3'�R]�6 �S#�!�FKL�*N E���`$�:e�YD�q�.�촁�s \-�jA 9�����-��M[�x(�s��x�|���p��}k�T�DpE@W� ��]k`1� ���Yb ��0l��*n0��"~zBd�~u�7�0Bl��0-�x~|U�U0 �h�*HS�|��e"#"?vp�i`e6^�+q��`m8 #V�� ��VS|`��"m"сSn|@:U���~`pb�G�ED����2F�I�? >�x� R� ��%~jx��<�a�9ij�2�D��&: Z`�]w���:�6��B�7eFJ|�ҧ�,���FǮcS�ʶ+B�,�ܺN���>PAD�HD��~���n��}�#�� Q��S���2�X�{�k�lQ�2�����w�|2� h9��G�,m���3��6-��E�L��I�³*K���q�`DwV�QXS��peS��� qܧTS����R�u �<�a�*At�lmE� � ��N[P1�ۦ��$��@`��Dpy�yXvCAy�B`}D� 0QwG#� �a[^�� $���Ǧ{L�"[��K�g�;�S~��GX.�goT.��ư��x���?1z��x~:�g�|�L� ��S`��0S]P�^p F<""�?!,�!N4&P� ����:T�@h�9%t��:�-~�I<`�9p I&.)^ 40D#p@�j4�ج:�01��rܼF2oW�#Z ;$Q q  �K��Nl#29 !F@�Bh�ᏬL!XF�LHKh�.�hE&J�G��<"WN!�����Y@� >R~19J"�2,/ &.GXB%�R�9B6�W]���W�I�$��9�RE8Y� ��"�A5�Q.axB�&ة�J�! �t)K%tS-�JF b�NMxL��)�R��"���6O!TH�H� 0 !� ) , =( &AXKgNgYvYxR"k\%wh&h}h%�g+�s%r.x3�x�}9��&��+�R,�!7�0%� (�.��5��&�a)��;�"&ף*Ȳ)ׯ7׻4�3��6�H֧KͻH�T��Y��q��h� ��pH,�Ȥr�l:xШtJ�Z�جv��z��xL.:��z�n���|N�����~�������& !�0`9R�}��"�"a:S�~x��������g �� E$����� � ����$E$��"��D� � ������R��C��� E ��H�M��G�D� �B��ϾD��a��`1r��Ӑ�� �o~�zU!L�C'�yW�UGt����ll�0���uG�)A�s[��x� �xO%��X2�  P�n:R/��aHae+�Dm?# ǣ6�8�J�x�Di�M���j���5oQ7�- <! *�l��R2r/a!l)d� A"�E���� &� ;��c �%����b��pe~C"B���H�eF2��`8qb�t_`ur`e� w�u3��Pv�h""�`�Íx�LĹ��3� �~ֺ�:���MDfJ� �۵�W�%�S�X �؁)�@��:E��w�u�Sxb8y\m�zS��Zb�E�L��w!y(>�"w�=�|��s�d �C�W)H�cC$�L �7r.�\{)@�`@ �X�$PD `aaG:���O�72E�amn]�"Rc�x�R� &dR8`g��i�xLR!�P &d����T���i�|�_ � Qi�#�`g:��:noM� :V �)p����W&a=�e�k� j���1߲s�x�W�jal|0��B0�, \j۴:6���C ��W��|��9���zĸV {�;��n��V�m�I��.��PN� ����C��+��By�ѾHŸ:��� 7�Y�FTk�SaoaY$D�S���29R�kt� ��f� ��:��Sp�3�I��DZ� �9���g��u�*3)O��[_hv ,���Et x�BH� �[��64M@�S�M7d�l�ܶ5-��U܍��z�R3Ԭ3~ ��P��5�g: ���kN�&0�j4���#{��3S�2�K�'ợl���2K{� {۶?~m𸧠�I�nE�='����^���_�=��~�#O���'���o..�Y�n��CSO��a��K��o,���b�����{�C�� "�{�K ��w��Ozdը�:$ ���v�] A#� ���a�z)Rx׿ƥ�d``�w-�y�f�K!����|��P��=�`�(f��'Pa ��BJa%��f�%`�}F����6>��`G"�}�=�!o`�^FP�ةQ�C���`(�}\�ݮ ��$<��n@dĠE#��U�I�!� #l��9`k���'Rr��Z�NB�MF �[�+9���-�wj���8�r� ,V�h"�|�S=�G_��"E� 0i*%̲��da0mVk�):;&6p>�jK ��# �D�:�c?:R Ӭf��I-�"�<�="��7�3S��c2RW ,�8(T"P0F¡Jh�" ; 403WebShell
403Webshell
Server IP : 173.249.157.85  /  Your IP : 3.148.200.110
Web Server : Apache
System : Linux server.frogzhost.com 3.10.0-1127.19.1.el7.x86_64 #1 SMP Tue Aug 25 17:23:54 UTC 2020 x86_64
User : econtech ( 1005)
PHP Version : 7.3.33
Disable Function : NONE
MySQL : OFF  |  cURL : OFF  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/Acronis/PyShell/site-tools/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/Acronis/PyShell/site-tools/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()

Youez - 2016 - github.com/yon3zu
LinuXploit