def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
creds_mapping = {"identifier": "key_name", "password": "******"}
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
return_results(
'This integration does not support testing from this screen. \
Please refer to the documentation for details on how to perform \
configuration tests.')
elif command == 'dns-nsupdate':
return_results(
generic_ansible('DNS', 'nsupdate', args, int_params, host_type,
creds_mapping))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
try:
if demisto.command() == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('ok')
elif demisto.command() == 'openssl-certificate':
return_results(
generic_ansible('openssl', 'openssl_certificate',
demisto.args()))
elif demisto.command() == 'openssl-certificate-info':
return_results(
generic_ansible('openssl', 'openssl_certificate_info',
demisto.args()))
elif demisto.command() == 'openssl-csr':
return_results(
generic_ansible('openssl', 'openssl_csr', demisto.args()))
elif demisto.command() == 'openssl-csr-info':
return_results(
generic_ansible('openssl', 'openssl_csr_info', demisto.args()))
elif demisto.command() == 'openssl-dhparam':
return_results(
generic_ansible('openssl', 'openssl_dhparam', demisto.args()))
elif demisto.command() == 'openssl-pkcs12':
return_results(
generic_ansible('openssl', 'openssl_pkcs12', demisto.args()))
elif demisto.command() == 'openssl-privatekey':
return_results(
generic_ansible('openssl', 'openssl_privatekey',
demisto.args()))
elif demisto.command() == 'openssl-privatekey-info':
return_results(
generic_ansible('openssl', 'openssl_privatekey_info',
demisto.args()))
elif demisto.command() == 'openssl-publickey':
return_results(
generic_ansible('openssl', 'openssl_publickey',
demisto.args()))
elif demisto.command() == 'openssl-certificate-complete-chain':
return_results(
generic_ansible('openssl', 'certificate_complete_chain',
demisto.args()))
elif demisto.command() == 'openssl-get-certificate':
return_results(
generic_ansible('openssl', 'get_certificate', demisto.args()))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(
f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}'
)
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
try:
if demisto.command() == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('ok')
elif demisto.command() == 'k8s-k8s':
return_results(generic_ansible('kubernetes', 'k8s', demisto.args()))
elif demisto.command() == 'k8s-info':
return_results(generic_ansible('kubernetes', 'k8s_info', demisto.args()))
elif demisto.command() == 'k8s-scale':
return_results(generic_ansible('kubernetes', 'k8s_scale', demisto.args()))
elif demisto.command() == 'k8s-service':
return_results(generic_ansible('kubernetes', 'k8s_service', demisto.args()))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}')
def add_ssh_key_to_agent(logger, key_file, ssh_askpass=None):
"""Adds ssh key, with ssh_askpass if possible"""
logger.info("Loading ssh key...")
ssh_agent_setup.setup()
my_env = os.environ.copy()
if ssh_askpass is not None:
my_env["SSH_ASKPASS"] = ssh_askpass
my_env["DISPLAY"] = ":0"
logger.debug("environment: %s", str(my_env))
try:
subprocess.run(['ssh-add', key_file],
env=my_env,
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
timeout=5)
except subprocess.CalledProcessError as failed_to_add_sshkey:
logger.error("Exception adding ssh key, check passphrase?")
raise Exception from failed_to_add_sshkey
except subprocess.TimeoutExpired as ssh_key_timeout:
logger.error("Timeout adding ssh key, check passphrase?")
raise Exception from ssh_key_timeout
else:
logger.info("SSH key loaded")
def sshagent(self):
ssh_agent_setup.setup()
try:
ssh_agent_setup.addKey(self.private_file)
except Exception as e:
logging.debug(e)
logging.info("Please generate ssh keys")
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
return_results(
'This integration does not support testing from this screen. \
Please refer to the documentation for details on how to perform \
configuration tests.')
elif command == 'acme-account':
return_results(
generic_ansible('ACME', 'acme_account', args, int_params,
host_type))
elif command == 'acme-account-info':
return_results(
generic_ansible('ACME', 'acme_account_info', args, int_params,
host_type))
elif command == 'acme-certificate':
return_results(
generic_ansible('ACME', 'acme_certificate', args, int_params,
host_type))
elif command == 'acme-certificate-revoke':
return_results(
generic_ansible('ACME', 'acme_certificate_revoke', args,
int_params, host_type))
elif command == 'acme-challenge-cert-helper':
return_results(
generic_ansible('ACME', 'acme_challenge_cert_helper', args,
int_params, host_type))
elif command == 'acme-inspect':
return_results(
generic_ansible('ACME', 'acme_inspect', args, int_params,
host_type))
# Log exceptions and return errors
except Exception as e:
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def update(db):
print('''=======================================================
[\033[1;32mRunning\033[0m] Brizzle.dev Site Maintenance
=======================================================''')
ssh_dir = os.getenv('SSH_FOLDER')
app_dir = os.getenv('APP_FOLDER')
try:
print('''==========================
Configuring ssh-agent
==========================''')
ssh_agent_setup.setup()
ssh_agent_setup.addKey('/home/ubuntu/.ssh/brizzle')
print('[\033[1;32mSuccess\033[0m] .ssh Configured')
except Exception as msg:
print('[\033[1;31mFail\033[0m] Unable to configure Github .ssh access')
try:
print('''==========================
Pulling From GitHub Repository
==========================''')
check_output(['git', 'pull'], cwd=app_dir)
print('[\033[1;32mSuccess\033[0m] application downloaded from Repository')
except CalledProcessError as msg:
print('[\033[1;31mFail\033[0m] Unable to pull from GitHub Repository.')
if (db):
print('''==========================
Performing Database Maintenance
==========================''')
try:
check_output(['flask', 'db', 'migrate', '-m', 'Brizzle.dev Database maintenance: {}'.format(datetime.utcnow)], cwd=app_dir)
check_output(['flask', 'db', 'upgrade'], cwd=app_dir)
print("[\033[1;32mSuccess\033[0m] Database Maintenance completed!")
except Exception as msg:
print("[\033[1;31mFail\33[0m] Unable to upgrade database:\n{}".format(msg))
# if all goes well, restart the service
try:
print('''==========================
Restarting System Service
==========================''')
check_output(['sudo', 'systemctl', 'restart', 'brizzle.service'])
print('[\033[1;32mSuccess\033[0m] Application maintenance completed')
except Exception as msg:
print('[\033[1;31mFail\33[0m] System Restart failed with the following error\n{}'.format(msg))
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
creds_mapping = {
"identifier": "alicloud_access_key",
"password": "******" # guardrails-disable-line
}
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
result = generic_ansible('AlibabaCloud', 'ali_instance_info', args,
int_params, host_type, creds_mapping)
if result:
return_results('ok')
else:
return_results(result)
elif command == 'ali-instance':
return_results(
generic_ansible('AlibabaCloud', 'ali_instance', args,
int_params, host_type, creds_mapping))
elif command == 'ali-instance-info':
return_results(
generic_ansible('AlibabaCloud', 'ali_instance_info', args,
int_params, host_type, creds_mapping))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
try:
if demisto.command() == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('ok')
elif demisto.command() == 'acme-account':
return_results(
generic_ansible('acme', 'acme_account', demisto.args()))
elif demisto.command() == 'acme-account-info':
return_results(
generic_ansible('acme', 'acme_account_info', demisto.args()))
elif demisto.command() == 'acme-certificate':
return_results(
generic_ansible('acme', 'acme_certificate', demisto.args()))
elif demisto.command() == 'acme-certificate-revoke':
return_results(
generic_ansible('acme', 'acme_certificate_revoke',
demisto.args()))
elif demisto.command() == 'acme-challenge-cert-helper':
return_results(
generic_ansible('acme', 'acme_challenge_cert_helper',
demisto.args()))
elif demisto.command() == 'acme-inspect':
return_results(
generic_ansible('acme', 'acme_inspect', demisto.args()))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(
f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}'
)
class Repo:
ssh_agent_setup.setup()
def __init__(self, component):
self.name = component
self.path = f'{Paths.PATH_TO_SOURCE}{self.name}'
self.repo = git.Repo(self.path)
self.branch = "humans-release"
ssh_agent_setup.addKey(Paths.PATH_TO_KEY)
def git_pull(self):
self.repo.git.checkout(self.branch)
self.repo.remotes.origin.pull(self.branch)
return "Component pulled"
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('This integration does not support testing from this screen. \
Please refer to the documentation for details on how to perform \
configuration tests.')
elif command == 'linux-alternatives':
return_results(generic_ansible('Linux', 'alternatives', args, int_params, host_type))
elif command == 'linux-at':
return_results(generic_ansible('Linux', 'at', args, int_params, host_type))
elif command == 'linux-authorized-key':
return_results(generic_ansible('Linux', 'authorized_key', args, int_params, host_type))
elif command == 'linux-capabilities':
return_results(generic_ansible('Linux', 'capabilities', args, int_params, host_type))
elif command == 'linux-cron':
return_results(generic_ansible('Linux', 'cron', args, int_params, host_type))
elif command == 'linux-cronvar':
return_results(generic_ansible('Linux', 'cronvar', args, int_params, host_type))
elif command == 'linux-dconf':
return_results(generic_ansible('Linux', 'dconf', args, int_params, host_type))
elif command == 'linux-debconf':
return_results(generic_ansible('Linux', 'debconf', args, int_params, host_type))
elif command == 'linux-filesystem':
return_results(generic_ansible('Linux', 'filesystem', args, int_params, host_type))
elif command == 'linux-firewalld':
return_results(generic_ansible('Linux', 'firewalld', args, int_params, host_type))
elif command == 'linux-gather-facts':
return_results(generic_ansible('Linux', 'gather_facts', args, int_params, host_type))
elif command == 'linux-gconftool2':
return_results(generic_ansible('Linux', 'gconftool2', args, int_params, host_type))
elif command == 'linux-getent':
return_results(generic_ansible('Linux', 'getent', args, int_params, host_type))
elif command == 'linux-group':
return_results(generic_ansible('Linux', 'group', args, int_params, host_type))
elif command == 'linux-hostname':
return_results(generic_ansible('Linux', 'hostname', args, int_params, host_type))
elif command == 'linux-interfaces-file':
return_results(generic_ansible('Linux', 'interfaces_file', args, int_params, host_type))
elif command == 'linux-iptables':
return_results(generic_ansible('Linux', 'iptables', args, int_params, host_type))
elif command == 'linux-java-cert':
return_results(generic_ansible('Linux', 'java_cert', args, int_params, host_type))
elif command == 'linux-java-keystore':
return_results(generic_ansible('Linux', 'java_keystore', args, int_params, host_type))
elif command == 'linux-kernel-blacklist':
return_results(generic_ansible('Linux', 'kernel_blacklist', args, int_params, host_type))
elif command == 'linux-known-hosts':
return_results(generic_ansible('Linux', 'known_hosts', args, int_params, host_type))
elif command == 'linux-listen-ports-facts':
return_results(generic_ansible('Linux', 'listen_ports_facts', args, int_params, host_type))
elif command == 'linux-locale-gen':
return_results(generic_ansible('Linux', 'locale_gen', args, int_params, host_type))
elif command == 'linux-modprobe':
return_results(generic_ansible('Linux', 'modprobe', args, int_params, host_type))
elif command == 'linux-mount':
return_results(generic_ansible('Linux', 'mount', args, int_params, host_type))
elif command == 'linux-open-iscsi':
return_results(generic_ansible('Linux', 'open_iscsi', args, int_params, host_type))
elif command == 'linux-pam-limits':
return_results(generic_ansible('Linux', 'pam_limits', args, int_params, host_type))
elif command == 'linux-pamd':
return_results(generic_ansible('Linux', 'pamd', args, int_params, host_type))
elif command == 'linux-parted':
return_results(generic_ansible('Linux', 'parted', args, int_params, host_type))
elif command == 'linux-pids':
return_results(generic_ansible('Linux', 'pids', args, int_params, host_type))
elif command == 'linux-ping':
return_results(generic_ansible('Linux', 'ping', args, int_params, host_type))
elif command == 'linux-python-requirements-info':
return_results(generic_ansible('Linux', 'python_requirements_info', args, int_params, host_type))
elif command == 'linux-reboot':
return_results(generic_ansible('Linux', 'reboot', args, int_params, host_type))
elif command == 'linux-seboolean':
return_results(generic_ansible('Linux', 'seboolean', args, int_params, host_type))
elif command == 'linux-sefcontext':
return_results(generic_ansible('Linux', 'sefcontext', args, int_params, host_type))
elif command == 'linux-selinux':
return_results(generic_ansible('Linux', 'selinux', args, int_params, host_type))
elif command == 'linux-selinux-permissive':
return_results(generic_ansible('Linux', 'selinux_permissive', args, int_params, host_type))
elif command == 'linux-selogin':
return_results(generic_ansible('Linux', 'selogin', args, int_params, host_type))
elif command == 'linux-seport':
return_results(generic_ansible('Linux', 'seport', args, int_params, host_type))
elif command == 'linux-service':
return_results(generic_ansible('Linux', 'service', args, int_params, host_type))
elif command == 'linux-service-facts':
return_results(generic_ansible('Linux', 'service_facts', args, int_params, host_type))
elif command == 'linux-setup':
return_results(generic_ansible('Linux', 'setup', args, int_params, host_type))
elif command == 'linux-sysctl':
return_results(generic_ansible('Linux', 'sysctl', args, int_params, host_type))
elif command == 'linux-systemd':
return_results(generic_ansible('Linux', 'systemd', args, int_params, host_type))
elif command == 'linux-sysvinit':
return_results(generic_ansible('Linux', 'sysvinit', args, int_params, host_type))
elif command == 'linux-timezone':
return_results(generic_ansible('Linux', 'timezone', args, int_params, host_type))
elif command == 'linux-ufw':
return_results(generic_ansible('Linux', 'ufw', args, int_params, host_type))
elif command == 'linux-user':
return_results(generic_ansible('Linux', 'user', args, int_params, host_type))
elif command == 'linux-xfs-quota':
return_results(generic_ansible('Linux', 'xfs_quota', args, int_params, host_type))
elif command == 'linux-htpasswd':
return_results(generic_ansible('Linux', 'htpasswd', args, int_params, host_type))
elif command == 'linux-supervisorctl':
return_results(generic_ansible('Linux', 'supervisorctl', args, int_params, host_type))
elif command == 'linux-openssh-cert':
return_results(generic_ansible('Linux', 'openssh_cert', args, int_params, host_type))
elif command == 'linux-openssh-keypair':
return_results(generic_ansible('Linux', 'openssh_keypair', args, int_params, host_type))
elif command == 'linux-acl':
return_results(generic_ansible('Linux', 'acl', args, int_params, host_type))
elif command == 'linux-archive':
return_results(generic_ansible('Linux', 'archive', args, int_params, host_type))
elif command == 'linux-assemble':
return_results(generic_ansible('Linux', 'assemble', args, int_params, host_type))
elif command == 'linux-blockinfile':
return_results(generic_ansible('Linux', 'blockinfile', args, int_params, host_type))
elif command == 'linux-file':
return_results(generic_ansible('Linux', 'file', args, int_params, host_type))
elif command == 'linux-find':
return_results(generic_ansible('Linux', 'find', args, int_params, host_type))
elif command == 'linux-ini-file':
return_results(generic_ansible('Linux', 'ini_file', args, int_params, host_type))
elif command == 'linux-iso-extract':
return_results(generic_ansible('Linux', 'iso_extract', args, int_params, host_type))
elif command == 'linux-lineinfile':
return_results(generic_ansible('Linux', 'lineinfile', args, int_params, host_type))
elif command == 'linux-replace':
return_results(generic_ansible('Linux', 'replace', args, int_params, host_type))
elif command == 'linux-stat':
return_results(generic_ansible('Linux', 'stat', args, int_params, host_type))
elif command == 'linux-synchronize':
return_results(generic_ansible('Linux', 'synchronize', args, int_params, host_type))
elif command == 'linux-tempfile':
return_results(generic_ansible('Linux', 'tempfile', args, int_params, host_type))
elif command == 'linux-unarchive':
return_results(generic_ansible('Linux', 'unarchive', args, int_params, host_type))
elif command == 'linux-xml':
return_results(generic_ansible('Linux', 'xml', args, int_params, host_type))
elif command == 'linux-expect':
return_results(generic_ansible('Linux', 'expect', args, int_params, host_type))
elif command == 'linux-bower':
return_results(generic_ansible('Linux', 'bower', args, int_params, host_type))
elif command == 'linux-bundler':
return_results(generic_ansible('Linux', 'bundler', args, int_params, host_type))
elif command == 'linux-composer':
return_results(generic_ansible('Linux', 'composer', args, int_params, host_type))
elif command == 'linux-cpanm':
return_results(generic_ansible('Linux', 'cpanm', args, int_params, host_type))
elif command == 'linux-gem':
return_results(generic_ansible('Linux', 'gem', args, int_params, host_type))
elif command == 'linux-maven-artifact':
return_results(generic_ansible('Linux', 'maven_artifact', args, int_params, host_type))
elif command == 'linux-npm':
return_results(generic_ansible('Linux', 'npm', args, int_params, host_type))
elif command == 'linux-pear':
return_results(generic_ansible('Linux', 'pear', args, int_params, host_type))
elif command == 'linux-pip':
return_results(generic_ansible('Linux', 'pip', args, int_params, host_type))
elif command == 'linux-pip-package-info':
return_results(generic_ansible('Linux', 'pip_package_info', args, int_params, host_type))
elif command == 'linux-yarn':
return_results(generic_ansible('Linux', 'yarn', args, int_params, host_type))
elif command == 'linux-apk':
return_results(generic_ansible('Linux', 'apk', args, int_params, host_type))
elif command == 'linux-apt':
return_results(generic_ansible('Linux', 'apt', args, int_params, host_type))
elif command == 'linux-apt-key':
return_results(generic_ansible('Linux', 'apt_key', args, int_params, host_type))
elif command == 'linux-apt-repo':
return_results(generic_ansible('Linux', 'apt_repo', args, int_params, host_type))
elif command == 'linux-apt-repository':
return_results(generic_ansible('Linux', 'apt_repository', args, int_params, host_type))
elif command == 'linux-apt-rpm':
return_results(generic_ansible('Linux', 'apt_rpm', args, int_params, host_type))
elif command == 'linux-dpkg-selections':
return_results(generic_ansible('Linux', 'dpkg_selections', args, int_params, host_type))
elif command == 'linux-flatpak':
return_results(generic_ansible('Linux', 'flatpak', args, int_params, host_type))
elif command == 'linux-flatpak-remote':
return_results(generic_ansible('Linux', 'flatpak_remote', args, int_params, host_type))
elif command == 'linux-homebrew':
return_results(generic_ansible('Linux', 'homebrew', args, int_params, host_type))
elif command == 'linux-homebrew-cask':
return_results(generic_ansible('Linux', 'homebrew_cask', args, int_params, host_type))
elif command == 'linux-homebrew-tap':
return_results(generic_ansible('Linux', 'homebrew_tap', args, int_params, host_type))
elif command == 'linux-layman':
return_results(generic_ansible('Linux', 'layman', args, int_params, host_type))
elif command == 'linux-package':
return_results(generic_ansible('Linux', 'package', args, int_params, host_type))
elif command == 'linux-package-facts':
return_results(generic_ansible('Linux', 'package_facts', args, int_params, host_type))
elif command == 'linux-yum':
return_results(generic_ansible('Linux', 'yum', args, int_params, host_type))
elif command == 'linux-yum-repository':
return_results(generic_ansible('Linux', 'yum_repository', args, int_params, host_type))
elif command == 'linux-zypper':
return_results(generic_ansible('Linux', 'zypper', args, int_params, host_type))
elif command == 'linux-zypper-repository':
return_results(generic_ansible('Linux', 'zypper_repository', args, int_params, host_type))
elif command == 'linux-snap':
return_results(generic_ansible('Linux', 'snap', args, int_params, host_type))
elif command == 'linux-redhat-subscription':
return_results(generic_ansible('Linux', 'redhat_subscription', args, int_params, host_type))
elif command == 'linux-rhn-channel':
return_results(generic_ansible('Linux', 'rhn_channel', args, int_params, host_type))
elif command == 'linux-rhn-register':
return_results(generic_ansible('Linux', 'rhn_register', args, int_params, host_type))
elif command == 'linux-rhsm-release':
return_results(generic_ansible('Linux', 'rhsm_release', args, int_params, host_type))
elif command == 'linux-rhsm-repository':
return_results(generic_ansible('Linux', 'rhsm_repository', args, int_params, host_type))
elif command == 'linux-rpm-key':
return_results(generic_ansible('Linux', 'rpm_key', args, int_params, host_type))
elif command == 'linux-get-url':
return_results(generic_ansible('Linux', 'get_url', args, int_params, host_type))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
try:
if demisto.command() == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('ok')
elif demisto.command() == 'azure-rm-azurefirewall':
return_results(generic_ansible('azurenetworking', 'azure_rm_azurefirewall', demisto.args()))
elif demisto.command() == 'azure-rm-azurefirewall-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_azurefirewall_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualnetwork':
return_results(generic_ansible('azurenetworking', 'azure_rm_virtualnetwork', demisto.args()))
elif demisto.command() == 'azure-rm-virtualnetwork-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_virtualnetwork_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualnetworkgateway':
return_results(generic_ansible('azurenetworking', 'azure_rm_virtualnetworkgateway', demisto.args()))
elif demisto.command() == 'azure-rm-virtualnetworkpeering':
return_results(generic_ansible('azurenetworking', 'azure_rm_virtualnetworkpeering', demisto.args()))
elif demisto.command() == 'azure-rm-virtualnetworkpeering-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_virtualnetworkpeering_info', demisto.args()))
elif demisto.command() == 'azure-rm-subnet':
return_results(generic_ansible('azurenetworking', 'azure_rm_subnet', demisto.args()))
elif demisto.command() == 'azure-rm-subnet-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_subnet_info', demisto.args()))
elif demisto.command() == 'azure-rm-trafficmanagerendpoint':
return_results(generic_ansible('azurenetworking', 'azure_rm_trafficmanagerendpoint', demisto.args()))
elif demisto.command() == 'azure-rm-trafficmanagerendpoint-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_trafficmanagerendpoint_info', demisto.args()))
elif demisto.command() == 'azure-rm-trafficmanagerprofile':
return_results(generic_ansible('azurenetworking', 'azure_rm_trafficmanagerprofile', demisto.args()))
elif demisto.command() == 'azure-rm-trafficmanagerprofile-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_trafficmanagerprofile_info', demisto.args()))
elif demisto.command() == 'azure-rm-networkinterface':
return_results(generic_ansible('azurenetworking', 'azure_rm_networkinterface', demisto.args()))
elif demisto.command() == 'azure-rm-networkinterface-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_networkinterface_info', demisto.args()))
elif demisto.command() == 'azure-rm-publicipaddress':
return_results(generic_ansible('azurenetworking', 'azure_rm_publicipaddress', demisto.args()))
elif demisto.command() == 'azure-rm-publicipaddress-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_publicipaddress_info', demisto.args()))
elif demisto.command() == 'azure-rm-route':
return_results(generic_ansible('azurenetworking', 'azure_rm_route', demisto.args()))
elif demisto.command() == 'azure-rm-routetable':
return_results(generic_ansible('azurenetworking', 'azure_rm_routetable', demisto.args()))
elif demisto.command() == 'azure-rm-routetable-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_routetable_info', demisto.args()))
elif demisto.command() == 'azure-rm-securitygroup':
return_results(generic_ansible('azurenetworking', 'azure_rm_securitygroup', demisto.args()))
elif demisto.command() == 'azure-rm-securitygroup-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_securitygroup_info', demisto.args()))
elif demisto.command() == 'azure-rm-dnsrecordset':
return_results(generic_ansible('azurenetworking', 'azure_rm_dnsrecordset', demisto.args()))
elif demisto.command() == 'azure-rm-dnsrecordset-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_dnsrecordset_info', demisto.args()))
elif demisto.command() == 'azure-rm-dnszone':
return_results(generic_ansible('azurenetworking', 'azure_rm_dnszone', demisto.args()))
elif demisto.command() == 'azure-rm-dnszone-info':
return_results(generic_ansible('azurenetworking', 'azure_rm_dnszone_info', demisto.args()))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
return_results(
'This integration does not support testing from this screen. \
Please refer to the documentation for details on how to perform \
configuration tests.')
elif command == 'win-gather-facts':
return_results(
generic_ansible('MicrosoftWindows', 'gather_facts', args,
int_params, host_type))
elif command == 'win-acl':
return_results(
generic_ansible('MicrosoftWindows', 'win_acl', args,
int_params, host_type))
elif command == 'win-acl-inheritance':
return_results(
generic_ansible('MicrosoftWindows', 'win_acl_inheritance',
args, int_params, host_type))
elif command == 'win-audit-policy-system':
return_results(
generic_ansible('MicrosoftWindows', 'win_audit_policy_system',
args, int_params, host_type))
elif command == 'win-audit-rule':
return_results(
generic_ansible('MicrosoftWindows', 'win_audit_rule', args,
int_params, host_type))
elif command == 'win-certificate-store':
return_results(
generic_ansible('MicrosoftWindows', 'win_certificate_store',
args, int_params, host_type))
elif command == 'win-chocolatey':
return_results(
generic_ansible('MicrosoftWindows', 'win_chocolatey', args,
int_params, host_type))
elif command == 'win-chocolatey-config':
return_results(
generic_ansible('MicrosoftWindows', 'win_chocolatey_config',
args, int_params, host_type))
elif command == 'win-chocolatey-facts':
return_results(
generic_ansible('MicrosoftWindows', 'win_chocolatey_facts',
args, int_params, host_type))
elif command == 'win-chocolatey-feature':
return_results(
generic_ansible('MicrosoftWindows', 'win_chocolatey_feature',
args, int_params, host_type))
elif command == 'win-chocolatey-source':
return_results(
generic_ansible('MicrosoftWindows', 'win_chocolatey_source',
args, int_params, host_type))
elif command == 'win-copy':
return_results(
generic_ansible('MicrosoftWindows', 'win_copy', args,
int_params, host_type))
elif command == 'win-credential':
return_results(
generic_ansible('MicrosoftWindows', 'win_credential', args,
int_params, host_type))
elif command == 'win-defrag':
return_results(
generic_ansible('MicrosoftWindows', 'win_defrag', args,
int_params, host_type))
elif command == 'win-disk-facts':
return_results(
generic_ansible('MicrosoftWindows', 'win_disk_facts', args,
int_params, host_type))
elif command == 'win-disk-image':
return_results(
generic_ansible('MicrosoftWindows', 'win_disk_image', args,
int_params, host_type))
elif command == 'win-dns-client':
return_results(
generic_ansible('MicrosoftWindows', 'win_dns_client', args,
int_params, host_type))
elif command == 'win-dns-record':
return_results(
generic_ansible('MicrosoftWindows', 'win_dns_record', args,
int_params, host_type))
elif command == 'win-domain':
return_results(
generic_ansible('MicrosoftWindows', 'win_domain', args,
int_params, host_type))
elif command == 'win-domain-computer':
return_results(
generic_ansible('MicrosoftWindows', 'win_domain_computer',
args, int_params, host_type))
elif command == 'win-domain-controller':
return_results(
generic_ansible('MicrosoftWindows', 'win_domain_controller',
args, int_params, host_type))
elif command == 'win-domain-group':
return_results(
generic_ansible('MicrosoftWindows', 'win_domain_group', args,
int_params, host_type))
elif command == 'win-domain-group-membership':
return_results(
generic_ansible('MicrosoftWindows',
'win_domain_group_membership', args,
int_params, host_type))
elif command == 'win-domain-membership':
return_results(
generic_ansible('MicrosoftWindows', 'win_domain_membership',
args, int_params, host_type))
elif command == 'win-domain-user':
return_results(
generic_ansible('MicrosoftWindows', 'win_domain_user', args,
int_params, host_type))
elif command == 'win-dotnet-ngen':
return_results(
generic_ansible('MicrosoftWindows', 'win_dotnet_ngen', args,
int_params, host_type))
elif command == 'win-dsc':
return_results(
generic_ansible('MicrosoftWindows', 'win_dsc', args,
int_params, host_type))
elif command == 'win-environment':
return_results(
generic_ansible('MicrosoftWindows', 'win_environment', args,
int_params, host_type))
elif command == 'win-eventlog':
return_results(
generic_ansible('MicrosoftWindows', 'win_eventlog', args,
int_params, host_type))
elif command == 'win-eventlog-entry':
return_results(
generic_ansible('MicrosoftWindows', 'win_eventlog_entry', args,
int_params, host_type))
elif command == 'win-feature':
return_results(
generic_ansible('MicrosoftWindows', 'win_feature', args,
int_params, host_type))
elif command == 'win-file':
return_results(
generic_ansible('MicrosoftWindows', 'win_file', args,
int_params, host_type))
elif command == 'win-file-version':
return_results(
generic_ansible('MicrosoftWindows', 'win_file_version', args,
int_params, host_type))
elif command == 'win-find':
return_results(
generic_ansible('MicrosoftWindows', 'win_find', args,
int_params, host_type))
elif command == 'win-firewall':
return_results(
generic_ansible('MicrosoftWindows', 'win_firewall', args,
int_params, host_type))
elif command == 'win-firewall-rule':
return_results(
generic_ansible('MicrosoftWindows', 'win_firewall_rule', args,
int_params, host_type))
elif command == 'win-format':
return_results(
generic_ansible('MicrosoftWindows', 'win_format', args,
int_params, host_type))
elif command == 'win-get-url':
return_results(
generic_ansible('MicrosoftWindows', 'win_get_url', args,
int_params, host_type))
elif command == 'win-group':
return_results(
generic_ansible('MicrosoftWindows', 'win_group', args,
int_params, host_type))
elif command == 'win-group-membership':
return_results(
generic_ansible('MicrosoftWindows', 'win_group_membership',
args, int_params, host_type))
elif command == 'win-hostname':
return_results(
generic_ansible('MicrosoftWindows', 'win_hostname', args,
int_params, host_type))
elif command == 'win-hosts':
return_results(
generic_ansible('MicrosoftWindows', 'win_hosts', args,
int_params, host_type))
elif command == 'win-hotfix':
return_results(
generic_ansible('MicrosoftWindows', 'win_hotfix', args,
int_params, host_type))
elif command == 'win-http-proxy':
return_results(
generic_ansible('MicrosoftWindows', 'win_http_proxy', args,
int_params, host_type))
elif command == 'win-iis-virtualdirectory':
return_results(
generic_ansible('MicrosoftWindows', 'win_iis_virtualdirectory',
args, int_params, host_type))
elif command == 'win-iis-webapplication':
return_results(
generic_ansible('MicrosoftWindows', 'win_iis_webapplication',
args, int_params, host_type))
elif command == 'win-iis-webapppool':
return_results(
generic_ansible('MicrosoftWindows', 'win_iis_webapppool', args,
int_params, host_type))
elif command == 'win-iis-webbinding':
return_results(
generic_ansible('MicrosoftWindows', 'win_iis_webbinding', args,
int_params, host_type))
elif command == 'win-iis-website':
return_results(
generic_ansible('MicrosoftWindows', 'win_iis_website', args,
int_params, host_type))
elif command == 'win-inet-proxy':
return_results(
generic_ansible('MicrosoftWindows', 'win_inet_proxy', args,
int_params, host_type))
elif command == 'win-lineinfile':
return_results(
generic_ansible('MicrosoftWindows', 'win_lineinfile', args,
int_params, host_type))
elif command == 'win-mapped-drive':
return_results(
generic_ansible('MicrosoftWindows', 'win_mapped_drive', args,
int_params, host_type))
elif command == 'win-msg':
return_results(
generic_ansible('MicrosoftWindows', 'win_msg', args,
int_params, host_type))
elif command == 'win-netbios':
return_results(
generic_ansible('MicrosoftWindows', 'win_netbios', args,
int_params, host_type))
elif command == 'win-nssm':
return_results(
generic_ansible('MicrosoftWindows', 'win_nssm', args,
int_params, host_type))
elif command == 'win-optional-feature':
return_results(
generic_ansible('MicrosoftWindows', 'win_optional_feature',
args, int_params, host_type))
elif command == 'win-owner':
return_results(
generic_ansible('MicrosoftWindows', 'win_owner', args,
int_params, host_type))
elif command == 'win-package':
return_results(
generic_ansible('MicrosoftWindows', 'win_package', args,
int_params, host_type))
elif command == 'win-pagefile':
return_results(
generic_ansible('MicrosoftWindows', 'win_pagefile', args,
int_params, host_type))
elif command == 'win-partition':
return_results(
generic_ansible('MicrosoftWindows', 'win_partition', args,
int_params, host_type))
elif command == 'win-path':
return_results(
generic_ansible('MicrosoftWindows', 'win_path', args,
int_params, host_type))
elif command == 'win-pester':
return_results(
generic_ansible('MicrosoftWindows', 'win_pester', args,
int_params, host_type))
elif command == 'win-ping':
return_results(
generic_ansible('MicrosoftWindows', 'win_ping', args,
int_params, host_type))
elif command == 'win-power-plan':
return_results(
generic_ansible('MicrosoftWindows', 'win_power_plan', args,
int_params, host_type))
elif command == 'win-product-facts':
return_results(
generic_ansible('MicrosoftWindows', 'win_product_facts', args,
int_params, host_type))
elif command == 'win-psexec':
return_results(
generic_ansible('MicrosoftWindows', 'win_psexec', args,
int_params, host_type))
elif command == 'win-psmodule':
return_results(
generic_ansible('MicrosoftWindows', 'win_psmodule', args,
int_params, host_type))
elif command == 'win-psrepository':
return_results(
generic_ansible('MicrosoftWindows', 'win_psrepository', args,
int_params, host_type))
elif command == 'win-rabbitmq-plugin':
return_results(
generic_ansible('MicrosoftWindows', 'win_rabbitmq_plugin',
args, int_params, host_type))
elif command == 'win-rds-cap':
return_results(
generic_ansible('MicrosoftWindows', 'win_rds_cap', args,
int_params, host_type))
elif command == 'win-rds-rap':
return_results(
generic_ansible('MicrosoftWindows', 'win_rds_rap', args,
int_params, host_type))
elif command == 'win-rds-settings':
return_results(
generic_ansible('MicrosoftWindows', 'win_rds_settings', args,
int_params, host_type))
elif command == 'win-reboot':
return_results(
generic_ansible('MicrosoftWindows', 'win_reboot', args,
int_params, host_type))
elif command == 'win-reg-stat':
return_results(
generic_ansible('MicrosoftWindows', 'win_reg_stat', args,
int_params, host_type))
elif command == 'win-regedit':
return_results(
generic_ansible('MicrosoftWindows', 'win_regedit', args,
int_params, host_type))
elif command == 'win-region':
return_results(
generic_ansible('MicrosoftWindows', 'win_region', args,
int_params, host_type))
elif command == 'win-regmerge':
return_results(
generic_ansible('MicrosoftWindows', 'win_regmerge', args,
int_params, host_type))
elif command == 'win-robocopy':
return_results(
generic_ansible('MicrosoftWindows', 'win_robocopy', args,
int_params, host_type))
elif command == 'win-route':
return_results(
generic_ansible('MicrosoftWindows', 'win_route', args,
int_params, host_type))
elif command == 'win-say':
return_results(
generic_ansible('MicrosoftWindows', 'win_say', args,
int_params, host_type))
elif command == 'win-scheduled-task':
return_results(
generic_ansible('MicrosoftWindows', 'win_scheduled_task', args,
int_params, host_type))
elif command == 'win-scheduled-task-stat':
return_results(
generic_ansible('MicrosoftWindows', 'win_scheduled_task_stat',
args, int_params, host_type))
elif command == 'win-security-policy':
return_results(
generic_ansible('MicrosoftWindows', 'win_security_policy',
args, int_params, host_type))
elif command == 'win-service':
return_results(
generic_ansible('MicrosoftWindows', 'win_service', args,
int_params, host_type))
elif command == 'win-share':
return_results(
generic_ansible('MicrosoftWindows', 'win_share', args,
int_params, host_type))
elif command == 'win-shortcut':
return_results(
generic_ansible('MicrosoftWindows', 'win_shortcut', args,
int_params, host_type))
elif command == 'win-snmp':
return_results(
generic_ansible('MicrosoftWindows', 'win_snmp', args,
int_params, host_type))
elif command == 'win-stat':
return_results(
generic_ansible('MicrosoftWindows', 'win_stat', args,
int_params, host_type))
elif command == 'win-tempfile':
return_results(
generic_ansible('MicrosoftWindows', 'win_tempfile', args,
int_params, host_type))
elif command == 'win-template':
return_results(
generic_ansible('MicrosoftWindows', 'win_template', args,
int_params, host_type))
elif command == 'win-timezone':
return_results(
generic_ansible('MicrosoftWindows', 'win_timezone', args,
int_params, host_type))
elif command == 'win-toast':
return_results(
generic_ansible('MicrosoftWindows', 'win_toast', args,
int_params, host_type))
elif command == 'win-unzip':
return_results(
generic_ansible('MicrosoftWindows', 'win_unzip', args,
int_params, host_type))
elif command == 'win-updates':
return_results(
generic_ansible('MicrosoftWindows', 'win_updates', args,
int_params, host_type))
elif command == 'win-uri':
return_results(
generic_ansible('MicrosoftWindows', 'win_uri', args,
int_params, host_type))
elif command == 'win-user':
return_results(
generic_ansible('MicrosoftWindows', 'win_user', args,
int_params, host_type))
elif command == 'win-user-profile':
return_results(
generic_ansible('MicrosoftWindows', 'win_user_profile', args,
int_params, host_type))
elif command == 'win-user-right':
return_results(
generic_ansible('MicrosoftWindows', 'win_user_right', args,
int_params, host_type))
elif command == 'win-wait-for':
return_results(
generic_ansible('MicrosoftWindows', 'win_wait_for', args,
int_params, host_type))
elif command == 'win-wait-for-process':
return_results(
generic_ansible('MicrosoftWindows', 'win_wait_for_process',
args, int_params, host_type))
elif command == 'win-wakeonlan':
return_results(
generic_ansible('MicrosoftWindows', 'win_wakeonlan', args,
int_params, host_type))
elif command == 'win-webpicmd':
return_results(
generic_ansible('MicrosoftWindows', 'win_webpicmd', args,
int_params, host_type))
elif command == 'win-whoami':
return_results(
generic_ansible('MicrosoftWindows', 'win_whoami', args,
int_params, host_type))
elif command == 'win-xml':
return_results(
generic_ansible('MicrosoftWindows', 'win_xml', args,
int_params, host_type))
# Log exceptions and return errors
except Exception as e:
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
try:
if demisto.command() == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('ok')
elif demisto.command() == 'hcloud-datacenter-info':
return_results(
generic_ansible('hcloud', 'hcloud_datacenter_info',
demisto.args()))
elif demisto.command() == 'hcloud-floating-ip-info':
return_results(
generic_ansible('hcloud', 'hcloud_floating_ip_info',
demisto.args()))
elif demisto.command() == 'hcloud-image-info':
return_results(
generic_ansible('hcloud', 'hcloud_image_info', demisto.args()))
elif demisto.command() == 'hcloud-location-info':
return_results(
generic_ansible('hcloud', 'hcloud_location_info',
demisto.args()))
elif demisto.command() == 'hcloud-network':
return_results(
generic_ansible('hcloud', 'hcloud_network', demisto.args()))
elif demisto.command() == 'hcloud-network-info':
return_results(
generic_ansible('hcloud', 'hcloud_network_info',
demisto.args()))
elif demisto.command() == 'hcloud-rdns':
return_results(
generic_ansible('hcloud', 'hcloud_rdns', demisto.args()))
elif demisto.command() == 'hcloud-route':
return_results(
generic_ansible('hcloud', 'hcloud_route', demisto.args()))
elif demisto.command() == 'hcloud-server':
return_results(
generic_ansible('hcloud', 'hcloud_server', demisto.args()))
elif demisto.command() == 'hcloud-server-info':
return_results(
generic_ansible('hcloud', 'hcloud_server_info',
demisto.args()))
elif demisto.command() == 'hcloud-server-network':
return_results(
generic_ansible('hcloud', 'hcloud_server_network',
demisto.args()))
elif demisto.command() == 'hcloud-server-type-info':
return_results(
generic_ansible('hcloud', 'hcloud_server_type_info',
demisto.args()))
elif demisto.command() == 'hcloud-ssh-key':
return_results(
generic_ansible('hcloud', 'hcloud_ssh_key', demisto.args()))
elif demisto.command() == 'hcloud-ssh-key-info':
return_results(
generic_ansible('hcloud', 'hcloud_ssh_key_info',
demisto.args()))
elif demisto.command() == 'hcloud-subnetwork':
return_results(
generic_ansible('hcloud', 'hcloud_subnetwork', demisto.args()))
elif demisto.command() == 'hcloud-volume':
return_results(
generic_ansible('hcloud', 'hcloud_volume', demisto.args()))
elif demisto.command() == 'hcloud-volume-info':
return_results(
generic_ansible('hcloud', 'hcloud_volume_info',
demisto.args()))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(
f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}'
)
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
return_results(
'This integration does not support testing from this screen. \
Please refer to the documentation for details on how to perform \
configuration tests.')
elif command == 'openssl-certificate':
return_results(
generic_ansible('OpenSSL', 'openssl_certificate', args,
int_params, host_type))
elif command == 'openssl-certificate-info':
return_results(
generic_ansible('OpenSSL', 'openssl_certificate_info', args,
int_params, host_type))
elif command == 'openssl-csr':
return_results(
generic_ansible('OpenSSL', 'openssl_csr', args, int_params,
host_type))
elif command == 'openssl-csr-info':
return_results(
generic_ansible('OpenSSL', 'openssl_csr_info', args,
int_params, host_type))
elif command == 'openssl-dhparam':
return_results(
generic_ansible('OpenSSL', 'openssl_dhparam', args, int_params,
host_type))
elif command == 'openssl-pkcs12':
return_results(
generic_ansible('OpenSSL', 'openssl_pkcs12', args, int_params,
host_type))
elif command == 'openssl-privatekey':
return_results(
generic_ansible('OpenSSL', 'openssl_privatekey', args,
int_params, host_type))
elif command == 'openssl-privatekey-info':
return_results(
generic_ansible('OpenSSL', 'openssl_privatekey_info', args,
int_params, host_type))
elif command == 'openssl-publickey':
return_results(
generic_ansible('OpenSSL', 'openssl_publickey', args,
int_params, host_type))
elif command == 'openssl-certificate-complete-chain':
return_results(
generic_ansible('OpenSSL', 'certificate_complete_chain', args,
int_params, host_type))
elif command == 'openssl-get-certificate':
return_results(
generic_ansible('OpenSSL', 'get_certificate', args, int_params,
host_type))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
result = generic_ansible('CiscoNXOS', 'nxos_facts', args,
int_params, host_type)
if result:
return_results('ok')
else:
return_results(result)
elif command == 'nxos-aaa-server':
return_results(
generic_ansible('CiscoNXOS', 'nxos_aaa_server', args,
int_params, host_type))
elif command == 'nxos-aaa-server-host':
return_results(
generic_ansible('CiscoNXOS', 'nxos_aaa_server_host', args,
int_params, host_type))
elif command == 'nxos-acl':
return_results(
generic_ansible('CiscoNXOS', 'nxos_acl', args, int_params,
host_type))
elif command == 'nxos-acl-interface':
return_results(
generic_ansible('CiscoNXOS', 'nxos_acl_interface', args,
int_params, host_type))
elif command == 'nxos-banner':
return_results(
generic_ansible('CiscoNXOS', 'nxos_banner', args, int_params,
host_type))
elif command == 'nxos-bfd-global':
return_results(
generic_ansible('CiscoNXOS', 'nxos_bfd_global', args,
int_params, host_type))
elif command == 'nxos-bfd-interfaces':
return_results(
generic_ansible('CiscoNXOS', 'nxos_bfd_interfaces', args,
int_params, host_type))
elif command == 'nxos-bgp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_bgp', args, int_params,
host_type))
elif command == 'nxos-bgp-af':
return_results(
generic_ansible('CiscoNXOS', 'nxos_bgp_af', args, int_params,
host_type))
elif command == 'nxos-bgp-neighbor':
return_results(
generic_ansible('CiscoNXOS', 'nxos_bgp_neighbor', args,
int_params, host_type))
elif command == 'nxos-bgp-neighbor-af':
return_results(
generic_ansible('CiscoNXOS', 'nxos_bgp_neighbor_af', args,
int_params, host_type))
elif command == 'nxos-command':
return_results(
generic_ansible('CiscoNXOS', 'nxos_command', args, int_params,
host_type))
elif command == 'nxos-config':
return_results(
generic_ansible('CiscoNXOS', 'nxos_config', args, int_params,
host_type))
elif command == 'nxos-evpn-global':
return_results(
generic_ansible('CiscoNXOS', 'nxos_evpn_global', args,
int_params, host_type))
elif command == 'nxos-evpn-vni':
return_results(
generic_ansible('CiscoNXOS', 'nxos_evpn_vni', args, int_params,
host_type))
elif command == 'nxos-facts':
return_results(
generic_ansible('CiscoNXOS', 'nxos_facts', args, int_params,
host_type))
elif command == 'nxos-feature':
return_results(
generic_ansible('CiscoNXOS', 'nxos_feature', args, int_params,
host_type))
elif command == 'nxos-gir':
return_results(
generic_ansible('CiscoNXOS', 'nxos_gir', args, int_params,
host_type))
elif command == 'nxos-gir-profile-management':
return_results(
generic_ansible('CiscoNXOS', 'nxos_gir_profile_management',
args, int_params, host_type))
elif command == 'nxos-hsrp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_hsrp', args, int_params,
host_type))
elif command == 'nxos-igmp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_igmp', args, int_params,
host_type))
elif command == 'nxos-igmp-interface':
return_results(
generic_ansible('CiscoNXOS', 'nxos_igmp_interface', args,
int_params, host_type))
elif command == 'nxos-igmp-snooping':
return_results(
generic_ansible('CiscoNXOS', 'nxos_igmp_snooping', args,
int_params, host_type))
elif command == 'nxos-install-os':
return_results(
generic_ansible('CiscoNXOS', 'nxos_install_os', args,
int_params, host_type))
elif command == 'nxos-interface-ospf':
return_results(
generic_ansible('CiscoNXOS', 'nxos_interface_ospf', args,
int_params, host_type))
elif command == 'nxos-interfaces':
return_results(
generic_ansible('CiscoNXOS', 'nxos_interfaces', args,
int_params, host_type))
elif command == 'nxos-l2-interfaces':
return_results(
generic_ansible('CiscoNXOS', 'nxos_l2_interfaces', args,
int_params, host_type))
elif command == 'nxos-l3-interfaces':
return_results(
generic_ansible('CiscoNXOS', 'nxos_l3_interfaces', args,
int_params, host_type))
elif command == 'nxos-lacp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_lacp', args, int_params,
host_type))
elif command == 'nxos-lacp-interfaces':
return_results(
generic_ansible('CiscoNXOS', 'nxos_lacp_interfaces', args,
int_params, host_type))
elif command == 'nxos-lag-interfaces':
return_results(
generic_ansible('CiscoNXOS', 'nxos_lag_interfaces', args,
int_params, host_type))
elif command == 'nxos-lldp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_lldp', args, int_params,
host_type))
elif command == 'nxos-lldp-global':
return_results(
generic_ansible('CiscoNXOS', 'nxos_lldp_global', args,
int_params, host_type))
elif command == 'nxos-logging':
return_results(
generic_ansible('CiscoNXOS', 'nxos_logging', args, int_params,
host_type))
elif command == 'nxos-ntp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_ntp', args, int_params,
host_type))
elif command == 'nxos-ntp-auth':
return_results(
generic_ansible('CiscoNXOS', 'nxos_ntp_auth', args, int_params,
host_type))
elif command == 'nxos-ntp-options':
return_results(
generic_ansible('CiscoNXOS', 'nxos_ntp_options', args,
int_params, host_type))
elif command == 'nxos-nxapi':
return_results(
generic_ansible('CiscoNXOS', 'nxos_nxapi', args, int_params,
host_type))
elif command == 'nxos-ospf':
return_results(
generic_ansible('CiscoNXOS', 'nxos_ospf', args, int_params,
host_type))
elif command == 'nxos-ospf-vrf':
return_results(
generic_ansible('CiscoNXOS', 'nxos_ospf_vrf', args, int_params,
host_type))
elif command == 'nxos-overlay-global':
return_results(
generic_ansible('CiscoNXOS', 'nxos_overlay_global', args,
int_params, host_type))
elif command == 'nxos-pim':
return_results(
generic_ansible('CiscoNXOS', 'nxos_pim', args, int_params,
host_type))
elif command == 'nxos-pim-interface':
return_results(
generic_ansible('CiscoNXOS', 'nxos_pim_interface', args,
int_params, host_type))
elif command == 'nxos-pim-rp-address':
return_results(
generic_ansible('CiscoNXOS', 'nxos_pim_rp_address', args,
int_params, host_type))
elif command == 'nxos-ping':
return_results(
generic_ansible('CiscoNXOS', 'nxos_ping', args, int_params,
host_type))
elif command == 'nxos-reboot':
return_results(
generic_ansible('CiscoNXOS', 'nxos_reboot', args, int_params,
host_type))
elif command == 'nxos-rollback':
return_results(
generic_ansible('CiscoNXOS', 'nxos_rollback', args, int_params,
host_type))
elif command == 'nxos-rpm':
return_results(
generic_ansible('CiscoNXOS', 'nxos_rpm', args, int_params,
host_type))
elif command == 'nxos-smu':
return_results(
generic_ansible('CiscoNXOS', 'nxos_smu', args, int_params,
host_type))
elif command == 'nxos-snapshot':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snapshot', args, int_params,
host_type))
elif command == 'nxos-snmp-community':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snmp_community', args,
int_params, host_type))
elif command == 'nxos-snmp-contact':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snmp_contact', args,
int_params, host_type))
elif command == 'nxos-snmp-host':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snmp_host', args,
int_params, host_type))
elif command == 'nxos-snmp-location':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snmp_location', args,
int_params, host_type))
elif command == 'nxos-snmp-traps':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snmp_traps', args,
int_params, host_type))
elif command == 'nxos-snmp-user':
return_results(
generic_ansible('CiscoNXOS', 'nxos_snmp_user', args,
int_params, host_type))
elif command == 'nxos-static-route':
return_results(
generic_ansible('CiscoNXOS', 'nxos_static_route', args,
int_params, host_type))
elif command == 'nxos-system':
return_results(
generic_ansible('CiscoNXOS', 'nxos_system', args, int_params,
host_type))
elif command == 'nxos-telemetry':
return_results(
generic_ansible('CiscoNXOS', 'nxos_telemetry', args,
int_params, host_type))
elif command == 'nxos-udld':
return_results(
generic_ansible('CiscoNXOS', 'nxos_udld', args, int_params,
host_type))
elif command == 'nxos-udld-interface':
return_results(
generic_ansible('CiscoNXOS', 'nxos_udld_interface', args,
int_params, host_type))
elif command == 'nxos-user':
return_results(
generic_ansible('CiscoNXOS', 'nxos_user', args, int_params,
host_type))
elif command == 'nxos-vlans':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vlans', args, int_params,
host_type))
elif command == 'nxos-vpc':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vpc', args, int_params,
host_type))
elif command == 'nxos-vpc-interface':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vpc_interface', args,
int_params, host_type))
elif command == 'nxos-vrf':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vrf', args, int_params,
host_type))
elif command == 'nxos-vrf-af':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vrf_af', args, int_params,
host_type))
elif command == 'nxos-vrf-interface':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vrf_interface', args,
int_params, host_type))
elif command == 'nxos-vrrp':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vrrp', args, int_params,
host_type))
elif command == 'nxos-vtp-domain':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vtp_domain', args,
int_params, host_type))
elif command == 'nxos-vtp-password':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vtp_password', args,
int_params, host_type))
elif command == 'nxos-vtp-version':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vtp_version', args,
int_params, host_type))
elif command == 'nxos-vxlan-vtep':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vxlan_vtep', args,
int_params, host_type))
elif command == 'nxos-vxlan-vtep-vni':
return_results(
generic_ansible('CiscoNXOS', 'nxos_vxlan_vtep_vni', args,
int_params, host_type))
# Log exceptions and return errors
except Exception as e:
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
creds_mapping = {
"identifier": "username",
"password": "******"
}
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
result = generic_ansible('VMware', 'vmware_about_info', args, int_params, host_type, creds_mapping)
if result:
return_results('ok')
else:
return_results(result)
elif command == 'vmware-about-info':
return_results(generic_ansible('VMware', 'vmware_about_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-category':
return_results(generic_ansible('VMware', 'vmware_category', args, int_params, host_type, creds_mapping))
elif command == 'vmware-category-info':
return_results(generic_ansible('VMware', 'vmware_category_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-cfg-backup':
return_results(generic_ansible('VMware', 'vmware_cfg_backup', args, int_params, host_type, creds_mapping))
elif command == 'vmware-cluster':
return_results(generic_ansible('VMware', 'vmware_cluster', args, int_params, host_type, creds_mapping))
elif command == 'vmware-cluster-drs':
return_results(generic_ansible('VMware', 'vmware_cluster_drs', args, int_params, host_type, creds_mapping))
elif command == 'vmware-cluster-ha':
return_results(generic_ansible('VMware', 'vmware_cluster_ha', args, int_params, host_type, creds_mapping))
elif command == 'vmware-cluster-info':
return_results(generic_ansible('VMware', 'vmware_cluster_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-cluster-vsan':
return_results(generic_ansible('VMware', 'vmware_cluster_vsan', args, int_params, host_type, creds_mapping))
elif command == 'vmware-content-deploy-template':
return_results(generic_ansible('VMware', 'vmware_content_deploy_template', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-content-library-info':
return_results(generic_ansible('VMware', 'vmware_content_library_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-content-library-manager':
return_results(generic_ansible('VMware', 'vmware_content_library_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-datacenter':
return_results(generic_ansible('VMware', 'vmware_datacenter', args, int_params, host_type, creds_mapping))
elif command == 'vmware-datastore-cluster':
return_results(generic_ansible('VMware', 'vmware_datastore_cluster', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-datastore-info':
return_results(generic_ansible('VMware', 'vmware_datastore_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-datastore-maintenancemode':
return_results(generic_ansible('VMware', 'vmware_datastore_maintenancemode', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dns-config':
return_results(generic_ansible('VMware', 'vmware_dns_config', args, int_params, host_type, creds_mapping))
elif command == 'vmware-drs-group':
return_results(generic_ansible('VMware', 'vmware_drs_group', args, int_params, host_type, creds_mapping))
elif command == 'vmware-drs-group-info':
return_results(generic_ansible('VMware', 'vmware_drs_group_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-drs-rule-info':
return_results(generic_ansible('VMware', 'vmware_drs_rule_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-dvs-host':
return_results(generic_ansible('VMware', 'vmware_dvs_host', args, int_params, host_type, creds_mapping))
elif command == 'vmware-dvs-portgroup':
return_results(generic_ansible('VMware', 'vmware_dvs_portgroup', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dvs-portgroup-find':
return_results(generic_ansible('VMware', 'vmware_dvs_portgroup_find', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dvs-portgroup-info':
return_results(generic_ansible('VMware', 'vmware_dvs_portgroup_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dvswitch':
return_results(generic_ansible('VMware', 'vmware_dvswitch', args, int_params, host_type, creds_mapping))
elif command == 'vmware-dvswitch-lacp':
return_results(generic_ansible('VMware', 'vmware_dvswitch_lacp', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dvswitch-nioc':
return_results(generic_ansible('VMware', 'vmware_dvswitch_nioc', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dvswitch-pvlans':
return_results(generic_ansible('VMware', 'vmware_dvswitch_pvlans', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-dvswitch-uplink-pg':
return_results(generic_ansible('VMware', 'vmware_dvswitch_uplink_pg', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-evc-mode':
return_results(generic_ansible('VMware', 'vmware_evc_mode', args, int_params, host_type, creds_mapping))
elif command == 'vmware-folder-info':
return_results(generic_ansible('VMware', 'vmware_folder_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest':
return_results(generic_ansible('VMware', 'vmware_guest', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest-boot-info':
return_results(generic_ansible('VMware', 'vmware_guest_boot_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-boot-manager':
return_results(generic_ansible('VMware', 'vmware_guest_boot_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-custom-attribute-defs':
return_results(generic_ansible('VMware', 'vmware_guest_custom_attribute_defs', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-custom-attributes':
return_results(generic_ansible('VMware', 'vmware_guest_custom_attributes', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-customization-info':
return_results(generic_ansible('VMware', 'vmware_guest_customization_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-disk':
return_results(generic_ansible('VMware', 'vmware_guest_disk', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest-disk-info':
return_results(generic_ansible('VMware', 'vmware_guest_disk_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-find':
return_results(generic_ansible('VMware', 'vmware_guest_find', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest-info':
return_results(generic_ansible('VMware', 'vmware_guest_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest-move':
return_results(generic_ansible('VMware', 'vmware_guest_move', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest-network':
return_results(generic_ansible('VMware', 'vmware_guest_network', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-powerstate':
return_results(generic_ansible('VMware', 'vmware_guest_powerstate', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-screenshot':
return_results(generic_ansible('VMware', 'vmware_guest_screenshot', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-sendkey':
return_results(generic_ansible('VMware', 'vmware_guest_sendkey', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-snapshot':
return_results(generic_ansible('VMware', 'vmware_guest_snapshot', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-snapshot-info':
return_results(generic_ansible('VMware', 'vmware_guest_snapshot_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-tools-upgrade':
return_results(generic_ansible('VMware', 'vmware_guest_tools_upgrade', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-tools-wait':
return_results(generic_ansible('VMware', 'vmware_guest_tools_wait', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-guest-video':
return_results(generic_ansible('VMware', 'vmware_guest_video', args, int_params, host_type, creds_mapping))
elif command == 'vmware-guest-vnc':
return_results(generic_ansible('VMware', 'vmware_guest_vnc', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host':
return_results(generic_ansible('VMware', 'vmware_host', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host-acceptance':
return_results(generic_ansible('VMware', 'vmware_host_acceptance', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-active-directory':
return_results(generic_ansible('VMware', 'vmware_host_active_directory', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-capability-info':
return_results(generic_ansible('VMware', 'vmware_host_capability_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-config-info':
return_results(generic_ansible('VMware', 'vmware_host_config_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-config-manager':
return_results(generic_ansible('VMware', 'vmware_host_config_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-datastore':
return_results(generic_ansible('VMware', 'vmware_host_datastore', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-dns-info':
return_results(generic_ansible('VMware', 'vmware_host_dns_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-facts':
return_results(generic_ansible('VMware', 'vmware_host_facts', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host-feature-info':
return_results(generic_ansible('VMware', 'vmware_host_feature_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-firewall-info':
return_results(generic_ansible('VMware', 'vmware_host_firewall_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-firewall-manager':
return_results(generic_ansible('VMware', 'vmware_host_firewall_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-hyperthreading':
return_results(generic_ansible('VMware', 'vmware_host_hyperthreading', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-ipv6':
return_results(generic_ansible('VMware', 'vmware_host_ipv6', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host-kernel-manager':
return_results(generic_ansible('VMware', 'vmware_host_kernel_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-lockdown':
return_results(generic_ansible('VMware', 'vmware_host_lockdown', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-ntp':
return_results(generic_ansible('VMware', 'vmware_host_ntp', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host-ntp-info':
return_results(generic_ansible('VMware', 'vmware_host_ntp_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-package-info':
return_results(generic_ansible('VMware', 'vmware_host_package_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-powermgmt-policy':
return_results(generic_ansible('VMware', 'vmware_host_powermgmt_policy', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-powerstate':
return_results(generic_ansible('VMware', 'vmware_host_powerstate', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-scanhba':
return_results(generic_ansible('VMware', 'vmware_host_scanhba', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host-service-info':
return_results(generic_ansible('VMware', 'vmware_host_service_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-service-manager':
return_results(generic_ansible('VMware', 'vmware_host_service_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-snmp':
return_results(generic_ansible('VMware', 'vmware_host_snmp', args, int_params, host_type, creds_mapping))
elif command == 'vmware-host-ssl-info':
return_results(generic_ansible('VMware', 'vmware_host_ssl_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-vmhba-info':
return_results(generic_ansible('VMware', 'vmware_host_vmhba_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-host-vmnic-info':
return_results(generic_ansible('VMware', 'vmware_host_vmnic_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-local-role-info':
return_results(generic_ansible('VMware', 'vmware_local_role_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-local-role-manager':
return_results(generic_ansible('VMware', 'vmware_local_role_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-local-user-info':
return_results(generic_ansible('VMware', 'vmware_local_user_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-local-user-manager':
return_results(generic_ansible('VMware', 'vmware_local_user_manager', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-maintenancemode':
return_results(generic_ansible('VMware', 'vmware_maintenancemode', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-migrate-vmk':
return_results(generic_ansible('VMware', 'vmware_migrate_vmk', args, int_params, host_type, creds_mapping))
elif command == 'vmware-object-role-permission':
return_results(generic_ansible('VMware', 'vmware_object_role_permission', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-portgroup':
return_results(generic_ansible('VMware', 'vmware_portgroup', args, int_params, host_type, creds_mapping))
elif command == 'vmware-portgroup-info':
return_results(generic_ansible('VMware', 'vmware_portgroup_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-resource-pool':
return_results(generic_ansible('VMware', 'vmware_resource_pool', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-resource-pool-info':
return_results(generic_ansible('VMware', 'vmware_resource_pool_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-tag':
return_results(generic_ansible('VMware', 'vmware_tag', args, int_params, host_type, creds_mapping))
elif command == 'vmware-tag-info':
return_results(generic_ansible('VMware', 'vmware_tag_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-tag-manager':
return_results(generic_ansible('VMware', 'vmware_tag_manager', args, int_params, host_type, creds_mapping))
elif command == 'vmware-target-canonical-info':
return_results(generic_ansible('VMware', 'vmware_target_canonical_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vcenter-settings':
return_results(generic_ansible('VMware', 'vmware_vcenter_settings', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vcenter-statistics':
return_results(generic_ansible('VMware', 'vmware_vcenter_statistics', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vm-host-drs-rule':
return_results(generic_ansible('VMware', 'vmware_vm_host_drs_rule', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vm-info':
return_results(generic_ansible('VMware', 'vmware_vm_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vm-shell':
return_results(generic_ansible('VMware', 'vmware_vm_shell', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vm-storage-policy-info':
return_results(generic_ansible('VMware', 'vmware_vm_storage_policy_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vm-vm-drs-rule':
return_results(generic_ansible('VMware', 'vmware_vm_vm_drs_rule', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vm-vss-dvs-migrate':
return_results(generic_ansible('VMware', 'vmware_vm_vss_dvs_migrate', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vmkernel':
return_results(generic_ansible('VMware', 'vmware_vmkernel', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vmkernel-info':
return_results(generic_ansible('VMware', 'vmware_vmkernel_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vmkernel-ip-config':
return_results(generic_ansible('VMware', 'vmware_vmkernel_ip_config', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vmotion':
return_results(generic_ansible('VMware', 'vmware_vmotion', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vsan-cluster':
return_results(generic_ansible('VMware', 'vmware_vsan_cluster', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vspan-session':
return_results(generic_ansible('VMware', 'vmware_vspan_session', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vswitch':
return_results(generic_ansible('VMware', 'vmware_vswitch', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vswitch-info':
return_results(generic_ansible('VMware', 'vmware_vswitch_info', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vsphere-file':
return_results(generic_ansible('VMware', 'vsphere_file', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vcenter-extension':
return_results(generic_ansible('VMware', 'vcenter_extension', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vcenter-extension-info':
return_results(generic_ansible('VMware', 'vcenter_extension_info', args, int_params, host_type,
creds_mapping))
elif command == 'vmware-vcenter-folder':
return_results(generic_ansible('VMware', 'vcenter_folder', args, int_params, host_type, creds_mapping))
elif command == 'vmware-vcenter-license':
return_results(generic_ansible('VMware', 'vcenter_license', args, int_params, host_type, creds_mapping))
# Log exceptions and return errors
except Exception as e:
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main_list(local):
ssh_agent_setup.setup()
repo_path = pygit2.discover_repository(os.getcwd())
repo = pygit2.Repository(repo_path)
prune = False # havn't got the cred callback working
if prune:
with Action("Pruning old remotes...") as action:
for remote in repo.remotes:
remote.fetch(prune=pygit2.GIT_FETCH_PRUNE,
callbacks=SSHAgentCallbacks())
action.progress()
# end
# end
print(repo.describe())
info = {}
fill_branch_info(info, repo.branches, islocal=True)
fill_branch_info(info, repo.branches, islocal=False)
fill_merged_info(info, isremote=False)
fill_merged_info(info, isremote=True)
rows = []
for name in info.keys():
data = info[name]
if local and not data.local:
continue
rows.append({
"flags":
"{}{}{}{}.".format(
"*" if data.head else " ",
"M" if data.up2date or data.merged else ".",
"P" if data.pushed else ".",
"D" if data.gone else ".",
),
"local":
"local" if data.local else ".....",
"remote":
"remote" if data.remote else "......",
"name":
name,
"log":
first_line(repo[data.target].message),
})
# end
max_width, _ = os.get_terminal_size(0)
used = 5 + 1 + 5 + 1 + 6 + 1 + 30 + 1
remaining = max_width - 1 - used
WIDTHS = {
"flags": 5,
"local": 5,
"remote": 6,
"name": 30,
"log": remaining
}
with OutputFormat("text"):
print_table(["flags", "local", "remote", "name", "log"],
rows,
max_column_widths=WIDTHS)
click.secho(" " * (max_width - 1), fg="black", bg="white")
print("* = current checkout, M = branch is merged into master")
print(
"P = local has been pushed into it's remote, D = No matching upstream branch for local"
)
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
creds_mapping = {"identifier": "client_id", "password": "******"}
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
result = generic_ansible('Azure', 'azure_rm_resource_info', args,
int_params, host_type, creds_mapping)
if result:
return_results('ok')
else:
return_results(result)
elif command == 'azure-rm-autoscale':
return_results(
generic_ansible('Azure', 'azure_rm_autoscale', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-autoscale-info':
return_results(
generic_ansible('Azure', 'azure_rm_autoscale_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-availabilityset':
return_results(
generic_ansible('Azure', 'azure_rm_availabilityset', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-availabilityset-info':
return_results(
generic_ansible('Azure', 'azure_rm_availabilityset_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-deployment':
return_results(
generic_ansible('Azure', 'azure_rm_deployment', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-deployment-info':
return_results(
generic_ansible('Azure', 'azure_rm_deployment_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-functionapp':
return_results(
generic_ansible('Azure', 'azure_rm_functionapp', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-functionapp-info':
return_results(
generic_ansible('Azure', 'azure_rm_functionapp_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-gallery':
return_results(
generic_ansible('Azure', 'azure_rm_gallery', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-gallery-info':
return_results(
generic_ansible('Azure', 'azure_rm_gallery_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-galleryimage':
return_results(
generic_ansible('Azure', 'azure_rm_galleryimage', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-galleryimage-info':
return_results(
generic_ansible('Azure', 'azure_rm_galleryimage_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-galleryimageversion':
return_results(
generic_ansible('Azure', 'azure_rm_galleryimageversion', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-galleryimageversion-info':
return_results(
generic_ansible('Azure', 'azure_rm_galleryimageversion_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-image':
return_results(
generic_ansible('Azure', 'azure_rm_image', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-image-info':
return_results(
generic_ansible('Azure', 'azure_rm_image_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-loadbalancer':
return_results(
generic_ansible('Azure', 'azure_rm_loadbalancer', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-loadbalancer-info':
return_results(
generic_ansible('Azure', 'azure_rm_loadbalancer_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-manageddisk':
return_results(
generic_ansible('Azure', 'azure_rm_manageddisk', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-manageddisk-info':
return_results(
generic_ansible('Azure', 'azure_rm_manageddisk_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-resource-info':
return_results(
generic_ansible('Azure', 'azure_rm_resource_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-resourcegroup':
return_results(
generic_ansible('Azure', 'azure_rm_resourcegroup', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-resourcegroup-info':
return_results(
generic_ansible('Azure', 'azure_rm_resourcegroup_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-snapshot':
return_results(
generic_ansible('Azure', 'azure_rm_snapshot', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-virtualmachine':
return_results(
generic_ansible('Azure', 'azure_rm_virtualmachine', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachine-info':
return_results(
generic_ansible('Azure', 'azure_rm_virtualmachine_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachineextension':
return_results(
generic_ansible('Azure', 'azure_rm_virtualmachineextension',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachineextension-info':
return_results(
generic_ansible('Azure',
'azure_rm_virtualmachineextension_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachineimage-info':
return_results(
generic_ansible('Azure', 'azure_rm_virtualmachineimage_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachinescaleset':
return_results(
generic_ansible('Azure', 'azure_rm_virtualmachinescaleset',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachinescaleset-info':
return_results(
generic_ansible('Azure',
'azure_rm_virtualmachinescaleset_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachinescalesetextension':
return_results(
generic_ansible('Azure',
'azure_rm_virtualmachinescalesetextension',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachinescalesetextension-info':
return_results(
generic_ansible(
'Azure', 'azure_rm_virtualmachinescalesetextension_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachinescalesetinstance':
return_results(
generic_ansible('Azure',
'azure_rm_virtualmachinescalesetinstance',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualmachinescalesetinstance-info':
return_results(
generic_ansible(
'Azure', 'azure_rm_virtualmachinescalesetinstance_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-webapp':
return_results(
generic_ansible('Azure', 'azure_rm_webapp', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-webapp-info':
return_results(
generic_ansible('Azure', 'azure_rm_webapp_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-webappslot':
return_results(
generic_ansible('Azure', 'azure_rm_webappslot', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-azurefirewall':
return_results(
generic_ansible('Azure', 'azure_rm_azurefirewall', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-azurefirewall-info':
return_results(
generic_ansible('Azure', 'azure_rm_azurefirewall_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualnetwork':
return_results(
generic_ansible('Azure', 'azure_rm_virtualnetwork', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualnetwork-info':
return_results(
generic_ansible('Azure', 'azure_rm_virtualnetwork_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualnetworkgateway':
return_results(
generic_ansible('Azure', 'azure_rm_virtualnetworkgateway',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualnetworkpeering':
return_results(
generic_ansible('Azure', 'azure_rm_virtualnetworkpeering',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-virtualnetworkpeering-info':
return_results(
generic_ansible('Azure', 'azure_rm_virtualnetworkpeering_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-subnet':
return_results(
generic_ansible('Azure', 'azure_rm_subnet', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-subnet-info':
return_results(
generic_ansible('Azure', 'azure_rm_subnet_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-trafficmanagerendpoint':
return_results(
generic_ansible('Azure', 'azure_rm_trafficmanagerendpoint',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-trafficmanagerendpoint-info':
return_results(
generic_ansible('Azure',
'azure_rm_trafficmanagerendpoint_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-trafficmanagerprofile':
return_results(
generic_ansible('Azure', 'azure_rm_trafficmanagerprofile',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-trafficmanagerprofile-info':
return_results(
generic_ansible('Azure', 'azure_rm_trafficmanagerprofile_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-networkinterface':
return_results(
generic_ansible('Azure', 'azure_rm_networkinterface', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-networkinterface-info':
return_results(
generic_ansible('Azure', 'azure_rm_networkinterface_info',
args, int_params, host_type, creds_mapping))
elif command == 'azure-rm-publicipaddress':
return_results(
generic_ansible('Azure', 'azure_rm_publicipaddress', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-publicipaddress-info':
return_results(
generic_ansible('Azure', 'azure_rm_publicipaddress_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-route':
return_results(
generic_ansible('Azure', 'azure_rm_route', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-routetable':
return_results(
generic_ansible('Azure', 'azure_rm_routetable', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-routetable-info':
return_results(
generic_ansible('Azure', 'azure_rm_routetable_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-securitygroup':
return_results(
generic_ansible('Azure', 'azure_rm_securitygroup', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-securitygroup-info':
return_results(
generic_ansible('Azure', 'azure_rm_securitygroup_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-dnsrecordset':
return_results(
generic_ansible('Azure', 'azure_rm_dnsrecordset', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-dnsrecordset-info':
return_results(
generic_ansible('Azure', 'azure_rm_dnsrecordset_info', args,
int_params, host_type, creds_mapping))
elif command == 'azure-rm-dnszone':
return_results(
generic_ansible('Azure', 'azure_rm_dnszone', args, int_params,
host_type, creds_mapping))
elif command == 'azure-rm-dnszone-info':
return_results(
generic_ansible('Azure', 'azure_rm_dnszone_info', args,
int_params, host_type, creds_mapping))
# Log exceptions and return errors
except Exception as e:
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
try:
if demisto.command() == 'test-module':
# This is the call made when pressing the integration Test button.
return_results('ok')
elif demisto.command() == 'azure-rm-autoscale':
return_results(generic_ansible('azurecomputev3', 'azure_rm_autoscale', demisto.args()))
elif demisto.command() == 'azure-rm-autoscale-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_autoscale_info', demisto.args()))
elif demisto.command() == 'azure-rm-availabilityset':
return_results(generic_ansible('azurecomputev3', 'azure_rm_availabilityset', demisto.args()))
elif demisto.command() == 'azure-rm-availabilityset-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_availabilityset_info', demisto.args()))
elif demisto.command() == 'azure-rm-deployment':
return_results(generic_ansible('azurecomputev3', 'azure_rm_deployment', demisto.args()))
elif demisto.command() == 'azure-rm-deployment-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_deployment_info', demisto.args()))
elif demisto.command() == 'azure-rm-functionapp':
return_results(generic_ansible('azurecomputev3', 'azure_rm_functionapp', demisto.args()))
elif demisto.command() == 'azure-rm-functionapp-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_functionapp_info', demisto.args()))
elif demisto.command() == 'azure-rm-gallery':
return_results(generic_ansible('azurecomputev3', 'azure_rm_gallery', demisto.args()))
elif demisto.command() == 'azure-rm-gallery-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_gallery_info', demisto.args()))
elif demisto.command() == 'azure-rm-galleryimage':
return_results(generic_ansible('azurecomputev3', 'azure_rm_galleryimage', demisto.args()))
elif demisto.command() == 'azure-rm-galleryimage-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_galleryimage_info', demisto.args()))
elif demisto.command() == 'azure-rm-galleryimageversion':
return_results(generic_ansible('azurecomputev3', 'azure_rm_galleryimageversion', demisto.args()))
elif demisto.command() == 'azure-rm-galleryimageversion-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_galleryimageversion_info', demisto.args()))
elif demisto.command() == 'azure-rm-image':
return_results(generic_ansible('azurecomputev3', 'azure_rm_image', demisto.args()))
elif demisto.command() == 'azure-rm-image-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_image_info', demisto.args()))
elif demisto.command() == 'azure-rm-loadbalancer':
return_results(generic_ansible('azurecomputev3', 'azure_rm_loadbalancer', demisto.args()))
elif demisto.command() == 'azure-rm-loadbalancer-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_loadbalancer_info', demisto.args()))
elif demisto.command() == 'azure-rm-manageddisk':
return_results(generic_ansible('azurecomputev3', 'azure_rm_manageddisk', demisto.args()))
elif demisto.command() == 'azure-rm-manageddisk-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_manageddisk_info', demisto.args()))
elif demisto.command() == 'azure-rm-resource':
return_results(generic_ansible('azurecomputev3', 'azure_rm_resource', demisto.args()))
elif demisto.command() == 'azure-rm-resource-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_resource_info', demisto.args()))
elif demisto.command() == 'azure-rm-resourcegroup':
return_results(generic_ansible('azurecomputev3', 'azure_rm_resourcegroup', demisto.args()))
elif demisto.command() == 'azure-rm-resourcegroup-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_resourcegroup_info', demisto.args()))
elif demisto.command() == 'azure-rm-snapshot':
return_results(generic_ansible('azurecomputev3', 'azure_rm_snapshot', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachine':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachine', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachine-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachine_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachineextension':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachineextension', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachineextension-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachineextension_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachineimage-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachineimage_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachinescaleset':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachinescaleset', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachinescaleset-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachinescaleset_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachinescalesetextension':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachinescalesetextension', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachinescalesetextension-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachinescalesetextension_info', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachinescalesetinstance':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachinescalesetinstance', demisto.args()))
elif demisto.command() == 'azure-rm-virtualmachinescalesetinstance-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_virtualmachinescalesetinstance_info', demisto.args()))
elif demisto.command() == 'azure-rm-webapp':
return_results(generic_ansible('azurecomputev3', 'azure_rm_webapp', demisto.args()))
elif demisto.command() == 'azure-rm-webapp-info':
return_results(generic_ansible('azurecomputev3', 'azure_rm_webapp_info', demisto.args()))
elif demisto.command() == 'azure-rm-webappslot':
return_results(generic_ansible('azurecomputev3', 'azure_rm_webappslot', demisto.args()))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
result = generic_ansible('CiscoIOS', 'ios_facts', args, int_params,
host_type)
if result:
return_results('ok')
else:
return_results(result)
elif command == 'ios-banner':
return_results(
generic_ansible('CiscoIOS', 'ios_banner', args, int_params,
host_type))
elif command == 'ios-bgp':
return_results(
generic_ansible('CiscoIOS', 'ios_bgp', args, int_params,
host_type))
elif command == 'ios-command':
return_results(
generic_ansible('CiscoIOS', 'ios_command', args, int_params,
host_type))
elif command == 'ios-config':
return_results(
generic_ansible('CiscoIOS', 'ios_config', args, int_params,
host_type))
elif command == 'ios-facts':
return_results(
generic_ansible('CiscoIOS', 'ios_facts', args, int_params,
host_type))
elif command == 'ios-interfaces':
return_results(
generic_ansible('CiscoIOS', 'ios_interfaces', args, int_params,
host_type))
elif command == 'ios-l2-interfaces':
return_results(
generic_ansible('CiscoIOS', 'ios_l2_interfaces', args,
int_params, host_type))
elif command == 'ios-l3-interfaces':
return_results(
generic_ansible('CiscoIOS', 'ios_l3_interfaces', args,
int_params, host_type))
elif command == 'ios-lacp':
return_results(
generic_ansible('CiscoIOS', 'ios_lacp', args, int_params,
host_type))
elif command == 'ios-lacp-interfaces':
return_results(
generic_ansible('CiscoIOS', 'ios_lacp_interfaces', args,
int_params, host_type))
elif command == 'ios-lag-interfaces':
return_results(
generic_ansible('CiscoIOS', 'ios_lag_interfaces', args,
int_params, host_type))
elif command == 'ios-linkagg':
return_results(
generic_ansible('CiscoIOS', 'ios_linkagg', args, int_params,
host_type))
elif command == 'ios-lldp':
return_results(
generic_ansible('CiscoIOS', 'ios_lldp', args, int_params,
host_type))
elif command == 'ios-lldp-global':
return_results(
generic_ansible('CiscoIOS', 'ios_lldp_global', args,
int_params, host_type))
elif command == 'ios-lldp-interfaces':
return_results(
generic_ansible('CiscoIOS', 'ios_lldp_interfaces', args,
int_params, host_type))
elif command == 'ios-logging':
return_results(
generic_ansible('CiscoIOS', 'ios_logging', args, int_params,
host_type))
elif command == 'ios-ntp':
return_results(
generic_ansible('CiscoIOS', 'ios_ntp', args, int_params,
host_type))
elif command == 'ios-ping':
return_results(
generic_ansible('CiscoIOS', 'ios_ping', args, int_params,
host_type))
elif command == 'ios-static-route':
return_results(
generic_ansible('CiscoIOS', 'ios_static_route', args,
int_params, host_type))
elif command == 'ios-system':
return_results(
generic_ansible('CiscoIOS', 'ios_system', args, int_params,
host_type))
elif command == 'ios-user':
return_results(
generic_ansible('CiscoIOS', 'ios_user', args, int_params,
host_type))
elif command == 'ios-vlans':
return_results(
generic_ansible('CiscoIOS', 'ios_vlans', args, int_params,
host_type))
elif command == 'ios-vrf':
return_results(
generic_ansible('CiscoIOS', 'ios_vrf', args, int_params,
host_type))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
# SSH Key integration requires ssh_agent to be running in the background
ssh_agent_setup.setup()
# Common Inputs
command = demisto.command()
args = demisto.args()
int_params = demisto.params()
creds_mapping = {"password": "******"}
try:
if command == 'test-module':
# This is the call made when pressing the integration Test button.
result = generic_ansible('HCloud', 'hcloud_datacenter_info', args,
int_params, host_type, creds_mapping)
if result:
return_results('ok')
else:
return_results(result)
elif command == 'hcloud-datacenter-info':
return_results(
generic_ansible('HCloud', 'hcloud_datacenter_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-floating-ip-info':
return_results(
generic_ansible('HCloud', 'hcloud_floating_ip_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-image-info':
return_results(
generic_ansible('HCloud', 'hcloud_image_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-location-info':
return_results(
generic_ansible('HCloud', 'hcloud_location_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-network':
return_results(
generic_ansible('HCloud', 'hcloud_network', args, int_params,
host_type, creds_mapping))
elif command == 'hcloud-network-info':
return_results(
generic_ansible('HCloud', 'hcloud_network_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-rdns':
return_results(
generic_ansible('HCloud', 'hcloud_rdns', args, int_params,
host_type, creds_mapping))
elif command == 'hcloud-route':
return_results(
generic_ansible('HCloud', 'hcloud_route', args, int_params,
host_type, creds_mapping))
elif command == 'hcloud-server':
return_results(
generic_ansible('HCloud', 'hcloud_server', args, int_params,
host_type, creds_mapping))
elif command == 'hcloud-server-info':
return_results(
generic_ansible('HCloud', 'hcloud_server_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-server-network':
return_results(
generic_ansible('HCloud', 'hcloud_server_network', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-server-type-info':
return_results(
generic_ansible('HCloud', 'hcloud_server_type_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-ssh-key':
return_results(
generic_ansible('HCloud', 'hcloud_ssh_key', args, int_params,
host_type, creds_mapping))
elif command == 'hcloud-ssh-key-info':
return_results(
generic_ansible('HCloud', 'hcloud_ssh_key_info', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-subnetwork':
return_results(
generic_ansible('HCloud', 'hcloud_subnetwork', args,
int_params, host_type, creds_mapping))
elif command == 'hcloud-volume':
return_results(
generic_ansible('HCloud', 'hcloud_volume', args, int_params,
host_type, creds_mapping))
elif command == 'hcloud-volume-info':
return_results(
generic_ansible('HCloud', 'hcloud_volume_info', args,
int_params, host_type, creds_mapping))
# Log exceptions and return errors
except Exception as e:
return_error(f'Failed to execute {command} command.\nError:\n{str(e)}')
