Provided by: libnet-cli-interact-perl_2.300003-1_all bug


       Net::CLI::Interact::Transport::Base - Spawns an Interactive CLI Session


       This module provides a generic cross-platform API with the purpose of interacting with a
       command line interface.

       On Windows the IPC::Run module is used and on Unix when IO::Pty is available (it requires
       a compiler) Net::Telnet, else "IPC::Run". In all cases, a program such as openssh is
       started and methods provided to send and receive data from the interactive session.

       You should not use this class directly, but instead inherit from it in specific Transport
       that will set the application command line name, and marshall any runtime options. The OS
       platform is detected automatically.


       This method must be called before any other, to bootstrap the application wrapper module
       (IPC::Run or Net::Telnet). However, via Net::CLI::Interact's "cmd", "match" or
       "find_prompt" it will be called for you automatically.

       Two attributes of the specific loaded Transport are used. First the Application set in
       "app" is of course required, plus the options in the Transport's "runtime_options" are
       retrieved, if set, and passed as command line arguments to the Application.

       Returns True if "connect" has been called successfully, otherwise returns False.

       Undefines the application wrapper flushes any output data buffer such that the next call
       to "cmd" or "macro" will cause a new connection to be made.  Useful if you intentionally
       timeout a command and end up with junk in the output buffer.

       When passed a Net::CLI::Interact::Action instance, will execute the contained instruction
       on the connected CLI. This might be a command to "send", or a regular expression to
       "match" in the output.

       Features of the commands and prompts are supported, such as Continuation matching (and
       slurping), and sending without an output record separator.

       On failing to succeed with a Match, the module will time-out (see "timeout", below) and
       raise an exception.

       Output returned after issuing a command is stored within the Match Action's "response" and
       "response_stash" slots by this method, with the latter then marshalled into the correct
       "send" Action by the ActionSet.

   put( @data )
       Items in @data are joined together by an empty string and sent as input to the connected
       program's interactive session.

       Attempts to retrieve pending output from the connected program's interactive session.
       Returns true if there is new data available in the buffer, else will time-out and raise a
       Perl exception. See "buffer" and "timeout".

       Empties the buffer used for response data returned from the connected CLI, and returns
       that data as a single text string (possibly with embedded newlines).

   timeout( $seconds? )
       When "do_action" is polling for response data matching a regular expression Action, it
       will eventually time-out and throw an exception if nothing matches and no more data

       The number of seconds to wait is set via this method, which will also return the current
       value of "timeout". The default value is 10 seconds.

       Returns the Regular Expression reference used to split lines of response from the
       connected device. In the end, you will only receive data from this module separated by the
       "ors" value (by default a newline character). The "irs_re" is used internally by the
       module and is:

        qr/(?:\015\012|\015|\012)/  # i.e. CRLF or CR or LF

       Line separator character(s) appended to a command sent to the connected CLI.  This
       defaults to a newline on the application's platform.

       Slot for storing a reference to the application's Logger object.

       Returns true if the current platform is Windows. Can be called as either a class or
       instance method.

       Location and name of the program used to establish an interactive CLI session.  On Unix
       platforms this will be "ssh" (openssh), "telnet", or "cu" (serial line). On Windows this
       must be the "plink.exe" program.

       Slot for storing a set of options for the specific loaded Transport, passed by the user of
       Net::CLI::Interact as a hash ref. Do not access this directly, but instead use
       "runtime_options" from the specific Transport class.

       Slot for storing the application wrapper instance (IPC::Run or Net::Telnet).  Do not mess
       with this unless you know what you are doing.

       After "pump" returns successfully, the output most recently received is stored in this
       slot. Do not access this directly, but instead use the "flush" method.

       During long sections of output, this slot allows more efficient detection of matches.
       Older data is placed here, and only the most recent line of data is stored in the
       "buffer". That's why "flush" is the only way to ensure you get all the output data in one


       FIXME: On Unix, when the Telnet transport is selected but "IP::Pty" is unavailable,
       "Net::Telnet" can still be used, but currently "IPC::Run" is used instead.