fog 0.3.34 → 0.4.0

data/examples/bluebox_create.rb

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-
-# For example only - you'd want to use your own AMI id.
-unless defined?(GENTOO_AMI)
-  GENTOO_AMI = 'ami-5ee70037'
-end
-
-require 'rubygems'
-require 'fog'
-
-@bluebox_api_key = "CHANGEME"
-@aws_access_key_id = "CHANGEME"
-@aws_secret_access_key = "CHANGEME"
-
-@flavor_id = "94fd37a7-2606-47f7-84d5-9000deda52ae" # Block 1GB Virtual Server
-@image_id = "03807e08-a13d-44e4-b011-ebec7ef2c928"  # Ubuntu 10.04 x64 LTS
-
-# Grab our current list of servers
-@bbg_servers = Fog::Bluebox.new(:bluebox_api_key => @bluebox_api_key).servers
-@ec2_servers = Fog::AWS::EC2.new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key).servers
-
-# Create a new server.
-@server = @bbg_servers.new(:flavor_id => @flavor_id, :image_id => @image_id,
-                           :name => "My Server", :password => "MyPassword")
-
-# Save the server, triggering its creation
-@server.save
-
-if @server.status == 'error'
-  # The create failed - create a new server on Amazon instead
-  @server = @ec2_servers.new(:image_id => GENTOO_AMI)
-  @server.save
-end

data/examples/dns_methods.rb

@@ -1,389 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib', 'fog')
-require 'fog/core/bin'
-
-#mark true for each cloud you wish to enable/run the sample for
-RUN_AWS_SAMPLE = true
-RUN_LINODE_SAMPLE = false
-RUN_SLICEHOST_SAMPLE = false
-RUN_ZERIGO_SAMPLE = false
-
-#domain to use in examples
-TEST_DOMAIN = 'test-343246324434.com'
-
-# example of how to use AWS Route 53 DNS calls
-def show_aws_dns_usage
-
-  begin    
-    
-    #use to keep track of zone we create
-    zone_id= nil
-    
-    # see if domain is already hosted on AWS
-    # important to check as AWS will let you create multiple zones with the same domain name
-    options= { :max_items => 200 }
-    response = AWS[:dns].list_hosted_zones( options)
-    if response.status == 200
-      zones = response.body['HostedZones']
-      zones.each { |zone|
-        domain_name = zone['Name']
-        if domain_name.chop == TEST_DOMAIN
-          zone_id = zone['Id'].sub('/hostedzone/', '')
-        end
-      }
-    end
-    
-    #if domain not yet created, do so now
-    if zone_id.nil?
-      options= { :comment => 'test domain - not for production use' }
-      response = AWS[:dns].create_hosted_zone( TEST_DOMAIN, options)
-      if response.status == 201
-        zone_id = response.body['HostedZone']['Id']
-        change_id = response.body['ChangeInfo']['Id']
-        status = response.body['ChangeInfo']['Status']
-      end
-    end
-    
-    #get details about zone including name servers (which AWS adds automatically)
-    response = AWS[:dns].get_hosted_zone( zone_id)
-    if response.status == 200
-      zone_info = response.body['HostedZone']
-      name_servers = response.body['NameServers']
-      num_ns_servers = name_servers.count
-    end
-
-    #add an A record for www
-    change_batch = []
-    host = 'www.' + TEST_DOMAIN
-    ip_addr = '1.2.3.4'
-    record = { :name => host, :type => 'A', :resource_records => [ip_addr], :ttl => 3600 }
-    
-    resource_record_set = record.merge( :action => 'CREATE' )
-    change_batch << resource_record_set
-    options = { :comment => 'add A record for www'}
-    response = AWS[:dns].change_resource_record_sets( zone_id, change_batch, options)
-    if response.status == 200
-      change_id = response.body['Id']
-      status = response.body['Status']
-    end
-    
-    debugger
-
-    #wait until new zone is live across all name servers
-    while status == 'PENDING'
-      sleep 2
-      response = AWS[:dns].get_change( change_id)
-      if response.status == 200
-        change_id = response.body['Id']
-        status = response.body['Status']
-      end
-      puts "your changes are #{status}"    
-    end
-
-    # get resource records for zone
-    response = AWS[:dns].list_resource_record_sets( zone_id)
-    if response.status == 200
-      record_sets= response.body['ResourceRecordSets']
-      num_records= record_sets.count
-    end
-
-    #now delete record for www
-    resource_record_set = record.merge( :action => 'DELETE' )
-    change_batch = []
-    change_batch << resource_record_set
-    options = { :comment => 'remove A record for www'}
-    response = AWS[:dns].change_resource_record_sets( zone_id, change_batch, options)
-    if response.status == 200
-      change_id = response.body['Id']
-      status = response.body['Status']
-    end
-    
-    #delete the zone
-    response = AWS[:dns].delete_hosted_zone( zone_id)
-    if response.status == 200
-      change_id = response.body['ChangeInfo']['Id']
-    end
-
-
-  rescue 
-    #opps, ran into a problem
-    puts $!.message
-    return false
-  end
-
-  true
-end
-
-
-# example of how to use Linode DNS calls
-def show_linode_dns_usage
-  
-  begin
-    
-    #create a zone for a domain
-    type = 'master'
-    options = { :SOA_email => 'netops@sample-domain.com', :description => "Sample-Domain Inc", :status => 0}
-    response = Linode[:compute].domain_create( TEST_DOMAIN, type, options)
-    if response.status == 200
-      master_zone_id = response.body['DATA']['DomainID']
-      puts "created zone for #{TEST_DOMAIN} - ID: #{master_zone_id}"
-    end
-    
-    #create a slave zone
-    domain = 'sample-slave-domain.com'
-    type = 'slave'
-    options = { :master_ips => '1.2.3.4; 1.2.3.5'}
-    response = Linode[:compute].domain_create( domain, type, options)
-    if response.status == 200
-      slave_zone_id = response.body['DATA']['DomainID']
-      puts "created slave zone for #{domain} - ID: #{slave_zone_id}"
-    end
-
-    #get a list of zones Linode hosted for account
-    response = Linode[:compute].domain_list()
-    if response.status == 200
-      zones = response.body['DATA']
-      num_zones = zones.count
-      puts "Linode is hosting #{num_zones} DNS zones for this account:"
-      zones.each { |zone|
-        puts "  #{zone['DOMAIN']}\n"
-      }
-    end
-
-    #add an A and a MX record
-    domain= 'www.' + TEST_DOMAIN
-    options = { :name => domain, :target => '4.5.6.7', :ttl_sec => 7200 }
-    response = Linode[:compute].domain_resource_create( master_zone_id, 'A', options)
-    if response.status == 200
-      resource_id = response.body['DATA']['ResourceID']
-      puts "added an A record for #{domain} - ID: #{resource_id}"
-    end
-
-    domain= 'mail.' + TEST_DOMAIN
-    options = { :target => domain, :priority => 1 }
-    response = Linode[:compute].domain_resource_create( master_zone_id, 'MX', options)
-    if response.status == 200
-      resource_id = response.body['DATA']['ResourceID']
-      puts "added a MX record for #{TEST_DOMAIN} - ID: #{resource_id}"
-    end
-
-    #change MX to have a lower priority
-    options = { :priority => 5 }
-    response = Linode[:compute].domain_resource_update( master_zone_id, resource_id, options)
-    if response.status == 200
-      resource_id = response.body['DATA']['ResourceID']
-      puts "updated MX record for #{TEST_DOMAIN} with new priority - ID: #{resource_id}"      
-    end
-    
-    #get the list of resource records for the domain
-    response = Linode[:compute].domain_resource_list( master_zone_id)
-    if response.status == 200
-      num_records = response.body['DATA'].count
-      puts "#{TEST_DOMAIN} zone has #{num_records} resource records"
-    end
-
-    #finally cleanup by deleting the zone we created
-    response = Linode[:compute].domain_delete( master_zone_id)
-    if response.status == 200
-      puts "deleted #{TEST_DOMAIN} zone"
-    end
-    response = Linode[:compute].domain_delete( slave_zone_id)
-    if response.status == 200
-      puts "deleted slave zone"
-    end
-       
-  rescue
-    #opps, ran into a problem
-    puts $!.message
-    return false
-  end
-
-  true
-end
-
-
-# example of how to use Slicehost DNS calls
-def show_slicehost_dns_usage
-  
-  begin
-    #create a zone for a domain
-    zone_id = 0
-    options = { :ttl => 1800, :active => 'N' }
-    response= Slicehost[:compute].create_zone( TEST_DOMAIN, options)
-    if response.status == 201
-      zone_id= response.body['id']
-      puts "created zone for #{TEST_DOMAIN} - ID: #{zone_id}"
-    end
-    
-    #add an A record for website 
-    record_id = 0
-    options = { :ttl => 3600, :active => 'N' }
-    host = "www.#{TEST_DOMAIN}"
-    response= Slicehost[:compute].create_record( 'A', zone_id, host, "1.2.3.4", options)
-    if response.status == 201
-      record_id= response.body['id']
-      puts "created 'A' record for #{host} - ID: #{record_id}"
-    end
-    
-    #get a list of zones Slicehost hosted for account
-    response = Slicehost[:compute].get_zones()
-    if response.status == 200
-      zones = response.body['zones']
-      num_zones= zones.count
-      puts "Slicehost is hosting #{num_zones} DNS zones for this account"
-      zones.each { |zone|
-        puts "  #{zone['origin']}\n"
-      }
-    end
-  
-    #now get details on www record for the zone
-    if record_id > 0
-      response = Slicehost[:compute].get_record( record_id)
-      if response.status == 200
-        record = response.body['records'][0]
-        name = record['name']
-        type = record['record-type']
-        puts "got details on record #{record_id} -is an #{type} record for #{name} domain"
-      end
-    end
-  
-    #finally cleanup by deleting the zone we created
-    if zone_id > 0
-      response = Slicehost[:compute].delete_zone( zone_id)
-      if response.status == 200
-        puts "#{TEST_DOMAIN} removed from Slicehost DNS"
-      end
-    end
-      
-  rescue 
-    #opps, ran into a problem
-    puts $!.message
-    return false
-  end
-
-  true
-end
-
-# example of how to use Zerigo DNS calls
-def show_zerigo_dns_usage
-  
-  begin
-    #create a domain
-    options = { :nx_ttl => 1800 }
-    response = Zerigo[:compute].create_zone( "sample-domain.com", 3600, 'pri_sec', options)
-    if response.status == 201
-      zone_id = response.body['id']
-    end
-
-    #update zone
-    options = { :notes => "domain for client ABC"}
-    response = Zerigo[:compute].update_zone( zone_id, options)
-    if response.status == 200
-      puts "update of zone #{zone_id} worked"
-    end
-    
-    #get details on the zone
-    response = Zerigo[:compute].get_zone( zone_id)
-    if response.status == 200
-      domain = response.body['domain']
-      hosts = response.body['hosts']
-    end
-    
-    #get zone stats    
-    response = Zerigo[:compute].get_zone_stats( zone_id)
-    if response.status == 200
-      queries = response.body['queries']
-    end
-    
-    #list all domains on this accont
-    response= Zerigo[:compute].list_zones()
-    if response.status == 200
-      zone_count = response.headers['X-Query-Count'].to_i
-    end
-   
-    #add an A record to the zone
-    options = { :hostname => 'www' }
-    response = Zerigo[:compute].create_host( zone_id, 'A', '1.2.3.4', options )
-    if response.status == 201
-      host_id = response.body['id']
-    end
-    
-    #add an MX record to the zone
-    options = { :priority => 5 }
-    response = Zerigo[:compute].create_host( zone_id, 'MX', 'mail.sample-domain.com', options)
-    if response.status == 201
-      mail_host_id = response.body['id']
-    end
-    
-    #update the record
-    options = { :priority => 10 }
-    response = Zerigo[:compute].update_host( mail_host_id, options)
-    if response.status == 200
-      #updated priority
-    end
-  
-    #find a specific record
-    response = Zerigo[:compute].find_hosts( "sample-domain.com" )
-    if response.status == 200
-      hosts= response.body['hosts']
-      num_records = hosts.count
-    end
-    
-    #get host record
-    response = Zerigo[:compute].get_host( host_id)
-    if response.status == 200
-      fqdn = response.body['fqdn']
-    end
-    
-    #list hosts
-    response = Zerigo[:compute].list_hosts( zone_id)
-    if response.status == 200
-      hosts = response.body['hosts']
-    end
-    
-    #delete the host record
-    response = Zerigo[:compute].delete_host( host_id)
-    if response.status == 200
-      puts "host record #{host_id} deleted from zone"
-    end
-    
-    #delete the zone we created
-    response = Zerigo[:compute].delete_zone( zone_id)
-    if response.status == 200
-      puts "deleted zone #{zone_id}"
-    end  
-    
-  rescue
-    #opps, ran into a problem
-    puts $!.message
-    return false
-  end
-  
-end
-
-######################################
-
-# make sure Fog credentials file has been setup 
-# (will throw exception if not)
-Fog::credentials
-
-# AWS Route 53
-if RUN_AWS_SAMPLE and Fog::credentials[:aws_access_key_id] and Fog::credentials[:aws_secret_access_key]
-  show_aws_dns_usage
-end
-
-# Linode
-if RUN_LINODE_SAMPLE and Fog::credentials[:linode_api_key]
-  show_linode_dns_usage
-end
-
-# Slicehost
-if RUN_SLICEHOST_SAMPLE and Fog::credentials[:slicehost_password]
-  show_slicehost_dns_usage
-end
-
-if RUN_ZERIGO_SAMPLE and Fog::credentials[:zerigo_email] and Fog::credentials[:zerigo_password]
-  show_zerigo_dns_usage
-end

data/spec/aws/requests/simpledb/batch_put_attributes_spec.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe 'SimpleDB.batch_put_attributes' do
-  describe 'success' do
-
-    before(:all) do
-      @domain_name = "fog_domain_#{Time.now.to_i}"
-      AWS[:sdb].create_domain(@domain_name)
-    end
-
-    after(:all) do
-      AWS[:sdb].delete_domain(@domain_name)
-    end
-
-    it 'should return proper attributes' do
-      actual = AWS[:sdb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
-      actual.body['RequestId'].should be_a(String)
-      actual.body['BoxUsage'].should be_a(Float)
-    end
-
-  end
-  describe 'failure' do
-
-    it 'should raise a BadRequest error if the domain does not exist' do
-      lambda {
-        AWS[:sdb].batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
-      }.should raise_error(Excon::Errors::BadRequest)
-    end
-
-  end
-end