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)