phpfog-fog 0.4.1

data/.document

@@ -0,0 +1,3 @@
+README.rdoc
+lib/**/*.rb
+bin/*

data/.gitignore

@@ -0,0 +1,11 @@
+*.gem
+*.rbc
+*.sw?
+.bundle
+.DS_Store
+_site/*
+coverage
+doc/*
+rdoc
+pkg
+spec/credentials.yml

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    fog (0.4.1)
+      builder
+      excon (>= 0.4.0)
+      formatador (>= 0.0.16)
+      json
+      mime-types
+      net-ssh (>= 2.0.23)
+      nokogiri (>= 1.4.4)
+      ruby-hmac
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    excon (0.4.0)
+    formatador (0.0.16)
+    json (1.4.6)
+    mime-types (1.16)
+    net-ssh (2.0.23)
+    nokogiri (1.4.4)
+    rake (0.8.7)
+    rspec (1.3.1)
+    ruby-hmac (0.4.0)
+    shindo (0.2.0)
+      formatador (>= 0.0.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  builder
+  excon (>= 0.4.0)
+  fog!
+  formatador (>= 0.0.16)
+  json
+  mime-types
+  net-ssh (>= 2.0.23)
+  nokogiri (>= 1.4.4)
+  rake
+  rspec (= 1.3.1)
+  ruby-hmac
+  shindo (= 0.2.0)

data/README.rdoc

@@ -0,0 +1,176 @@
+http://geemus.s3.amazonaws.com/fog.png
+
+fog is the Ruby cloud computing library, top to bottom:
+
+* Collections provide a simplified interface, making clouds easier to work with and switch between.
+* Requests allow power users to get the most out of the features of each individual cloud.
+* Mocks make testing and integrating a breeze.
+
+== Getting Started
+
+  sudo gem install fog
+
+Now type 'fog' to try stuff, confident that fog will let you know what to do. Here is an example of wading through server creation for Amazon Elastic Compute Cloud:
+
+  >> server = AWS.servers.create
+  ArgumentError: image_id is required for this operation
+
+  >> server = AWS.servers.create(:image_id => 'ami-5ee70037')
+  <Fog::AWS::EC2::Server [...]>
+
+  >> server.destroy # cleanup after yourself or regret it, trust me
+  true
+
+== Collections
+
+A high level interface to each cloud is provided through collections, such as `images` and `servers`.
+You can see a list of available collections by calling `collections` on the connection object. You can try it out using the `fog` command:
+
+  >> AWS.collections
+  [:addresses, :directories, ..., :volumes, :zones]
+
+Some collections are available across multiple providers:
+
+* compute providers have +flavors+, +images+ and +servers+
+* dns providers have +zones+ and +records+
+* storage providers have +directories+ and +files+
+
+Collections share basic CRUD type operations, such as:
+* +all+ - fetch every object of that type from the provider.
+* +create+ - initialize a new record locally and a remote resource with the provider.
+* +get+ - fetch a single object by it's identity from the provider.
+* +new+ - initialize a new record locally, but do not create a remote resource with the provider.
+
+As an example, we'll try initializing and persisting a Rackspace Cloud server:
+
+  require 'fog'
+
+  compute = Fog::Compute.new(
+    :provider           => 'Rackspace',
+    :rackspace_api_key  => key,
+    :rackspace_username => username
+  )
+
+  # boot a gentoo server (flavor 1 = 256, image 3 = gentoo 2008.0)
+  server = compute.servers.create(:flavor_id => 1, :image_id => 3, :name => 'my_server')
+  server.wait_for { ready? } # give server time to boot
+
+  # DO STUFF
+
+  server.destroy # cleanup after yourself or regret it, trust me
+
+== Models
+
+Many of the collection methods return individual objects, which also provide common methods:
+* +destroy+ - will destroy the persisted object from the provider
+* +save+ - persist the object to the provider
+* +wait_for+ - takes a block and waits for either the block to return true for the object or for a timeout (defaults to 10 minutes)
+
+== Mocks
+
+As you might imagine, testing code using Fog can be slow and expensive, constantly turning on and and shutting down instances.
+Mocking allows skipping this overhead by providing an in memory representation resources as you make requests.
+Enabling mocking easy to use, before you run other commands, simply run:
+
+  Fog.mock!
+
+Then proceed as usual, if you run into unimplemented mocks fog will raise an error and as always contributions are welcome!
+
+== Requests
+
+Requests allow you to dive deeper when the models just can't cut it.
+You can see a list of available requests by calling #requests on the connection object.
+
+For instance, ec2 provides methods related to reserved instances that don't have any models (yet). Here is how you can lookup your reserved instances:
+
+  $ fog
+  >> AWS[:ec2].describe_reserved_instances
+  #<Excon::Response [...]>
+
+It will return an {excon}[http://github.com/geemus/excon] response, which has `body`, `headers` and `status`. Both return nice hashes.
+
+== Go forth and conquer
+
+Play around and use the console to explore or check out the {getting started guide}[http://wiki.github.com/geemus/fog/getting-started-with-fog] for more details. Once you are reading to start scripting fog, here is a quick hint on how to make connections without the command line thing to help you.
+
+  # create a compute connection
+  compute = Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
+  # compute operations go here
+
+  # create a storage connection
+  storage = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
+  # storage operations go here
+
+geemus says: "That should give you everything you need to get started, but let me know if there is anything I can do to help!"
+
+== Providers
+
+You should try out the (varying) support fog has for:
+* {AWS}[http://aws.amazon.com] [{Compute}[http://aws.amazon.com/ec2], {DNS}[http://aws.amazon.com/route53], {ELB}[http://aws.amazon.com/elasticloadbalancing], {Storage}[http://aws.amazon.com/s3], {SimpleDB}[http://aws.amazon.com/simpledb]]
+* <b><em>{Blue Box Group}[http://www.bluebox.net]</em></b> [{Compute}[http://www.bluebox.net/blocks]]
+* <b><em>{Brightbox}[http://www.brightbox.co.uk]</em></b> [{Compute}[http://beta.brightbox.com/]]
+* {Google}[http://www.google.com] [{Storage}[http://code.google.com/apis/storage]]
+* {Linode}[http://www.linode.com] [{DNS}[http://www.linode.com]]
+* Local [Storage]
+* {Rackspace}[http://www.rackspace.com] [{Compute}[http://www.rackspacecloud.com/cloud_hosting_products/servers], {Storage}[http://www.rackspacecloud.com/cloud_hosting_products/files]]
+* {Slicehost}[http://www.slicehost.com] [{Compute}[http://www.slicehost.com], {DNS}[http://www.slicehost.com]]
+* {Terremark}[http://www.terremark.com] [{vCloud Express}[http://vcloudexpress.terremark.com]]
+* {Zerigo}[http://www.zerigo.com] [{DNS}[http://www.zerigo.com/managed-dns]]
+
+There are also the basics of these providers (that could use your love):
+* <b><em>{GoGrid}[http://www.gogrid.com]</b></em> [{Compute}[http://www.gogrid.com]]
+* {Linode}[http://www.linode.com] [{Compute}[http://www.linode.com]]
+* {New Servers}[http://www.newservers.com] [{Compute}[http://www.newservers.com]]
+
+Special thanks to providers listed in <b><em>bold italics</em></b> for donating resources for fog tests!
+
+== Additional Resources
+
+Enjoy, and let me know what I can do to continue improving fog!
+
+* Follow {@fog}[http://twitter.com/fog] and/or {@geemus}[http://twitter.com/geemus] on Twitter
+* Discuss in irc on the {#ruby-fog}[irc://irc.freenode.net/ruby-fog] channel on Freenode
+* Discuss via email on the {mailing list}[http://groups.google.com/group/ruby-fog] (note: release notes appear on this list)
+* Report bugs or find stuff to work on in {issues}[http://github.com/geemus/fog/issues]
+* Learn about {contributing}[http://github.com/geemus/fog/wiki/contributor-guide] or find more info about the {Providers}[http://github.com/geemus/fog/wiki/Providers] (including some todo items)
+* See what already uses fog and add your own stuff to {the list}[http://wiki.github.com/geemus/fog/in-the-wild]
+* Check out blog posts and other mentions from elsewhere {press}[http://wiki.github.com/geemus/fog/press]
+
+== Sponsorship
+
+http://www.engineyard.com/images/logo.png
+
+All new work on fog is sponsored by {Engine Yard}[http://engineyard.com]
+
+== T-Shirts
+
+Wonder how you can get a shirt? Look no further!
+
+* Blue shirts go to people who have contributed indirectly, where contribution is a judgement call on geemus's part (but he is a pretty nice guy).
+* Grey shirts and a follow from @fog go to people who have made it on to the {contributors list}[https://github.com/geemus/fog/contributors] by submitting code.
+* Black shirts go to people who have made it on to the {collaborators list}[https://github.com/api/v2/json/repos/show/geemus/fog/collaborators] by coercing geemus into adding them (geemus is currently the only member of this list).
+
+== Copyright
+
+(The MIT License)
+
+Copyright (c) 2010 {geemus (Wesley Beary)}[http://github.com/geemus]
+
+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/Rakefile

@@ -0,0 +1,132 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+task :examples do
+  sh("export FOG_MOCK=false && bundle exec shindont examples")
+  # some don't provide mocks so we'll leave this out for now
+  # sh("export FOG_MOCK=true  && bundle exec shindont examples")
+end
+
+task :test => :examples do
+  sh("export FOG_MOCK=true  && bundle exec spec spec") &&
+  sh("export FOG_MOCK=true  && bundle exec shindont tests") &&
+  sh("export FOG_MOCK=false && bundle exec spec spec") &&
+  sh("export FOG_MOCK=false && bundle exec shindont tests")
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "gem install pkg/#{name}-#{version}.gem"
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+
+  # replace name version and date
+  replace_header(spec, :name)
+  replace_header(spec, :version)
+  replace_header(spec, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(spec, :rubyforge_project)
+
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/benchs/fog_vs.rb

@@ -0,0 +1,106 @@
+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/params.rb

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,60 @@
+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 << 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
+
+end
+
+data = <<-DATA
+<items>
+  <item>
+    <key>value</key>
+  </item>
+</items>
+DATA
+
+COUNT = 100
+
+Benchmark.bmbm(25) do |bench|
+  bench.report('parse') do
+    parser = Parser.new
+    Nokogiri::XML::SAX::Parser.new(parser).parse(data)
+    parser.response
+  end
+
+  bench.report('push') do
+    parser = Parser.new
+    Nokogiri::XML::SAX::PushParser.new(parser).write(data, true)
+    parser.response
+  end
+end

data/bin/fog

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'fog'))
+require 'irb'
+require 'yaml'
+Fog.credential = ARGV.first ? ARGV.first.to_sym : nil
+Fog.mock! if ENV['FOG_MOCK']
+unless Fog.credentials
+  exit
+end
+
+require 'fog/bin'
+
+providers = Fog.providers.map{|provider| provider.to_s}
+providers = if providers.length > 1
+  providers[0...-1].join(', ') << ' and ' << providers[-1]
+else
+  providers.first
+end
+
+if ARGV.length > 1
+
+  puts(instance_eval(ARGV[1..-1].join(' ')).to_json)
+
+else
+
+  ARGV.clear # Avoid passing args to IRB
+  IRB.setup(nil)
+  @irb = IRB::Irb.new(nil)
+  IRB.conf[:MAIN_CONTEXT] = @irb.context
+  IRB.conf[:PROMPT][:FOG] = IRB.conf[:PROMPT][:SIMPLE].dup
+  IRB.conf[:PROMPT][:FOG][:RETURN] = "%s\n"
+  @irb.context.prompt_mode = :FOG
+  @irb.context.workspace = IRB::WorkSpace.new(binding)
+
+  Formatador.display_line('Welcome to fog interactive!')
+  Formatador.display_line(":#{Fog.credential} provides #{providers}")
+  providers = Fog.providers
+  Fog.modules.each do |_module_|
+    if _module_.respond_to?(:startup_notice)
+      _module_.send(:startup_notice)
+    end
+  end
+
+  catch(:IRB_EXIT) { @irb.eval_input }
+
+end