em-ftp-client 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+test_client.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in em-ftp-client.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Ben Hughes
+Copyright (c) 2011 NabeWise Media, Inc.
+
+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.
+

data/README

@@ -0,0 +1,38 @@
+em-ftp-client is a simple EventMachine based FTP Client supporting operations
+on stream data.  The primary interface is EventMachine::FtpClient::Session.  A
+standard usage would look like:
+
+    require 'eventmachine'
+    require 'em-ftp-client'
+    
+    EM.run do
+      EM::FtpClient::Session.new("0.0.0.0", 
+        :username => "test", 
+        :password => "1234") do |ftp|
+        
+        ftp.list do |l1|
+          puts l1
+          puts
+          ftp.cwd("files") do
+            ftp.list do |l2|
+              puts l2
+              puts
+              ftp.stream {|d| puts "STREAMING: #{d.inspect}" }
+              ftp.get("two.txt") do |t1|
+                puts "COMPLETED"
+                puts t1
+                puts
+                EM.stop
+              end
+            end
+          end
+        end
+      end
+    end
+
+This library also includes the class SyncSession, which uses fibers and works
+with em-synchrony.
+
+TODO:
+
+Add support for put/STOR operations

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+

data/em-ftp-client.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-ftp-client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em-ftp-client"
+  s.version     = Em::Ftp::Client::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ben Hughes"]
+  s.email       = ["ben@pixelmachine.org"]
+  s.homepage    = ""
+  s.summary     = %q{EventMachine FTP client}
+  s.description = %q{An FTP client designed to work well with EventMachine}
+
+  s.rubyforge_project = "em-ftp-client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.add_dependency('eventmachine')
+  s.add_dependency('net-ftp-list')
+
+  s.add_development_dependency('shoulda')
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('redgreen')
+  s.add_development_dependency('rake')
+end

data/lib/em-ftp-client.rb

@@ -0,0 +1,7 @@
+require 'eventmachine'
+require 'net/ftp/list'
+
+require 'em-ftp-client/control_connection'
+require 'em-ftp-client/data_connection'
+require 'em-ftp-client/session'
+require 'em-ftp-client/sync_session'

data/lib/em-ftp-client/control_connection.rb

@@ -0,0 +1,274 @@
+module EventMachine
+  module FtpClient
+    class ControlConnection < Connection
+      include Protocols::LineText2
+  
+      attr_accessor :username, :password
+
+      attr_reader :responder
+
+      class InvalidResponseFormat < RuntimeError; end
+
+      class Response
+        attr_reader :code, :body, :parent
+        def initialize(code=nil, body=nil)
+          @code = code
+          @body = body
+          @empty = true
+          @complete = false
+        end
+
+        def complete?
+          @complete
+        end
+
+        def mark?
+          code && code[0,1] == "1"
+        end
+
+        def success?
+          complete? && code && (code[0,1] == "2" || code[0,1] == "3")
+        end
+
+        def failure?
+          complete? && code && (code[0,1] == "4" || code[0,1] == "5")
+        end
+
+        def <<(line)
+          # For an empty response
+          if @empty
+            # If the response is a valid format
+            if line =~ /^[1-5]\d{2}( |-)/
+              # If the response is multiline
+              if line[3,1] == '-'
+                @code, @body = line.chomp.split('-', 2)
+              # If the response is single line
+              elsif line[3,1] == ' '
+                @code, @body = line.chomp.split(' ', 2)
+                @complete = true
+              end
+              @empty = false
+            else
+              raise InvalidResponseFormat.new(line.chomp)
+            end
+          # If the response is a continuation of a multiline response
+          else
+            # If this response is terminal
+            if line[0..3] == "#{code} "
+              @body += "\n#{line.chomp.split(' ', 2)[1]}"
+              @complete = true
+            # Otherwise continue hoping and wishing for it to be terminated
+            else
+              @body += "\n#{line.chomp}"
+            end
+          end
+
+          line
+        end
+      end
+  
+      def initialize
+      end
+
+      def post_init
+        @data_connection = nil
+        @response = Response.new
+        @responder = nil
+      end
+  
+      def connection_completed
+        @responder = :receive_greetings
+      end
+
+      def error(e)
+        @errback.call(e) if @errback
+      end
+
+      def receive_line(line)
+        @response << line
+        if @response.complete?
+          # get a new fresh response ready
+          old_response = @response
+          @response = Response.new
+
+          # dispatch appropriately
+          if old_response.success?
+            send(@responder, old_response) if @responder
+          elsif old_response.mark?
+            #maybe notice the mark or something
+          elsif old_response.failure?
+            error(old_response)
+          end
+        end
+      rescue InvalidResponseFormat => e
+        @response = Response.new
+        error(e)
+      end
+
+      def data_connection_closed(data)
+        @data_buffer = data
+        @data_connection = nil
+        send(@responder) if @responder
+      end
+
+      def callback(&blk)
+        @callback = blk
+      end
+
+      def errback(&blk)
+        @errback = blk
+      end
+
+      def call_callback(*args)
+        old_callback = @callback
+        @callback = nil
+        old_callback.call(*args) if old_callback
+      end
+
+      def call_errback(*args)
+        @errback.call(*args) if @errback
+        @errback = nil
+      end
+
+      # commands
+      def user(name)
+        send_data("USER #{name}\r\n")
+        @responder = :user_response
+      end
+
+      def pass(word)
+        send_data("PASS #{word}\r\n")
+        @responder = :password_response
+      end
+
+      def type(t)
+        send_data("TYPE #{t}\r\n")
+        @responder = :type_response
+      end
+
+      def cwd(dir)
+        send_data("CWD #{dir}\r\n")
+        @responder = :cwd_response
+      end
+
+      def pwd
+        send_data("PWD\r\n")
+        @responder = :pwd_response
+      end
+
+      def pasv
+        send_data("PASV\r\n")
+        @responder = :pasv_response
+      end
+
+      def retr(file)
+        send_data("RETR #{file}\r\n")
+        @responder = :retr_response
+      end
+
+      def list
+        send_data("LIST\r\n")
+        @responder = :list_response
+      end
+
+      # handlers
+      
+      # Called after initial connection
+      def receive_greetings(banner)
+        if banner.code == "220"
+          user username
+        end
+      end
+
+      # Called when a response for the USER verb is received
+      def user_response(response)
+        pass password
+      end
+
+      # Called when a response for the PASS verb is received
+      def password_response(response)
+        type "I"
+      end
+
+      # Called when a response for the TYPE verb is received
+      def type_response(response)
+        @responder = nil
+        call_callback
+      end
+
+      # Called when a response for the CWD or CDUP is received
+      def cwd_response(response)
+        @responder = nil
+        call_callback
+      end
+
+      # Called when a response for the PWD verb is received
+      #
+      # Calls out with the result to the callback given to pwd
+      def pwd_response(response)
+        @responder = nil
+        call_callback(response.body)
+      end
+
+      # Called when a response for the PASV verb is received
+      #
+      # Opens a new data connection and executes the callback
+      def pasv_response(response)
+        @responder = nil
+        if response.code == "227"
+          if m = /(\d{1,3},\d{1,3},\d{1,3},\d{1,3}),(\d+),(\d+)/.match(response.body)
+            host_ip = m[1].gsub(",", ".")
+            host_port = m[2].to_i*256 + m[3].to_i
+            pasv_callback = @callback
+            @data_connection = EM.connect(host_ip, host_port, DataConnection)
+            @data_connection.on_connect &pasv_callback
+            @data_connection.callback {|data| data_connection_closed(data) }
+          end
+        end
+      end
+
+      def retr_response(response=nil)
+        if response && response.code != "226"
+          @data_connection.close_connection
+          @responder = nil
+          error(response)
+        end
+
+        if response && @data_connection
+          #well we still gots to wait for the file
+        elsif @data_connection
+          #well we need to wait for a response
+        else
+          @responder = nil
+          old_data_buffer = @data_buffer
+          @data_buffer = nil
+          call_callback(old_data_buffer)
+        end
+      end
+
+      def list_response(response=nil)
+        if response && response.code != "226"
+          @data_connection.close_connection
+          @responder = nil
+          error(response)
+        end
+
+        if response && @data_connection
+          #well we still gots to wait for the file
+        elsif @data_connection
+          #well we need to wait for a response
+        else
+          @responder = nil
+          old_data_buffer = @data_buffer
+          @data_buffer = nil
+          # parse it into a real form
+          file_list = old_data_buffer.split("\r\n").map do |line|
+            ::Net::FTP::List.parse(line)
+          end
+          call_callback(file_list)
+        end
+      end
+        
+    end
+  end
+end

data/lib/em-ftp-client/data_connection.rb

@@ -0,0 +1,31 @@
+module EventMachine
+  module FtpClient
+    class DataConnection < Connection
+      include Deferrable
+
+      def on_connect(&blk); @on_connect = blk; end
+
+      def stream(&blk); @stream = blk; end
+
+      def post_init
+        @buf = ''
+      end
+
+      def connection_completed
+        @on_connect.call(self) if @on_connect
+      end
+
+      def receive_data(data)
+        @buf += data
+        if @stream
+          @stream.call(@buf)
+          @buf = ''
+        end
+      end
+
+      def unbind
+        succeed(@buf)
+      end
+    end
+  end
+end

data/lib/em-ftp-client/session.rb

@@ -0,0 +1,53 @@
+module EventMachine
+  module FtpClient
+    # Main class for interacting with a server
+    class Session
+      attr_accessor :username, :password, :port
+
+      attr_reader :control_connection
+
+      def initialize(url, options={}, &cb)
+        self.username = options[:username] || "anonymous"
+        self.password = options[:password] || "anonymous"
+        self.port = options[:port] || 21
+
+        @control_connection = EM.connect(url, port, ControlConnection)
+        @control_connection.username = username
+        @control_connection.password = password
+        @control_connection.callback do
+          cb.call(self)
+        end
+      end
+
+      def pwd(&cb)
+        control_connection.callback(&cb)
+        control_connection.pwd
+      end
+
+      def cwd(dir, &cb)
+        control_connection.callback(&cb)
+        control_connection.cwd(dir)
+      end
+
+      def list(&cb)
+        control_connection.callback do
+          control_connection.callback(&cb)
+          control_connection.list
+        end
+        control_connection.pasv
+      end
+
+      def stream(&cb); @stream = cb; end
+
+      def get(file, &cb)
+        control_connection.callback do |data_connection|
+          data_connection.stream(&@stream) if @stream
+          control_connection.callback(&cb)
+          control_connection.retr file
+        end
+        control_connection.pasv
+      end
+    end
+  end
+end
+

data/lib/em-ftp-client/sync_session.rb

@@ -0,0 +1,57 @@
+begin
+  require 'fiber'
+
+  module EventMachine
+    module FtpClient
+      class SyncSession < Session
+        def initialize(url, options={})
+          f = Fiber.current
+          super url, options do |conn|
+            f.resume(conn)
+          end
+
+          Fiber.yield
+        end
+
+        def pwd
+          f = Fiber.current
+          super do |arg|
+            f.resume(arg)
+          end
+
+          Fiber.yield
+        end
+
+        def cwd(dir)
+          f = Fiber.current
+          super dir do
+            f.resume
+          end
+
+          Fiber.yield
+        end
+
+        def list
+          f = Fiber.current
+          super do |data|
+            f.resume(data)
+          end
+
+          Fiber.yield
+        end
+
+        def get(file)
+          f = Fiber.current
+
+          super file do |data|
+            f.resume(data)
+          end
+
+          Fiber.yield
+        end
+      end
+    end
+  end
+rescue LoadError
+  # Could not load fiber support
+end

data/lib/em-ftp-client/version.rb

@@ -0,0 +1,7 @@
+module Em
+  module Ftp
+    module Client
+      VERSION = "0.0.1"
+    end
+  end
+end

data/test/control_connection_test.rb

@@ -0,0 +1,196 @@
+require File.join(File.dirname(__FILE__), "helper")
+
+class ControlConnectionTest < Test::Unit::TestCase
+  def setup
+    @control_connection = EventMachine::FtpClient::ControlConnection.new(:foo)
+  end
+
+  context "Response" do
+    setup do
+      @response = EM::FtpClient::ControlConnection::Response.new
+    end
+
+    context "single line" do
+      context "success response" do
+        setup do
+          @code = "200"
+          @body = "OK Yeah"
+          @response << "#{@code} #{@body}\r\n"
+        end
+  
+        should "be complete" do
+          assert @response.complete?
+        end
+  
+        should "be successful" do
+          assert @response.success?
+          assert !@response.failure?
+        end
+  
+        should "have code and body" do
+          assert_equal @code, @response.code
+          assert_equal @body, @response.body
+        end
+  
+        should "not be a mark" do
+          assert !@response.mark?
+        end
+      end
+  
+      context "failure response" do
+        setup do
+          @code = "500"
+          @body = "No Soup For You"
+          @response << "#{@code} #{@body}\r\n"
+        end
+  
+        should "be complete" do
+          assert @response.complete?
+        end
+  
+        should "be a failure" do
+          assert !@response.success?
+          assert @response.failure?
+        end
+  
+        should "have code and body" do
+          assert_equal @code, @response.code
+          assert_equal @body, @response.body
+        end
+  
+        should "not be a mark" do
+          assert !@response.mark?
+        end
+      end
+  
+      context "mark response" do
+        setup do
+          @code = "150"
+          @body = "Roger that"
+          @response << "#{@code} #{@body}\r\n"
+        end
+  
+        should "be complete" do
+          assert @response.complete?
+        end
+  
+        should "not be a failure or a success" do
+          assert !@response.success?
+          assert !@response.failure?
+        end
+  
+        should "have code and body" do
+          assert_equal @code, @response.code
+          assert_equal @body, @response.body
+        end
+  
+        should "be a mark" do
+          assert @response.mark?
+        end
+      end
+    end
+
+    context "multiline" do
+      context "valid" do
+        should "work" do
+          @code = "226"
+          @body = ["Oh yeah", "Its on", "And done"]
+          @response << "#{@code}-#{@body[0]}\r\n"
+          assert !@response.complete?
+          @response << "#{@body[1]}\r\n"
+          assert !@response.complete?
+          @response << "#{@code} #{@body[2]}\r\n"
+          assert @response.complete?
+          assert_equal @code, @response.code
+          assert_equal @body.join("\n"), @response.body
+        end
+      end
+
+      context "attempted to be closed with a different code" do
+        should "not complete" do
+          @code = "226"
+          @response << "#{@code}-Foo\r\n"
+          assert !@response.complete?
+          @response << "227 Done\r\n"
+          assert !@response.complete?
+        end
+      end
+    end
+    
+    context "invalid response" do
+      should "raise an invalid response format error" do
+        assert_raise EM::FtpClient::ControlConnection::InvalidResponseFormat do
+          @response << "THIS IS SPARTA\r\n"
+        end
+      end
+    end
+  end
+
+  def test_basic_login
+    r = EM::FtpClient::ControlConnection::Response
+    @control_connection.username = "kingsly"
+    @control_connection.password = "password"
+
+    @control_connection.stubs(:send_data => true)
+
+    @control_connection.connection_completed
+    assert_equal :receive_greetings, @control_connection.responder
+    @control_connection.receive_greetings(r.new("220", "Come on in"))
+    assert_equal :user_response, @control_connection.responder
+    @control_connection.user_response(r.new("331", "Cool"))
+    assert_equal :password_response, @control_connection.responder
+    @control_connection.password_response(r.new("230", "Awesome"))
+    assert_equal :type_response, @control_connection.responder
+  end
+
+  def test_protocol_interaction
+    @control_connection.username = "kingsly"
+    @control_connection.password = "password"
+
+    @control_connection.connection_completed
+
+    started = false
+    working_dir = nil
+
+    @data_host = "127.0.0.1"
+    @data_port = 56789
+
+    @data_host_string = "127,0,0,1,221,213"
+    
+    @data_connection = EM::FtpClient::DataConnection.new(:foo)
+    EventMachine.expects(:connect).with(@data_host, @data_port, 
+                                        EM::FtpClient::DataConnection).
+                                   returns(@data_connection)
+
+    pasv_callback_called = false
+
+    [[nil, nil, "220 Come on in"],
+     [nil, "USER kingsly", "331 Cool"],
+     [nil, "PASS password", "230 Awesome"],
+     [nil, "TYPE I", "200 So Say We All", lambda { started = true }],
+     [[:pwd], "PWD", "257 \"/foo\"", lambda{|d| working_dir = d }],
+     [[:pasv], "PASV", "227 =#{@data_host_string}", lambda{ pasv_callback_called }]].each do |set|
+      @control_connection.expects(:send_data).with(set[1]+"\r\n") if set[1]
+    end.each do |set|
+      @control_connection.callback(&set[3]) if set[3]
+      @control_connection.send(*set[0]) if set[0]
+      @control_connection.receive_line(set[2]+"\r\n") if set[2]
+    end
+
+    @control_connection.expects(:send_data).with("RETR foo.txt\r\n")
+    @control_connection.retr("foo.txt")
+
+    retr_completed = false
+    @control_connection.callback {|data| assert_equal "Bar", data; retr_completed = true }
+    assert !retr_completed
+    @control_connection.receive_line("226 Hooray\r\n")
+    assert !retr_completed
+    @data_connection.receive_data("Bar")
+    @data_connection.unbind
+    assert retr_completed
+
+    assert started
+    assert_equal "\"/foo\"", working_dir
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require File.join(File.dirname(__FILE__), "..", "lib", "em-ftp-client")
+
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+require 'redgreen' unless '1.9'.respond_to?(:force_encoding)

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification 
+name: em-ftp-client
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ben Hughes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-29 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-ftp-list
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: redgreen
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: An FTP client designed to work well with EventMachine
+email: 
+- ben@pixelmachine.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- em-ftp-client.gemspec
+- lib/em-ftp-client.rb
+- lib/em-ftp-client/control_connection.rb
+- lib/em-ftp-client/data_connection.rb
+- lib/em-ftp-client/session.rb
+- lib/em-ftp-client/sync_session.rb
+- lib/em-ftp-client/version.rb
+- test/control_connection_test.rb
+- test/helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: em-ftp-client
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: EventMachine FTP client
+test_files: 
+- test/control_connection_test.rb
+- test/helper.rb