def get_tickets(
self,
*,
trash: Optional[bool] = None,
filter: Optional[str] = None,
filter_id: Optional[str] = None
) -> Any:
"""Request a list of tickets
Arguments:
filter: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: True to request the tickets in the trashcan
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_tickets")
_add_filter(cmd, filter, filter_id)
if trash is not None:
cmd.set_attribute("trash", _to_bool(trash))
return self._send_xml_command(cmd)
def delete_ticket(self,
ticket_id: str,
*,
ultimate: Optional[bool] = False):
"""Deletes an existing ticket
Arguments:
ticket_id: UUID of the ticket to be deleted.
ultimate: Whether to remove entirely, or to the trashcan.
"""
if not ticket_id:
raise RequiredArgument(function=self.delete_ticket.__name__,
argument='ticket_id')
cmd = XmlCommand("delete_ticket")
cmd.set_attribute("ticket_id", ticket_id)
cmd.set_attribute("ultimate", _to_bool(ultimate))
return self._send_xml_command(cmd)
def create_credential(
self,
name: str,
credential_type: CredentialType,
*,
comment: Optional[str] = None,
allow_insecure: Optional[bool] = None,
certificate: Optional[str] = None,
key_phrase: Optional[str] = None,
private_key: Optional[str] = None,
login: Optional[str] = None,
password: Optional[str] = None,
auth_algorithm: Optional[SnmpAuthAlgorithm] = None,
community: Optional[str] = None,
privacy_algorithm: Optional[SnmpPrivacyAlgorithm] = None,
privacy_password: Optional[str] = None,
public_key: Optional[str] = None) -> Any:
"""Create a new credential
Create a new credential e.g. to be used in the method of an alert.
Currently the following credential types are supported:
- Username + Password
- Username + SSH-Key
- Client Certificates
- SNMPv1 or SNMPv2c protocol
- S/MIME Certificate
- OpenPGP Key
- Password only
Arguments:
name: Name of the new credential
credential_type: The credential type.
comment: Comment for the credential
allow_insecure: Whether to allow insecure use of the credential
certificate: Certificate for the credential.
Required for client-certificate and smime credential types.
key_phrase: Key passphrase for the private key.
Used for the username+ssh-key credential type.
private_key: Private key to use for login. Required
for usk credential type. Also used for the cc credential type.
The supported key types (dsa, rsa, ecdsa, ...) and formats (PEM,
PKC#12, OpenSSL, ...) depend on your installed GnuTLS version.
login: Username for the credential. Required for username+password,
username+ssh-key and snmp credential type.
password: Password for the credential. Used for username+password
and snmp credential types.
community: The SNMP community
auth_algorithm: The SNMP authentication algorithm. Required for snmp
credential type.
privacy_algorithm: The SNMP privacy algorithm
privacy_password: The SNMP privacy password
public_key: PGP public key in *armor* plain text format. Required
for pgp credential type.
Examples:
Creating a Username + Password credential
.. code-block:: python
gmp.create_credential(
name='UP Credential',
credential_type=CredentialType.USERNAME_PASSWORD,
login='******',
password='******',
);
Creating a Username + SSH Key credential
.. code-block:: python
with open('path/to/private-ssh-key') as f:
key = f.read()
gmp.create_credential(
name='USK Credential',
credential_type=CredentialType.USERNAME_SSH_KEY,
login='******',
key_phrase='foobar',
private_key=key,
)
Creating a PGP credential
.. note::
A compatible public pgp key file can be exported with GnuPG via
::
$ gpg --armor --export [email protected] > alice.asc
.. code-block:: python
with open('path/to/pgp.key.asc') as f:
key = f.read()
gmp.create_credential(
name='PGP Credential',
credential_type=CredentialType.PGP_ENCRYPTION_KEY,
public_key=key,
)
Creating a S/MIME credential
.. code-block:: python
with open('path/to/smime-cert') as f:
cert = f.read()
gmp.create_credential(
name='SMIME Credential',
credential_type=CredentialType.SMIME_CERTIFICATE,
certificate=cert,
)
Creating a Password-Only credential
.. code-block:: python
gmp.create_credential(
name='Password-Only Credential',
credential_type=CredentialType.PASSWORD_ONLY,
password='******',
)
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not name:
raise RequiredArgument(function=self.create_credential.__name__,
argument='name')
if not isinstance(credential_type, CredentialType):
raise InvalidArgumentType(
function=self.create_credential.__name__,
argument='credential_type',
arg_type=CredentialType.__name__,
)
cmd = XmlCommand("create_credential")
cmd.add_element("name", name)
cmd.add_element("type", credential_type.value)
if comment:
cmd.add_element("comment", comment)
if allow_insecure is not None:
cmd.add_element("allow_insecure", _to_bool(allow_insecure))
if (credential_type == CredentialType.CLIENT_CERTIFICATE
or credential_type == CredentialType.SMIME_CERTIFICATE):
if not certificate:
raise RequiredArgument(
function=self.create_credential.__name__,
argument='certificate',
)
cmd.add_element("certificate", certificate)
if (credential_type == CredentialType.USERNAME_PASSWORD
or credential_type == CredentialType.USERNAME_SSH_KEY
or credential_type == CredentialType.SNMP):
if not login:
raise RequiredArgument(
function=self.create_credential.__name__,
argument='login',
)
cmd.add_element("login", login)
if credential_type == CredentialType.PASSWORD_ONLY and not password:
raise RequiredArgument(
function=self.create_credential.__name__,
argument='password',
)
if (credential_type == CredentialType.USERNAME_PASSWORD
or credential_type == CredentialType.SNMP or credential_type
== CredentialType.PASSWORD_ONLY) and password:
cmd.add_element("password", password)
if credential_type == CredentialType.USERNAME_SSH_KEY:
if not private_key:
raise RequiredArgument(
function=self.create_credential.__name__,
argument='private_key',
)
_xmlkey = cmd.add_element("key")
_xmlkey.add_element("private", private_key)
if key_phrase:
_xmlkey.add_element("phrase", key_phrase)
if credential_type == CredentialType.CLIENT_CERTIFICATE and private_key:
_xmlkey = cmd.add_element("key")
_xmlkey.add_element("private", private_key)
if credential_type == CredentialType.SNMP:
if not isinstance(auth_algorithm, SnmpAuthAlgorithm):
raise InvalidArgumentType(
function=self.create_credential.__name__,
argument='auth_algorithm',
arg_type=SnmpAuthAlgorithm.__name__,
)
cmd.add_element("auth_algorithm", auth_algorithm.value)
if community:
cmd.add_element("community", community)
if privacy_algorithm is not None or privacy_password:
_xmlprivacy = cmd.add_element("privacy")
if privacy_algorithm is not None:
if not isinstance(privacy_algorithm, SnmpPrivacyAlgorithm):
raise InvalidArgumentType(
function=self.create_credential.__name__,
argument='privacy_algorithm',
arg_type=SnmpPrivacyAlgorithm.__name__,
)
_xmlprivacy.add_element("algorithm",
privacy_algorithm.value)
if privacy_password:
_xmlprivacy.add_element("password", privacy_password)
if credential_type == CredentialType.PGP_ENCRYPTION_KEY:
if not public_key:
raise RequiredArgument(
function=self.create_credential.__name__,
argument='public_key',
)
_xmlkey = cmd.add_element("key")
_xmlkey.add_element("public", public_key)
return self._send_xml_command(cmd)
def modify_tag(self,
tag_id: str,
*,
comment: Optional[str] = None,
name: Optional[str] = None,
value=None,
active=None,
resource_action: Optional[str] = None,
resource_type: Optional[EntityType] = None,
resource_filter: Optional[str] = None,
resource_ids: Optional[List[str]] = None) -> Any:
"""Modifies an existing tag.
Arguments:
tag_id: UUID of the tag.
comment: Comment to add to the tag.
name: Name of the tag.
value: Value of the tag.
active: Whether the tag is active.
resource_action: Whether to add or remove resources instead of
overwriting. One of '', 'add', 'set' or 'remove'.
resource_type: Type of the resources to which to attach the tag.
Required if resource_filter is set.
resource_filter: Filter term to select resources the tag is to be
attached to.
resource_ids: IDs of the resources to which to attach the tag.
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not tag_id:
raise RequiredArgument(function=self.modify_tag.__name__,
argument='tag_id')
cmd = XmlCommand("modify_tag")
cmd.set_attribute("tag_id", str(tag_id))
if comment:
cmd.add_element("comment", comment)
if name:
cmd.add_element("name", name)
if value:
cmd.add_element("value", value)
if active is not None:
cmd.add_element("active", _to_bool(active))
if resource_action or resource_filter or resource_ids or resource_type:
if resource_filter and not resource_type:
raise RequiredArgument(
function=self.modify_tag.__name__,
argument='resource_type',
)
_xmlresources = cmd.add_element("resources")
if resource_action is not None:
_xmlresources.set_attribute("action", resource_action)
if resource_filter is not None:
_xmlresources.set_attribute("filter", resource_filter)
for resource_id in resource_ids or []:
_xmlresources.add_element("resource",
attrs={"id": str(resource_id)})
if resource_type is not None:
if not isinstance(resource_type, EntityType):
raise InvalidArgumentType(
function=self.modify_tag.__name__,
argument="resource_type",
arg_type=EntityType.__name__,
)
_xmlresources.add_element("type", resource_type.value)
return self._send_xml_command(cmd)
def modify_credential(
self,
credential_id: str,
*,
name: Optional[str] = None,
comment: Optional[str] = None,
allow_insecure: Optional[bool] = None,
certificate: Optional[str] = None,
key_phrase: Optional[str] = None,
private_key: Optional[str] = None,
login: Optional[str] = None,
password: Optional[str] = None,
auth_algorithm: Optional[SnmpAuthAlgorithm] = None,
community: Optional[str] = None,
privacy_algorithm: Optional[SnmpPrivacyAlgorithm] = None,
privacy_password: Optional[str] = None,
public_key: Optional[str] = None) -> Any:
"""Modifies an existing credential.
Arguments:
credential_id: UUID of the credential
name: Name of the credential
comment: Comment for the credential
allow_insecure: Whether to allow insecure use of the credential
certificate: Certificate for the credential
key_phrase: Key passphrase for the private key
private_key: Private key to use for login
login: Username for the credential
password: Password for the credential
auth_algorithm: The authentication algorithm for SNMP
community: The SNMP community
privacy_algorithm: The privacy algorithm for SNMP
privacy_password: The SNMP privacy password
public_key: PGP public key in *armor* plain text format
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not credential_id:
raise RequiredArgument(
function=self.modify_credential.__name__,
argument='credential_id',
)
cmd = XmlCommand("modify_credential")
cmd.set_attribute("credential_id", credential_id)
if comment:
cmd.add_element("comment", comment)
if name:
cmd.add_element("name", name)
if allow_insecure is not None:
cmd.add_element("allow_insecure", _to_bool(allow_insecure))
if certificate:
cmd.add_element("certificate", certificate)
if key_phrase and private_key:
_xmlkey = cmd.add_element("key")
_xmlkey.add_element("phrase", key_phrase)
_xmlkey.add_element("private", private_key)
elif (not key_phrase and private_key) or (key_phrase
and not private_key):
raise RequiredArgument(
function=self.modify_credential.__name__,
argument='key_phrase and private_key',
)
if login:
cmd.add_element("login", login)
if password:
cmd.add_element("password", password)
if auth_algorithm:
if not isinstance(auth_algorithm, SnmpAuthAlgorithm):
raise InvalidArgumentType(
function=self.modify_credential.__name__,
argument='auth_algorithm',
arg_type=SnmpAuthAlgorithm.__name__,
)
cmd.add_element("auth_algorithm", auth_algorithm.value)
if community:
cmd.add_element("community", community)
if privacy_algorithm is not None or privacy_password is not None:
_xmlprivacy = cmd.add_element("privacy")
if privacy_algorithm is not None:
if not isinstance(privacy_algorithm, SnmpPrivacyAlgorithm):
raise InvalidArgumentType(
function=self.modify_credential.__name__,
argument='privacy_algorithm',
arg_type=SnmpPrivacyAlgorithm.__name__,
)
_xmlprivacy.add_element("algorithm", privacy_algorithm.value)
if privacy_password is not None:
_xmlprivacy.add_element("password", privacy_password)
if public_key:
_xmlkey = cmd.add_element("key")
_xmlkey.add_element("public", public_key)
return self._send_xml_command(cmd)