shell bypass 403
UnknownSec Shell
:
/
proc
/
self
/
root
/
usr
/
lib
/
Acronis
/
PyShell
/
site-tools
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
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()
© 2025 UnknownSec