pax_global_header00006660000000000000000000000064130704475240014520gustar00rootroot0000000000000052 comment=c12641c728c05698a19935328d7d4987fd6e55e9 kytos-utils-2017.1b1.post1/000077500000000000000000000000001307044752400154115ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/.gitignore000066400000000000000000000021621307044752400174020ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class *.egg-info # C extensions *.so *.swp # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover .hypothesis/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ docs/kytos*.rst # PyBuilder target/ # IPython Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # dotenv .env # virtualenv venv/ ENV/ # Spyder project settings .spyderproject # Rope project settings .ropeproject # Auxilary files to test the controller aux_*.py aux_*.sh kytos-utils-2017.1b1.post1/AUTHORS.rst000066400000000000000000000004051307044752400172670ustar00rootroot00000000000000####### Authors ####### - Beraldo Leal - Carlos Eduardo Moreira dos Santos - Diego Rabatone Oliveira - Macártur de Sousa Carvalho kytos-utils-2017.1b1.post1/CHANGELOG.rst000066400000000000000000000025371307044752400174410ustar00rootroot00000000000000########## Change log ########## This is a log of changes made to the *kytos-utils* project. Version: "bethania" beta1 (2017.1b1) ************************************ Added ===== - etc/skel files, with templates to create all the necessary NApp files when executing :code:`kytos napps create`. - Command line tool to manage the kytos NApps. A set of commands to help managing NApps. - May now use the command line to: - Create new NApps. - Install NApps created locally or from the NApps server. - Enable/disable installed NApps. - List installed / enabled NApps. - Search for NApps in the NApps server. - Upload NApps to the server. - Help is available for command line tools. Appending :code:`--help` to the end of a command displays useful information about it. Changed ======= - Setup script now installs all the requirements during the setup process. There is no need to worry about them beforehand. - Updated to Python 3.6. - Several bug fixes. - Separate CLI code from NApps code: refactored code to make clear what is related to the command line tools and what is related to the kytos NApps. - Clean and descriptive log messages. Security ======== - Authentication for NApps upload process - there is need for an account in the `NApps server `__ to upload any NApp. kytos-utils-2017.1b1.post1/LICENSE000066400000000000000000000020651307044752400164210ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2016 Kytos Team Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. kytos-utils-2017.1b1.post1/MANIFEST.in000066400000000000000000000001641307044752400171500ustar00rootroot00000000000000include etc/kytos.conf include etc/logging.ini include *.txt include *.rst include LICENSE recursive-include etc/ * kytos-utils-2017.1b1.post1/README.rst000066400000000000000000000027311307044752400171030ustar00rootroot00000000000000######## Overview ######## This is a command line interface (cli) for `Kytos SDN Platform `_. With these utilities you can interact with Kytos daemon and manage Network Applications (NApps) on your controller. QuickStart ********** Installing ========== We use python3.6. So in order to use this software please install python3.6 into your environment beforehand. We are doing a huge effort to make Kytos and its components available on all common distros. So, we recommend you to download it from your distro repository. But if you are trying to test, develop or just want a more recent version of our software no problem: Download now, the latest release (it still a beta software), from our repository: First you need to clone *kytos-utils* repository: .. code-block:: shell $ git clone https://github.com/kytos/kytos-utils.git After cloning, the installation process is done by standard `setuptools` install procedure: .. code-block:: shell $ cd kytos-utils $ sudo python3.6 setup.py install Usage ***** In order to execute *kytos* command line, please run: .. code-block:: shell $ kytos --help Authors ******* For a complete list of authors, please open ``AUTHORS.rst`` file. Contributing ************ If you want to contribute to this project, please read `Kytos Documentation `__ website. License ******* This software is under *MIT-License*. For more information please read ``LICENSE`` file. kytos-utils-2017.1b1.post1/bin/000077500000000000000000000000001307044752400161615ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/bin/kytos000077500000000000000000000024261307044752400172640ustar00rootroot00000000000000#!/usr/bin/env python3 # This file is part of kytos-utils. # # Copyright (c) 2016 by Kytos Team. # # Authors: # Beraldo Leal """kytos - The kytos command line. Usage: kytos [-c |--config ] [...] kytos [-v|--version] kytos [-h|--help] Options: -c , --config Load config file [default: ~/.kytosrc] -h, --help Show this screen. -v, --version Show version. The most commonly used kytos commands are: napps Create, list, enable, install (and other actions) NApps. server Start, Stop your Kytos Controller (Kytos) See 'kytos -h|--help' for more information on a specific command. """ import logging from docopt import docopt logging.basicConfig(format='%(levelname)-5s %(message)s', level=logging.INFO) if __name__ == '__main__': args = docopt(__doc__, version='kytos command line, version 2017.1b1', options_first=True) command = args[''] command_args = args[''] argv = [command] + command_args if command == 'napps': from kytos.cli.commands.napps.parser import parse parse(argv) else: print("Error: Invalid syntax") exit(__doc__) kytos-utils-2017.1b1.post1/etc/000077500000000000000000000000001307044752400161645ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/000077500000000000000000000000001307044752400171225ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/000077500000000000000000000000001307044752400202735ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/000077500000000000000000000000001307044752400232675ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/000077500000000000000000000000001307044752400245715ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/__init__.py000066400000000000000000000000001307044752400266700ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/napp/000077500000000000000000000000001307044752400255275ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/napp/README.rst.template000066400000000000000000000000751307044752400310320ustar00rootroot00000000000000Overview ======== {{description}} Requirements ============ kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/napp/__init__.py000066400000000000000000000000001307044752400276260ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/napp/kytos.json.template000066400000000000000000000002571307044752400314110ustar00rootroot00000000000000{ "author": "{{author}}", "name": "{{napp}}", "description": "{{description}}", "version": "", "napp_dependencies": [], "license": "", "tags": [], "url": "" } kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/napp/main.py.template000066400000000000000000000020711307044752400306370ustar00rootroot00000000000000"""Main module of {{author}}/{{napp}} Kytos Network Application. {{ description }} """ from kytos.core.napps import KytosNApp from napps.{{author}}.{{napp}} import settings class Main(KytosNApp): """Main class of {{author}}/{{napp}} NApp. This class is the entry point for this napp. """ def setup(self): """Replace the '__init__' method for the KytosNApp subclass. The setup method is automatically called by the controller when your application is loaded. So, if you have any setup routine, insert it here. """ pass def execute(self): """This method is executed right after the setup method execution. You can also use this method in loop mode if you add to the above setup method a line like the following example: self.execute_as_loop(30) # 30-second interval. """ pass def shutdown(self): """This method is executed when your napp is unloaded. If you have some cleanup procedure, insert it here. """ pass kytos-utils-2017.1b1.post1/etc/skel/kytos/napp-structure/author/napp/settings.py.template000066400000000000000000000000001307044752400315410ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/kytos/000077500000000000000000000000001307044752400165625ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/kytos/__init__.py000066400000000000000000000001451307044752400206730ustar00rootroot00000000000000"""Kytos SDN Platform.""" from pkgutil import extend_path __path__ = extend_path(__path__, __name__) kytos-utils-2017.1b1.post1/kytos/cli/000077500000000000000000000000001307044752400173315ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/kytos/cli/__init__.py000066400000000000000000000000241307044752400214360ustar00rootroot00000000000000"""CLI commands.""" kytos-utils-2017.1b1.post1/kytos/cli/commands/000077500000000000000000000000001307044752400211325ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/kytos/cli/commands/__init__.py000066400000000000000000000000321307044752400232360ustar00rootroot00000000000000"""Basic CLI commands.""" kytos-utils-2017.1b1.post1/kytos/cli/commands/napps/000077500000000000000000000000001307044752400222535ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/kytos/cli/commands/napps/__init__.py000066400000000000000000000000321307044752400243570ustar00rootroot00000000000000"""NAPPS CLI Commands.""" kytos-utils-2017.1b1.post1/kytos/cli/commands/napps/api.py000066400000000000000000000145701307044752400234050ustar00rootroot00000000000000"""Translate cli commands to non-cli code.""" import json import logging import os import re from urllib.error import HTTPError import requests from kytos.utils.napps import NAppsManager log = logging.getLogger(__name__) class NAppsAPI: """An API for the command-line interface. Use the config file only for required options. Static methods are called by the parser and they instantiate an object of this class to fulfill the request. """ @classmethod def disable(cls, args): """Disable subcommand.""" mgr = NAppsManager() for napp in args['']: mgr.set_napp(*napp) log.info('NApp %s:', mgr.napp_id) cls.disable_napp(mgr) @staticmethod def disable_napp(mgr): """Disable a NApp.""" if mgr.is_enabled(): log.info(' Disabling...') mgr.disable() log.info(' Disabled.') @classmethod def enable(cls, args): """Enable subcommand.""" mgr = NAppsManager() for napp in args['']: mgr.set_napp(*napp) log.info('NApp %s:', mgr.napp_id) cls.enable_napp(mgr) @staticmethod def enable_napp(mgr): """Install one NApp using NAppManager object.""" try: if not mgr.is_enabled(): log.info(' Enabling...') mgr.enable() log.info(' Enabled.') except (FileNotFoundError, PermissionError) as e: log.error(' %s', e) @classmethod def create(cls, args): """Bootstrap a basic NApp structure on the current folder.""" NAppsManager.create_napp() @classmethod def upload(cls, args): """Upload the NApp to the NApps server. Create the NApp package and upload it to the NApp server. """ try: NAppsManager().upload() except FileNotFoundError: log.error("Couldn't find kytos.json in current directory.") @classmethod def uninstall(cls, args): """Uninstall and delete NApps. For local installations, do not delete code outside install_path and enabled_path. """ mgr = NAppsManager() for napp in args['']: mgr.set_napp(*napp) log.info('NApp %s:', mgr.napp_id) if mgr.is_installed(): if mgr.is_enabled(): cls.disable_napp(mgr) log.info(' Uninstalling...') mgr.uninstall() log.info(' Uninstalled.') @classmethod def install(cls, args): """Install local or remote NApps.""" mgr = NAppsManager() for napp in args['']: mgr.set_napp(*napp) log.info('NApp %s:', mgr.napp_id) if not mgr.is_installed(): cls.install_napp(mgr) else: log.info(' Installed.') @classmethod def install_napp(cls, mgr): """Install a NApp.""" try: log.info(' Searching local NApp...') mgr.install_local() log.info(' Found and installed.') cls.enable_napp(mgr) except FileNotFoundError: log.info(' Not found. Downloading from NApps Server...') try: mgr.install_remote() log.info(' Downloaded and installed.') cls.enable_napp(mgr) except HTTPError as e: if e.code == 404: log.error(' NApp not found.') else: log.error(' NApps Server error: %s', e) @classmethod def search(cls, args): """Search for NApps in NApps server matching a pattern.""" safe_shell_pat = re.escape(args['']).replace(r'\*', '.*') pat_str = '.*{}.*'.format(safe_shell_pat) pattern = re.compile(pat_str, re.IGNORECASE) remote_json = NAppsManager.search(pattern) mgr = NAppsManager() enabled = mgr.get_enabled() installed = mgr.get_installed() remote = (((n['author'], n['name']), n['description']) for n in remote_json) napps = [] for napp, desc in sorted(remote): status = 'i' if napp in installed else '-' status += 'e' if napp in enabled else '-' status = '[{}]'.format(status) name = '{}/{}'.format(*napp) napps.append((status, name, desc)) cls.print_napps(napps) @classmethod def list(cls, args): """List all installed NApps and inform whether they are installed.""" mgr = NAppsManager() # Add status napps = [napp + ('[ie]',) for napp in mgr.get_enabled()] napps += [napp + ('[i-]',) for napp in mgr.get_disabled()] # Sort, add description and reorder coloumns napps.sort() napps = [(s, '{}/{}'.format(u, n), mgr.get_description(u, n)) for u, n, s in napps] cls.print_napps(napps) @staticmethod def print_napps(napps): """Print status, name and description.""" if not napps: print('No NApps found.') return stat_w = 6 # We already know the size of Status col name_w = max(len(n[1]) for n in napps) desc_w = max(len(n[2]) for n in napps) term_w = os.popen('stty size', 'r').read().split()[1] remaining = int(term_w) - stat_w - name_w - 6 desc_w = min(desc_w, remaining) widths = (stat_w, name_w, desc_w) header = '\n{:^%d} | {:^%d} | {:^%d}' % widths row = '{:^%d} | {:<%d} | {:<%d}' % widths print(header.format('Status', 'NApp ID', 'Description')) print('=+='.join('=' * w for w in widths)) for user, name, desc in napps: desc = (desc[:desc_w-3] + '...') if len(desc) > desc_w else desc print(row.format(user, name, desc)) print('\nStatus: (i)nstalled, (e)nabled\n') @staticmethod def delete(args): """Delete NApps from server.""" mgr = NAppsManager() for napp in args['']: mgr.set_napp(*napp) log.info('Deleting NApp %s from server...', mgr.napp_id) try: mgr.delete() log.info(' Deleted.') except requests.HTTPError as e: msg = json.loads(e.response.content) log.error(' Server error: %s - ', msg['error']) kytos-utils-2017.1b1.post1/kytos/cli/commands/napps/parser.py000066400000000000000000000042601307044752400241230ustar00rootroot00000000000000"""kytos - The kytos command line. You are at the "napps" command. Usage: kytos napps create kytos napps upload kytos napps delete ... kytos napps list kytos napps install ... kytos napps uninstall ... kytos napps enable ... kytos napps disable ... kytos napps search kytos napps -h | --help Options: -h, --help Show this screen. Common napps subcommands: create Create a bootstrap NApp structure for development. upload Upload current NApp to Kytos repository. delete Delete NApps from NApps Server. list List all NApps installed into your system. install Install a local or remote NApp into a controller. uninstall Remove a NApp from your controller. enable Enable a installed NApp. disable Disable a NApp. search Search for NApps in NApps Server. """ import sys from docopt import docopt from kytos.cli.commands.napps.api import NAppsAPI from kytos.utils.exceptions import KytosException def parse(argv): """Parse cli args.""" args = docopt(__doc__, argv=argv) try: call(sys.argv[2], args) except KytosException as e: print("Error parsing args: {}".format(e)) exit() def call(subcommand, args): """Call a subcommand passing the args.""" args[''] = parse_napps(args['']) func = getattr(NAppsAPI, subcommand) func(args) def parse_napps(napp_args): """Return a list of author and name from the napp list argument. The expected format of a NApp is napp_author/napp_name. Args: napp_args (list): NApps from the cli. Return: list: tuples (author_name, napp_name). Raises: KytosException: If a NApp has not the form _author/name_. """ def parse_napp(arg): """Parse one argument.""" napp = arg.split('/') if len(napp) != 2 or len(napp[0]) == 0 or len(napp[1]) == 0: msg = '"{}" NApp has not the form username/napp_name.'.format(arg) raise KytosException(msg) return tuple(napp) return [parse_napp(arg) for arg in napp_args] kytos-utils-2017.1b1.post1/kytos/utils/000077500000000000000000000000001307044752400177225ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/kytos/utils/__init__.py000066400000000000000000000000371307044752400220330ustar00rootroot00000000000000"""Utility modules for CLI.""" kytos-utils-2017.1b1.post1/kytos/utils/client.py000066400000000000000000000067311307044752400215610ustar00rootroot00000000000000"""REST communication with NApps Server.""" # This file is part of kytos-utils. # # Copyright (c) 2016 by Kytos Team. # # Authors: # Beraldo Leal import json import logging import os import sys import requests from kytos.utils.config import KytosConfig from kytos.utils.decorators import kytos_auth from kytos.utils.exceptions import KytosException log = logging.getLogger(__name__) class NAppsClient(): """Client for the NApps Server.""" def __init__(self, config=None): """Set Kytos config.""" if config is None: config = KytosConfig().config self._config = config def get_napps(self): """Get all NApps from the server.""" endpoint = os.path.join(self._config.get('napps', 'api'), 'napps', '') res = self.make_request(endpoint) if res.status_code != 200: msg = 'Error getting NApps from server (%s) - %s' log.error(msg, res.status_code, res.reason) sys.exit(1) return json.loads(res.content)['napps'] def get_napp(self, username, name): """Return napp metadata or None if not found.""" endpoint = os.path.join(self._config.get('napps', 'api'), 'napps', username, name, '') res = self.make_request(endpoint) if res.status_code == 404: # We need to know if NApp is not found return None elif res.status_code != 200: raise KytosException('Error getting %s/%s from server: (%d) - %s', username, name, res.status_code, res.reason) return json.loads(res.content) @kytos_auth def upload_napp(self, metadata, package): """Upload the napp from the current directory to the napps server.""" endpoint = os.path.join(self._config.get('napps', 'api'), 'napps', '') metadata['token'] = self._config.get('auth', 'token') request = self.make_request(endpoint, json=metadata, package=package, method="POST") if request.status_code != 201: KytosConfig().clear_token() log.error("%s: %s", request.status_code, request.reason) sys.exit(1) print("SUCCESS: NApp {}/{} uploaded.".format(metadata['author'], metadata['name'])) @kytos_auth def delete(self, username, napp): """Delete a NApp. Raises: requests.HTTPError: If 400 <= status < 600. """ api = self._config.get('napps', 'api') endpoint = os.path.join(api, 'napps', username, napp, '') content = {'token': self._config.get('auth', 'token')} response = self.make_request(endpoint, json=content, method='DELETE') response.raise_for_status() @staticmethod def make_request(endpoint, **kwargs): """Send a request to server.""" data = kwargs.get('json', []) package = kwargs.get('package', None) method = kwargs.get('method', 'GET') function = getattr(requests, method.lower()) try: if package: response = function(endpoint, data=data, files={'file': package}) else: response = function(endpoint, json=data) except response.exceptions.ConnectionError: log.error("Couldn't connect to NApps server %s.", endpoint) sys.exit(1) return response kytos-utils-2017.1b1.post1/kytos/utils/config.py000066400000000000000000000120021307044752400215340ustar00rootroot00000000000000"""Kytos utils configuration.""" # This file is part of kytos-utils. # # Copyright (c) 2016 Kytos Team # # Authors: # Beraldo Leal import logging import os from configparser import ConfigParser log = logging.getLogger(__name__) class KytosConfig(): """Kytos Configs. Read the config file for kytos utils and/or request data for the user in order to get the correct paths and links. """ def __init__(self, config_file='~/.kytosrc'): """Init method. Receive the confi_file as argument. """ self.config_file = os.path.expanduser(config_file) self.debug = False if self.debug: log.setLevel(logging.DEBUG) # allow_no_value=True is used to keep the comments on the config file. self.config = ConfigParser(allow_no_value=True) # Parse the config file. If no config file was found, then create some # default sections on the config variable. self.config.read(self.config_file) self.check_sections(self.config) self.set_env_or_defaults() if not os.path.exists(self.config_file): log.warning("Config file %s not found.", self.config_file) log.warning("Creating a new empty config file.") with open(self.config_file, 'w') as output_file: os.chmod(self.config_file, 0o0600) self.config.write(output_file) def log_configs(self): """Log the read configs if debug is enabled.""" for sec in self.config.sections(): log.debug(' %s: %s', sec, self.config.options(sec)) def set_env_or_defaults(self): """Read some environment variables and set them on the config. If no environment variable is found and the config section/key is empty, then set some default values. """ napps_api = os.environ.get('NAPPS_API_URI') napps_repo = os.environ.get('NAPPS_REPO_URI') user = os.environ.get('NAPPS_USER') token = os.environ.get('NAPPS_TOKEN') napps_path = os.environ.get('NAPPS_PATH') self.config.set('global', 'debug', str(self.debug)) if user is not None: self.config.set('auth', 'user', user) if token is not None: self.config.set('auth', 'token', token) if napps_api is not None: self.config.set('napps', 'api', napps_api) elif not self.config.has_option('napps', 'api'): self.config.set('napps', 'api', 'https://napps.kytos.io/api/') if napps_repo is not None: self.config.set('napps', 'repo', napps_repo) elif not self.config.has_option('napps', 'repo'): self.config.set('napps', 'repo', 'https://napps.kytos.io/repo/') # Set paths if NAPPS_PATH is given or if not found in config if napps_path or not self.config.has_option('napps', 'enabled_path'): if not napps_path: # default paths base = os.environ.get('VIRTUAL_ENV') or '/' napps_path = os.path.join(base, 'var', 'lib', 'kytos', 'napps') self.config.set('napps', 'enabled_path', napps_path) self.config.set('napps', 'installed_path', os.path.join(napps_path, '.installed')) @staticmethod def check_sections(config): """Create a empty config file.""" default_sections = ['global', 'auth', 'napps'] for section in default_sections: if not config.has_section(section): config.add_section(section) def save_token(self, user, token): """Save the token on the config file.""" self.config.set('auth', 'user', user) self.config.set('auth', 'token', token) # allow_no_value=True is used to keep the comments on the config file. new_config = ConfigParser(allow_no_value=True) # Parse the config file. If no config file was found, then create some # default sections on the config variable. new_config.read(self.config_file) self.check_sections(new_config) new_config.set('auth', 'user', user) new_config.set('auth', 'token', token) filename = os.path.expanduser(self.config_file) with open(filename, 'w') as out_file: os.chmod(filename, 0o0600) new_config.write(out_file) def clear_token(self): """Clear Token information on config file.""" # allow_no_value=True is used to keep the comments on the config file. new_config = ConfigParser(allow_no_value=True) # Parse the config file. If no config file was found, then create some # default sections on the config variable. new_config.read(self.config_file) self.check_sections(new_config) new_config.remove_option('auth', 'user') new_config.remove_option('auth', 'token') filename = os.path.expanduser(self.config_file) with open(filename, 'w') as out_file: os.chmod(filename, 0o0600) new_config.write(out_file) kytos-utils-2017.1b1.post1/kytos/utils/decorators.py000066400000000000000000000045651307044752400224530ustar00rootroot00000000000000"""Decorators for Kytos-utils.""" import logging import os import sys from getpass import getpass import requests from kytos.utils.config import KytosConfig log = logging.getLogger(__name__) class kytos_auth: """Class to be used as decorator to require authentication.""" def __init__(self, func): """Init method. Save the function on the func attribute and bootstrap a new config. """ self.func = func self.config = KytosConfig().config def __call__(self, *args, **kwargs): """Code run when func is called.""" if not (self.config.has_option('napps', 'api') and self.config.has_option('napps', 'repo')): uri = input("Enter the kytos napps server address: ") self.config.set('napps', 'api', os.path.join(uri, 'api', '')) self.config.set('napps', 'repo', os.path.join(uri, 'repo', '')) if not self.config.has_option('auth', 'user'): user = input("Enter the username: ") self.config.set('auth', 'user', user) else: user = self.config.get('auth', 'user') if not self.config.has_option('auth', 'token'): token = self.authenticate() else: token = self.config.get('auth', 'token') # pylint: disable=W0212 self.obj._config.set('auth', 'user', user) # pylint: disable=W0212 self.obj._config.set('auth', 'token', token) self.func.__call__(self.obj, *args, **kwargs) def __get__(self, instance, owner): """Deal with owner class.""" # pylint: disable=W0201 self.cls = owner # pylint: disable=W0201 self.obj = instance return self.__call__ def authenticate(self): """Check the user authentication.""" endpoint = os.path.join(self.config.get('napps', 'api'), 'auth', '') username = self.config.get('auth', 'user') password = getpass("Enter the password for {}: ".format(username)) response = requests.get(endpoint, auth=(username, password)) if response.status_code != 201: log.error(response.content) log.error('ERROR: %s: %s', response.status_code, response.reason) sys.exit(1) else: data = response.json() KytosConfig().save_token(username, data.get('hash')) return data.get('hash') kytos-utils-2017.1b1.post1/kytos/utils/exceptions.py000066400000000000000000000001471307044752400224570ustar00rootroot00000000000000"""Kytos utils exceptions.""" class KytosException(Exception): """Kytos utils main exception.""" kytos-utils-2017.1b1.post1/kytos/utils/napps.py000066400000000000000000000345001307044752400214170ustar00rootroot00000000000000"""Manage Network Application files.""" import json import logging import os import re import shutil import sys import tarfile import tempfile import urllib from pathlib import Path from jinja2 import Environment, FileSystemLoader from kytos.utils.client import NAppsClient from kytos.utils.config import KytosConfig log = logging.getLogger(__name__) class NAppsManager: """Deal with NApps at filesystem level and ask Kytos to (un)load NApps.""" def __init__(self, controller=None): """If controller is not informed, the necessary paths must be. If ``controller`` is available, NApps will be (un)loaded at runtime and you don't need to inform the paths. Otherwise, you should inform the required paths for the methods called. Args: controller (kytos.Controller): Controller to (un)load NApps. install_path (str): Folder where NApps should be installed. If None, use the controller's configuration. enabled_path (str): Folder where enabled NApps are stored. If None, use the controller's configuration. """ self._controller = controller self._config = KytosConfig().config self._installed = Path(self._config.get('napps', 'installed_path')) self._enabled = Path(self._config.get('napps', 'enabled_path')) self.user = None self.napp = None def set_napp(self, user, napp): """Set info about NApp. Args: user (str): NApps Server username. napp (str): NApp name. """ self.user = user self.napp = napp @property def napp_id(self): """Identifier of NApp.""" return '/'.join((self.user, self.napp)) @staticmethod def _get_napps(napps_dir): """List of (author, napp_name) found in ``napps_dir``.""" jsons = napps_dir.glob('*/*/kytos.json') return sorted(j.parts[-3:-1] for j in jsons) def get_enabled(self): """Sorted list of (author, napp_name) of enabled napps.""" return self._get_napps(self._enabled) def get_installed(self): """Sorted list of (author, napp_name) of installed napps.""" return self._get_napps(self._installed) def is_installed(self): """Whether a NApp is installed.""" return (self.user, self.napp) in self.get_installed() def get_disabled(self): """Sorted list of (author, napp_name) of disabled napps. The difference of installed and enabled. """ installed = set(self.get_installed()) enabled = set(self.get_enabled()) return sorted(installed - enabled) def get_description(self, user=None, napp=None): """Return the description from kytos.json.""" if user is None: user = self.user if napp is None: napp = self.napp kj = self._installed / user / napp / 'kytos.json' try: with kj.open() as f: meta = json.load(f) return meta['description'] except (FileNotFoundError, json.JSONDecodeError, KeyError): return '' def disable(self): """Disable a NApp if it is enabled.""" enabled = self._enabled / self.user / self.napp try: enabled.unlink() if self._controller is not None: self._controller.unload_napp(self.user, self.napp) except FileNotFoundError: pass # OK, it was already disabled def enable(self): """Enable a NApp if not already enabled. Raises: FileNotFoundError: If NApp is not installed. PermissionError: No filesystem permission to enable NApp. """ enabled = self._enabled / self.user / self.napp installed = self._installed / self.user / self.napp if not installed.is_dir(): raise FileNotFoundError('Install NApp {} first.'.format( self.napp_id)) elif not enabled.exists(): self._check_module(enabled.parent) try: # Create symlink enabled.symlink_to(installed) if self._controller is not None: self._controller.load_napp(self.user, self.napp) except FileExistsError: pass # OK, NApp was already enabled except PermissionError: raise PermissionError('Permission error on enabling NApp. Try ' 'with sudo.') def is_enabled(self): """Whether a NApp is enabled.""" return (self.user, self.napp) in self.get_enabled() def uninstall(self): """Delete code inside NApp directory, if existent.""" if self.is_installed(): installed = self._installed / self.user / self.napp if installed.is_symlink(): installed.unlink() else: shutil.rmtree(str(installed)) @staticmethod def valid_name(username): """Check the validity of the given 'name'. The following checks are done: - name starts with a letter - name contains only letters, numbers or underscores """ return username and re.match(r'[a-zA-Z][a-zA-Z0-9_]{2,}$', username) @staticmethod def render_template(templates_path, template_filename, context): """Render Jinja2 template for a NApp structure.""" TEMPLATE_ENV = Environment(autoescape=False, trim_blocks=False, loader=FileSystemLoader(templates_path)) return TEMPLATE_ENV.get_template(template_filename).render(context) @staticmethod def search(pattern): """Search all server NApps matching pattern. Args: pattern (str): Python regular expression. """ def match(napp): """Whether a NApp metadata matches the pattern.""" strings = ['{}/{}'.format(napp['author'], napp['name']), napp['description']] + napp['tags'] return any(pattern.match(string) for string in strings) napps = NAppsClient().get_napps() return [napp for napp in napps if match(napp)] def install_local(self): """Make a symlink in install folder to a local NApp. Raises: FileNotFoundError: If NApp is not found. """ folder = self._get_local_folder() installed = self._installed / self.user / self.napp self._check_module(installed.parent) installed.symlink_to(folder.resolve()) def _get_local_folder(self, root=None): """Return local NApp root folder. Search for kytos.json in _./_ folder and _./user/napp_. Args: root (pathlib.Path): Where to begin searching. Raises: FileNotFoundError: If there is no such local NApp. Return: pathlib.Path: NApp root folder. """ if root is None: root = Path() for folders in ['.'], [self.user, self.napp]: kytos_json = root / Path(*folders) / 'kytos.json' if kytos_json.exists(): with kytos_json.open() as f: meta = json.load(f) if meta['author'] == self.user and \ meta['name'] == self.napp: return kytos_json.parent raise FileNotFoundError('kytos.json not found.') def install_remote(self): """Download, extract and install NApp.""" package, pkg_folder = None, None try: package = self._download() pkg_folder = self._extract(package) napp_folder = self._get_local_folder(pkg_folder) dst = self._installed / self.user / self.napp self._check_module(dst.parent) shutil.move(str(napp_folder), str(dst)) finally: # Delete temporary files if package: Path(package).unlink() if pkg_folder and pkg_folder.exists(): shutil.rmtree(str(pkg_folder)) def _download(self): """Download NApp package from server. Raises: urllib.error.HTTPError: If download is not successful. Return: str: Downloaded temp filename. """ repo = self._config.get('napps', 'repo') uri = os.path.join(repo, self.user, '{}-latest.napp'.format(self.napp)) return urllib.request.urlretrieve(uri)[0] @staticmethod def _extract(filename): """Extract package to a temporary folder. Return: pathlib.Path: Temp dir with package contents. """ tmp = tempfile.mkdtemp(prefix='kytos') with tarfile.open(filename, 'r:xz') as tar: tar.extractall(tmp) return Path(tmp) @classmethod def create_napp(cls): """Bootstrap a basic NApp strucutre for you to develop your NApp. This will create, on the current folder, a clean structure of a NAPP, filling some contents on this structure. """ base = os.environ.get('VIRTUAL_ENV') or '/' templates_path = os.path.join(base, 'etc', 'skel', 'kytos', 'napp-structure', 'author', 'napp') author = None napp_name = None description = None print('--------------------------------------------------------------') print('Welcome to the bootstrap process of your NApp.') print('--------------------------------------------------------------') print('In order to answer both the author name and the napp name,') print('You must follow this naming rules:') print(' - name starts with a letter') print(' - name contains only letters, numbers or underscores') print(' - at least three characters') print('--------------------------------------------------------------') print('') msg = 'Please, insert your NApps Server username: ' while not cls.valid_name(author): author = input(msg) while not cls.valid_name(napp_name): napp_name = input('Please, insert your NApp name: ') msg = 'Please, insert a brief description for your NApp [optional]: ' description = input(msg) if not description: # pylint: disable=W0511 description = '# TODO: <<<< Insert here your NApp description >>>>' context = {'author': author, 'napp': napp_name, 'description': description} #: Creating the directory structure (author/name) os.makedirs(author, exist_ok=True) #: Creating ``__init__.py`` files with open(os.path.join(author, '__init__.py'), 'w'): pass os.makedirs(os.path.join(author, napp_name)) with open(os.path.join(author, napp_name, '__init__.py'), 'w'): pass #: Creating the other files based on the templates templates = os.listdir(templates_path) templates.remove('__init__.py') for tmp in templates: fname = os.path.join(author, napp_name, tmp.rsplit('.template')[0]) with open(fname, 'w') as file: content = cls.render_template(templates_path, tmp, context) file.write(content) msg = '\nCongratulations! Your NApp have been bootstrapped!\nNow you ' msg += 'can go to the directory {}/{} and begin to code your NApp.' print(msg.format(author, napp_name)) print('Have fun!') @staticmethod def _check_module(folder): """Create module folder with empty __init__.py if it doesn't exist. Args: folder (pathlib.Path): Module path. """ if not folder.exists(): folder.mkdir() (folder / '__init__.py').touch() @staticmethod def build_napp_package(napp_name): """Build the .napp file to be sent to the napps server. Args: napp_identifier (str): Identifier formatted as / Return: file_payload (binary): The binary representation of the napp package that will be POSTed to the napp server. """ ignored_extensions = ['.swp', '.pyc', '.napp'] ignored_dirs = ['__pycache__'] files = os.listdir() for filename in files: if os.path.isfile(filename) and '.' in filename and \ filename.rsplit('.', 1)[1] in ignored_extensions: files.remove(filename) elif os.path.isdir(filename) and filename in ignored_dirs: files.remove(filename) # Create the '.napp' package napp_file = tarfile.open(napp_name + '.napp', 'x:xz') for local_f in files: napp_file.add(local_f) napp_file.close() # Get the binary payload of the package file_payload = open(napp_name + '.napp', 'rb') # remove the created package from the filesystem os.remove(napp_name + '.napp') return file_payload @staticmethod def create_metadata(*args, **kwargs): """Generate the metadata to send the napp package.""" json_filename = kwargs.get('json_filename', 'kytos.json') readme_filename = kwargs.get('readme_filename', 'README.rst') ignore_json = kwargs.get('ignore_json', False) metadata = {} if not ignore_json: try: with open(json_filename) as json_file: metadata = json.load(json_file) except FileNotFoundError: print("ERROR: Could not access kytos.json file.") sys.exit(1) try: with open(readme_filename) as readme_file: metadata['readme'] = readme_file.read() except FileNotFoundError: metadata['readme'] = '' return metadata def upload(self, *args, **kwargs): """Create package and upload it to NApps Server. Raises: FileNotFoundError: If kytos.json is not found. """ metadata = self.create_metadata(*args, **kwargs) package = self.build_napp_package(metadata['name']) NAppsClient().upload_napp(metadata, package) def delete(self): """Delete a NApp. Raises: requests.HTTPError: When there's a server error. """ client = NAppsClient(self._config) client.delete(self.user, self.napp) kytos-utils-2017.1b1.post1/requirements-dev.txt000066400000000000000000000000421307044752400214450ustar00rootroot00000000000000pylama-pylint>=3.0.1 radon>=1.4.2 kytos-utils-2017.1b1.post1/requirements-docs.txt000066400000000000000000000000001307044752400216110ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/requirements.txt000066400000000000000000000000361307044752400206740ustar00rootroot00000000000000docopt requests jinja2>=2.9.5 kytos-utils-2017.1b1.post1/setup.cfg000066400000000000000000000006361307044752400172370ustar00rootroot00000000000000[pycodestyle] exclude = .eggs,ENV,build,docs/conf.py,venv [pylama] linters = isort,pydocstyle,radon,pylint,pycodestyle,pyflakes ignore = D105,D203,D213 # D105: Missing docstring in magic method [pep257] # D203: 1 blank line required before class docstring (found 0) [pep257] # Conflicts with D211: No blank lines allowed before class docstring # D213: Should be ignored by default, but sometimes it is not. kytos-utils-2017.1b1.post1/setup.py000066400000000000000000000073051307044752400171300ustar00rootroot00000000000000"""Setup script. Run "python3 setup --help-commands" to list all available commands and their descriptions. """ import os import sys from subprocess import CalledProcessError, check_call from setuptools import Command, find_packages, setup from setuptools.command.develop import develop from setuptools.command.test import test as TestCommand if 'VIRTUAL_ENV' in os.environ: BASE_ENV = os.environ['VIRTUAL_ENV'] else: BASE_ENV = '/' SKEL_PATH = 'etc/skel' KYTOS_SKEL_PATH = os.path.join(SKEL_PATH, 'kytos') AUTHOR_PATH = os.path.join(KYTOS_SKEL_PATH, 'napp-structure/author') NAPP_PATH = os.path.join(AUTHOR_PATH, 'napp') ETC_FILES = [(os.path.join(BASE_ENV, AUTHOR_PATH), [os.path.join(AUTHOR_PATH, '__init__.py')]), (os.path.join(BASE_ENV, NAPP_PATH), [os.path.join(NAPP_PATH, '__init__.py'), os.path.join(NAPP_PATH, 'kytos.json.template'), os.path.join(NAPP_PATH, 'main.py.template'), os.path.join(NAPP_PATH, 'README.rst.template'), os.path.join(NAPP_PATH, 'settings.py.template')])] class Linter(Command): """Code linters.""" description = 'run Pylama on Python files' user_options = [] def run(self): """Run linter.""" self.lint() @staticmethod def lint(): """Run pylama and radon.""" files = 'tests setup.py kytos' print('Pylama is running. It may take several seconds...') cmd = 'pylama {}'.format(files) try: check_call(cmd, shell=True) except CalledProcessError as exception: print('FAILED: please, fix the error(s) above.') sys.exit(exception.returncode) def initialize_options(self): """Set default values for options.""" pass def finalize_options(self): """Post-process options.""" pass class Test(TestCommand): """Run doctest and linter besides tests/*.""" def run(self): """First, tests/*.""" super().run() Linter.lint() class DevelopMode(develop): """Recommended setup for kytos-utils developers. Instead of copying the files to the expected directories, a symlink is created on the system aiming the current source code. """ def run(self): """Install the package in a developer mode.""" super().run() self._create_data_files_directory() @staticmethod def _create_data_files_directory(): current_directory = os.path.abspath(os.path.dirname(__file__)) etc_dir = os.path.join(BASE_ENV, 'etc') if not os.path.exists(etc_dir): os.mkdir(etc_dir) dst_dir = os.path.join(BASE_ENV, SKEL_PATH) if not os.path.exists(dst_dir): os.mkdir(dst_dir) src = os.path.join(current_directory, KYTOS_SKEL_PATH) dst = os.path.join(BASE_ENV, KYTOS_SKEL_PATH) if not os.path.exists(dst): os.symlink(src, dst) # parse_requirements() returns generator of pip.req.InstallRequirement objects # requirements = parse_requirements('requirements.txt', session=False) REQS = [i.strip() for i in open("requirements.txt").readlines()] setup(name='kytos-utils', version='2017.1b1', description=' Command line utilities to use with Kytos.', url='http://github.com/kytos/kytos-utils', author='Kytos Team', author_email='of-ng-dev@ncc.unesp.br', license='MIT', test_suite='tests', include_package_data=True, scripts=['bin/kytos'], install_requires=REQS, data_files=ETC_FILES, packages=find_packages(exclude=['tests']), cmdclass={ 'develop': DevelopMode, 'lint': Linter, 'test': Test }, zip_safe=False) kytos-utils-2017.1b1.post1/tests/000077500000000000000000000000001307044752400165535ustar00rootroot00000000000000kytos-utils-2017.1b1.post1/tests/__init__.py000066400000000000000000000000411307044752400206570ustar00rootroot00000000000000"""Test suit for kytos-utils."""