abiquo-etk 0.4.13

data/vendor/api_ruby_client/examples/create_dc_and_hv.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'abiquo'
+require 'pp'
+
+auth = Abiquo::BasicAuth.new('Abiquo', 'admin', 'xabiquo')
+api = Abiquo::Resource('http://abiquo-server-ip:8080/api', auth)
+
+
+#
+# Create a DataCenter
+#
+#puts "Creating DC1 in BCN..."
+api.datacenters.create :name => 'DC1', :location => 'BCN'
+
+#
+# Create Remote Services
+# 
+api.datacenters.first.remoteServices.create :type => 'VIRTUAL_FACTORY', :uri => 'http://localhost:8080/virtualfactory'
+api.datacenters.first.remoteServices.create :type => 'STORAGE_SYSTEM_MONITOR', :uri => 'http://localhost:8080/ssm'
+api.datacenters.first.remoteServices.create :type => 'VIRTUAL_SYSTEM_MONITOR', :uri => 'http://localhost:8080/vsm'
+api.datacenters.first.remoteServices.create :type => 'NODE_COLLECTOR', :uri => 'http://localhost:8080/nodecollector'
+api.datacenters.first.remoteServices.create :type => 'APPLIANCE_MANAGER', :uri => 'http://localhost:8080/am'
+api.datacenters.first.remoteServices.create :type => 'DHCP_SERVICE', :uri => 'http://localhost:7911'
+api.datacenters.first.remoteServices.create :type => 'BPM_SERVICE', :uri => 'http://localhost:7911'
+
+#
+# Create a new Rack
+#
+puts "Creating rack 'myrack01'..."
+api.datacenters.first.racks.create :name => 'myrack01'
+
+#
+# Iterate over all the racks and print the rack name
+#
+puts "Listing racks.."
+api.datacenters.first.racks.each do |rack|
+  pp rack.name
+end

data/vendor/api_ruby_client/examples/hypervisor_resource.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'abiquo'
+require 'pp'
+
+auth = Abiquo::BasicAuth.new('Abiquo', 'admin', 'admin')
+api = Abiquo::Resource('http://as-testing.bcn.abiquo.com:8080/api', auth)
+
+#
+# Iterate over all the racks and print the rack name and the hypervisors underneath
+#
+api.datacenters.first.racks.each do |rack|
+  puts "- RACK [#{rack.name}]" 
+  rack.machines.each do |m|
+    puts "---" + m.name
+  end
+end

data/vendor/api_ruby_client/examples/rack_resource.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'abiquo'
+require 'pp'
+
+auth = Abiquo::BasicAuth.new('Abiquo', 'admin', 'admin')
+api = Abiquo::Resource('http://as-testing.bcn.abiquo.com:8080/api', auth)
+
+#
+# Create a new Rack
+#
+puts "Creating rack 'myrack01'..."
+api.datacenters.first.racks.create :name => 'myrack01'
+
+#
+# Iterate over all the racks and print the rack name
+#
+puts "Listing racks.."
+api.datacenters.first.racks.each do |rack|
+  pp rack.name
+end
+
+#
+# Iterate over all the racks and print the rack name
+#
+puts "Listing racks..."
+api.datacenters.first.racks.each do |rack|
+  pp rack.name
+end
+
+#
+# Delete the rack myrack01
+# 
+# NOT SUPPORTED IN ABIQUO1.6
+#
+#puts "Deleting rack 'myrack01'..."
+#api.datacenters.first.racks.each do |r|
+#  r.delete if r.name == 'myrack01'
+#end

data/vendor/api_ruby_client/lib/abiquo.rb

@@ -0,0 +1,201 @@
+require 'resourceful'
+require 'nokogiri'
+#gem 'activesupport', '2.3.8'
+require 'active_support'
+require File.expand_path('../core_ext', __FILE__)
+require File.expand_path('../to_xml', __FILE__)
+require 'uri'
+
+module Abiquo
+
+  class NotAllowed < RuntimeError
+    def initialize(method, url)
+      @method = method
+      @url = url
+    end
+
+    def message
+      "Method #{@method} not allowed for #{@url}"
+    end
+  end
+  
+  class BasicAuth < Resourceful::BasicAuthenticator
+    def can_handle?(request); true; end
+  end
+  
+  module HttpAccessor
+    
+    def xml
+      @xml ||= begin
+        response = http.resource(url_with_params).get
+        Nokogiri.parse(response.body).root
+      end
+    end
+    
+    private
+    
+    def url_with_params
+      @options[:expand] = @options[:expand].join(",") if @options[:expand].is_a?(Array)
+      params = @options.map { |k, v| "#{k}=#{v}" }.join("&")
+      params = "?#{params}" unless params.empty?
+      @url + params
+    end
+    
+    def http
+      Resourceful::HttpAccessor.new(:authenticator => @auth)
+    end
+
+    def rest_options
+      @rest_options ||= begin
+        response = http.resource(@url).options
+        response.header['Allow'].map {|m| m.to_sym }
+      end
+    end
+    
+  end
+  
+  class SingleResource
+    
+    include HttpAccessor
+    
+    undef id
+    
+    def initialize(url, auth, xml = nil, options = {})
+      @url = url
+      @auth = auth
+      @xml = xml
+      @options = options
+    end
+    
+    def update(attrs = {})
+      raise Abiquo::NotAllowed.new(:PUT, url) unless rest_options.include?(:PUT)
+      response = http.resource(url).put(attrs.to_xml(:root => object_type), :content_type => "application/xml")
+      @xml = Nokogiri.parse(response.body).root
+    end
+    
+    def delete
+      raise Abiquo::NotAllowed.new(:DELETE, url) unless rest_options.include?(:DELETE)
+      http.resource(url).delete
+    end
+    
+    def url
+      @url ||= xml.at_xpath("./link[@rel='edit']").try(:[], "href")
+    end
+    
+    delegate :to_xml, :to => :xml
+    alias_method :inspect, :to_xml
+    
+    private
+    
+    def object_type
+      @object_type ||= URI.parse(url).path.split("/")[-2].singularize
+    end
+    
+    def method_missing(meth, *args, &blk)
+      attribute = xml.at_xpath("./*[name()='#{meth}' or name()='#{attribute_name(meth)}']")
+      return node_text(attribute) if attribute
+      
+      link = xml.at_xpath("./link[@rel='#{meth}' or @rel='#{attribute_name(meth)}']")
+      return Resource.new(link["href"], @auth, link.at_xpath("./*"), *args) if link
+
+      if xml.namespaces.has_key?('xmlns:ns2')
+        @xml = Nokogiri.parse(xml.to_s.downcase).root
+        link = xml.at_xpath("//ns2:collection/xmlns:title[. = '#{meth}']").try(:parent)
+        return Resource.new(link['href'], @auth, nil, *args) if link
+      end
+      
+      super
+    end
+    
+    def node_text(node)
+      node.text
+    end
+    
+    def attribute_name(attribute)
+      attribute.to_s.gsub('_', '-')
+    end
+    
+  end
+  
+  class ResourceCollection
+    
+    include HttpAccessor
+    
+    delegate :inspect, :to => :resources
+    
+    def initialize(url, auth, xml = nil, options = {})
+      @url = url
+      @auth = auth
+      @xml = xml if options.empty?
+      @options = options
+    end
+    
+    def create(attrs = {})
+      raise Abiquo::NotAllowed.new(:POST, url) unless rest_options.include?(:POST)
+      response = http.resource(url_with_params).post(attrs.to_xml(:root => object_type, :convert_links => true), :content_type => "application/xml")
+      Resource.new(nil, @auth, Nokogiri.parse(response.body).root)
+    end
+    
+    private
+    
+    def object_type
+      @object_type ||= URI.parse(@url).path.split("/").last.singularize
+    end
+    
+    def resources
+      @resources ||= xml.xpath("./*").map { |subnode| Resource.new(subnode.at_xpath("./link[@rel='edit']").try(:[], "href"), @auth, subnode, @options) }
+    end
+    
+    def method_missing(meth, *args, &blk)
+      resources.send(meth, *args, &blk)
+    end
+  end
+  
+  class Resource
+    
+    include HttpAccessor
+    
+    undef id
+    undef type
+    
+    delegate :inspect, :to => :get!
+    
+    def self.from_xml(xml, auth = nil)
+      new(nil, auth, Nokogiri.parse(xml).root)
+    end
+    
+    def initialize(url, auth, xml = nil, options = {})
+      @url = url
+      @auth = auth
+      @xml = xml
+      @options = options
+    end
+    
+    def method_missing(meth, *args, &blk)
+      @resource_object ||= resource_class(meth).new(@url, @auth, @xml, @options)
+      @resource_object.send(meth, *args, &blk)
+    end
+    
+    def resource_class(meth)
+      @resource_class ||= if (Array.instance_methods + ["create"] - ["delete", "id"]).include?(meth.to_s)
+        ResourceCollection
+      else
+        SingleResource
+      end
+    end
+    
+    def get!
+      klass = SingleResource
+      if (!xml.children.empty? && xml.name.singularize == xml.children.first.name)
+        klass = ResourceCollection
+      end
+      @resource_object = klass.new(@url, @auth, @xml, @options)
+    end
+        
+  end
+  
+  def self.Resource(url, auth, params = {})
+    Resource.new(url, auth, nil, params)
+  end
+  
+end

data/vendor/api_ruby_client/lib/core_ext.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+
+module Resourceful
+  class Resource
+    def options(header = {})
+      request(:options, nil, header)
+    end
+
+    def host_with_port
+      add = Addressable::URI.parse(uri)
+      !add.port.blank? && add.port != 80 ? [add.host, add.port].join(':') : add.host
+    end
+
+    alias_method_chain :host, :port
+  end
+
+  class NetHttpAdapter
+    def net_http_request_class_with_options(method)
+      if method == :options
+        Net::HTTP::Options
+      else
+        net_http_request_class_without_options(method)
+      end
+    end
+
+    alias_method_chain :net_http_request_class, :options
+  end
+end

data/vendor/api_ruby_client/lib/to_xml.rb

@@ -0,0 +1,22 @@
+module Abiquo
+  
+  module ToXml
+    
+    def to_xml_with_links(options = {})
+      if options[:convert_links] && options[:builder]
+        options[:builder].tag!(:link, :rel => options[:root]) do
+          to_xml_without_links(options)
+        end
+      else
+        to_xml_without_links(options)
+      end
+    end
+    
+  end
+  
+end
+
+class Array
+  include Abiquo::ToXml
+  alias_method_chain :to_xml, :links
+end

data/vendor/api_ruby_client/spec/acceptance/create_resource_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+feature "Creating new resources" do
+  
+  scenario "Creating a resource in a collection" do
+    
+    datacenters = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters", auth)
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters").
+      to_return(:headers => {'Allow' => 'GET, POST, OPTIONS'})
+
+    stub_auth_request(:post, "http://admin:admin@abiquo.example.com/api/admin/datacenters").with do |req|
+      # we parse because comparing strings is too fragile because of order changing, different indentations, etc.
+      # we're expecting something very close to this:
+      # <datacenter>
+      #   <name>Wadus</name>
+      # </datacenter>
+      Nokogiri.parse(req.body).at_xpath("/datacenter/name").text == "Wadus"
+    end.to_return(:body => %q{
+      <datacenter>
+        <name>Wadus</name>
+        <link rel="edit" href="http://abiquo.example.com/api/admin/datacenters/1"/>
+      </datacenter>
+    })
+    
+    datacenter = datacenters.create(:name => "Wadus")
+    
+    datacenter.should be_a(Abiquo::Resource)
+    datacenter.name.should == "Wadus"
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:headers => {'Allow' => 'GET, PUT, OPTIONS'})
+    
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => %q{
+      <datacenter>
+        <name>Wadus</name>
+        <link rel="edit" href="http://abiquo.example.com/api/admin/datacenters/1"/>
+      </datacenter>
+    })
+
+    datacenter.name == Abiquo::Resource(datacenter.url, auth).name
+  end
+end

data/vendor/api_ruby_client/spec/acceptance/delete_resource_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+feature "Deleting resources" do
+  
+  scenario "return status 200 when delete is allowed" do
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+    
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:status => 200, :headers => {'Allow' => 'GET, PUT, OPTIONS, HEAD, DELETE'})
+
+    stub_auth_request(:delete, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:status => 200)
+    
+    datacenter.delete
+    
+    auth_request(:delete, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").should have_been_made.once
+  end
+
+  scenario "raise Abiquo::NotAllowed when delete is not allowed" do
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:status => 200, :headers => {'Allow' => 'GET, PUT, OPTIONS, HEAD'})
+    
+    lambda { datacenter.delete }.should raise_error(Abiquo::NotAllowed)
+  end
+  
+end

data/vendor/api_ruby_client/spec/acceptance/fetch_resource_collections_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+feature "Fetching resource collections" do
+  
+  scenario "Fetch collection" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters").to_return(:body => <<-XML)
+      <datacenters>
+        <datacenter>
+          <link rel='edit' href='http://abiquo.example.com/api/admin/datacenters/1'/>
+          <name>Resource 1</name>
+        </datacenter>
+        <datacenter>
+          <link rel='edit' href='http://abiquo.example.com/api/admin/datacenters/2'/>
+          <name>Resource 2</name>
+        </datacenter>
+      </datacenters>
+    XML
+    
+    resources = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters", auth)
+    
+    resources.map(&:name).should == ["Resource 1", "Resource 2"]
+    resources.size.should == 2
+    resources.first.name.should == "Resource 1"
+    resources.last.name.should  == "Resource 2"
+  end
+  
+  scenario "Inspecting a collection" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters").to_return(:body => %q{
+      <datacenters><datacenter><name>Resource 1</name></datacenter></datacenters>
+    })
+
+    resources = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters", auth)
+
+    resources.inspect.should == "[#{resources.first.inspect}]"
+  end
+
+  scenario 'Fetch service document' do
+    stub_auth_request(:get, 'http://admin:admin@abiquo.example.com/api').to_return(:body => <<-XML)
+      <ns2:service xmlns="http://www.w3.org/2005/Atom" xmlns:ns2="http://www.w3.org/2007/app" xmlns:ns3="http://a9.com/-/spec/opensearch/1.1/" xmlns:ns4="http://www.w3.org/1999/xhtml">
+        <ns2:workspace>
+          <title>Abiquo administration workspace</title>
+          <ns2:collection href="http://localhost:8080/api/admin/datacenters">
+            <title>Datacenters</title>
+            <ns2:accept/>
+          </ns2:collection>
+        </ns2:workspace>
+      </ns2:service>
+    XML
+
+    resources = Abiquo::Resource('http://abiquo.example.com/api', auth)
+
+    lambda { resources.datacenters }.should_not raise_error
+  end
+  
+end

data/vendor/api_ruby_client/spec/acceptance/fetch_single_resources_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+feature "Fetching individual resources" do  
+
+  scenario "Fetching untyped attributes" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => <<-XML)
+      <datacenter>
+        <name>Resource Name</name>
+        <id>12345</id>
+      </datacenter>
+    XML
+
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+    datacenter.name.should == "Resource Name"
+    datacenter.id.should == "12345"
+
+    expect { datacenter.wadus }.to raise_error(NoMethodError)
+  end
+
+  scenario "Fetching typed attributes" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => <<-XML)
+      <datacenter>
+        <id>12345</id>
+        <name>Resource Name</name>
+      </datacenter>
+    XML
+
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+
+    datacenter.id.should == "12345"
+  end
+
+  scenario "Inspecting a resource" do
+    xml = %q{
+      <datacenter>
+        <id>12345</id>
+        <name>Resource Name</name>
+      </datacenter>      
+    }
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => xml)
+
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+
+    Nokogiri.parse(datacenter.inspect).to_xml.should == Nokogiri.parse(xml).to_xml
+  end
+  
+end

data/vendor/api_ruby_client/spec/acceptance/from_xml_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+feature "Instantiate resources from xml" do
+  
+  it "should instantiate the resource without HTTP calls" do
+    xml = %q{
+      <datacenter>
+        <name>Resource 1</name>
+      </datacenter>
+    }
+    datacenter = Abiquo::Resource.from_xml(xml)
+    
+    datacenter.name.should == "Resource 1"
+  end
+end

data/vendor/api_ruby_client/spec/acceptance/navigate_linked_resources_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+feature "Navigating linked resources" do
+  scenario "Link to a collection of resources" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => <<-XML)
+      <datacenter>
+        <link rel="racks" href="http://abiquo.example.com/api/admin/datacenters/1/racks"/>
+      </datacenter>
+    XML
+    
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+    
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1/racks").to_return(:body => <<-XML)
+      <racks>
+        <rack>
+          <name>Rack 1</name>
+        </rack>
+        <rack>
+          <name>Rack 2</name>
+        </rack>
+      </racks>
+    XML
+    
+    datacenter.racks.size.should == 2
+    datacenter.racks.first.name.should == 'Rack 1'
+    datacenter.racks.last.name.should == 'Rack 2'
+  end
+  
+  scenario "Link to a collection of resources with params" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => <<-XML)
+      <datacenter>
+        <link rel="racks" href="http://abiquo.example.com/api/admin/datacenters/1/racks"/>
+      </datacenter>
+    XML
+
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1/racks").to_return(:body => <<-XML)
+      <racks>
+        <rack>
+          <name>Rack 1</name>
+        </rack>
+      </racks>
+    XML
+    
+    datacenter.racks.size.should == 1
+    datacenter.racks.first.name.should == 'Rack 1'
+  end
+
+  scenario "Link to self" do
+    stub_auth_request(:get, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").to_return(:body => <<-XML)
+      <datacenter>
+        <link rel="edit" href="http://abiquo.example.com/datacenters/1"/>
+      </datacenter>
+    XML
+    
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+    
+    datacenter.url.should == "http://abiquo.example.com/api/admin/datacenters/1"
+  end
+end

data/vendor/api_ruby_client/spec/acceptance/update_resource_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+feature "Updating resources" do
+  
+  scenario "Updating a resource" do
+    datacenter = Abiquo::Resource("http://abiquo.example.com/api/admin/datacenters/1", auth)
+
+    stub_auth_request(:options, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").
+      to_return(:headers => {'Allow' => 'GET, PUT, OPTIONS'})
+
+    stub_auth_request(:put, "http://admin:admin@abiquo.example.com/api/admin/datacenters/1").with do |req|
+      req.body == {:name => "Wadus Wadus"}.to_xml(:root => "datacenter")
+    end.to_return(:body => <<-XML)
+      <datacenter>
+        <name>Wadus Wadus</name>
+        <link rel="edit" href="http://abiquo.example.com/api/admin/datacenters/1"/>
+      </datacenter>
+    XML
+    
+    
+    datacenter.update(:name => "Wadus Wadus")
+    
+    datacenter.name.should == "Wadus Wadus"
+  end
+  
+end

data/vendor/api_ruby_client/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'steak'
+require 'webmock/rspec'
+require "abiquo"
+
+module Helpers
+
+  def stub_auth_request(*args)
+    stub_request(*args)
+  end
+  
+  def auth_request(*args)
+    request(*args)
+  end
+  
+  def auth
+    Abiquo::BasicAuth.new("Abiquo", "admin", "admin")
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include Helpers
+  config.include WebMock
+  config.before(:each) do
+    stub_request(:any, //).with { |request| !request.headers.has_key?("Authorization") }.
+                           to_return(
+                             :status => 401, :headers => {
+                               "WWW-Authenticate" => 'Basic realm="Abiquo"'
+                            })
+  end
+  config.after(:each) { reset_webmock }
+end