opensipscli 0.3.1__py3-none-any.whl

opensipscli/defaults.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## 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/>.
+##
+
+"""
+Default configuration for OpenSIPS CLI
+"""
+
+import os
+import time
+
+DEFAULT_SECTION = 'default'
+DEFAULT_NAME = 'opensips-cli'
+try:
+    home_dir = os.environ["HOME"]
+except:
+    # default home dir to root
+    home_dir = "/"
+
+"""
+Default history file is in ~/.opensips-cli.history
+"""
+HISTORY_FILE = os.path.join(home_dir, ".{}.history".format(DEFAULT_NAME))
+
+"""
+Try configuration files in this order:
+    * ~/.opensips-cli.cfg
+    * /etc/opensips-cli.cfg
+    * /etc/opensips/opensips-cli.cfg
+"""
+CFG_PATHS = [
+    os.path.join(home_dir, ".{}.cfg".format(DEFAULT_NAME)),
+    "/etc/{}.cfg".format(DEFAULT_NAME),
+    "/etc/opensips/{}.cfg".format(DEFAULT_NAME),
+]
+
+DEFAULT_VALUES = {
+    # CLI settings
+    "prompt_name": "opensips-cli",
+    "prompt_intro": "Welcome to OpenSIPS Command Line Interface!",
+    "prompt_emptyline_repeat_cmd": "False",
+    "history_file": HISTORY_FILE,
+    "history_file_size": "1000",
+    "output_type": "pretty-print",
+    "log_level": "INFO",
+
+    # communication information
+    "communication_type": "fifo",
+    "fifo_reply_dir": "/tmp",
+    "fifo_file": "/var/run/opensips/opensips_fifo",
+    "fifo_file_fallback": "/tmp/opensips_fifo",
+    "url": "http://127.0.0.1:8888/mi",
+    "datagram_ip": "127.0.0.1",
+    "datagram_port": "8080",
+
+    # database module
+    "database_url": "mysql://opensips:opensipsrw@localhost",
+    "database_name": "opensips",
+    "database_schema_path": "/usr/share/opensips",
+
+    # user module
+    "plain_text_passwords": "False",
+
+    # diagnose module
+    "diagnose_listen_ip": "127.0.0.1",
+    "diagnose_listen_port": "8899",
+
+    # trace module
+    "trace_listen_ip": "127.0.0.1",
+    "trace_listen_port": "0",
+
+    # trap module
+    "trap_file": '/tmp/gdb_opensips_{}'.format(time.strftime('%Y%m%d_%H%M%S'))
+}
+
+# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4

opensipscli/libs/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## 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/>.
+##
+
+from opensipscli.libs import sqlalchemy_utils

opensipscli/libs/sqlalchemy_utils.py

@@ -0,0 +1,244 @@
+## Copyright (c) 2012, Konsta Vesterinen
+##
+## All rights reserved.
+##
+## Redistribution and use in source and binary forms, with or without
+## modification, are permitted provided that the following conditions are met:
+##
+## * Redistributions of source code must retain the above copyright notice, this
+##   list of conditions and the following disclaimer.
+##
+## * Redistributions in binary form must reproduce the above copyright notice,
+##   this list of conditions and the following disclaimer in the documentation
+##   and/or other materials provided with the distribution.
+##
+## * The names of the contributors may not be used to endorse or promote products
+##   derived from this software without specific prior written permission.
+##
+## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+## ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+## WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+## DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT,
+## INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+## BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+## LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+## OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+## ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## Copied from https://github.com/kvesteri/sqlalchemy-utils/blob/2e8ee0093f4a33a5c7479bc9aaf16d7863a74a16/sqlalchemy_utils/functions/database.py
+## Please check LICENSE
+
+from copy import copy
+
+import os
+import sqlalchemy as sa
+from sqlalchemy.engine.url import make_url
+from sqlalchemy.exc import OperationalError, ProgrammingError
+from sqlalchemy.engine.interfaces import Dialect
+from sqlalchemy.orm.session import object_session
+from sqlalchemy.orm.exc import UnmappedInstanceError
+
+def database_exists(url):
+    """Check if a database exists.
+    :param url: A SQLAlchemy engine URL.
+    Performs backend-specific testing to quickly determine if a database
+    exists on the server. ::
+        database_exists('postgresql://postgres@localhost/name')  #=> False
+        create_database('postgresql://postgres@localhost/name')
+        database_exists('postgresql://postgres@localhost/name')  #=> True
+    Supports checking against a constructed URL as well. ::
+        engine = create_engine('postgresql://postgres@localhost/name')
+        database_exists(engine.url)  #=> False
+        create_database(engine.url)
+        database_exists(engine.url)  #=> True
+    """
+
+    def get_scalar_result(engine, sql):
+        result_proxy = engine.execute(sql)
+        result = result_proxy.scalar()
+        result_proxy.close()
+        engine.dispose()
+        return result
+
+    def sqlite_file_exists(database):
+        if not os.path.isfile(database) or os.path.getsize(database) < 100:
+            return False
+
+        with open(database, 'rb') as f:
+            header = f.read(100)
+
+        return header[:16] == b'SQLite format 3\x00'
+
+    url = copy(make_url(url))
+    if hasattr(url, "_replace"):
+        database = url.database
+        url = url._replace(database=None)
+    else:
+        database, url.database = url.database, None
+
+    engine = sa.create_engine(url)
+
+    if engine.dialect.name == 'postgresql':
+        text = "SELECT 1 FROM pg_database WHERE datname='%s'" % database
+        return bool(get_scalar_result(engine, text))
+
+    elif engine.dialect.name == 'mysql':
+        text = ("SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA "
+                "WHERE SCHEMA_NAME = '%s'" % database)
+        return bool(get_scalar_result(engine, text))
+
+    elif engine.dialect.name == 'sqlite':
+        if database:
+            return database == ':memory:' or sqlite_file_exists(database)
+        else:
+            # The default SQLAlchemy database is in memory,
+            # and :memory is not required, thus we should support that use-case
+            return True
+
+    else:
+        engine.dispose()
+        engine = None
+        text = 'SELECT 1'
+        try:
+            if hasattr(url, "_replace"):
+                url = url._replace(database=database)
+            else:
+                url.database = database
+
+            engine = sa.create_engine(url)
+            result = engine.execute(text)
+            result.close()
+            return True
+
+        except (ProgrammingError, OperationalError):
+            return False
+        finally:
+            if engine is not None:
+                engine.dispose()
+
+def get_bind(obj):
+    """
+    Return the bind for given SQLAlchemy Engine / Connection / declarative
+    model object.
+    :param obj: SQLAlchemy Engine / Connection / declarative model object
+    ::
+        from sqlalchemy_utils import get_bind
+        get_bind(session)  # Connection object
+        get_bind(user)
+    """
+    if hasattr(obj, 'bind'):
+        conn = obj.bind
+    else:
+        try:
+            conn = object_session(obj).bind
+        except UnmappedInstanceError:
+            conn = obj
+
+    if not hasattr(conn, 'execute'):
+        raise TypeError(
+            'This method accepts only Session, Engine, Connection and '
+            'declarative model objects.'
+        )
+    return conn
+
+def quote(mixed, ident):
+    """
+    Conditionally quote an identifier.
+    ::
+        from sqlalchemy_utils import quote
+        engine = create_engine('sqlite:///:memory:')
+        quote(engine, 'order')
+        # '"order"'
+        quote(engine, 'some_other_identifier')
+        # 'some_other_identifier'
+    :param mixed: SQLAlchemy Session / Connection / Engine / Dialect object.
+    :param ident: identifier to conditionally quote
+    """
+    if isinstance(mixed, Dialect):
+        dialect = mixed
+    else:
+        dialect = get_bind(mixed).dialect
+    return dialect.preparer(dialect).quote(ident)
+
+def drop_database(url):
+    """Issue the appropriate DROP DATABASE statement.
+    :param url: A SQLAlchemy engine URL.
+    Works similar to the :ref:`create_database` method in that both url text
+    and a constructed url are accepted. ::
+        drop_database('postgresql://postgres@localhost/name')
+        drop_database(engine.url)
+    """
+
+    url = copy(make_url(url))
+
+    database = url.database
+
+    if url.drivername.startswith('postgres'):
+        if hasattr(url, "set"):
+            url = url.set(database='postgres')
+        else:
+            url.database = 'postgres'
+
+    elif url.drivername.startswith('mssql'):
+        if hasattr(url, "set"):
+            url = url.set(database='master')
+        else:
+            url.database = 'master'
+
+    elif not url.drivername.startswith('sqlite'):
+        if hasattr(url, "_replace"):
+            url = url._replace(database=None)
+        else:
+            url.database = None
+
+    if url.drivername == 'mssql+pyodbc':
+        engine = sa.create_engine(url, connect_args={'autocommit': True})
+    elif url.drivername == 'postgresql+pg8000':
+        engine = sa.create_engine(url, isolation_level='AUTOCOMMIT')
+    else:
+        engine = sa.create_engine(url)
+    conn_resource = None
+
+    if engine.dialect.name == 'sqlite' and database != ':memory:':
+        if database:
+            os.remove(database)
+
+    elif (
+                engine.dialect.name == 'postgresql' and
+                engine.driver in {'psycopg2', 'psycopg2cffi'}
+    ):
+        if engine.driver == 'psycopg2':
+            from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
+            connection = engine.connect()
+            connection.connection.set_isolation_level(
+                ISOLATION_LEVEL_AUTOCOMMIT
+            )
+        else:
+            connection = engine.connect()
+            connection.connection.set_session(autocommit=True)
+
+        # Disconnect all users from the database we are dropping.
+        version = connection.dialect.server_version_info
+        pid_column = (
+            'pid' if (version >= (9, 2)) else 'procpid'
+        )
+        text = '''
+        SELECT pg_terminate_backend(pg_stat_activity.%(pid_column)s)
+        FROM pg_stat_activity
+        WHERE pg_stat_activity.datname = '%(database)s'
+          AND %(pid_column)s <> pg_backend_pid();
+        ''' % {'pid_column': pid_column, 'database': database}
+        connection.execute(text)
+
+        # Drop the database.
+        text = 'DROP DATABASE {0}'.format(quote(connection, database))
+        connection.execute(text)
+        conn_resource = connection
+    else:
+        text = 'DROP DATABASE {0}'.format(quote(engine, database))
+        conn_resource = engine.execute(text)
+
+    if conn_resource is not None:
+        conn_resource.close()
+    engine.dispose()

opensipscli/logger.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## 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/>.
+##
+
+"""
+logger.py - implements coloured logging for the opensips-cli project
+"""
+
+import logging
+
+#These are the sequences need to get colored ouput
+RESET_SEQ = "\033[0m"
+COLOR_SEQ = "\033[1;%dm"
+BOLD_SEQ = "\033[1m"
+
+def formatter_message(message, use_color = True):
+    if use_color:
+        message = message.replace("$RESET", RESET_SEQ).replace("$BOLD", BOLD_SEQ)
+    else:
+        message = message.replace("$RESET", "").replace("$BOLD", "")
+    return message
+
+# Custom logger class with multiple destinations
+class ColoredLogger(logging.Logger):
+
+    BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
+
+    FORMAT = "$BOLD%(levelname)s$RESET: %(message)s"
+    COLOR_FORMAT = formatter_message(FORMAT, True)
+
+    def __init__(self, name):
+        logging.Logger.__init__(self, name)
+
+        color_formatter = ColoredFormatter(self.COLOR_FORMAT)
+
+        console = logging.StreamHandler()
+        console.setFormatter(color_formatter)
+
+        self.addHandler(console)
+        return
+
+    def color(self, color, message):
+        return COLOR_SEQ % (30 + color) + message + RESET_SEQ
+
+class ColoredFormatter(logging.Formatter):
+
+    LEVELS_COLORS = {
+        'WARNING': ColoredLogger.YELLOW,
+        'INFO': ColoredLogger.MAGENTA,
+        'DEBUG': ColoredLogger.BLUE,
+        'CRITICAL': ColoredLogger.YELLOW,
+        'ERROR': ColoredLogger.RED
+    }
+
+    def __init__(self, msg, use_color = True):
+        logging.Formatter.__init__(self, msg)
+        self.use_color = use_color
+
+    def format(self, record):
+        levelname = record.levelname
+        if self.use_color and levelname in self.LEVELS_COLORS:
+            levelname_color = COLOR_SEQ % (30 + self.LEVELS_COLORS[levelname]) + levelname + RESET_SEQ
+            record.levelname = levelname_color
+        return logging.Formatter.format(self, record)
+
+
+logging.setLoggerClass(ColoredLogger)
+logger = logging.getLogger(__name__)
+
+# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4

opensipscli/main.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## 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 sys
+import argparse
+from opensipscli import cli, defaults, version
+
+parser = argparse.ArgumentParser(description='OpenSIPS CLI interactive tool',
+                                 prog=sys.argv[0],
+                                 usage='%(prog)s [OPTIONS]',
+                                 epilog='\n')
+
+# Argument used to print the current version
+parser.add_argument('-v', '--version',
+                    action='version',
+                    default=None,
+                    version='OpenSIPS CLI {}'.format(version.__version__))
+# Argument used to enable debugging
+parser.add_argument('-d', '--debug',
+                    action='store_true',
+                    default=False,
+                    help='enable debugging')
+# Argument used to specify a configuration file
+parser.add_argument('-f', '--config',
+                    metavar='[FILE]',
+                    type=str,
+                    default=None,
+                    help='used to specify a configuration file')
+# Argument used to switch to a different instance
+parser.add_argument('-i', '--instance',
+                    metavar='[INSTANCE]',
+                    type=str,
+                    action='store',
+                    default=defaults.DEFAULT_SECTION,
+                    help='choose an opensips instance')
+# Argument used to overwrite certain values in the config
+parser.add_argument('-o', '--option',
+                    metavar='[KEY=VALUE]',
+                    action='append',
+                    type=str,
+                    dest="extra_options",
+                    default=None,
+                    help='overwrite certain values in the config')
+# Argument used to dump the configuration
+parser.add_argument('-p', '--print',
+                    action='store_true',
+                    default=False,
+                    help='dump the configuration')
+# Argument used to run the command in non-interactive mode
+parser.add_argument('-x', '--execute',
+                    action='store_true',
+                    default=False,
+                    help='run the command in non-interactive mode')
+# Argument used to specify the command to run
+parser.add_argument('command',
+                    nargs='*',
+                    default=[],
+                    help='the command to run')
+
+def main():
+
+    # Parse all arguments
+    args = parser.parse_args()
+
+    # Open the CLI
+    shell = cli.OpenSIPSCLI(args)
+    sys.exit(shell.cmdloop())
+
+if __name__ == '__main__':
+    main()

opensipscli/module.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## 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/>.
+##
+
+class Module:
+    """
+    An abstract class, that has to be implemented by every Module that should be handled
+    """
+
+    def __exclude__(self):
+        """
+        indicates whether the module should be excluded
+        """
+        return (False, None)
+
+    def __invoke__(self, cmd, params=None, modifiers=None):
+        """
+        used to invoke a command from the module (starting with prefix 'do_')
+        """
+        f = getattr(self, 'do_' + cmd)
+        return f(params, modifiers)
+
+    def __get_methods__(self):
+         """
+         returns all the available methods of the module
+         if the method returns None, the do_`module_name`
+         method is called for each command
+         """
+         return ([x[3:] for x in dir(self)
+                 if x.startswith('do_') and callable(getattr(self, x))])
+
+    def __get_modifiers__(self):
+         """
+         returns all the available modifiers of a specific module
+         """
+         return None
+
+    def __complete__(self, command, text, line, begidx, endidx):
+        """
+        returns a list with all the auto-completion values
+        """
+        if not command:
+            modifiers = self.__get_modifiers__()
+            return modifiers if modifiers else ['']
+        try:
+            compfunc = getattr(self, 'complete_' + command)
+            l = compfunc(text, line, begidx, endidx)
+            if not l:
+                return ['']
+        except AttributeError:
+            return None
+        if len(l) == 1:
+            l[0] += " "
+        return l

opensipscli/modules/__init__.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## 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 pkgutil
+
+__path__ = pkgutil.extend_path(__path__, __name__)
+for importer, modname, ispkg in pkgutil.walk_packages(path=__path__, prefix=__name__+'.'):
+    __import__(modname)