mirror of
https://github.com/fog/fog.git
synced 2022-11-09 13:51:43 -05:00
getting examples in order
This commit is contained in:
geemus
parent
15ead3ec2a
commit
763d7940c4
6 changed files with 117 additions and 437 deletions
|
|
@ -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
|
||||
76
examples/dns.rb
Normal file
76
examples/dns.rb
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
require 'rubygems'
|
||||
require 'shindo'
|
||||
|
||||
require File.join(File.dirname(__FILE__), '..', 'lib', 'fog')
|
||||
require File.join(File.dirname(__FILE__), '..', 'tests', 'helper')
|
||||
|
||||
Shindo.tests('dns tests', 'dns') do
|
||||
|
||||
# iterate over all the providers
|
||||
Fog.providers.each do |provider|
|
||||
|
||||
# skip if provider does not have storage
|
||||
next unless provider.respond_to?(:services) && provider.services.include?(:dns)
|
||||
|
||||
tests(provider, provider.to_s.downcase) do
|
||||
|
||||
# use shortcuts to instantiate connection
|
||||
@dns = Fog::DNS.new(:provider => provider.to_s)
|
||||
|
||||
# create a zone
|
||||
# domain should be the hostname
|
||||
# email is only required for linode, but included for consistency
|
||||
tests('@zone = @dns.zones.create').succeeds do
|
||||
@zone = @dns.zones.create(
|
||||
:domain => 'fogdnsexamples.com',
|
||||
:email => 'tests@fogdnsexamples.com'
|
||||
)
|
||||
end
|
||||
|
||||
# create a record in the zone
|
||||
# ip is the address to route to
|
||||
# name is the name for the record
|
||||
# type is the type of record to create
|
||||
tests('@record = @zone.records.create').succeeds do
|
||||
@record = @zone.records.create(
|
||||
:ip => '1.2.3.4',
|
||||
:name => 'www.fogdnsexamples.com',
|
||||
:type => 'A'
|
||||
)
|
||||
end
|
||||
|
||||
# list zones
|
||||
tests('@zones = @dns.zones').succeeds do
|
||||
@zones = @dns.zones
|
||||
end
|
||||
|
||||
# get a zone
|
||||
tests('@dns.zones.get(@zone.identity)').succeeds do
|
||||
@dns.zones.get(@zone.identity)
|
||||
end
|
||||
|
||||
# list records
|
||||
tests('@records = @zone.records').succeeds do
|
||||
@records = @zone.records
|
||||
end
|
||||
|
||||
# get a record
|
||||
tests('@zone.records.get(@record.identity)').succeeds do
|
||||
@zone.records.get(@record.identity)
|
||||
end
|
||||
|
||||
# destroy the record
|
||||
tests('@record.destroy').succeeds do
|
||||
@record.destroy
|
||||
end
|
||||
|
||||
# destroy the zone
|
||||
tests('@zone.destroy').succeeds do
|
||||
@zone.destroy
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
|
|
@ -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
|
||||
|
|
@ -9,8 +9,8 @@ Shindo.tests('storage tests', 'storage') do
|
|||
# iterate over all the providers
|
||||
Fog.providers.each do |provider|
|
||||
|
||||
# return immediately if provider does not have storage
|
||||
break unless provider.services.include?(:storage)
|
||||
# skip if provider does not have storage
|
||||
next unless provider.respond_to?(:services) && provider.services.include?(:storage)
|
||||
|
||||
tests(provider, provider.to_s.downcase) do
|
||||
|
||||
|
|
@ -25,13 +25,23 @@ Shindo.tests('storage tests', 'storage') do
|
|||
# create a directory
|
||||
# key should be a unique string
|
||||
# public should be a boolean
|
||||
tests('@directory = @directories.create').succeeds do
|
||||
tests('@directory = @storage.directories.create').succeeds do
|
||||
@directory = @storage.directories.create(
|
||||
:key => "fogstoragedirectory#{Time.now.to_i}",
|
||||
:public => publicity
|
||||
)
|
||||
end
|
||||
|
||||
# list directories
|
||||
tests('@directories = @storage.directories').succeeds do
|
||||
@directories = @storage.directories
|
||||
end
|
||||
|
||||
# get a directory
|
||||
tests('@storage.directories.get(@directory.identity)').succeeds do
|
||||
@storage.directories.get(@directory.identity)
|
||||
end
|
||||
|
||||
# create a file in the directory
|
||||
# key can be any string
|
||||
# body can be a string or a file as File.open(path)
|
||||
|
|
@ -49,19 +59,9 @@ Shindo.tests('storage tests', 'storage') do
|
|||
@files = @directory.files
|
||||
end
|
||||
|
||||
# fetch the latest files data
|
||||
tests('@files.reload').succeeds do
|
||||
@files.reload
|
||||
end
|
||||
|
||||
# get a file
|
||||
tests('@directory.files.get(@file.key)').succeeds do
|
||||
@directory.files.get(@file.key)
|
||||
end
|
||||
|
||||
# fetch the latest file data
|
||||
tests('@file.reload').succeeds do
|
||||
@file.reload
|
||||
tests('@directory.files.get(@file.identity)').succeeds do
|
||||
@directory.files.get(@file.identity)
|
||||
end
|
||||
|
||||
# test the publicity of files
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ require 'fog/core/compute'
|
|||
require 'fog/core/connection'
|
||||
require 'fog/core/credentials'
|
||||
require 'fog/core/deprecation'
|
||||
require 'fog/core/dns'
|
||||
require 'fog/core/errors'
|
||||
require 'fog/core/hmac'
|
||||
require 'fog/core/model'
|
||||
|
|
|
|||
25
lib/fog/core/dns.rb
Normal file
25
lib/fog/core/dns.rb
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
module Fog
|
||||
class DNS
|
||||
|
||||
def self.new(attributes)
|
||||
attributes = attributes.dup # prevent delete from having side effects
|
||||
case provider = attributes.delete(:provider)
|
||||
when 'AWS'
|
||||
require 'fog/aws'
|
||||
Fog::AWS::DNS.new(attributes)
|
||||
when 'Linode'
|
||||
require 'fog/linode'
|
||||
Fog::Linode::DNS.new(attributes)
|
||||
when 'Slicehost'
|
||||
require 'fog/slicehost'
|
||||
Fog::Slicehost::DNS.new(attributes)
|
||||
when 'Zerigo'
|
||||
require 'fog/zerigo'
|
||||
Fog::Zerigo::DNS.new(attributes)
|
||||
else
|
||||
raise ArgumentError.new("#{provider} is not a recognized storage provider")
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
Loading…
Add table
Reference in a new issue