rackspace-fog 1.4.2

data/.document

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

data/.gitignore

@@ -0,0 +1,21 @@
+*~
+*.gem
+*.rbc
+*.sw?
+.rvmrc
+.bundle
+.DS_Store
+.idea
+bin/*
+!bin/fog
+!bin/rdoc
+.fog
+coverage
+doc/*
+docs/_site/*
+docs/about/supported_services.markdown
+Gemfile.lock
+rdoc
+pkg
+spec/credentials.yml
+vendor/*

data/.irbrc

@@ -0,0 +1,87 @@
+## This is primarily used for easier testing and development or
+#  usage of Fog.
+#
+#  How to use:
+#  1. Add this at the end of your `.irbrc` in your home directory.
+#
+#    @working_directory = Dir.pwd
+#    @local_irbrc = File.join(@working_directory, '.irbrc')
+#
+#    if @working_directory != ENV['HOME']
+#      load @local_irbrc if File.exists?(@local_irbrc)
+#    end
+#
+#    remove_instance_variable(:@working_directory)
+#    remove_instance_variable(:@local_irbrc)
+#
+#  2. Inside the Fog execute `bundle exec irb`
+#
+
+require 'fog'
+
+class ConnectionManager < Hash
+  def [](key)
+    $connection_manager_previous_key = key
+    super(key)
+  end
+
+  def []=(key, value)
+    $connection_manager_previous_key = key
+    super(key, value)
+  end
+end
+
+def connections
+  return @connections if @connections
+  @connections = ConnectionManager.new
+end
+
+def connection
+  connections[$connection_manager_previous_key]
+end
+
+def connect_openstack(username, password, tenant = nil, url = 'http://192.168.27.100:35357/')
+  parameters = {
+    :provider => 'openstack',
+    :openstack_api_key => password,
+    :openstack_username => username,
+    :openstack_auth_url => "#{url}v2.0/tokens"
+  }
+
+  parameters.merge!(:openstack_tenant => tenant) if tenant
+
+  identity = Fog::Identity.new(parameters)
+  compute  = Fog::Compute.new(parameters)
+  volume   = Fog::Volume.new(parameters)
+  image    = Fog::Image.new(parameters)
+
+  connections[username.to_sym] = {
+    :identity => identity,
+    :compute  => compute ,
+    :image    => image
+  }
+end
+
+def connect(parameters)
+  connections_count = connections.count
+  connections[connections_count] = Hash.new
+
+  set_service(connections_count, Fog::Identity, parameters)
+  set_service(connections_count, Fog::Compute , parameters)
+  set_service(connections_count, Fog::Storage , parameters)
+  set_service(connections_count, Fog::Volume  , parameters)
+  set_service(connections_count, Fog::Image   , parameters)
+  set_service(connections_count, Fog::DNS     , parameters)
+  set_service(connections_count, Fog::CDN     , parameters)
+  connection
+end
+
+def set_service(connections_count, type, parameters)
+  service_symbol = type.to_s.split('::').last.downcase.to_sym
+
+  connections[connections_count].merge!({
+    service_symbol => type.new(parameters)
+  })
+rescue
+  # Service not available
+end

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,147 @@
+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 = Compute[:aws].servers.create
+  ArgumentError: image_id is required for this operation
+
+  >> server = Compute[: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:
+
+  >> Compute[: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
+  >> Compute[:aws].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 {fog.io}[http://fog.io] for more details and examples. Once you are ready 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!"
+
+== Contributing
+
+* Find something you would like to work on. For suggestions look for the `easy`, `medium` and `hard` tags in the {issues}[http://github.com/fog/fog/issues]
+* Fork the project and do your work in a topic branch.
+* Add shindo tests to prove your code works and run all the tests using `bundle exec rake`.
+* Rebase your branch against fog/fog to make sure everything is up to date.
+* Commit your changes and send a pull request.
+
+== Additional Resources
+
+{fog.io}[http://fog.io]
+
+== Sponsorship
+
+http://www.engineyard.com/images/logo.png
+
+All new work on fog is sponsored by {Engine Yard}[http://engineyard.com]
+
+== 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,414 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'date'
+require File.dirname(__FILE__) + '/lib/rackspace-fog'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/rackspace-fog.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
+
+namespace :test do
+  task :dynect do
+    [false].each do |mock|
+      sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/dns/requests/dynect")
+      #sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/dns/models/")
+    end
+  end
+end
+
+task :test do
+  Rake::Task[:mock_tests].invoke && Rake::Task[:real_tests].invoke
+end
+
+def tests(mocked)
+  Formatador.display_line
+  sh("export FOG_MOCK=#{mocked} && bundle exec spec spec")
+  Formatador.display_line
+  start = Time.now.to_i
+  threads = []
+  Thread.main[:results] = []
+  Fog.providers.each do |key, value|
+    threads << Thread.new do
+      Thread.main[:results] << {
+        :provider => value,
+        :success  => sh("export FOG_MOCK=#{mocked} && bundle exec shindont +#{key}")
+      }
+    end
+  end
+  threads.each do |thread|
+    thread.join
+  end
+  Formatador.display_table(Thread.main[:results].sort {|x,y| x[:provider] <=> y[:provider]})
+  Formatador.display_line("[bold]FOG_MOCK=#{mocked}[/] tests completed in [bold]#{Time.now.to_i - start}[/] seconds")
+  Formatador.display_line
+end
+
+task :mock_tests do
+  tests(true)
+end
+
+task :real_tests do
+  tests(false)
+end
+
+task :nuke do
+  Fog.providers.each do |provider|
+    next if ['Vmfusion'].include?(provider)
+    begin
+      compute = Fog::Compute.new(:provider => provider)
+      for server in compute.servers
+        Formatador.display_line("[#{provider}] destroying server #{server.identity}")
+        server.destroy rescue nil
+      end
+    rescue
+    end
+    begin
+      dns = Fog::DNS.new(:provider => provider)
+      for zone in dns.zones
+        for record in zone.records
+          record.destroy rescue nil
+        end
+        Formatador.display_line("[#{provider}] destroying zone #{zone.identity}")
+        zone.destroy rescue nil
+      end
+    rescue
+    end
+  end
+end
+
+require 'rdoc/task'
+RDoc::Task.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
+  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"
+  Rake::Task[:docs].invoke
+end
+
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+task :gemspec => :validate do
+end
+
+task :validate do
+end
+
+task :changelog do
+  timestamp = Time.now.utc.strftime('%m/%d/%Y')
+  sha = `git log | head -1`.split(' ').last
+  changelog = ["#{version} #{timestamp} #{sha}"]
+  changelog << ('=' * changelog[0].length)
+  changelog << ''
+
+  github_repo_data = Fog::JSON.decode(Excon.get('http://github.com/api/v2/json/repos/show/fog/fog').body)
+  data = github_repo_data['repository'].reject {|key, value| !['forks', 'open_issues', 'watchers'].include?(key)}
+  github_collaborator_data = Fog::JSON.decode(Excon.get('http://github.com/api/v2/json/repos/show/fog/fog/collaborators').body)
+  data['collaborators'] = github_collaborator_data['collaborators'].length
+  rubygems_data = Fog::JSON.decode(Excon.get('https://rubygems.org/api/v1/gems/fog.json').body)
+  data['downloads'] = rubygems_data['downloads']
+  stats = []
+  for key in data.keys.sort
+    stats << "'#{key}' => #{data[key]}"
+  end
+  changelog << "Stats! { #{stats.join(', ')} }"
+  changelog << ''
+
+  last_sha = `cat changelog.txt | head -1`.split(' ').last
+  shortlog = `git shortlog #{last_sha}..HEAD`
+  changes = {}
+  committers = {}
+  for line in shortlog.split("\n")
+    if line =~ /^\S/
+      committer = line.split(' (', 2).first
+      committers[committer] = 0
+    elsif line =~ /^\s*((Merge.*)|(Release.*))?$/
+      # skip empty lines, Merge and Release commits
+    else
+      unless line[-1..-1] == '.'
+        line << '.'
+      end
+      line.lstrip!
+      line.gsub!(/^\[([^\]]*)\] /, '')
+      tag = $1 || 'misc'
+      changes[tag] ||= []
+      changes[tag] << (line << ' thanks ' << committer)
+      committers[committer] += 1
+    end
+  end
+
+  for committer, commits in committers.to_a.sort {|x,y| y[1] <=> x[1]}
+    if [
+        'Aaron Suggs',
+        'Brian Hartsock',
+        'Christopher Oliver',
+        'Decklin Foster',
+        'Dylan Egan',
+        'geemus',
+        'Henry Addison',
+        'Kevin Menard',
+        'Lincoln Stoll',
+        'Luqman Amjad',
+        'Michael Zeng',
+        'nightshade427',
+        'Patrick Debois',
+        'Stepan G. Fedorov',
+        'Wesley Beary'
+      ].include?(committer)
+      next
+    end
+    changelog << "MVP! #{committer}"
+    changelog << ''
+    break
+  end
+
+  for tag in changes.keys.sort
+    changelog << ('[' << tag << ']')
+    for commit in changes[tag]
+      changelog << ('  ' << commit)
+    end
+    changelog << ''
+  end
+
+  old_changelog = File.read('changelog.txt')
+  File.open('changelog.txt', 'w') do |file|
+    file.write(changelog.join("\n"))
+    file.write("\n\n")
+    file.write(old_changelog)
+  end
+end
+
+task :docs do
+  Rake::Task[:supported_services_docs].invoke
+  Rake::Task[:upload_fog_io].invoke
+  Rake::Task[:upload_rdoc].invoke
+
+  # connect to storage provider
+  Fog.credential = :geemus
+  storage = Fog::Storage.new(:provider => 'AWS')
+  directory = storage.directories.new(:key => 'fog.io')
+  # write base index with redirect to new version
+  directory.files.create(
+    :body         => redirecter('latest'),
+    :content_type => 'text/html',
+    :key          => 'index.html',
+    :public       => true
+  )
+
+  Formatador.display_line
+end
+
+task :supported_services_docs do
+  support, shared = {}, []
+  for key, values in Fog.services
+    unless values.length == 1
+      shared |= [key]
+      values.each do |value|
+        support[value] ||= {}
+        support[value][key] = '+'
+      end
+    else
+      value = values.first
+      support[value] ||= {}
+      support[value][:other] ||= []
+      support[value][:other] << key
+    end
+  end
+  shared.sort! {|x,y| x.to_s <=> y.to_s}
+  columns = [:provider] + shared + [:other]
+  data = []
+  for key in support.keys.sort {|x,y| x.to_s <=> y.to_s}
+    data << { :provider => key }.merge!(support[key])
+  end
+
+  table = ''
+  table << "<table border='1'>\n"
+
+  table << "  <tr>"
+  for column in columns
+    table << "<th>#{column}</th>"
+  end
+  table << "</tr>\n"
+
+  for datum in data
+    table << "  <tr>"
+    for column in columns
+      if value = datum[column]
+        case value
+        when Array
+          table << "<td>#{value.join(', ')}</td>"
+        when '+'
+          table << "<td style='text-align: center;'>#{value}</td>"
+        else
+          table << "<th>#{value}</th>"
+        end
+      else
+        table << "<td></td>"
+      end
+    end
+    table << "</tr>\n"
+  end
+
+  table << "</table>\n"
+
+  File.open('docs/about/supported_services.markdown', 'w') do |file|
+    file.puts <<-METADATA
+---
+layout: default
+title:  Supported Services
+---
+
+METADATA
+    file.puts(table)
+  end
+end
+
+task :upload_fog_io do
+  # connect to storage provider
+  Fog.credential = :geemus
+  storage = Fog::Storage.new(:provider => 'AWS')
+  directory = storage.directories.new(:key => 'fog.io')
+
+  # build the docs locally
+  sh "jekyll docs docs/_site"
+
+  # write web page files to versioned 'folder'
+  for file_path in Dir.glob('docs/_site/**/*')
+    next if File.directory?(file_path)
+    file_name = file_path.gsub('docs/_site/', '')
+    key = '' << version << '/' << file_name
+    Formatador.redisplay(' ' * 128)
+    Formatador.redisplay("Uploading [bold]#{key}[/]")
+    if File.extname(file_name) == '.html'
+      # rewrite links with version
+      body = File.read(file_path)
+      body.gsub!(/vX.Y.Z/, 'v' << version)
+      body.gsub!(/='\//, %{='/} << version << '/')
+      body.gsub!(/="\//, %{="/} << version << '/')
+      content_type = 'text/html'
+      directory.files.create(
+        :body         => redirecter(key),
+        :content_type => 'text/html',
+        :key          => 'latest/' << file_name,
+        :public       => true
+      )
+    else
+      body = File.open(file_path)
+      content_type = nil # leave it up to mime-types
+    end
+    directory.files.create(
+      :body         => body,
+      :content_type => content_type,
+      :key          => key,
+      :public       => true
+    )
+  end
+  Formatador.redisplay(' ' * 128)
+  Formatador.redisplay("Uploaded docs/_site\n")
+end
+
+task :upload_rdoc do
+  # connect to storage provider
+  Fog.credential = :geemus
+  storage = Fog::Storage.new(:provider => 'AWS')
+  directory = storage.directories.new(:key => 'fog.io')
+
+  # write rdoc files to versioned 'folder'
+  Rake::Task[:rdoc].invoke
+  for file_path in Dir.glob('rdoc/**/*')
+    next if File.directory?(file_path)
+    file_name = file_path.gsub('rdoc/', '')
+    key = '' << version << '/rdoc/' << file_name
+    Formatador.redisplay(' ' * 128)
+    Formatador.redisplay("Uploading [bold]#{key}[/]")
+    directory.files.create(
+      :body         => File.open(file_path),
+      :key          => key,
+      :public       => true
+    )
+  end
+  Formatador.redisplay(' ' * 128)
+  directory.files.create(
+    :body         => redirecter("#{version}/rdoc/index.html"),
+    :content_type => 'text/html',
+    :key          => 'latest/rdoc/index.html',
+    :public       => true
+  )
+  Formatador.redisplay("Uploaded rdoc\n")
+end
+
+def redirecter(path)
+  redirecter = <<-HTML
+<!doctype html>
+<head>
+<title>fog</title>
+<meta http-equiv="REFRESH" content="0;url=http://fog.io/#{path}">
+</head>
+<body>
+  <a href="http://fog.io/#{path}">redirecting to lastest (#{path})</a>
+</body>
+</html>
+HTML
+end