filefm 0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Sergio Rubio
+
+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.md

@@ -0,0 +1,107 @@
+# FileFM
+
+Dead simple file uploads and downloads from/to:
+
+* HTTP
+* Rackspace Cloudfiles
+* Openstack Swift
+
+## API
+
+### Downloadinf files
+
+*Swift*
+
+    FileFM.download "swift://swift-server.com/container1/foofile", 
+                    :progressbar => true,
+                    :secure => false,
+                    :destination => '/tmp/myfoofile',
+                    :username => 'admin:admin',
+                    :password => 'admin'
+
+*Cloudfiles*
+
+    FileFM.download "cloudfiles://container1/foofile", 
+                    :progressbar => true,
+                    :destination => '/tmp/myfoofile',
+                    :username => 'foo-user',
+                    :password => 'RACKSPACE-API-KEY-HERE'
+
+*HTTP*
+    
+    FileFM.download "http://imaginary-server/foo-linux.iso", 
+                    :progressbar => true,
+                    :destination => '/tmp/ubuntu.iso'
+
+### Uploading files
+      
+*Swift*
+
+    FileFM.upload "myfoo-file.txt, 
+                  "swift://swift-server.com/container1/myfoo-file.txt", 
+                  :username => "admin:admin",
+                  :password => "admin",
+                  :secure => false,           # no SSL
+                  :progressbar => true        # print progress while uploading
+
+Using v2.0 authentication style (keystone)
+
+    FileFM::Uploaders::Swift.upload("/home/user/my-file", 
+                                    "swift://swift.myserver.com/container1/my-file", 
+                                    { 
+                                      :username => "tenant:username",
+                                      :password => "secret",
+                                      :auth_url => "http://my-keystone-server:5000/v2.0/tokens", 
+                                      :progressbar => true
+                                    })
+
+
+*Cloudfiles*
+
+    FileFM.upload   "myfoo-file.txt",
+                    "cloudfiles://container1/foofile", 
+                    :progressbar => true,
+                    :username => 'foo-user',
+                    :password => 'RACKSPACE-API-KEY-HERE'
+
+## Command line
+
+
+*Swift*
+
+    filefm upload --insecure --user admin:admin \
+                  --password secret \
+                  /home/user/my-file \
+                  swift://server/container1/my-file
+
+Using v2.0 authentication style (keystone)
+
+    filefm upload -A http://my-keystone-server:5000/v2.0/tokens \
+                  --insecure -u admin:admin -p ADMIN \
+                  /path/to/my/file \
+                  swift://swift.myserver.com/container1/my-file
+
+*Rackspace*
+
+    filefm upload --user <rackspace-username> \
+                  --password <RACKSPACE_API> \
+                  <path-to-file> \
+                  cloudfiles://container1/foo.tmp
+
+*HTTP*
+
+    filefm download http://my-server.com/my-big-file
+
+
+## DEBUGGING ENABLED
+
+    DEBUG=yes filefm upload --insecure --user admin:admin \
+                  --password secret \
+                  /home/user/my-file \
+                  swift://server/container1/my-file
+
+# Copyright
+
+Copyright (c) 2012 Sergio Rubio. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'filefm'
+
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.version = FileFM::VERSION
+  gem.name = "filefm"
+  gem.homepage = "http://github.com/rubiojr/filefm"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple library to download/upload files}
+  gem.description = %Q{Simple library to download/upload files}
+  gem.email = "rubiojr@frameos.org"
+  gem.authors = ["Sergio Rubio"]
+  # dependencies defined in Gemfile
+  gem.add_runtime_dependency 'clamp'
+  gem.add_runtime_dependency 'fog'
+  gem.add_runtime_dependency 'progressbar'
+  gem.add_runtime_dependency 'rest-client'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :build

data/bin/filefm

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'filefm'
+require 'clamp'
+require 'uri'
+
+trap("INT") do
+  $stderr.puts "\nAborting."
+  exit 1
+end
+
+class UploadCommand < Clamp::Command
+
+  option ["-u","--user"], "PASSWORD", "User name when auth required"
+  option ["-p","--password"], "PASSWORD", "Password when auth required"
+  option ["-A","--auth-url"], "URL", "Optional authentication URL", :attribute_name => :auth_url
+  option "--insecure", :flag, "Secure uploads using SSL", :default => false
+  option "--no-progressbar", :flag, "Do not display progress", :default => false 
+
+  parameter "SOURCE", "File to upload", :attribute_name => :source
+  parameter "TARGET", "Destination of the file", :attribute_name => :target
+
+  def execute
+    uri = URI.parse(target)
+    begin
+      FileFM.upload source, 
+                    target, 
+                    :username => user,
+                    :password => password,
+                    :secure => !insecure?,
+                    :auth_url => auth_url,
+                    :progressbar => !no_progressbar?
+    rescue => e
+      puts e.class
+      puts e.backtrace
+      puts "ERROR: #{e.message}"
+    end
+  end
+
+end
+
+class DownloadCommand < Clamp::Command
+
+  option "--no-progressbar", :flag, "Do not display progress", :default => false
+  option ["-u","--user"], "PASSWORD", "User name when auth required"
+  option ["-p","--password"], "PASSWORD", "Password when auth required"
+  option ["-d","--destination"], "PATH", "Path where the file will be saved"
+  option "--insecure", :flag, "Secure download using SSL", :default => true
+
+  parameter "FILES ...", "the thing to say", :attribute_name => :files
+
+  def execute
+    file = files.join(" ")
+    begin
+      FileFM.download file, :progressbar => !no_progressbar?,
+                            :secure => !insecure?,
+                            :username => user,
+                            :destination => destination,
+                            :password => password
+    rescue => e
+      puts "ERROR: #{e.message}"
+    end
+  end
+
+end
+
+class MainCommand < Clamp::Command
+
+  subcommand "download", "Download a file", DownloadCommand
+  subcommand "upload", "Upload a file", UploadCommand 
+
+end
+
+MainCommand.run

data/examples/basics.rb

@@ -0,0 +1,8 @@
+require 'filefm'
+
+# Swift
+# download
+FileFM.download "swift://swift-server/containerfoo/foo.tmp", :username => 'admin:admin', :password => 'secret', :progressbar => true
+
+# upload
+

data/lib/filefm.rb

@@ -0,0 +1,54 @@
+require 'progressbar'
+require 'net/http'
+require 'uri'
+require 'filefm/streaming_uploader'
+require 'filefm/config'
+require 'restclient'
+require 'fileutils'
+require 'multi_json'
+require 'fog'
+require 'logger'
+
+module FileFM
+
+  if !defined? Log or Log.nil?
+    Log = Logger.new($stdout)
+    Log.formatter = proc do |severity, datetime, progname, msg|
+        "[FileFM] #{severity}: #{msg}\n"
+    end
+    Log.level = Logger::INFO unless ENV["DEBUG"].eql? "yes"
+    Log.debug "Initializing logger"
+  end
+
+  VERSION="0.1"
+
+  def self.download(link, opts={})
+    uri = URI.parse link
+    if uri.scheme =~ /^http/
+      require 'filefm/downloaders/http'
+      FileFM::Downloaders::HTTP.download link, opts
+    elsif uri.scheme =~ /^swift/
+      require 'filefm/downloaders/swift'
+      FileFM::Downloaders::Swift.download link, opts
+    elsif uri.scheme =~ /^cloudfiles/
+      require 'filefm/downloaders/cloudfiles'
+      FileFM::Downloaders::Cloudfiles.download link, opts
+    end
+
+  end
+
+  def self.upload(source, destination, options = {})
+    uri = URI.parse destination 
+    if uri.scheme =~ /^swift/
+      uri = URI.parse(destination)
+        # swift://swift-server/container/object
+        require 'filefm/uploaders/swift'
+        FileFM::Uploaders::Swift.upload source, destination, options
+    elsif uri.scheme =~ /^cloudfiles/
+        require 'filefm/uploaders/cloudfiles'
+        FileFM::Uploaders::Cloudfiles.upload source, destination, options
+    end
+  end
+
+end
+

data/lib/filefm/config.rb

@@ -0,0 +1,33 @@
+module FileFM
+  require 'yaml'
+
+  class Config 
+
+    def self.file=(file)
+      @file = file
+    end
+    
+    def self.provider=(provider)
+      @provider = provider
+    end
+
+    def self.provider
+      @provider || :default
+    end
+
+    def self.file
+      @file || ENV["HOME"] + "/.filefm"
+    end
+
+    def self.load
+      return nil if not File.exist?(file)
+      @config ||= YAML.load_file file
+    end
+
+    def self.[](key)
+      self.load[provider][key]
+    end
+
+  end
+
+end

data/lib/filefm/downloaders/cloudfiles.rb

@@ -0,0 +1,91 @@
+module FileFM
+  module Downloaders
+    class Cloudfiles
+      def self.download(link, opts = {})
+        require 'fog'
+        require 'fog/rackspace/storage'
+        
+        uri = URI.parse(link)
+        container = uri.host
+        object = link.gsub(/^.*#{container}\//, "")
+        auth_url = "https://auth.api.rackspacecloud.com/v1.0"
+
+        if (not opts[:username] or not opts[:password])
+          raise "Invalid Credentials"
+        end
+        secure = true
+        scheme = secure ? "https" : "http"
+        username = opts[:username]
+        password = opts[:password]
+
+        #puts "#{scheme}://#{uri.host}/auth/v1.0"
+        conn = Fog::Storage.new({
+          :provider => 'Rackspace',
+          :rackspace_username => username,
+          :rackspace_api_key => password
+        })
+
+        out = RestClient.get auth_url, 'X-Auth-User' => username, 'X-Auth-Key' => password
+        storage_url = out.headers[:x_storage_url]
+        auth_token = out.headers[:x_auth_token]
+        raise "Error authenticating" unless out.code == 204
+
+        o = {
+          :location => nil,
+          :size => nil,
+          :filename => nil
+        }.merge(opts)
+        
+        @location = o[:location] ||= ""
+        @filename = o[:filename]
+        progress = 0
+        
+        headers = {
+                    "User-Agent" => "FileFM #{VERSION}",
+                    "X-Auth-Token" => auth_token
+                   }
+        
+        c = conn.directories.get container
+        raise "Container not found" if c.nil?
+
+        o = c.files.get object
+        @size = o.content_length
+
+        uri = URI.parse storage_url 
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == "https"
+        http.open_timeout = 3 # seconds
+        http.read_timeout = 3 # seconds
+        path = uri.path + "/#{container}/#{object}"
+        request = Net::HTTP::Get.new(path)
+
+        request.initialize_http_header headers
+
+        puts "unknown file size for #{@filename} but downloading..." if @size.nil?
+        
+        dest_file = opts[:destination] || File.basename(object)
+
+        response = http.request(request) do |response|
+          if opts[:progressbar]
+            bar = ProgressBar.new("Progress", @size.to_i) unless @size.nil?
+            bar.format_arguments=[:title, :percentage, :bar, :stat_for_file_transfer] unless @size.nil?
+          end
+                
+          File.open(dest_file, "wb") do |file|
+            response.read_body do |segment|
+              if opts[:progressbar]
+                progress += segment.length
+                bar.set(progress) unless @size.nil?
+              end
+              file.write(segment)
+            end
+          end
+        end
+
+        FileUtils.rm dest_file unless response.is_a? Net::HTTPOK
+        raise "Error downlading file: #{response.class.to_s}" unless response.is_a? Net::HTTPOK
+      end
+    end
+  end
+end
+        

data/lib/filefm/downloaders/http.rb

@@ -0,0 +1,59 @@
+module FileFM
+  module Downloaders
+    class HTTP
+      def self.download(link, opts = {})
+        o = {
+          :location => nil,
+          :size => nil,
+          :filename => nil
+        }.merge(opts)
+        
+        @link = link
+        @size = o[:size]
+        @location = o[:location] ||= ""
+        @filename = o[:filename]
+        @progress = 0
+        
+        uri = URI.parse(@link.to_s)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == "https"
+        http.open_timeout = 3 # seconds
+        http.read_timeout = 3 # seconds
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request.initialize_http_header({"User-Agent" => "FileFM #{VERSION}"})
+
+        head = http.request_head(URI.escape(uri.request_uri))
+        case head
+        when Net::HTTPForbidden
+          @size = nil #no content-length no progress bar
+        else
+          @size = head['content-length'] if @size.nil? && head['content-length'].to_i > 1024
+        end
+        
+        #puts "unknown file size for #{@filename} but downloading..." if @size.nil?
+        #puts @link.to_s
+        
+        dest_file = @location + (@filename ||= File.basename(uri.path))
+        response = http.request(request) do |response|
+          if opts[:progressbar]
+            bar = ProgressBar.new("Progress", @size.to_i) unless @size.nil?
+            bar.format_arguments=[:title, :percentage, :bar, :stat_for_file_transfer] unless @size.nil?
+          end
+                
+          File.open(dest_file, "wb") do |file|
+            response.read_body do |segment|
+              if opts[:progressbar]
+                @progress += segment.length
+                bar.set(@progress) unless @size.nil?
+              end
+              file.write(segment)
+            end
+          end
+        end
+        FileUtils.rm dest_file unless response.is_a? Net::HTTPOK
+        raise "Error downlading file: #{response.class.to_s}" unless response.is_a? Net::HTTPOK
+      end
+    end
+  end
+end
+        

data/lib/filefm/downloaders/swift.rb

@@ -0,0 +1,93 @@
+module FileFM
+  module Downloaders
+    class Swift
+      def self.download(link, opts = {})
+        require 'fog'
+        require 'fog/rackspace/storage'
+        
+        uri = URI.parse(link)
+        container = uri.path.split("/")[1]
+        object = uri.path.split("/")[2..-1].join("/")
+
+        if (not opts[:username] or not opts[:password])
+          raise "Invalid Credentials"
+        end
+        secure = opts[:secure] == true 
+        scheme = secure ? "https" : "http"
+        username = opts[:username]
+        password = opts[:password]
+
+        #puts "#{scheme}://#{uri.host}/auth/v1.0"
+        conn = Fog::Storage.new({
+          :provider => 'Rackspace',
+          :rackspace_username => username,
+          :rackspace_api_key => password,
+          :rackspace_auth_url => "#{scheme}://#{uri.host}/auth/v1.0"
+                        })
+
+
+        out = RestClient.get "#{scheme}://#{uri.host}/auth/v1.0", 'X-Storage-User' => username, 'X-Storage-Pass' => password
+        storage_url = out.headers[:x_storage_url]
+        auth_token = out.headers[:x_auth_token]
+        raise "Error authenticating" unless out.code == 200
+
+        o = {
+          :location => nil,
+          :size => nil,
+          :filename => nil
+        }.merge(opts)
+        
+        @link = storage_url + "#{uri.path}"
+        @size = o[:size]
+        @location = o[:location] ||= ""
+        @filename = o[:filename]
+        @progress = 0
+        
+        headers = {
+                    "User-Agent" => "FileFM #{VERSION}",
+                    "X-Auth-Token" => auth_token
+                   }
+
+        uri = URI.parse storage_url + uri.path
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == "https"
+        http.open_timeout = 3 # seconds
+        http.read_timeout = 3 # seconds
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        request.initialize_http_header headers
+
+        container = conn.directories.get container
+        raise "Container not found" if container.nil?
+
+        object = container.files.get object
+        @size = object.content_length
+        
+        puts "unknown file size for #{@filename} but downloading..." if @size.nil?
+        #puts @link.to_s
+        
+        dest_file = @location + (@filename ||= File.basename(uri.path))
+        response = http.request(request) do |response|
+          if opts[:progressbar]
+            bar = ProgressBar.new("Progress", @size.to_i) unless @size.nil?
+            bar.format_arguments=[:title, :percentage, :bar, :stat_for_file_transfer] unless @size.nil?
+          end
+                
+          File.open(dest_file, "wb") do |file|
+            response.read_body do |segment|
+              if opts[:progressbar]
+                @progress += segment.length
+                bar.set(@progress) unless @size.nil?
+              end
+              file.write(segment)
+            end
+          end
+        end
+
+        FileUtils.rm dest_file unless response.is_a? Net::HTTPOK
+        raise "Error downlading file: #{response.class.to_s}" unless response.is_a? Net::HTTPOK
+      end
+    end
+  end
+end
+        

data/lib/filefm/streaming_uploader.rb

@@ -0,0 +1,157 @@
+module FileFM
+
+  # StreamingUploader Adapted by Sergio Rubio <rubiojr@frameos.org>
+  #
+  # inspired by Opscode Chef StreamingCookbookUploader chef/streaming_cookbook_uploader.rb
+  # http://opscode.com
+  # 
+  # inspired by/cargo-culted from http://stanislavvitvitskiy.blogspot.com/2008/12/multipart-post-in-ruby.html
+  # On Apr 6, 2010, at 3:00 PM, Stanislav Vitvitskiy wrote:
+  #
+  # It's free to use / modify / distribute. No need to mention anything. Just copy/paste and use.
+  #
+  # Regards,
+  # Stan
+
+
+  require 'net/http'
+
+  class StreamingUploader
+
+    class << self
+
+      def put(to_url, params = {}, &block)
+        boundary = '----RubyMultipartClient' + rand(1000000).to_s + 'ZZZZZ'
+        parts = []
+        content_file = nil
+        
+        unless params.nil? || params.empty?
+          params.each do |key, value|
+            if value.kind_of?(File)
+              content_file = value
+              filepath = value.path
+              filename = File.basename(filepath)
+              parts << StringPart.new( "--" + boundary + "\r\n" +
+                                       "Content-Disposition: form-data; name=\"" + key.to_s + "\"; filename=\"" + filename + "\"\r\n" +
+                                       "Content-Type: application/octet-stream\r\n\r\n")
+              parts << StreamPart.new(value, File.size(filepath))
+              parts << StringPart.new("\r\n")
+            else
+              parts << StringPart.new( "--" + boundary + "\r\n" +
+                                       "Content-Disposition: form-data; Content-Type:application/json; name=\"" + key.to_s + "\"\r\n\r\n")
+              parts << StringPart.new(value.to_s + "\r\n")
+            end
+          end
+          parts << StringPart.new("--" + boundary + "--\r\n")
+        end
+        
+        body_stream = MultipartStream.new(parts, block)
+        
+        url = URI.parse(to_url)
+        
+        headers = { 'Content-Length' => body_stream.size.to_s, 'Content-Type' => 'application/json' }.merge(params[:headers])
+
+        req = Net::HTTP::Put.new(url.path, headers)
+        if ENV["DEBUG"] == "yes"
+          puts "HEADERS: " + headers.inspect
+          puts "HOST:    " + url.host 
+          puts "PORT:    " + url.port.to_s
+          puts "PATH:    " + url.path
+        end
+        
+        req.content_length = body_stream.size
+        req.content_type = 'multipart/form-data; boundary=' + boundary unless parts.empty?
+        req.body_stream = body_stream
+        
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true if url.scheme == "https"
+        #http.verify_mode = OpenSSL::SSL::VERIFY_NONE if url.scheme == "https"
+        res = http.request(req)
+        res
+      end
+      
+    end
+
+    class StreamPart
+      def initialize(stream, size)
+        @stream, @size = stream, size
+      end
+
+      def size
+        @size
+      end
+
+      # read the specified amount from the stream
+      def read(offset, how_much)
+        @stream.read(how_much)
+      end
+    end
+
+    class StringPart
+      def initialize(str)
+        @str = str
+      end
+      
+      def size
+        @str.length
+      end
+
+      # read the specified amount from the string startiung at the offset
+      def read(offset, how_much)
+        @str[offset, how_much]
+      end
+    end
+
+    class MultipartStream
+      def initialize(parts, blk = nil)
+        @callback = nil
+        if blk
+          @callback = blk
+        end
+        @parts = parts
+        @part_no = 0
+        @part_offset = 0
+      end
+      
+      def size
+        @parts.inject(0) {|size, part| size + part.size}
+      end
+      
+      def read(how_much)
+        @callback.call(how_much) if @callback
+        return nil if @part_no >= @parts.size
+
+        how_much_current_part = @parts[@part_no].size - @part_offset
+        
+        how_much_current_part = if how_much_current_part > how_much
+                                  how_much
+                                else
+                                  how_much_current_part
+                                end
+        
+        how_much_next_part = how_much - how_much_current_part
+
+        current_part = @parts[@part_no].read(@part_offset, how_much_current_part)
+        
+        # recurse into the next part if the current one was not large enough
+        if how_much_next_part > 0
+          @part_no += 1
+          @part_offset = 0
+          next_part = read(how_much_next_part)
+          current_part + if next_part
+                           next_part
+                         else
+                           ''
+                         end
+        else
+          @part_offset += how_much_current_part
+          current_part
+        end
+      end
+    end
+    
+  end
+
+
+end
+

data/lib/filefm/uploaders/cloudfiles.rb

@@ -0,0 +1,59 @@
+module FileFM
+  module Uploaders
+    class Cloudfiles 
+
+      def self.upload(source, destination, options)
+        uri = URI.parse(destination)
+        container = uri.host
+        object = uri.path
+
+        if (not options[:username] or not options[:password])
+          raise "Invalid Credentials"
+        end
+        secure = options[:secure] == true 
+        scheme = "https"
+        username = options[:username]
+        password = options[:password]
+
+        #puts "#{scheme}://#{uri.host}/auth/v1.0"
+        out = RestClient.get "#{scheme}://auth.api.rackspacecloud.com/v1.0", 'X-Auth-User' => username, 'X-Auth-Key' => password
+        storage_url = out.headers[:x_storage_url]
+        auth_token = out.headers[:x_auth_token]
+        raise "Error authenticating" unless out.code == 204
+        
+        begin
+          out = RestClient.get storage_url + "/#{container}", 'X-Auth-Token' => auth_token
+        rescue
+          raise "Error accessing the container: #{container}"  
+        end
+
+        if options[:progressbar]
+          pbar = ProgressBar.new "Progress", 100
+          fsize = File.size(source)
+          count = 0
+        end
+
+        headers = { 'X-Auth-Token' => auth_token, 'Content-Type' => "application/json" }
+        path = storage_url + "/#{container}#{object}"
+
+        res = FileFM::StreamingUploader.put(
+            path,
+            :headers => { 'X-Auth-Token' => auth_token }, :file => File.open(source) 
+        ) do |size|
+            if block_given?
+              yield size
+            elsif options[:progressbar]
+             count += size
+             per = (100*count)/fsize 
+             pbar.set per
+            else
+            end
+          end
+        if options[:progressbar]
+          pbar.finish
+        end
+      end
+
+    end
+  end
+end

data/lib/filefm/uploaders/swift.rb

@@ -0,0 +1,109 @@
+module FileFM
+  module Uploaders
+    class Swift
+
+      def self.authenticate_keystone(username, tenant, api_key, auth_url)
+        Log.debug "Using Swift keystone authentication"
+        rackspace_auth_url = auth_url
+        uri = URI.parse(rackspace_auth_url)
+        connection = Fog::Connection.new(rackspace_auth_url, false)
+        req_body= {
+          'auth' => {
+            'passwordCredentials'  => {
+              'username' => username,
+              'password' => api_key
+            }
+          }
+        }
+        req_body['auth']['tenantName'] = tenant
+
+        response = connection.request({
+          :expects  => [200, 204],
+          :headers => {'Content-Type' => 'application/json'},
+          :body  => MultiJson.encode(req_body),
+          :host     => uri.host,
+          :method   => 'POST',
+          :path     =>  (uri.path and not uri.path.empty?) ? uri.path : 'v2.0'
+        })
+        body=MultiJson.decode(response.body)
+
+        if svc = body['access']['serviceCatalog'].detect{ |x| x['name'] == 'swift' }
+          mgmt_url = svc['endpoints'].detect{|x| x['publicURL']}['publicURL']
+          token = body['access']['token']['id']
+          r = {
+            "X-Storage-Url" => mgmt_url,
+            "X-Auth-Token" => token,
+            "X-Server-Management-Url" => svc['endpoints'].detect{|x| x['adminURL']}['adminURL']
+          } 
+          return r
+        else
+          raise "Unable to parse service catalog."
+        end
+      end
+
+      def self.upload(source, destination, options = {})
+        uri = URI.parse(destination)
+        if uri.path.split("/").size == 2
+          uri.path = File.join(uri.path,File.basename(source))
+        end
+        if (not options[:username] or not options[:password])
+          raise "Invalid Credentials"
+        end
+        secure = options[:secure] == true 
+        scheme = secure ? "https" : "http"
+        username = options[:username]
+        password = options[:password]
+
+        if options[:auth_url]
+          auth_url = options[:auth_url]
+          username,tenant = username.split(":")
+          out = authenticate_keystone(username, tenant, password, auth_url)
+          storage_url = out["X-Storage-Url"]
+          auth_token = out["X-Auth-Token"]
+        else
+          Log.debug "Using Swift legacy auth"
+          Log.debug "Legacy auth URL #{scheme}://#{uri.host}/auth/v1.0"
+          out = RestClient.get "#{scheme}://#{uri.host}/auth/v1.0", 'X-Storage-User' => username, 'X-Storage-Pass' => password
+          storage_url = out.headers[:x_storage_url]
+          auth_token = out.headers[:x_auth_token]
+          raise "Error authenticating" unless out.code == 200
+        end
+
+        Log.debug "authentication OK"
+        Log.debug "X-Storage-Url: #{storage_url}"
+
+        begin
+          container = "#{uri.path.split("/")[1]}"
+          out = RestClient.get storage_url + "/#{container}", 'X-Storage-User' => username, 'X-Auth-Token' => auth_token
+        rescue
+          raise "Error accessing the container: #{container}"  
+        end
+
+        if options[:progressbar]
+          pbar = ProgressBar.new "Progress", 100
+          fsize = File.size(source)
+          count = 0
+        end
+
+        res = FileFM::StreamingUploader.put(
+            storage_url + uri.path,
+            :headers => { 'X-Auth-Token' => auth_token }, :file => File.open(source) 
+        ) do |size|
+            if block_given?
+              yield size
+            elsif options[:progressbar]
+             count += size
+             per = (100*count)/fsize 
+             per = 100 if per > 100
+             pbar.set per
+            else
+            end
+          end
+        if options[:progressbar]
+          pbar.finish
+        end
+      end
+
+    end
+  end
+end

data/tests/config.yml

@@ -0,0 +1,12 @@
+:default:
+  :swift_user: admin:admin
+  :swift_password: lkajsdflkj
+  :cloudfiles_key: lakjsldkfj
+  :cloudfiles_user: fooser
+  
+:testing:
+  :swift_user: admin:admin
+  :swift_password: lkajsdflkjaldf
+  :cloudfiles_key: lkjaslkfjlakd
+  :cloudfiles_user: fooser
+  

data/tests/config/config_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Test Config') do
+
+  def set_file f
+    FileFM::Config.file = f
+  end
+
+  tests("checking settings") do
+    returns(true, 'default file') do
+      FileFM::Config.file = nil
+      FileFM::Config.file == ENV["HOME"] + '/.filefm'
+    end
+    returns(true, 'changed file') do
+      FileFM::Config.file =  '/foo/bar'
+      FileFM::Config.file == '/foo/bar'
+    end
+    returns(true, 'default provider is default') do
+      FileFM::Config.provider == :default
+    end
+    returns(true, 'set the provider to testing') do
+      FileFM::Config.provider = :testing
+      FileFM::Config.provider == :testing
+    end
+  end
+
+  tests("check loading") do
+    returns(true, 'with non existent file') do
+      FileFM::Config.file =  '/foo/bar'
+      FileFM::Config.load.nil? 
+    end
+    returns(true, 'with valid file returns Hash') do
+      FileFM::Config.file =  test_config
+      FileFM::Config.load.kind_of? Hash
+    end
+  end
+
+  tests("config keys") do
+    FileFM::Config.file =  test_config
+
+    returns true, 'have valid swift_user key' do
+      FileFM::Config[:swift_user] == 'admin:admin'
+    end
+    returns true, 'have valid swift_password key' do
+      FileFM::Config[:swift_user] == 'admin:admin'
+    end
+
+  end
+
+end
+

data/tests/downloaders/swift_tests.rb

@@ -0,0 +1,4 @@
+Shindo.tests('Test Swift Downloader') do
+
+end
+

data/tests/helper.rb

@@ -0,0 +1,5 @@
+require 'filefm'
+
+def test_config
+  File.join(File.dirname(__FILE__), 'config.yml')
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: filefm
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Sergio Rubio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &23328280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23328280
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &23326980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *23326980
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &23325780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *23325780
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &23325260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23325260
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: &23324520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23324520
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &23323720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23323720
+- !ruby/object:Gem::Dependency
+  name: progressbar
+  requirement: &23340420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23340420
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &23339580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23339580
+description: Simple library to download/upload files
+email: rubiojr@frameos.org
+executables:
+- filefm
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/filefm
+- examples/basics.rb
+- lib/filefm.rb
+- lib/filefm/config.rb
+- lib/filefm/downloaders/cloudfiles.rb
+- lib/filefm/downloaders/http.rb
+- lib/filefm/downloaders/swift.rb
+- lib/filefm/streaming_uploader.rb
+- lib/filefm/uploaders/cloudfiles.rb
+- lib/filefm/uploaders/swift.rb
+- tests/config.yml
+- tests/config/config_tests.rb
+- tests/downloaders/swift_tests.rb
+- tests/helper.rb
+homepage: http://github.com/rubiojr/filefm
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Simple library to download/upload files
+test_files: []