Merge pull request #64 from QualiSystems/dev

Release 3.1.1

Author: Yaroslav Nikonorov

.coveragerc

@@ -0,0 +1,4 @@
+[report]
+omit =
+    *__init__*
+    */examples/*

.travis.yml

@@ -1,19 +1,19 @@
 language: python
 python:
-- '2.7'
-
-before_install:
-    - pip install coveralls
-    - pip install -r test_requirements.txt --extra-index-url https://testpypi.python.org/pypi
+    - "2.7"
 
 install:
-    - pip install -r requirements.txt --extra-index-url https://testpypi.python.org/pypi
-    - python setup.py install
+    - 'if [ ${TRAVIS_BRANCH} \!= "master" ] && [ -f dev_requirements.txt ]; then
+        pip install --extra-index-url https://testpypi.python.org/pypi -r dev_requirements.txt;
+        python setup.py develop --no-deps;
+      else
+        python setup.py install;
+      fi'
+    - pip install -r test_requirements.txt
+    - pip install coveralls
 
 script:
-    - python runtests.py --with-coverage  --cover-package=cloudshell
-    - python setup.py develop
-    - python setup.py sdist --format zip
+    - nosetests --with-coverage --cover-package=cloudshell.cli tests
 
 after_success:
-    - coveralls
+    - coveralls

README.md

@@ -1,5 +1,5 @@
 # cloudshell-cli
-![alt tag](https://travis-ci.org/QualiSystems/cloudshell-cli.svg?branch=7.0_refactoring)
+[![Build status](https://travis-ci.org/QualiSystems/cloudshell-cli.svg?branch=dev)](https://travis-ci.org/QualiSystems/cloudshell-cli)
 [![Coverage Status](https://coveralls.io/repos/github/QualiSystems/cloudshell-cli/badge.svg?branch=dev)](https://coveralls.io/github/QualiSystems/cloudshell-cli?branch=dev)
 [![PyPI version](https://badge.fury.io/py/cloudshell-cli.svg)](https://badge.fury.io/py/cloudshell-cli)
 [![Dependency Status](https://dependencyci.com/github/QualiSystems/cloudshell-cli/badge)](https://dependencyci.com/github/QualiSystems/cloudshell-cli)

cloudshell/cli/command_mode_helper.py

@@ -22,7 +22,7 @@ def determine_current_mode(session, command_mode, logger):
         defined_modes = CommandModeHelper.defined_modes_by_prompt(command_mode)
         prompts_re = r'|'.join(defined_modes.keys())
         try:
-            result = session.hardware_expect('', expected_string=prompts_re, logger=logger)
+            result = session.probe_for_prompt(expected_string=prompts_re, logger=logger)
         except Exception as e:
             logger.debug(e.message)
             raise CommandModeException(CommandModeHelper.__class__.__name__,

cloudshell/cli/session/connection_params.py

@@ -25,6 +25,10 @@ def __init__(self, host, port=None, on_session_start=None, pkey=None):
         self.on_session_start = on_session_start
         self.pkey = pkey
 
+    def _on_session_start(self, logger):
+        if self.on_session_start and callable(self.on_session_start):
+            self.on_session_start(self, logger)
+
     def __eq__(self, other):
         """
         :param other:

cloudshell/cli/session/console_session.py

@@ -1,13 +1,12 @@
-import socket
+import re
 import time
+from abc import ABCMeta, abstractmethod
 from collections import OrderedDict
 
-from abc import ABCMeta
+from cloudshell.cli.helper.normalize_buffer import normalize_buffer
+from cloudshell.cli.session.session import Session
 from cloudshell.cli.session.session_exceptions import SessionLoopDetectorException, SessionLoopLimitException, \
     ExpectedSessionException, CommandExecutionException, SessionReadTimeout, SessionReadEmptyData
-import re
-from cloudshell.cli.session.session import Session
-from cloudshell.cli.helper.normalize_buffer import normalize_buffer
 
 
 class ExpectSession(Session):
@@ -60,6 +59,26 @@ def __init__(self, timeout=READ_TIMEOUT, new_line='\r', max_loop_retries=MAX_LOO
     def session_type(self):
         return self.SESSION_TYPE
 
+    @abstractmethod
+    def _connect_actions(self, prompt, logger):
+        """Read out buffer and run on_session_start actions
+        :param prompt: expected string in output
+        :param logger: logger
+        """
+
+        pass
+
+    @abstractmethod
+    def _initialize_session(self, prompt, logger):
+        """Create handler and initialize session
+        :param prompt: expected string in output
+        :param logger: logger
+        """
+        pass
+
+    def set_active(self, state):
+        self._active = state
+
     def active(self):
         return self._active
 
@@ -82,6 +101,20 @@ def _clear_buffer(self, timeout, logger):
                 break
         return out
 
+    def connect(self, prompt, logger):
+        """Connect to device.
+        :param prompt: expected string in output
+        :param logger: logger
+        """
+
+        try:
+            self._initialize_session(prompt, logger)
+            self._connect_actions(prompt, logger)
+            self.set_active(True)
+        except:
+            self.disconnect()
+            raise
+
     def send_line(self, command, logger):
         """
         Add new line to the end of command string and send
@@ -112,6 +145,9 @@ def _receive_all(self, timeout, logger):
                 elif time.time() - start_time > timeout:
                     raise ExpectedSessionException(self.__class__.__name__, 'Socket closed by timeout')
 
+    def probe_for_prompt(self, expected_string, logger):
+        return self.hardware_expect('', expected_string, logger)
+
     def hardware_expect(self, command, expected_string, logger, action_map=None, error_map=None,
                         timeout=None, retries=None, check_action_loop_detector=True, empty_loop_timeout=None,
                         remove_command_from_output=True, **optional_args):
@@ -170,7 +206,7 @@ def hardware_expect(self, command, expected_string, logger, action_map=None, err
 
             if read_buffer:
                 read_buffer = normalize_buffer(read_buffer)
-                logger.info(read_buffer)
+                logger.debug(read_buffer)
                 output_str += read_buffer
                 # if option remove_command_from_output is set to True, look for command in output buffer,
                 #  remove it in case of found

cloudshell/cli/session/expect_session.py

@@ -0,0 +1,50 @@
+import re
+import socket
+
+from cloudshell.cli.session.tcp_session import TCPSession
+
+
+class SCPISession(TCPSession):
+    SESSION_TYPE = 'SCPI'
+    BUFFER_SIZE = 1024
+
+    def __init__(self, host, port, on_session_start=None, *args, **kwargs):
+        super(SCPISession, self).__init__(host, port, on_session_start, *args, **kwargs)
+
+    def _initialize_session(self, prompt, logger):
+        self._handler = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        server_address = (self.host, self.port)
+        self._handler.connect(server_address)
+        self._handler.settimeout(self._timeout)
+
+    def _connect_actions(self, prompt, logger):
+        self._on_session_start(logger)
+
+    def probe_for_prompt(self, expected_string, logger):
+        return 'DUMMY_PROMPT'
+
+    def hardware_expect(self, command, expected_string, logger, action_map=None, error_map=None, timeout=None,
+                        retries=None, check_action_loop_detector=True, empty_loop_timeout=None,
+                        remove_command_from_output=True, **optional_args):
+
+        if ';:system:error?' not in command.lower():
+            command += ';:system:error?'
+
+        statusre = r'([-0-9]+), "(.*)"[\r\n]*$'
+
+        remove_command_from_output = False  # avoid 'multiple repeat' error from '?' in the command - bug in expect_session
+
+        rv = super(SCPISession, self).hardware_expect(command, statusre, logger, action_map, error_map, timeout,
+                                                     retries, check_action_loop_detector, empty_loop_timeout,
+                                                     remove_command_from_output, **optional_args)
+
+        m = re.search(statusre, rv)
+        if not m:
+            raise Exception('SCPI status code not found in output: %s' % rv)
+
+        code, message = m.groups()
+        if code < 0:
+            raise Exception('SCPI error: %d: %s' % (code, message))
+
+        return rv

cloudshell/cli/session/scpi_session.py

@@ -1,6 +1,5 @@
-from collections import OrderedDict
-
 from abc import ABCMeta, abstractmethod
+from collections import OrderedDict
 
 
 class Session(object):
@@ -32,10 +31,18 @@ def hardware_expect(self, command, expected_string, logger, action_map=OrderedDi
                         **optional_args):
         pass
 
+    @abstractmethod
+    def probe_for_prompt(self, expected_string, logger):
+        pass
+
     @abstractmethod
     def reconnect(self, prompt, logger, timeout=None):
         pass
 
     @abstractmethod
     def active(self):
         pass
+
+    @abstractmethod
+    def set_active(self, state):
+        pass

cloudshell/cli/session/session.py

@@ -51,17 +51,13 @@ def __eq__(self, other):
     def __del__(self):
         self.disconnect()
 
-    def connect(self, prompt, logger):
-        """Connect to device through ssh
-        :param prompt: expected string in output
-        :param logger: logger
-        """
-
-        if not self._handler:
-            self._handler = paramiko.SSHClient()
-            self._handler.load_system_host_keys()
-            self._handler.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    def _create_handler(self):
+        self._handler = paramiko.SSHClient()
+        self._handler.load_system_host_keys()
+        self._handler.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 
+    def _initialize_session(self, prompt, logger):
+        self._create_handler()
         try:
             self._handler.connect(self.host, self.port, self.username, self.password, timeout=self._timeout,
                                   banner_timeout=30, allow_agent=False, look_for_keys=False, pkey=self.pkey)
@@ -73,10 +69,9 @@ def connect(self, prompt, logger):
         self._current_channel = self._handler.invoke_shell()
         self._current_channel.settimeout(self._timeout)
 
+    def _connect_actions(self, prompt, logger):
         self.hardware_expect(None, expected_string=prompt, timeout=self._timeout, logger=logger)
-        if self.on_session_start and callable(self.on_session_start):
-            self.on_session_start(self, logger)
-        self._active = True
+        self._on_session_start(logger)
 
     def disconnect(self):
         """Disconnect from device