fog-digitalocean 0.1.0 → 0.2.0

data/benchs/each_provider.sh

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-# for each provider
-grep -lr "< Fog::Service$" lib/fog | xargs -L1 dirname | sort | uniq | sed -e 's/lib\///' |
-  # trigger rubygem cost then benchmark the load time
-  xargs -I{} ruby -Ilib -rbenchmark -e 'Gem::Specification._all; puts "{}: #{Benchmark.realtime{require "{}" }}"'

data/benchs/each_service.sh

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-# for each service
-grep -lr "< Fog::Service$" lib/fog | sed -e 's/lib\///' -e 's/.rb$//' |
-  # trigger rubygem cost then benchmark the load time
-  xargs -I{} ruby -Ilib -rbenchmark -e 'Gem::Specification._all; puts "{}: #{Benchmark.realtime{ require "{}" }}"'

data/benchs/fog_vs.rb

@@ -1,106 +0,0 @@
-require 'rubygems'
-require 'aws/s3'
-require 'benchmark'
-require 'right_aws'
-
-require File.join(File.dirname(__FILE__), '..', 'lib', 'fog')
-
-data = File.open(File.expand_path('~/.fog')).read
-config = YAML.load(data)[:default]
-fog = Fog::AWS::S3.new(
-  :aws_access_key_id     => config[:aws_access_key_id],
-  :aws_secret_access_key => config[:aws_secret_access_key]
-)
-raws = RightAws::S3Interface.new(
-  config[:aws_access_key_id],
-  config[:aws_secret_access_key]
-)
-raws.logger.level = 3 # ERROR
-awss3 = AWS::S3::Base.establish_connection!(
-  :access_key_id     => config[:aws_access_key_id],
-  :secret_access_key => config[:aws_secret_access_key],
-  :persistent        => true
-)
-
-TIMES = 10
-
-Benchmark.bmbm(25) do |bench|
-  bench.report('fog.put_bucket') do
-    TIMES.times do |x|
-      fog.put_bucket("fogbench#{x}")
-    end
-  end
-  bench.report('raws.create_bucket') do
-    TIMES.times do |x|
-      raws.create_bucket("rawsbench#{x}")
-    end
-  end
-  bench.report('awss3::Bucket.create') do
-    TIMES.times do |x|
-      AWS::S3::Bucket.create("awss3bench#{x}")
-    end
-  end
-
-  bench.report('fog.put_object') do
-    TIMES.times do |x|
-      TIMES.times do |y|
-        file = File.open(File.dirname(__FILE__) + '/../spec/lorem.txt', 'r')
-        fog.put_object("fogbench#{x}", "lorem_#{y}", file)
-      end
-    end
-  end
-  bench.report('raws.put') do
-    TIMES.times do |x|
-      TIMES.times do |y|
-        file = File.open(File.dirname(__FILE__) + '/../spec/lorem.txt', 'r')
-        raws.put("rawsbench#{x}", "lorem_#{y}", file)
-      end
-    end
-  end
-  bench.report('awss3::S3Object.create') do
-    TIMES.times do |x|
-      TIMES.times do |y|
-        file = File.open(File.dirname(__FILE__) + '/../spec/lorem.txt', 'r')
-        AWS::S3::S3Object.create("lorem_#{y}", file, "awss3bench#{x}")
-      end
-    end
-  end
-
-  bench.report('fog.delete_object') do
-    TIMES.times do |x|
-      TIMES.times do |y|
-        fog.delete_object("fogbench#{x}", "lorem_#{y}")
-      end
-    end
-  end
-  bench.report('raws.delete') do
-    TIMES.times do |x|
-      TIMES.times do |y|
-        raws.delete("rawsbench#{x}", "lorem_#{y}")
-      end
-    end
-  end
-  bench.report('awss3::S3Object.delete') do
-    TIMES.times do |x|
-      TIMES.times do |y|
-        AWS::S3::S3Object.delete("lorem_#{y}", "awss3bench#{x}")
-      end
-    end
-  end
-
-  bench.report('fog.delete_bucket') do
-    TIMES.times do |x|
-      fog.delete_bucket("fogbench#{x}")
-    end
-  end
-  bench.report('raws.delete_bucket') do
-    TIMES.times do |x|
-      raws.delete_bucket("rawsbench#{x}")
-    end
-  end
-  bench.report('awss3::Bucket.delete') do
-    TIMES.times do |x|
-      AWS::S3::Bucket.delete("awss3bench#{x}")
-    end
-  end
-end

data/benchs/load_times.rb

@@ -1,37 +0,0 @@
-require 'benchmark'
-$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
-
-def time_in_fork(&block)
-  read, write = IO.pipe
-  Process.fork do
-    write.puts Benchmark.realtime{ block.call }
-  end
-  Process.wait
-  write.close
-  read.read.tap do
-    read.close
-  end
-end
-
-class Array
-  def avg
-    map(&:to_f).inject(:+) / size
-  end
-end
-
-def report(label, n = 10, &block)
-  puts label
-  puts "%.4f" % n.times.map{ time_in_fork &block }.avg
-  puts
-end
-
-# make rubygems load specifications now so the
-# time is not included below.
-Gem::Specification._all
-
-N = 10
-
-report("require fog:", N)             { require 'fog' }
-report("require fog/aws:", N)         { require 'fog/aws' }
-report("require fog/aws/compute:", N) { require 'fog/aws/compute' }
-report("require fog/aws/core:", N)    { require 'fog/aws/core'}

data/benchs/params.rb

@@ -1,43 +0,0 @@
-require 'benchmark'
-
-def hash(options)
-  result = "#{options.delete(:name)}"
-  for key, value in options
-    result << " #{key} => #{value} "
-  end
-  result
-end
-
-def optional(name, a = nil, b = nil, c = nil)
-  result = "#{name}"
-  options = { :a => a, :b => b, :c => c }
-  for key, value in options
-    result << " #{key} => #{value} "
-  end
-  result
-end
-
-COUNT = 100_000
-data = "Content-Length: 100"
-Benchmark.bmbm(25) do |bench|
-  bench.report('hash') do
-    COUNT.times do
-      hash({:name => 'name'})
-    end
-  end
-  bench.report('optional') do
-    COUNT.times do
-      optional('name')
-    end
-  end
-  bench.report('hash_with_option') do
-    COUNT.times do
-      hash({:name => 'name', :a => 'a', :b => 'b', :c => 'c'})
-    end
-  end
-  bench.report('optional_with_option') do
-    COUNT.times do
-      optional('name', :a => 'a', :b => 'b', :c => 'c')
-    end
-  end
-end

data/benchs/parse_vs_push.rb

@@ -1,67 +0,0 @@
-require 'benchmark'
-require 'rubygems'
-require 'nokogiri'
-
-class Parser < Nokogiri::XML::SAX::Document
-  attr_reader :response
-
-  def initialize
-    reset
-  end
-
-  def reset
-    @item = {}
-    @response = { :items => [] }
-  end
-
-  def characters(string)
-    @value ||= ''
-    @value << string.strip
-  end
-
-  def start_element(name, attrs = [])
-    @value = nil
-  end
-
-  def end_element(name)
-    case name
-    when 'item'
-      @response[:items] << @item
-      @item = {}
-    when 'key'
-      @item[:key] = value
-    end
-  end
-
-  def value
-    @value.dup
-  end
-end
-
-data = <<-DATA
-<items>
-  <item>
-    <key>value</key>
-  </item>
-</items>
-DATA
-
-COUNT = 10_000
-
-Benchmark.bmbm(25) do |bench|
-  bench.report('parse') do
-    COUNT.times do
-      parser = Parser.new
-      Nokogiri::XML::SAX::Parser.new(parser).parse(data)
-      parser.response
-    end
-  end
-
-  bench.report('push') do
-    COUNT.times do
-      parser = Parser.new
-      Nokogiri::XML::SAX::PushParser.new(parser).write(data, true)
-      parser.response
-    end
-  end
-end

data/spec/fog/account_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-
-describe Fog::Account do
-  Fog::Account.providers.each do |provider|
-    describe "when #{provider} is passed with no available credentials" do
-      it "returns ArgumentError" do
-        # Stub credentials so you still see errors where the tester really has credentials
-        Fog.stub :credentials, {} do
-          assert_raises(ArgumentError) { Fog::Account[provider] }
-        end
-      end
-    end
-  end
-end

data/spec/fog/billing_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-
-describe Fog::Billing do
-  Fog::Billing.providers.each do |provider|
-    describe "when #{provider} is passed with no available credentials" do
-      it "returns ArgumentError" do
-        # Stub credentials so you still see errors where the tester really has credentials
-        Fog.stub :credentials, {} do
-          assert_raises(ArgumentError) { Fog::Billing[provider] }
-        end
-      end
-    end
-  end
-end

data/spec/fog/bin/atmos_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-require "fog/bin"
-require "helpers/bin"
-
-describe Atmos do
-  include Fog::BinSpec
-
-  let(:subject) { Atmos }
-
-  describe "#services" do
-    it "includes all services" do
-      assert_includes Atmos.services, :storage
-    end
-  end
-
-  describe "#class_for" do
-    describe "when requesting storage service" do
-      it "returns correct class" do
-        assert_equal Fog::Storage::Atmos, Atmos.class_for(:storage)
-      end
-    end
-  end
-
-  describe "#[]" do
-    describe "when requesting storage service" do
-      it "returns instance" do
-        Fog::Storage::Atmos.stub(:new, "instance") do
-          assert_equal "instance", Atmos[:storage]
-        end
-      end
-    end
-  end
-end

data/spec/fog/bin/aws_spec.rb

@@ -1,98 +0,0 @@
-require "spec_helper"
-require "fog/bin"
-require "helpers/bin"
-
-describe AWS do
-  include Fog::BinSpec
-
-  let(:subject) { AWS }
-
-  KEY_CLASS_MAPPING = {
-    :auto_scaling => Fog::AWS::AutoScaling,
-    :beanstalk => Fog::AWS::ElasticBeanstalk,
-    :cdn => Fog::CDN::AWS,
-    :cloud_formation => Fog::AWS::CloudFormation,
-    :cloud_watch => Fog::AWS::CloudWatch,
-    :compute => Fog::Compute::AWS,
-    :data_pipeline => Fog::AWS::DataPipeline,
-    :ddb => Fog::AWS::DynamoDB,
-    :dynamodb => Fog::AWS::DynamoDB,
-    :dns => Fog::DNS::AWS,
-    :elasticache => Fog::AWS::Elasticache,
-    :elb => Fog::AWS::ELB,
-    :emr => Fog::AWS::EMR,
-    :glacier => Fog::AWS::Glacier,
-    :iam => Fog::AWS::IAM,
-    :redshift => Fog::AWS::Redshift,
-    :sdb => Fog::AWS::SimpleDB,
-    :simpledb => Fog::AWS::SimpleDB,
-    :ses => Fog::AWS::SES,
-    :sqs => Fog::AWS::SQS,
-    :eu_storage => Fog::Storage::AWS,
-    :storage => Fog::Storage::AWS,
-    :rds => Fog::AWS::RDS,
-    :sns => Fog::AWS::SNS,
-    :sts => Fog::AWS::STS
-  }
-
-  describe "#services" do
-    it "includes all services" do
-      assert_includes AWS.services, :auto_scaling
-      assert_includes AWS.services, :beanstalk
-      assert_includes AWS.services, :cdn
-      assert_includes AWS.services, :cloud_formation
-      assert_includes AWS.services, :cloud_watch
-      assert_includes AWS.services, :compute
-      assert_includes AWS.services, :data_pipeline
-      assert_includes AWS.services, :dynamodb
-      assert_includes AWS.services, :dns
-      assert_includes AWS.services, :elasticache
-      assert_includes AWS.services, :elb
-      assert_includes AWS.services, :emr
-      assert_includes AWS.services, :glacier
-      assert_includes AWS.services, :iam
-      assert_includes AWS.services, :redshift
-      assert_includes AWS.services, :rds
-      assert_includes AWS.services, :simpledb
-      assert_includes AWS.services, :ses
-      assert_includes AWS.services, :sqs
-      assert_includes AWS.services, :storage
-      assert_includes AWS.services, :sns
-      assert_includes AWS.services, :sts
-    end
-  end
-
-  describe "#class_for" do
-    describe "when key exists" do
-      it "maps to correct class" do
-        KEY_CLASS_MAPPING.each do |key, klass|
-          assert_equal klass, AWS.class_for(key)
-        end
-      end
-    end
-
-    describe "when key does not exist" do
-      it "raises ArgumentError" do
-        assert_raises(ArgumentError) { AWS.class_for(:bad_key) }
-      end
-    end
-  end
-
-  describe "#[]" do
-    describe "when service is recognised" do
-      it "returns correct instance" do
-        KEY_CLASS_MAPPING.each do |key, klass|
-          klass.stub(:new, "#{klass} instance") do
-            assert_equal "#{klass} instance", AWS[key]
-          end
-        end
-      end
-    end
-
-    describe "when service is not recognised" do
-      it "raises ArgumentError" do
-        assert_raises(ArgumentError) { AWS[:bad_service] }
-      end
-    end
-  end
-end

data/spec/fog/bin/baremetalcloud_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-require "fog/bin"
-require "helpers/bin"
-
-describe BareMetalCloud do
-  include Fog::BinSpec
-
-  let(:subject) { BareMetalCloud }
-
-  describe "#services" do
-    it "includes all services" do
-      assert_includes BareMetalCloud.services, :compute
-    end
-  end
-
-  describe "#class_for" do
-    describe "when requesting storage service" do
-      it "returns correct class" do
-        assert_equal Fog::Compute::BareMetalCloud, BareMetalCloud.class_for(:compute)
-      end
-    end
-  end
-
-  describe "#[]" do
-    describe "when requesting compute service" do
-      it "returns instance" do
-        Fog::Compute::BareMetalCloud.stub(:new, "instance") do
-          assert_equal "instance", BareMetalCloud[:compute]
-        end
-      end
-    end
-  end
-end