gvmtools.pyshell.main() - Code Metrics - Inspection of "Use a common parser for both cli tools" - greenbone/gvm-tools - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#140)

unknown

created 2018-12-13 14:51 UTC

gvmtools.pyshell.main() C

↳ Parent: gvmtools.pyshell

Complexity

Conditions

Size

Total Lines	79
Code Lines	56

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	11
eloc	56
nop	0
dl	0
loc	79
rs	5.22
c	0
b	0
f	0

How to fix Long Method Complexity

# -*- 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/>.

import code
import logging
import os
import sys

from gvm import get_version as get_gvm_version
from gvm.protocols.latest import Gmp, Osp
from gvm.transforms import EtreeCheckCommandTransform

from gvmtools import get_version
from gvmtools.helper import authenticate
from gvmtools.parser import create_parser, create_connection, PROTOCOL_OSP

__version__ = get_version()
__api_version__ = get_gvm_version()

logger = logging.getLogger(__name__)

HELP_TEXT = """
    Command line tool to access services via GMP (Greenbone Management
    Protocol) and OSP (Open Scanner Protocol)

    gvm-pyshell provides an interactive shell for GMP and OSP services
    and can be used to execute custom OSP/GMP scripts.

    Example:
        >>> tasks = gmp.get_tasks()
        >>> task_names = tasks.xpath('task/name/text()')
        >>> print(task_names)
        ['Scan Task']

    The interactive shell can be exited with:
        Ctrl + D on Linux  or
        Ctrl + Z on Windows

    The protocol specifications for GMP and OSP are available at:
      https://docs.greenbone.net/index.html#api_documentation"""


class Help(object):
    """Help class to overwrite the help function from python itself.
    """

    def __call__(self):
        return print(HELP_TEXT)

    def __repr__(self):
        # do pwd command
        return HELP_TEXT


class Arguments:

    def __init__(self, **kwargs):
        self._args = kwargs

    def get(self, key):
        return self._args[key]

    def __getattr__(self, key):
        return self.get(key)

    def __setattr__(self, name, value):
        if name.startswith('_'):
            super().__setattr__(name, value)
        else:
            self._args[name] = value

    def __getitem__(self, key):
        return self.get(key)

    def __repr__(self):
        return repr(self._args)


def main():
    parser = create_parser(
        description=HELP_TEXT, logfilename='gvm-pyshell.log')

    parser.add_protocol_argument()

    parser.add_argument(
        '-i', '--interactive', action='store_true', default=False,
        help='Start an interactive Python shell')

    parser.add_argument(
        'scriptname', nargs='?', metavar="SCRIPT",
        help='Path to script to be preloaded (example: myscript.gmp)')
    parser.add_argument(
        'scriptargs', nargs='*', metavar="ARG",
        help='Arguments for preloaded script')

    args = parser.parse_args()

    if 'socket' in args.connection_type and args.sockpath:
        print('The --sockpath parameter has been deprecated. Please use '
              '--socketpath instead', file=sys.stderr)

    connection = create_connection(**vars(args))

    transform = EtreeCheckCommandTransform()

    global_vars = {
        'help': Help(),
        '__version__': __version__,
        '__api_version__': __api_version__,
    }

    username = None
    password = None

    if args.protocol == PROTOCOL_OSP:
        protocol = Osp(connection, transform=transform)
        global_vars['osp'] = protocol
        global_vars['__name__'] = '__osp__'
    else:
        protocol = Gmp(connection, transform=transform)
        global_vars['gmp'] = protocol
        global_vars['__name__'] = '__gmp__'

        if args.gmp_username:
            (username, password) = authenticate(
                protocol, username=args.gmp_username,
                password=args.gmp_password)

    shell_args = Arguments(
        username=username, password=password)

    global_vars['args'] = shell_args

    with_script = args.scriptname and len(args.scriptname) > 0

    if with_script:
        argv = [os.path.abspath(args.scriptname), *args.scriptargs]
        shell_args.argv = argv
        # for backwards compatibility we add script here
        shell_args.script = argv

    no_script_no_interactive = not args.interactive and not with_script
    script_and_interactive = args.interactive and with_script
    only_interactive = not with_script and args.interactive
    only_script = not args.interactive and with_script

    if only_interactive or no_script_no_interactive:
        enter_interactive_mode(global_vars)

    if script_and_interactive or only_script:
        script_name = args.scriptname
        load(script_name, global_vars)

        if not only_script:
            enter_interactive_mode(global_vars)

    protocol.disconnect()


def enter_interactive_mode(global_vars):
    code.interact(
        banner='GVM Interactive Console. Type "help" to get information \
about functionality.',
        local=dict(global_vars))


def load(path, global_vars):
    """Loads a file into the interactive console

    Loads a file into the interactive console and execute it.
    TODO: Needs some security checks.

    Arguments:
        path {str} -- Path of file
    """
    try:
        file = open(path, 'r', newline='').read()

        exec(file, global_vars) # pylint: disable=exec-used
    except OSError as e:
        print(str(e))


if __name__ == '__main__':
    main()


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			import code
20			import logging
21			import os
22			import sys
23
24			from gvm import get_version as get_gvm_version
25			from gvm.protocols.latest import Gmp, Osp
26			from gvm.transforms import EtreeCheckCommandTransform
27
28			from gvmtools import get_version
29			from gvmtools.helper import authenticate
30			from gvmtools.parser import create_parser, create_connection, PROTOCOL_OSP
31
32			__version__ = get_version()
33			__api_version__ = get_gvm_version()
34
35			logger = logging.getLogger(__name__)
36
37			HELP_TEXT = """
38			Command line tool to access services via GMP (Greenbone Management
39			Protocol) and OSP (Open Scanner Protocol)
40
41			gvm-pyshell provides an interactive shell for GMP and OSP services
42			and can be used to execute custom OSP/GMP scripts.
43
44			Example:
45			>>> tasks = gmp.get_tasks()
46			>>> task_names = tasks.xpath('task/name/text()')
47			>>> print(task_names)
48			['Scan Task']
49
50			The interactive shell can be exited with:
51			Ctrl + D on Linux or
52			Ctrl + Z on Windows
53
54			The protocol specifications for GMP and OSP are available at:
55			https://docs.greenbone.net/index.html#api_documentation"""
56
57
58			class Help(object):
59			"""Help class to overwrite the help function from python itself.
60			"""
61
62			def __call__(self):
63			return print(HELP_TEXT)
64
65			def __repr__(self):
66			# do pwd command
67			return HELP_TEXT
68
69
70			class Arguments:
71
72			def __init__(self, **kwargs):
73			self._args = kwargs
74
75			def get(self, key):
76			return self._args[key]
77
78			def __getattr__(self, key):
79			return self.get(key)
80
81			def __setattr__(self, name, value):
82			if name.startswith('_'):
83			super().__setattr__(name, value)
84			else:
85			self._args[name] = value
86
87			def __getitem__(self, key):
88			return self.get(key)
89
90			def __repr__(self):
91			return repr(self._args)
92
93
94			def main():
95			parser = create_parser(
96			description=HELP_TEXT, logfilename='gvm-pyshell.log')
97
98			parser.add_protocol_argument()
99
100			parser.add_argument(
101			'-i', '--interactive', action='store_true', default=False,
102			help='Start an interactive Python shell')
103
104			parser.add_argument(
105			'scriptname', nargs='?', metavar="SCRIPT",
106			help='Path to script to be preloaded (example: myscript.gmp)')
107			parser.add_argument(
108			'scriptargs', nargs='*', metavar="ARG",
109			help='Arguments for preloaded script')
110
111			args = parser.parse_args()
112
113			if 'socket' in args.connection_type and args.sockpath:
114			print('The --sockpath parameter has been deprecated. Please use '
115			'--socketpath instead', file=sys.stderr)
116
117			connection = create_connection(**vars(args))
118
119			transform = EtreeCheckCommandTransform()
120
121			global_vars = {
122			'help': Help(),
123			'__version__': __version__,
124			'__api_version__': __api_version__,
125			}
126
127			username = None
128			password = None
129
130			if args.protocol == PROTOCOL_OSP:
131			protocol = Osp(connection, transform=transform)
132			global_vars['osp'] = protocol
133			global_vars['__name__'] = '__osp__'
134			else:
135			protocol = Gmp(connection, transform=transform)
136			global_vars['gmp'] = protocol
137			global_vars['__name__'] = '__gmp__'
138
139			if args.gmp_username:
140			(username, password) = authenticate(
141			protocol, username=args.gmp_username,
142			password=args.gmp_password)
143
144			shell_args = Arguments(
145			username=username, password=password)
146
147			global_vars['args'] = shell_args
148
149			with_script = args.scriptname and len(args.scriptname) > 0
150
151			if with_script:
152			argv = [os.path.abspath(args.scriptname), *args.scriptargs]
153			shell_args.argv = argv
154			# for backwards compatibility we add script here
155			shell_args.script = argv
156
157			no_script_no_interactive = not args.interactive and not with_script
158			script_and_interactive = args.interactive and with_script
159			only_interactive = not with_script and args.interactive
160			only_script = not args.interactive and with_script
161
162			if only_interactive or no_script_no_interactive:
163			enter_interactive_mode(global_vars)
164
165			if script_and_interactive or only_script:
166			script_name = args.scriptname
167			load(script_name, global_vars)
168
169			if not only_script:
170			enter_interactive_mode(global_vars)
171
172			protocol.disconnect()
173
174
175			def enter_interactive_mode(global_vars):
176			code.interact(
177			banner='GVM Interactive Console. Type "help" to get information \
178			about functionality.',
179			local=dict(global_vars))
180
181
182			def load(path, global_vars):
183			"""Loads a file into the interactive console
184
185			Loads a file into the interactive console and execute it.
186			TODO: Needs some security checks.
187
188			Arguments:
189			path {str} -- Path of file
190			"""
191			try:
192			file = open(path, 'r', newline='').read()
193
194			exec(file, global_vars) # pylint: disable=exec-used
195			except OSError as e:
196			print(str(e))
197
198
199			if __name__ == '__main__':
200			main()
201

greenbone / gvm-tools

Pull Request — master (#140)

gvmtools.pyshell.main() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like