From: Christopher Dicely <cmdicely@...>
Date: 2011-04-17T23:56:43+09:00
Subject: Re: Telnet "More?"

On Sun, Apr 17, 2011 at 12:10 AM, Eric T. <erictetz@gmail.com> wrote:
> I'm trying to use the telnet library. I don't know Ruby AT ALL
> (evaluating it side by side with Python to see which is going to be best
> for my admin chores; this is my very first script), and this has got me
> stumped:
>
>   require 'net/telnet'
>   t = Net::Telnet::new(
>      'Host'       => 'somehost.com',
>      'Prompt'     => /:.*>/,
>   )
>   out = lambda do |c| print c end
>   t.login('someusername', 'somepassword', &out)
>   t.cmd('dir', &out)
>   t.cmd('dir', &out)
>
> The second dir command hangs with the server responding "More?" Here's
> the tail end of the output log, after the first dir command:
>
>   ...
>   04/13/2011  04:21 PM    <DIR>          Searches
>   04/13/2011  04:21 PM    <DIR>          Videos
>   04/16/2011  12:54 AM             6,558 _viminfo
>                  1 File(s)          6,558 bytes
>                 13 Dir(s)  279,022,981,120 bytes free
>
>   C:\Users\foo>dir
>   More?
>
> And it just hangs there.

It looks like the server is sending something other than the default
prompt and expecting a response; you probably need to handle that
case.

If you use telnet directly (from the console, not a script) and do the
same sequence of commands, what happens?

>
> In a slightly unrelated question, I don't understand why I have to do
> this:
>
>   out = lambda do |c| print c end
>   t.login('someusername', 'somepassword', &out)
>   t.cmd('dir', &out)
>   t.cmd('dir', &out)
>
> Rather than simply this:
>
>   t.login('someusername', 'somepassword', &print)
>   t.cmd('dir', &print)
>   t.cmd('dir', &print)
>
> Seems kinda pointless to make a function which does nothing but pass
> it's arguments unaltered to another function.

Ruby is unlike Python in that, while it has functions that are objects
(e.g., Proc objects), methods (including Kernel#print) are not
functions (or objects). So you are creating a function that performs a
method call against the object that is the current value of "self"
passing that method  the same arguments that the function was called
with, not creating a function that calls a function with the same
arguments the first function is called with.

You could capture the method as a callable, function-like object with
self.method(:print) instead of an explicit lambda declaration, which
makes the difference more clear, but is somewhat less concise in this
case.