ftp_service 0.2.0 → 0.3.0

data/.gitignore

@@ -19,5 +19,7 @@ rdoc
 doc
 pkg
 .yardoc
+tmp
 
 ## PROJECT::SPECIFIC
+test_keys/random_seed

data/CHANGELOG.markdown

@@ -1,8 +1,16 @@
+# v0.3.0 (2010-03-18)
+
+* `FtpService#write_request` and `FtpService#read_response` support
+  encryption/decryption with gpg.
+* `FtpService#write_request` uses an intermediate temp file while
+  uploading to avoid case where server might try and respond to an
+  in-progress upload of a large request.
+* `FtpService#read_response` polls for a response.
+
 # v0.2.0 (2010-03-08)
 
 * Add `FtpService#write_request` and `FtpService#read_response` methods,
   making this thing actually usable.
-
 * Switch to Markdown + Yardoc for rdocs.
 
 # v0.1.1 (2010-03-08)

data/README.markdown

@@ -3,7 +3,7 @@
 An FTP Service is like a web service except stupid. You send your
 request by uploading an xml file and get your response by downloading
 another xml file. Have you ever had to deal with something like that? I
-have.
+have. It sucks.
 
 RDocs on [rdoc.info](http://rdoc.info/projects/blaix/ftp_service).
 
@@ -18,20 +18,15 @@ Source code on [github](http://github.com/blaix/ftp_service).
     require 'ftp_service'
   
     FtpService.open('host', 'user', 'pass') do |service|
-      path = '/the/remote/path'
-      service.write_request("#{path}/request.xml", '<foo>bar</foo>')
-      response = service.read_response("#{path}/response.xml")
+      service.write_request('<foo>bar</foo>', "/request/path.xml")
+      response = service.read_response("/response/path.xml")
     end
 
-* `read_response` will block while it polls the server waiting for a
-  response.
-* Temp files are created for the local request and response files and
-  deleted when no longer needed.
-
 For more details, see the
-[RDocs](http://rdoc.info/projects/blaix/ftp_service) (sike they are
-really yardocs!).
+[RDocs](http://rdoc.info/projects/blaix/ftp_service).
   
 ## Copyright
 
-Copyright (c) 2010 Justin Blake. See LICENSE for details.
+Copyright (c) 2010 Justin Blake. See
+[LICENSE](http://github.com/blaix/ftp_service/raw/master/LICENSE) for
+details.

data/Rakefile

@@ -10,9 +10,11 @@ begin
     gem.email = "justin@megablaix.com"
     gem.homepage = "http://github.com/blaix/ftp_service"
     gem.authors = ["Justin Blake"]
+    gem.add_dependency "ruby_gpg", ">= 0.2.0"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_development_dependency "mocha", ">= 0.9.8"
-    gem.add_development_dependency "yard", ">= 0"
+    gem.add_development_dependency "yard", ">= 0.5.3"
+    gem.add_development_dependency "cucumber", ">= 0.6.3"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -26,6 +28,9 @@ Spec::Rake::SpecTask.new(:spec) do |spec|
   spec.spec_files = FileList['spec/**/*_spec.rb']
 end
 
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
 namespace :spec do
   Spec::Rake::SpecTask.new(:doc) do |spec|
     spec.libs << 'lib' << 'spec'
@@ -47,7 +52,7 @@ task :default => :spec
 begin
   require 'yard'
   YARD::Rake::YardocTask.new do |y|
-    y.files << '-' << 'CHANGELOG.*'
+    y.files << '-' << 'CHANGELOG.*' << 'TODO.*'
   end
 rescue LoadError
   task :yardoc do

data/TODO.markdown

@@ -0,0 +1,4 @@
+# For v1.0.0
+
+* Log everything
+* Cleanup remote files on close

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/cucumber.yml

@@ -0,0 +1 @@
+default: features

data/features/basic_request.feature

@@ -0,0 +1,19 @@
+# To run, you must have an FTP server running and accessible by the 
+# credentials defined in features/support/ftp_helper.rb
+
+Feature: Making a request
+  In order to take advantage of a web service over FTP
+  As a poor unfortunate soul
+  I want to make a request
+  
+  Background:
+    Given I connect to an FTP service
+
+  Scenario: send a request
+    When I send the request "request" to the path "request_path"
+    Then the request "request" should exist at "request_path"
+  
+  Scenario: read a response
+    When the server responds with "response" at the path "response_path"
+    Then I can read the response at the path "response_path"
+    And the response should be "response"

data/features/encrypted_request.feature

@@ -0,0 +1,25 @@
+# To run, you must have an FTP server running and accessible by the 
+# credentials defined in features/support/ftp_helper.rb
+
+# The encryption uses the gpg keys in the test_keys dir.
+
+Feature: GPG Encryption
+  In order to keep my request secure over insecure FTP
+  As a user
+  I want to use gpg to encrypt and decrypt my request and response files
+
+  Background:
+    Given I connect to an FTP service
+
+  Scenario: send a request
+    When I send the request "secret content" to the path "request_path.gpg" with gpg recipient "Slow Joe Crow"
+    Then a binary request should exist at "request_path.gpg"
+    And the binary request at "request_path.gpg" should not contain "secret content"
+    When I download the binary request at "request_path.gpg" to "downloaded_request.gpg"
+    And I decrypt the file "downloaded_request.gpg" with passphrase "test"
+    Then the file "downloaded_request" should contain "secret content"
+  
+  Scenario: read a response
+    When the server responds with "secret response" encrypted for "Slow Joe Crow" at the path "response_path.gpg"
+    Then I can read the response at the path "response_path.gpg" with the passphrase "test"
+    And the response should be "secret response"

data/features/step_definitions/ftp_request_steps.rb

@@ -0,0 +1,68 @@
+Given /^I connect to an FTP service$/ do
+  @service = FtpService.new(FtpHelper::SERVER, FtpHelper::USER, FtpHelper::PASS)
+end
+
+When /^I send the request "([^\"]*)" to the path "([^\"]*)"$/ do |request, remote_path|
+  @service.write_request(request, remote_path)
+end
+
+When /^I send the request "([^\"]*)" to the path "([^\"]*)" with gpg recipient "([^\"]*)"$/ do |request, remote_path, gpg_recipient|
+  @service.write_request(request, remote_path, :gpg_recipient => gpg_recipient)
+end
+
+When /^the server responds with "([^\"]*)" at the path "([^\"]*)"$/ do |response, remote_path|
+  response = StringIO.new(response)
+  ftp.storlines("STOR #{remote_path}", response)
+end
+
+When /^the server responds with "([^\"]*)" encrypted for "([^\"]*)" at the path "([^\"]*)"$/ do |response, gpg_recipient, remote_path|
+  # Cheating a bit here to mimic a ftp service response by sending a request...
+  @service.write_request(response, remote_path, :gpg_recipient => gpg_recipient)
+end
+
+When /^I download the binary request at "([^\"]*)" to "([^\"]*)"$/ do |remote_path, local_path|
+  File.delete(local_path) if File.exist?(local_path)
+  ftp.getbinaryfile(remote_path, "#{TMP_PATH}/#{local_path}")
+end
+
+When /^I decrypt the file "([^\"]*)" with passphrase "([^\"]*)"$/ do |filename, passphrase|
+  RubyGpg.decrypt("#{TMP_PATH}/#{filename}", passphrase)
+end
+
+Then /^the request "([^\"]*)" should exist at "([^\"]*)"$/ do |request, remote_path|
+  actual_request = ""
+  ftp.retrlines("RETR #{remote_path}") { |line| actual_request << line }
+  actual_request.should == request
+end
+
+Then /^a binary request should exist at "([^\"]*)"$/ do |remote_path|
+  lambda {
+    ftp.retrbinary("RETR #{remote_path}", 128) {}
+  }.should_not raise_error
+end
+
+Then /^the binary request at "([^\"]*)" should not contain "([^\"]*)"$/ do |remote_path, request|
+  actual = ""
+  ftp.retrbinary("RETR #{remote_path}", 128) { |chunk| actual << chunk }
+  actual.strip.should_not == request.strip
+end
+
+Then /^I can read the response at the path "([^\"]*)"$/ do |remote_path|
+  @actual_response = @service.read_response(remote_path)
+end
+
+Then /^I can read the response at the path "([^\"]*)" with the passphrase "([^\"]*)"$/ do |remote_path, gpg_passphrase|
+  @actual_response = @service.read_response(remote_path, :gpg_passphrase => gpg_passphrase)
+end
+
+Then /^the response should be "([^\"]*)"$/ do |response|
+  @actual_response.strip.should == response
+end
+
+Then /^the file "([^\"]*)" should contain "([^\"]*)"$/ do |filename, contents|
+  File.read("#{TMP_PATH}/#{filename}").strip.should == contents.strip
+end
+
+After do
+  @service.close if @service
+end

data/features/support/env.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'ftp_service'
+
+RubyGpg.config.homedir = File.dirname(__FILE__) + '/../../test_keys'
+
+TMP_PATH = File.dirname(__FILE__) + '/../../tmp'

data/features/support/ftp_helper.rb

@@ -0,0 +1,13 @@
+require 'net/ftp'
+
+module FtpHelper
+  SERVER = 'localhost'
+  USER   = 'cucumber'
+  PASS   = 'cucumber_pass123'
+  
+  def ftp
+    @connection ||= Net::FTP.new(SERVER, USER, PASS)
+  end
+end
+
+World(FtpHelper)

data/ftp_service.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ftp_service}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin Blake"]
-  s.date = %q{2010-03-08}
+  s.date = %q{2010-03-18}
   s.description = %q{An FTP Service is like a web service except stupid. You send your request by uploading an xml file and get your response by downloading another xml file.}
   s.email = %q{justin@megablaix.com}
   s.extra_rdoc_files = [
@@ -22,14 +22,25 @@ Gem::Specification.new do |s|
      "LICENSE",
      "README.markdown",
      "Rakefile",
+     "TODO.markdown",
      "VERSION",
+     "cucumber.yml",
+     "features/basic_request.feature",
+     "features/encrypted_request.feature",
+     "features/step_definitions/ftp_request_steps.rb",
+     "features/support/env.rb",
+     "features/support/ftp_helper.rb",
      "ftp_service.gemspec",
      "lib/ftp_service.rb",
+     "lib/ftp_service/encryption.rb",
      "lib/tempfile_helper.rb",
      "spec/ftp_service_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
-     "spec/tempfile_helper_spec.rb"
+     "spec/tempfile_helper_spec.rb",
+     "test_keys/pubring.gpg",
+     "test_keys/secring.gpg",
+     "test_keys/trustdb.gpg"
   ]
   s.homepage = %q{http://github.com/blaix/ftp_service}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -47,18 +58,24 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ruby_gpg>, [">= 0.2.0"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_development_dependency(%q<mocha>, [">= 0.9.8"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0.5.3"])
+      s.add_development_dependency(%q<cucumber>, [">= 0.6.3"])
     else
+      s.add_dependency(%q<ruby_gpg>, [">= 0.2.0"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_dependency(%q<mocha>, [">= 0.9.8"])
-      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0.5.3"])
+      s.add_dependency(%q<cucumber>, [">= 0.6.3"])
     end
   else
+    s.add_dependency(%q<ruby_gpg>, [">= 0.2.0"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
     s.add_dependency(%q<mocha>, [">= 0.9.8"])
-    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0.5.3"])
+    s.add_dependency(%q<cucumber>, [">= 0.6.3"])
   end
 end
 

data/lib/ftp_service.rb

@@ -1,5 +1,6 @@
 require 'net/ftp'
 require 'tempfile_helper'
+require 'ftp_service/encryption'
 
 # Class for dealing with a service that acts like a web service, except
 # over FTP. Meaning an xml request is uploaded as a file, and the
@@ -21,6 +22,7 @@ require 'tempfile_helper'
 #   response = service.read_response("#{path}/response.xml")
 #   service.close
 class FtpService
+  include Encryption
   
   # Open a connection to the FTP server and return an FtpService object.
   # The object must be closed explicitely. See FtpServier#open for a
@@ -42,18 +44,49 @@ class FtpService
     end
   end
   
-  # Write `request` to a local temp file and upload it to `remote_path`
+  # Write +request+ to a local temp file and upload it to +remote_path+
   # on the FTP server.
-  def write_request(request, remote_path)
-    tmp = TempfileHelper.write(request, 'request')
-    @ftp.puttextfile(tmp.path, remote_path)
+  #
+  #   ftp_service.write_request('<foo>bar</foo>', '/remote/path.xml')
+  #
+  # You can encrypt the request using GPG:
+  #
+  #   ftp_service.write_request('<secret>stuff</secret>', '/remote/path.xml.gpg', :gpg_recipient => 'recipient@email.com')
+  # 
+  # You must have +gpg+ installed and have a public key available for 
+  # the intended recipient. This uses the +ruby_gpg+ gem. To configure
+  # the gpg settings, see {http://rdoc.info/projects/blaix/ruby_gpg}.
+  def write_request(request, remote_path, options = {})
+    request = TempfileHelper.write(request, 'request')
+    remote_temp_path = remote_path + ".tmp"
+    if options[:gpg_recipient]
+      encrypt(request, options[:gpg_recipient])
+      @ftp.putbinaryfile(request.path, remote_temp_path)
+    else
+      @ftp.puttextfile(request.path, remote_temp_path)
+    end
+    @ftp.rename(remote_temp_path, remote_path)
   end
   
-  # Download the file at `remote_path` from the FTP server to a  local
-  # temp file and return its contents.
-  def read_response(remote_path)
-    TempfileHelper.read('response') do |tmp|
-      @ftp.gettextfile(remote_path, tmp.path)
+  # Download the file at +remote_path+ from the FTP server to a local
+  # temp file and return its contents. If +remote_path+ doesn't exist,
+  # keep trying for 2 minutes before raising a Timeout::Error.
+  #
+  #   response = ftp_service.read_response('/remote/path.xml')
+  #
+  # If you expect the response to be encrypted for you with gpg:
+  #
+  #   response = ftp_service.read_response('/remote/path.xml.gpg', :gpg_passphrase => "my_passphrase")
+  #
+  # You must have +gpg+ installed and have the necessarry private key.
+  # This uses the +ruby_gpg+ gem. To configure the gpg settings, see
+  # {http://rdoc.info/projects/blaix/ruby_gpg}.
+  def read_response(remote_path, options = {})
+    response = download_and_read_response(remote_path, options)
+    if options[:gpg_passphrase]
+      RubyGpg.decrypt_string(response, options[:gpg_passphrase])
+    else
+      response
     end
   end
   
@@ -61,4 +94,38 @@ class FtpService
   def close
     @ftp.close
   end
+  
+  private
+  
+  def download_and_read_response(remote_path, options = {})
+    TempfileHelper.read('response') do |tmp|
+      Timeout::timeout(120) do
+        loop_until_downloaded(remote_path, tmp.path, options)
+      end
+    end
+  end
+  
+  def loop_until_downloaded(remote_path, local_path, options = {})
+    loop do
+      begin
+        download(remote_path, local_path, options)
+        break
+      rescue Net::FTPPermError => e
+        raise unless e.message.include?("No such file")
+        rest_between_requests
+      end
+    end
+  end
+  
+  def download(remote_path, local_path, options = {})
+    if options[:gpg_passphrase]
+      @ftp.getbinaryfile(remote_path, local_path)
+    else
+      @ftp.gettextfile(remote_path, local_path)
+    end
+  end
+  
+  def rest_between_requests
+    sleep(2)
+  end
 end

data/lib/ftp_service/encryption.rb

@@ -0,0 +1,17 @@
+begin
+  require 'ruby_gpg'
+rescue LoadError
+  require 'rubygems'
+  require 'ruby_gpg'
+end
+
+class FtpService
+  module Encryption
+    private
+    # Expects a tempfile object and a string for the recipient.
+    def encrypt(file, recipient)
+      RubyGpg.encrypt(file.path, recipient)
+      file.path << ".gpg"
+    end
+  end
+end

data/spec/ftp_service_spec.rb

@@ -54,9 +54,28 @@ describe "FtpService" do
       @service.write_request('request', '/remote/path')
     end
     
-    it "uploads the request to `path` on the FTP server" do
+    it "encrypts the request if passed a gpg recipient" do
       TempfileHelper.stubs(:write).returns(@tempfile)
-      @ftp.expects(:puttextfile).with('/local/path', '/remote/path')
+      RubyGpg.expects(:encrypt).with('/local/path', 'recipient')
+      @service.write_request('request', '/remote/path.gpg', :gpg_recipient => 'recipient')
+    end
+    
+    it "uploads the request to a temp path on the FTP server" do
+      TempfileHelper.stubs(:write).returns(@tempfile)
+      @ftp.expects(:puttextfile).with('/local/path', '/remote/path.tmp')
+      @service.write_request('request', '/remote/path')
+    end
+
+    it "uploads the request as binary if passed a gpg recipient" do
+      TempfileHelper.stubs(:write).returns(@tempfile)
+      RubyGpg.stubs(:encrypt)
+      @ftp.expects(:putbinaryfile).with('/local/path.gpg', '/remote/path.gpg.tmp')
+      @service.write_request('request', '/remote/path.gpg', :gpg_recipient => 'recipient')
+    end
+    
+    it "renames the temp path on the FTP server to the passed `path`" do
+      TempfileHelper.stubs(:write).returns(@tempfile)
+      @ftp.expects(:rename).with('/remote/path.tmp', '/remote/path')
       @service.write_request('request', '/remote/path')
     end
   end
@@ -65,7 +84,10 @@ describe "FtpService" do
     before do
       tempfile = stub('tempfile', :path => '/local/path')
       TempfileHelper.stubs(:read).returns('response').yields(tempfile)
+
       @service = FtpService.new('host', 'user', 'pass')
+      # No need to be nice to the "server" during testing...
+      @service.stubs(:rest_between_requests)
     end
     
     it "downloads the response at `path` from the FTP server" do
@@ -73,9 +95,45 @@ describe "FtpService" do
       @service.read_response('/remote/path')
     end
     
+    it "downloads the response as binary if passed a gpg passphrase" do
+      RubyGpg.stubs(:decrypt_string)
+      @ftp.expects(:getbinaryfile).with('/remote/path.gpg', '/local/path')
+      @service.read_response('/remote/path.gpg', :gpg_passphrase => "my_passphrase")
+    end
+    
+    it "decrypts the response if passed a gpg passphrase" do
+      RubyGpg.expects(:decrypt_string).with('response', 'my_passphrase')
+      @service.read_response('/remote/path.gpg', :gpg_passphrase => "my_passphrase")
+    end
+    
     it "returns the contents of the downloaded response" do
       @service.read_response('/remote/path').should == "response"
     end
+    
+    it "polls until response shows up" do
+      error = Net::FTPPermError.new("No such file")
+      # Raise error on the first two calls...
+      @ftp.expects(:gettextfile).times(3).raises(error).then.raises(error).then.returns(nil)
+      lambda {
+        @service.read_response('/remote/path')
+      }.should_not raise_error
+    end
+    
+    it "times out if response takes longer than 2 minutes to show up" do
+      # TODO: Less brittle way to test this?
+      # Currently depends on inner workings of Timeout.
+      Timeout.expects(:sleep).with(120)
+      lambda {
+        @service.read_response('/remote/path')
+      }.should raise_error(Timeout::Error)
+    end
+
+    it "doesn't gobble up every FTP exception" do
+      @ftp.stubs(:gettextfile).raises(Net::FTPPermError.new("Permission denied")).then.returns(nil)
+      lambda {
+        @service.read_response('/remote/path')
+      }.should raise_error(Net::FTPPermError, "Permission denied")
+    end
   end
   
   describe '#close' do

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Justin Blake
@@ -14,13 +14,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-08 00:00:00 -05:00
+date: 2010-03-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: ruby_gpg
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -30,11 +44,11 @@ dependencies:
         - 9
         version: 1.2.9
   type: :development
-  version_requirements: *id001
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: mocha
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -44,19 +58,35 @@ dependencies:
         - 8
         version: 0.9.8
   type: :development
-  version_requirements: *id002
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: yard
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        version: "0"
+        - 5
+        - 3
+        version: 0.5.3
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 3
+        version: 0.6.3
+  type: :development
+  version_requirements: *id005
 description: An FTP Service is like a web service except stupid. You send your request by uploading an xml file and get your response by downloading another xml file.
 email: justin@megablaix.com
 executables: []
@@ -72,14 +102,25 @@ files:
 - LICENSE
 - README.markdown
 - Rakefile
+- TODO.markdown
 - VERSION
+- cucumber.yml
+- features/basic_request.feature
+- features/encrypted_request.feature
+- features/step_definitions/ftp_request_steps.rb
+- features/support/env.rb
+- features/support/ftp_helper.rb
 - ftp_service.gemspec
 - lib/ftp_service.rb
+- lib/ftp_service/encryption.rb
 - lib/tempfile_helper.rb
 - spec/ftp_service_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/tempfile_helper_spec.rb
+- test_keys/pubring.gpg
+- test_keys/secring.gpg
+- test_keys/trustdb.gpg
 has_rdoc: true
 homepage: http://github.com/blaix/ftp_service
 licenses: []