gmp.protocols.gmpv7.Gmp._connect() - Code Metrics - Inspection of "Add own class for OSP support" - greenbone/gvm-tools - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#122)

by Juan José
created 2018-11-01 10:35 UTC
gmp.protocols.gmpv7.Gmp._connect() A

↳ Parent: gmp.protocols.gmpv7.Gmp.authenticate()
Complexity

Conditions
Size

Total Lines	4
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	4
nop	1
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.protocols.base import Protocol
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(Protocol):

    """Python interface for Greenbone Management Protocol

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

    Attributes:
        connection (:class:`gmp.connections.GmpConnection`): Connection to use
            to talk with the gvmd daemon. See :mod:`gmp.connections` 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.transforms` 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):
        super().__init__(connection, transform)

        # Is authenticated on gvmd
        self._authenticated = False

        # GMP Message Creator
        self._generator = GmpCommandFactory()

    @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 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 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 = self._generator.delete_agent_command(kwargs)
        return self.send_command(cmd)

    def delete_alert(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.delete_alert_command(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 = self._generator.delete_asset_command(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 = self._generator.delete_config_command(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 = self._generator.delete_credential_command(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 = self._generator.delete_filter_command(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 = self._generator.delete_group_command(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 = self._generator.delete_note_command(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 = self._generator.delete_override_command(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 = self._generator.delete_permission_command(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 = self._generator.delete_port_list_command(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 = self._generator.delete_port_range_command(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 = self._generator.delete_report_command(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 = self._generator.delete_report_format_command(
            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 = self._generator.delete_role_command(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 = self._generator.delete_scanner_command(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."""
        cmd = self._generator.delete_schedule_command(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 = self._generator.delete_tag_command(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 = self._generator.delete_target_command(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 = self._generator.delete_task_command(task_id, ultimate)
        return self.send_command(cmd)

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

    def describe_auth(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.describe_command()

        return self.send_command(cmd)

    def empty_trashcan(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.empty_trashcan_command()
        return self.send_command(cmd)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return self.send_command(cmd)

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

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

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

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

    def get_version(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.get_version_command()
        return self.send_command(cmd)

    def help(self, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cmd = self._generator.help_command(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			import logging
22
23			from lxml import etree
24
25			from gmp.protocols.base import Protocol
26			from gmp.xml import _GmpCommandFactory as GmpCommandFactory
27
28			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...
29
30			PROTOCOL_VERSION = (7,)
31
32			def arguments_to_string(kwargs):
33			"""Convert arguments
34
35			Converts dictionaries into gmp arguments string
36
37			Arguments:
38			kwargs {dict} -- Arguments
39
greenbone / gvm-tools

Pull Request — master (#122)

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

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
