nightcrawler_swift 0.3.0 → 0.4.0

data/lib/nightcrawler_swift/connection.rb

@@ -1,26 +1,13 @@
 module NightcrawlerSwift
   class Connection
-    attr_accessor :opts, :auth_response, :token_id, :expires_at, :admin_url, :upload_url, :public_url
-
-    # Hash with: bucket, tenant_name, username, password, auth_url
-    #
-    def initialize opts = {}
-      @opts = OpenStruct.new opts
-      raise NightcrawlerSwift::Exceptions::ConfigurationError.new "max_age should be an Integer" if @opts.max_age and not @opts.max_age.is_a? Numeric
-    end
+    attr_accessor :auth_response
+    attr_reader :token_id, :expires_at, :catalog, :admin_url, :upload_url, :public_url
 
     def connect!
-      auth_response = authenticate!
-
-      @token_id = auth_response.access["token"]["id"]
-      @expires_at = auth_response.access["token"]["expires"]
-      @expires_at = DateTime.parse(@expires_at).to_time
+      authenticate!
+      configure
 
-      @admin_url = auth_response.access["serviceCatalog"].first["endpoints"].first["adminURL"]
-      @upload_url = "#{@admin_url}/#{opts.bucket}"
-      @public_url = auth_response.access["serviceCatalog"].first["endpoints"].first["publicURL"]
-
-      NightcrawlerSwift.logger.info  "Connected, token_id: #{@token_id}"
+      NightcrawlerSwift.logger.debug  "[NightcrawlerSwift] Connected, token_id: #{token_id}"
       self
     end
 
@@ -28,7 +15,17 @@ module NightcrawlerSwift
       !self.token_id.nil? and self.expires_at > Time.now
     end
 
+    def configure
+      select_token
+      select_catalog
+      select_endpoints
+      configure_urls
+    end
+
     private
+    def opts
+      NightcrawlerSwift.options
+    end
 
     def authenticate!
       auth_options = {
@@ -36,15 +33,39 @@ module NightcrawlerSwift
         passwordCredentials: {username: opts.username, password: opts.password}
       }
 
-      response = RestClient.post(
-        opts.auth_url, { auth: auth_options }.to_json,
-        content_type: :json,
-        accept: :json,
+      resource = RestClient::Resource.new(
+        opts.auth_url,
+        verify_ssl: NightcrawlerSwift.options.verify_ssl,
+        timeout: NightcrawlerSwift.options.timeout
       )
 
-      OpenStruct.new(JSON.parse(response.body))
+      response = resource.post({ auth: auth_options }.to_json, content_type: :json, accept: :json)
+
+      @auth_response = OpenStruct.new(JSON.parse(response.body))
     rescue StandardError => e
       raise Exceptions::ConnectionError.new(e)
     end
+
+    def select_token
+      @token_id = auth_response.access["token"]["id"]
+      @expires_at = auth_response.access["token"]["expires"]
+      @expires_at = DateTime.parse(@expires_at).to_time
+    end
+
+    def select_catalog
+      catalogs = auth_response.access["serviceCatalog"]
+      @catalog = catalogs.find {|catalog| catalog["type"] == "object-store"}
+    end
+
+    def select_endpoints
+      raise Exceptions::ConfigurationError.new "No catalog of type 'object-store' found" if catalog.nil?
+      @endpoints = catalog["endpoints"].first
+    end
+
+    def configure_urls
+      @admin_url = @endpoints["adminURL"]
+      @upload_url = "#{@admin_url}/#{opts.bucket}"
+      @public_url = @endpoints["publicURL"]
+    end
   end
 end

data/lib/nightcrawler_swift/exceptions.rb

@@ -11,6 +11,7 @@ module NightcrawlerSwift
     end
 
     class ConnectionError < BaseError; end
+    class ValidationError < ConnectionError; end
     class NotFoundError < BaseError; end
     class ConfigurationError < StandardError; end
   end

data/lib/nightcrawler_swift/tasks/asset_sync.rake

@@ -4,7 +4,7 @@ namespace :nightcrawler_swift do
   namespace :rails do
 
     desc "Synchronizes the public directory with OpenStack Swift"
-    task asset_sync: ["assets:precompile", "environment"] do
+    task sync: ["environment"] do
       begin
         NightcrawlerSwift.sync File.join(Rails.root, "public")
       rescue => e
@@ -13,5 +13,11 @@ namespace :nightcrawler_swift do
       end
     end
 
+    desc "Run 'assets:precompile' and synchronizes the public directory with OpenStack Swift"
+    task :asset_sync do
+      Rake::Task["assets:precompile"].invoke
+      Rake::Task["nightcrawler_swift:rails:sync"].invoke
+    end
+
   end
 end

data/lib/nightcrawler_swift/version.rb

@@ -1,3 +1,3 @@
 module NightcrawlerSwift
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/nightcrawler_swift.rb

@@ -1,5 +1,6 @@
 require "date"
 require "logger"
+require "digest"
 require "ostruct"
 require "multi_mime"
 require "rest_client"
@@ -7,29 +8,45 @@ require "nightcrawler_swift/version"
 require "nightcrawler_swift/exceptions"
 require "nightcrawler_swift/command"
 require "nightcrawler_swift/connection"
-require "nightcrawler_swift/upload"
-require "nightcrawler_swift/download"
-require "nightcrawler_swift/list"
-require "nightcrawler_swift/delete"
-require "nightcrawler_swift/sync"
+require "nightcrawler_swift/commands/upload"
+require "nightcrawler_swift/commands/download"
+require "nightcrawler_swift/commands/list"
+require "nightcrawler_swift/commands/delete"
+require "nightcrawler_swift/commands/sync"
 require "nightcrawler_swift/railtie" if defined?(Rails)
 
 module NightcrawlerSwift
   class << self
 
     attr_accessor :logger
-    attr_reader :connection
+    attr_reader :options, :connection
 
     def logger
-      @logger || Logger.new(STDOUT)
+      @logger ||= Logger.new(STDOUT).tap {|l| l.level = Logger::INFO}
     end
 
+    # Hash with:
+    # - bucket
+    # - tenant_name
+    # - username
+    # - password
+    # - auth_url
+    #
+    # - max_age (optional, default: nil)
+    # - verify_ssl (optional, default: false)
+    # - timeout (in seconds. Optional, default: nil)
+    #
     def configure opts = {}
-      @connection = Connection.new opts
+      @options = OpenStruct.new({verify_ssl: false}.merge(opts))
+
+      if @options.max_age and not @options.max_age.is_a?(Numeric)
+        raise Exceptions::ConfigurationError.new "max_age should be an Integer"
+      end
+
+      @connection = Connection.new
     end
 
     def sync dir_path
-      connection.connect!
       Sync.new.execute(dir_path)
     end
 

data/spec/fixtures/auth_success.json

@@ -7,9 +7,9 @@
             "type" : "object-store",
             "endpoints" : [
                {
-                  "publicURL" : "http://public.url.com",
-                  "internalURL" : "http://internal.url.com",
-                  "adminURL" : "http://api.url.com",
+                  "publicURL" : "http://public-url-com",
+                  "internalURL" : "http://internal-url-com",
+                  "adminURL" : "http://api-url-com",
                   "region" : "RegionOne",
                   "id" : "1"
                }
@@ -21,9 +21,9 @@
             "type" : "identity",
             "endpoints" : [
                {
-                  "publicURL" : "http://auth.url.com:123/v2.0",
-                  "internalURL" : "https://auth.url.com:123/v2.0",
-                  "adminURL" : "https://auth.url.com:321/v2.0",
+                  "publicURL" : "http://auth-url-com:123/v2.0",
+                  "internalURL" : "https://auth-url-com:123/v2.0",
+                  "adminURL" : "https://auth-url-com:321/v2.0",
                   "region" : "RegionOne",
                   "id" : "2"
                }

data/spec/lib/nightcrawler_swift/cli_spec.rb

@@ -0,0 +1,293 @@
+require "spec_helper"
+require "nightcrawler_swift/cli"
+
+describe NightcrawlerSwift::CLI do
+
+  let :config_dir do
+    File.expand_path(File.join(File.dirname(__FILE__), "../../fixtures"))
+  end
+
+  let :config_file do
+    File.join(config_dir, NightcrawlerSwift::CLI::CONFIG_FILE)
+  end
+
+  let :cache_file do
+    File.join(config_dir, NightcrawlerSwift::CLI::CACHE_FILE)
+  end
+
+  let :connection_success_json do
+    JSON.parse File.read(File.join(File.dirname(__FILE__), "../..", "fixtures/auth_success.json"))
+  end
+
+  let :opts do
+    {
+      "bucket"      => "my-bucket-name",
+      "tenant_name" => "tenant_username1",
+      "username"    => "username1",
+      "password"    => "some-pass",
+      "auth_url"    => "https://auth-url-com:123/v2.0/tokens"
+    }
+  end
+
+  subject do
+    NightcrawlerSwift::CLI.new argv.dup
+  end
+
+  before do
+    allow(subject).to receive(:user_home_dir).and_return(config_dir)
+  end
+
+  after do
+    File.delete(config_file) if File.exist?(config_file)
+    File.delete(cache_file) if File.exist?(cache_file)
+  end
+
+  shared_examples "CLI with default options" do
+    before do
+      File.open(config_file, "w") {|f| f.write(opts.to_json)}
+      allow(subject).to receive(:execute_command)
+    end
+
+    it "points to a config file in the user home dir" do
+      subject.run
+      path = File.join(config_dir, NightcrawlerSwift::CLI::CONFIG_FILE)
+      expect(subject.options.config_file).to eql File.expand_path(path)
+    end
+
+    it "points to a cache file in the uder home dir" do
+      subject.run
+      path = File.join(config_dir, NightcrawlerSwift::CLI::CACHE_FILE)
+      expect(subject.options.cache_file).to eql File.expand_path(path)
+    end
+  end
+
+  shared_examples "CLI with parsed parameters" do
+    context "--version or -v" do
+      it "prints the version number" do
+        subject.argv << "-v"
+        expect(subject).to receive(:log).with(NightcrawlerSwift::VERSION)
+        expect { subject.run }.to raise_error SystemExit
+
+        expect(subject).to receive(:log).with(NightcrawlerSwift::VERSION)
+        subject.argv = (argv << "--version")
+        expect { subject.run }.to raise_error SystemExit
+      end
+    end
+
+    context "--help or -h" do
+      before do
+        subject.send :configure_default_options
+        subject.send :configure_opt_parser
+
+        allow(subject).to receive(:configure_default_options)
+        allow(subject).to receive(:configure_opt_parser)
+      end
+
+      it "prints the help" do
+        subject.argv << "-h"
+        expect(subject).to receive(:log).with(subject.opt_parser.help)
+        expect { subject.run }.to raise_error SystemExit
+
+        expect(subject).to receive(:log).with(subject.opt_parser.help)
+        subject.argv = (argv << "--help")
+        expect { subject.run }.to raise_error SystemExit
+      end
+    end
+
+    context "--config or -c" do
+      let :config_file do
+        File.join(config_dir, "#{NightcrawlerSwift::CLI::CONFIG_FILE}-test")
+      end
+
+      before do
+        allow(subject).to receive(:execute_command)
+        allow(subject).to receive(:log)
+        File.open(config_file, "w") {|f| f.write("test")}
+      end
+
+      after do
+        File.delete(config_file) if File.exist?(config_file)
+      end
+
+      it "configures the config_file" do
+        subject.argv << "-c #{config_file}"
+        subject.run
+        expect(subject.options.config_file).to eql config_file
+
+        subject.argv = (argv << "--config=#{config_file}")
+        subject.run
+        expect(subject.options.config_file).to eql config_file
+      end
+    end
+  end
+
+  shared_examples "CLI that creates a sample config file" do
+    before do
+      allow(subject).to receive(:execute_command)
+      allow(subject).to receive(:log)
+    end
+
+    it "creates a sample config file" do
+      expect(File.exist?(config_file)).to eql false
+      expect { subject.run }.to raise_error SystemExit
+      expect(File.exist?(config_file)).to eql true
+      expect(File.read(config_file)).to eql subject.send(:sample_rcfile)
+    end
+
+    it "flags as not configured" do
+      expect { subject.run }.to raise_error SystemExit
+      expect(subject.options.configured).to eql false
+    end
+  end
+
+  shared_examples "CLI that uses the configured command" do
+    let :connection do
+      NightcrawlerSwift::Connection.new
+    end
+
+    before do
+      allow(subject).to receive(command_method)
+      allow(NightcrawlerSwift).to receive(:connection).and_return(connection)
+      File.open(config_file, "w") {|f| f.write(opts.to_json)}
+    end
+
+    it "configures NightcrawlerSwift" do
+      expect(NightcrawlerSwift).to receive(:configure).with opts
+      subject.run
+    end
+
+    context "when exist a previous valid authorization" do
+      it "reuses that" do
+        File.open(cache_file, "w") {|f| f.write(connection_success_json.to_json)}
+        expect(File.exist?(cache_file)).to eql true
+
+        expect(connection).to receive(:configure).and_call_original
+        subject.run
+        expect(connection.auth_response).to eql(OpenStruct.new(connection_success_json))
+      end
+    end
+
+    it "writes the auth_response into cache file" do
+      expect(File.exist?(cache_file)).to eql false
+      expect(connection).to receive(:auth_response).and_return(OpenStruct.new(connection_success_json))
+      subject.run
+      expect(File.exist?(cache_file)).to eql true
+      expect(File.read(cache_file)).to eql connection_success_json.to_json
+    end
+  end
+
+  describe "command list" do
+    let(:argv) { ["list"] }
+    let(:command) { NightcrawlerSwift::List.new }
+    let(:command_method) { :command_list }
+    let :result do
+      [{
+        "hash"=>"c9df50d4a29542f8b6d426a50c72b3de",
+        "last_modified"=>"2014-08-27T19:35:46.053560",
+        "bytes"=>4994,
+        "name"=>"assets/file.png",
+        "content_type"=>"image/png"
+      }]
+    end
+
+    it_behaves_like "CLI with default options"
+    it_behaves_like "CLI with parsed parameters"
+    it_behaves_like "CLI that creates a sample config file"
+    it_behaves_like "CLI that uses the configured command"
+
+    context "when executing the command" do
+      before do
+        File.open(config_file, "w") {|f| f.write(opts.to_json)}
+      end
+
+      it "lists all files in the bucket/container configured" do
+        expect(NightcrawlerSwift::List).to receive(:new).and_return(command)
+        expect(command).to receive(:execute).and_return(result)
+        expect(subject).to receive(:log).with(result.first["name"])
+        subject.run
+      end
+    end
+  end
+
+  describe "command download" do
+    let(:filepath) { "testfile.txt" }
+    let(:argv) { ["download", filepath] }
+    let(:command) { NightcrawlerSwift::Download.new }
+    let(:command_method) { :command_download }
+
+    it_behaves_like "CLI with default options"
+    it_behaves_like "CLI with parsed parameters"
+    it_behaves_like "CLI that creates a sample config file"
+    it_behaves_like "CLI that uses the configured command"
+
+    context "when executing the command" do
+      before do
+        File.open(config_file, "w") {|f| f.write(opts.to_json)}
+      end
+
+      it "downloads the file" do
+        expect(NightcrawlerSwift::Download).to receive(:new).and_return(command)
+        expect(command).to receive(:execute).with(filepath).and_return("test-content")
+        expect(subject).to receive(:log).with("test-content")
+        subject.run
+      end
+    end
+  end
+
+  describe "command upload" do
+    let(:swiftpath) { "testfile.txt" }
+    let(:realpath) { File.join(config_dir, swiftpath) }
+    let(:argv) { ["upload", realpath, swiftpath] }
+    let(:command) { NightcrawlerSwift::Upload.new }
+    let(:command_method) { :command_upload }
+
+    it_behaves_like "CLI with default options"
+    it_behaves_like "CLI with parsed parameters"
+    it_behaves_like "CLI that creates a sample config file"
+    it_behaves_like "CLI that uses the configured command"
+
+    context "when executing the command" do
+      before do
+        File.open(config_file, "w") {|f| f.write(opts.to_json)}
+        File.open(realpath, "w") {|f| f.write("test") }
+      end
+
+      after do
+        File.delete(realpath) if File.exist?(realpath)
+      end
+
+      it "uploads the file" do
+        expect(NightcrawlerSwift::Upload).to receive(:new).and_return(command)
+        expect(command).to receive(:execute).with(swiftpath, instance_of(File)).and_return(true)
+        expect(subject).to receive(:log).with("success")
+        subject.run
+      end
+    end
+  end
+
+  describe "command delete" do
+    let(:filepath) { "testfile.txt" }
+    let(:argv) { ["delete", filepath] }
+    let(:command) { NightcrawlerSwift::Delete.new }
+    let(:command_method) { :command_delete }
+
+    it_behaves_like "CLI with default options"
+    it_behaves_like "CLI with parsed parameters"
+    it_behaves_like "CLI that creates a sample config file"
+    it_behaves_like "CLI that uses the configured command"
+
+    context "when executing the command" do
+      before do
+        File.open(config_file, "w") {|f| f.write(opts.to_json)}
+      end
+
+      it "downloads the file" do
+        expect(NightcrawlerSwift::Delete).to receive(:new).and_return(command)
+        expect(command).to receive(:execute).with(filepath).and_return(true)
+        expect(subject).to receive(:log).with("success")
+        subject.run
+      end
+    end
+  end
+
+end