gmp.protocols.gmpv7.Gmp.delete_permission() - Code Metrics - Inspection of "Api improvements" - greenbone/gvm-tools - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#119)

unknown
created 2018-10-30 14:29 UTC
gmp.protocols.gmpv7.Gmp.delete_permission() A

↳ Parent: gmp.protocols.gmpv7
Complexity

Conditions
Size

Total Lines	4
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	4
nop	3
dl	0
loc	4
rs	10
c	0
b	0
f	0
# -*- coding: utf-8 -*-
# Copyright (C) 2018 Greenbone Networks GmbH
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""
Module for communication with gvmd in Greenbone Management Protocol version 7
"""

import logging

from lxml import etree

from gmp.errors import GmpError
from gmp.xml import _GmpCommandFactory as GmpCommandFactory

logger = logging.getLogger(__name__)


PROTOCOL_VERSION = (7,)

def arguments_to_string(kwargs):
    """Convert arguments

    Converts dictionaries into gmp arguments string

    Arguments:
        kwargs {dict} -- Arguments

    Returns:
        string -- Arguments as string
    """
    msg = ''
    for key, value in kwargs.items():
        msg += str(key) + '=\'' + str(value) + '\' '

    return msg

def _check_command_status(xml):
    """Check gmp response

    Look into the gmp response and check for the status in the root element

    Arguments:
        xml {string} -- XML-Source

    Returns:
        bool -- True if valid, otherwise False
    """

    if xml is 0 or xml is None:
        logger.error('XML Command is empty')
        return False

    try:
        parser = etree.XMLParser(encoding='utf-8', recover=True)


        root = etree.XML(xml, parser=parser)

        status = root.attrib['status']
        return status is not None and status[0] == '2'

    except etree.Error as e:

        logger.error('etree.XML(xml): %s', e)
        return False


class Gmp:

    """Python interface for Greenbone Management Protocol

    This class implements the `Greenbone Management Protocol version 7`_

    Attributes:
        connection (:class:`gmp.connection.GmpConnection`): Connection to use to
            talk with the gvmd daemon. See :mod:`gmp.connection` for possible
            connection types.
        transform (`callable`_, optional): Optional transform callable to
            convert response data. After each request the callable gets passed
            the plain response data which can be used to check the data and/or
            conversion into different representaitions like a xml dom.

            See :mod:`gmp.transform` for existing transforms.

    .. _Greenbone Management Protocol version 7:
        https://docs.greenbone.net/API/GMP/gmp-7.0.html
    .. _callable:
        https://docs.python.org/3.6/library/functions.html#callable
    """

    def __init__(self, connection, transform=None):
        # GMP Message Creator
        self._generator = GmpCommandFactory()
        self._connection = connection

        self._connected = False

        # Is authenticated on gvm
        self._authenticated = False

        self._transform_callable = transform

    @staticmethod
    def get_protocol_version():
        """Allow to determine the Greenbone Management Protocol version.

            Returns:
                str: Implemented version of the Greenbone Management Protocol
        """
        return '.'.join(str(x) for x in PROTOCOL_VERSION)

    def _read(self):
        """Read a command response from gvmd

        Returns:
            str: Response from server.
        """
        response = self._connection.read()

        logger.debug('read() %i Bytes response: %s', len(response), response)

        if response is None or len(str(response)) == 0:

            raise GmpError('Connection was closed by remote server')

        return response

    def _send(self, data):
        """Send a command to gvmd

        Args:
            data (str): Data to be send over the connection to gvmd
        """
        self._connect()
        self._connection.send(data)

    def _connect(self):
        if not self.is_connected():
            self._connection.connect()
            self._connected = True

    def _transform(self, data):
        transform = self._transform_callable
        if transform is None:
            return data
        return transform(data)

    def is_connected(self):
        """Status of the current connection to gvmd

        Returns:
            bool: True if a connection to gvmd has been established.
        """
        return self._connected

    def is_authenticated(self):
        """Checks if the user is authenticated

        If the user is authenticated privilged GMP commands like get_tasks
        may be send to gvmd.

        Returns:
            bool: True if an authenticated connection to gvmd has been
            established.
        """
        return self._authenticated

    def disconnect(self):
        """Disconnect the connection to gvmd.

        Ends and closes the connection to gvmd.
        """
        if self.is_connected():
            self._connection.disconnect()
            self._connected = False

    def send_command(self, cmd):
        """Send a GMP command to gsad

        If the class isn't connected to gvmd yet the connection will be
        established automatically.

        Arguments:
            cmd (str): GMP command as string to be send over the connection to
                gvmd.

        Returns:
            any: The actual returned type depends on the set transform.

            Per default - if no transform is set explicitly - the response is
            returned as string.
        """
        self._send(cmd)
        response = self._read()
        return self._transform(response)

    def authenticate(self, username, password):
        """Authenticate to gvmd.

        The generated authenticate command will be send to server.
        Afterwards the response is read, tranformed and returned.

        Arguments:
            username (str): Username
            password (str): Password

        Returns:
            any, str by default: Transformed response from server.
        """
        cmd = self._generator.create_authenticate_command(
            username=username, password=password)

        self._send(cmd)
        response = self._read()

        if _check_command_status(response):
            self._authenticated = True

        return self._transform(response)

    def create_agent(self, installer, signature, name, comment='', copy='',
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                     howto_install='', howto_use=''):
        cmd = self._generator.create_agent_command(
            installer, signature, name, comment, copy, howto_install,
            howto_use)
        return self.send_command(cmd)

    def create_alert(self, name, condition, event, method, filter_id='',
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                     copy='', comment=''):
        cmd = self._generator.create_alert_command(name, condition, event,
                                                   method, filter_id, copy,
                                                   comment)
        return self.send_command(cmd)

    def create_asset(self, name, asset_type, comment=''):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        # TODO: Add the missing second method. Also the docs are not complete!

        cmd = self._generator.create_asset_command(name, asset_type, comment)
        return self.send_command(cmd)

    def create_config(self, copy_id, name):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_config_command(copy_id, name)
        return self.send_command(cmd)

    def create_credential(self, name, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_credential_command(name, kwargs)
        return self.send_command(cmd)

    def create_filter(self, name, make_unique, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_filter_command(name, make_unique,
                                                    kwargs)
        return self.send_command(cmd)

    def create_group(self, name, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_group_command(name, kwargs)
        return self.send_command(cmd)

    # TODO: Create notes with comment returns bogus element. Research

    def create_note(self, text, nvt_oid, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_note_command(text, nvt_oid, kwargs)
        return self.send_command(cmd)

    def create_override(self, text, nvt_oid, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_override_command(text, nvt_oid, kwargs)
        return self.send_command(cmd)

    def create_permission(self, name, subject_id, permission_type, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_permission_command(
            name, subject_id, permission_type, kwargs)
        return self.send_command(cmd)

    def create_port_list(self, name, port_range, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_port_list_command(name, port_range, kwargs)
        return self.send_command(cmd)

    def create_port_range(self, port_list_id, start, end, port_range_type,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                          comment=''):
        cmd = self._generator.create_port_range_command(
            port_list_id, start, end, port_range_type, comment)
        return self.send_command(cmd)

    def create_report(self, report_xml_string, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_report_command(report_xml_string, kwargs)
        return self.send_command(cmd)

    def create_role(self, name, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_role_command(name, kwargs)
        return self.send_command(cmd)

    def create_scanner(self, name, host, port, scanner_type, ca_pub,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                       credential_id, **kwargs):
        cmd = self._generator.create_scanner_command(name, host, port,
                                                     scanner_type, ca_pub,
                                                     credential_id, kwargs)
        return self.send_command(cmd)

    def create_schedule(self, name, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_schedule_command(name, kwargs)
        return self.send_command(cmd)

    def create_tag(self, name, resource_id, resource_type, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.create_tag_command(name, resource_id,
                                                 resource_type, kwargs)
        return self.send_command(cmd)

    def create_target(self, name, make_unique, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        # TODO: Missing variables

        cmd = self._generator.create_target_command(name, make_unique, kwargs)
        return self.send_command(cmd)

    def create_task(self, name, config_id, target_id, scanner_id,
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                    alert_ids=None, comment=''):
        if alert_ids is None:
            alert_ids = []
        cmd = self._generator.create_task_command(
            name, config_id, target_id, scanner_id, alert_ids, comment)
        return self.send_command(cmd)

    def create_user(self, name, password, copy='', hosts_allow='0',
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
                    ifaces_allow='0', role_ids=(), hosts=None, ifaces=None):
        cmd = self._generator.create_user_command(
            name, password, copy, hosts_allow, ifaces_allow, role_ids, hosts,
            ifaces)
        return self.send_command(cmd)

    def delete_agent(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_agent {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def delete_alert(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_alert {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def delete_asset(self, asset_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_asset asset_id="{0}" ultimate="{1}"/>'.format(
            asset_id, ultimate)
        return self.send_command(cmd)

    def delete_config(self, config_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_config config_id="{0}" ultimate="{1}"/>'.format(
            config_id, ultimate)
        return self.send_command(cmd)

    def delete_credential(self, credential_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_credential credential_id="{0}" ultimate="{1}"/>'.format(
            credential_id, ultimate)
        return self.send_command(cmd)

    def delete_filter(self, filter_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_filter filter_id="{0}" ultimate="{1}"/>'.format(
            filter_id, ultimate)
        return self.send_command(cmd)

    def delete_group(self, group_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_group group_id="{0}" ultimate="{1}"/>'.format(
            group_id, ultimate)
        return self.send_command(cmd)

    def delete_note(self, note_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_note note_id="{0}" ultimate="{1}"/>'.format(
            note_id, ultimate)
        return self.send_command(cmd)

    def delete_override(self, override_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_override override_id="{0}" ultimate="{1}"/>'.format(
            override_id, ultimate)
        return self.send_command(cmd)

    def delete_permission(self, permission_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_permission permission_id="{0}" ultimate="{1}"/>'.format(
            permission_id, ultimate)
        return self.send_command(cmd)

    def delete_port_list(self, port_list_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_port_list port_list_id="{0}" ultimate="{1}"/>'.format(
            port_list_id, ultimate)
        return self.send_command(cmd)

    def delete_port_range(self, port_range_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_port_range port_range_id="{0}"/>'.format(port_range_id)
        return self.send_command(cmd)

    def delete_report(self, report_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_report report_id="{0}"/>'.format(report_id)
        return self.send_command(cmd)

    def delete_report_format(self, report_format_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_report_format report_format_id="{0}" ' \
            'ultimate="{1}"/>'.format(report_format_id, ultimate)
        return self.send_command(cmd)

    def delete_role(self, role_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_role role_id="{0}" ultimate="{1}"/>'.format(
            role_id, ultimate)
        return self.send_command(cmd)

    def delete_scanner(self, scanner_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_scanner scanner_id="{0}" ultimate="{1}"/>'.format(
            scanner_id, ultimate)
        return self.send_command(cmd)

    def delete_schedule(self, schedule_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        # if self.ask_yes_or_no('Are you sure to delete this schedule? '):
        cmd = '<delete_schedule schedule_id="{0}" ultimate="{1}"/>'.format(
            schedule_id, ultimate)
        return self.send_command(cmd)

    def delete_tag(self, tag_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_tag tag_id="{0}" ultimate="{1}"/>'.format(
            tag_id, ultimate)
        return self.send_command(cmd)

    def delete_target(self, target_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_target target_id="{0}" ultimate="{1}"/>'.format(
            target_id, ultimate)
        return self.send_command(cmd)

    def delete_task(self, task_id, ultimate=0):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<delete_task task_id="{0}" ultimate="{1}"/>'.format(
            task_id, ultimate)
        return self.send_command(cmd)

    def delete_user(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        user_id = kwargs.get('user_id', '')
        if user_id:
            user_id = ' user_id="%s"' % user_id

        name = kwargs.get('name', '')
        if name:
            name = ' name="%s"' % name

        inheritor_id = kwargs.get('inheritor_id', '')
        if inheritor_id:
            inheritor_id = ' inheritor_id="%s"' % inheritor_id

        inheritor_name = kwargs.get('inheritor_name', '')
        if inheritor_name:
            inheritor_name = ' inheritor_name="%s"' % inheritor_name

        cmd = '<delete_user{0}{1}{2}{3}/>'.format(
            user_id, name, inheritor_id, inheritor_name)
        return self.send_command(cmd)

    def describe_auth(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self.send_command('<describe_auth/>')

    def empty_trashcan(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self.send_command('<empty_trashcan/>')

    def get_agents(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_agents {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_aggregates(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_aggregates {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_alerts(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_alerts {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_assets(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_assets {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_credentials(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_credentials {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_configs(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_configs {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_feeds(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_feeds {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_filters(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_filters {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_groups(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_groups {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_info(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_info {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_notes(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_notes {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_nvts(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_nvts {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_nvt_families(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_nvt_families {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_overrides(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_overrides {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_permissions(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_permissions {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_port_lists(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_port_lists {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_preferences(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_preferences {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_reports(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_reports {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_report_formats(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_report_formats {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_results(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_results {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_roles(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_roles {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_scanners(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_scanners {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_schedules(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_schedules {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_settings(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_settings {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_system_reports(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_system_reports {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_tags(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_tags {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_targets(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_targets {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_tasks(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_tasks {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_users(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<get_users {0}/>'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def get_version(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self.send_command('<get_version/>')

    def help(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<help {0} />'.format(arguments_to_string(kwargs))
        return self.send_command(cmd)

    def modify_agent(self, agent_id, name='', comment=''):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_agent_command(agent_id, name, comment)
        return self.send_command(cmd)

    def modify_alert(self, alert_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_alert_command(alert_id, kwargs)
        return self.send_command(cmd)

    def modify_asset(self, asset_id, comment):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<modify_asset asset_id="%s"><comment>%s</comment>' \
              '</modify_asset>' % (asset_id, comment)
        return self.send_command(cmd)

    def modify_auth(self, group_name, auth_conf_settings):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_auth_command(group_name,
                                                  auth_conf_settings)
        return self.send_command(cmd)

    def modify_config(self, selection, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_config_command(selection, kwargs)
        return self.send_command(cmd)

    def modify_credential(self, credential_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_credential_command(
            credential_id, kwargs)
        return self.send_command(cmd)

    def modify_filter(self, filter_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_filter_command(filter_id, kwargs)
        return self.send_command(cmd)

    def modify_group(self, group_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_group_command(group_id, kwargs)
        return self.send_command(cmd)

    def modify_note(self, note_id, text, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_note_command(note_id, text, kwargs)
        return self.send_command(cmd)

    def modify_override(self, override_id, text, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_override_command(override_id, text,
                                                      kwargs)
        return self.send_command(cmd)

    def modify_permission(self, permission_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_permission_command(
            permission_id, kwargs)
        return self.send_command(cmd)

    def modify_port_list(self, port_list_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_port_list_command(port_list_id, kwargs)
        return self.send_command(cmd)

    def modify_report(self, report_id, comment):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<modify_report report_id="{0}"><comment>{1}</comment>' \
              '</modify_report>'.format(report_id, comment)
        return self.send_command(cmd)

    def modify_report_format(self, report_format_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_report_format_command(report_format_id,
                                                           kwargs)
        return self.send_command(cmd)

    def modify_role(self, role_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_role_command(role_id, kwargs)
        return self.send_command(cmd)

    def modify_scanner(self, scanner_id, host, port, scanner_type, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_scanner_command(scanner_id, host, port,
                                                     scanner_type, kwargs)
        return self.send_command(cmd)

    def modify_schedule(self, schedule_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_schedule_command(schedule_id, kwargs)
        return self.send_command(cmd)

    def modify_setting(self, setting_id, name, value):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<modify_setting setting_id="{0}"><name>{1}</name>' \
              '<value>{2}</value></modify_setting>' \
              ''.format(setting_id, name, value)
        return self.send_command(cmd)

    def modify_tag(self, tag_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_tag_command(tag_id, kwargs)
        return self.send_command(cmd)

    def modify_target(self, target_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_target_command(target_id, kwargs)
        return self.send_command(cmd)

    def modify_task(self, task_id, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_task_command(task_id, kwargs)
        return self.send_command(cmd)

    def modify_user(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.modify_user_command(kwargs)
        return self.send_command(cmd)

    def move_task(self, task_id, slave_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<move_task task_id="{0}" slave_id="{1}"/>'.format(
            task_id, slave_id)
        return self.send_command(cmd)

    def restore(self, entity_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<restore id="{0}"/>'.format(entity_id)
        return self.send_command(cmd)

    def resume_task(self, task_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<resume_task task_id="{0}"/>'.format(task_id)
        return self.send_command(cmd)

    def start_task(self, task_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<start_task task_id="{0}"/>'.format(task_id)
        return self.send_command(cmd)

    def stop_task(self, task_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<stop_task task_id="{0}"/>'.format(task_id)
        return self.send_command(cmd)

    def sync_cert(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<sync_cert/>'
        return self.send_command(cmd)

    def sync_config(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<sync_config/>'
        return self.send_command(cmd)

    def sync_feed(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<sync_feed/>'
        return self.send_command(cmd)

    def sync_scap(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<sync_scap/>'
        return self.send_command(cmd)

    def test_alert(self, alert_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<test_alert alert_id="{0}"/>'.format(alert_id)
        return self.send_command(cmd)

    def verify_agent(self, agent_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<verify_agent agent_id="{0}"/>'.format(agent_id)
        return self.send_command(cmd)

    def verify_report_format(self, report_format_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<verify_report_format report_format_id="{0}"/>'.format(
            report_format_id)
        return self.send_command(cmd)

    def verify_scanner(self, scanner_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = '<verify_scanner scanner_id="{0}"/>'.format(scanner_id)
        return self.send_command(cmd)

1			# -- coding: utf-8 --
2			# Copyright (C) 2018 Greenbone Networks GmbH
3			#
4			# SPDX-License-Identifier: GPL-3.0-or-later
5			#
6			# This program is free software: you can redistribute it and/or modify
7			# it under the terms of the GNU General Public License as published by
8			# the Free Software Foundation, either version 3 of the License, or
9			# (at your option) any later version.
10			#
11			# This program is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with this program. If not, see <http://www.gnu.org/licenses/>.
18			"""
19			Module for communication with gvmd in Greenbone Management Protocol version 7
20			"""
21
22			import logging
23
24			from lxml import etree
25
26			from gmp.errors import GmpError
27			from gmp.xml import _GmpCommandFactory as GmpCommandFactory
28
29			logger = logging.getLogger(__name__)
			0 ignored issues – show Coding Style Naming introduced 2018-06-12 10:47 UTC by Report Bug Copy Issue Report The name `logger` does not conform to the constant naming conventions (`(([A-Z_][A-Z0-9_])\|(__.__))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
30
31			PROTOCOL_VERSION = (7,)
32
33			def arguments_to_string(kwargs):
34			"""Convert arguments
35
36			Converts dictionaries into gmp arguments string
37
38			Arguments:
39			kwargs {dict} -- Arguments
greenbone / gvm-tools

Pull Request — master (#119)

gmp.protocols.gmpv7.Gmp.delete_permission() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
