webee 0.1 → 0.2

data/README.md

@@ -98,3 +98,7 @@ gem install webee
     # FIXME: Not supported in Abiquo right now
     #
     #rack.delete
+
+
+More examples can be found in the examples folder
+

data/examples/basics.rb

@@ -4,46 +4,72 @@ require 'md5'
 
 WeBee::Api.user = ENV['user'] || 'admin'
 WeBee::Api.password = ENV['pass'] || 'xabiquo'
-WeBee::Api.url = 'http://abiquo/api'
+WeBee::Api.url = "http://#{ENV['host'] || 'abiquo'}/api"
+
+#
+# Add a license
+#
+license_file = ARGV[0]
+if license_file.nil? or (not File.exist?(license_file))
+  $stderr.puts "Invalid license file"
+  exit 1
+end
+WeBee::Config.add_license File.read(license_file).strip.chomp
+
+#
+# Create a new datacenter
+#
+# This assumes the Remote Services are located in the same server
+#
+dc = WeBee::Datacenter.create :name => 'BCN'
+
+#
+# Advanced Datacenter Creation: 
+#
+# If you want to add a Datacenter with remote services located in another host
+# use this.
+#
+# remote_services= WeBee::RemoteService.create_for_host("10.60.1.24")
+# WeBee::Datacenter.create :name => 'foo'
+#                         :remote_services => remote_services
+
 
 #
 # List all datacenters available
 # 
 WeBee::Datacenter.all.each do |dc|
-  puts dc.name
+  # do something like printing dc.name
 end
 
-
 # 
 # Return the first datacenter whose name matches BCN (matched via Regexp)
 #
 dc = WeBee::Datacenter.find_by_name('BCN').first
-puts dc.name
+# puts dc.name
 
 #
-# List Datacenter Racks
+# Create an enterprise
 #
-dc.racks.each do |r|
-  puts r.name
-end
+ent = WeBee::Enterprise.create :name => 'QA'
 
 #
 # List all the enterprises
 #
 WeBee::Enterprise.all.each do |e|
-  puts e.name
+  # do something like printing e.name
 end
 
 #
 # Find an enterprise named QA
 #
-qa_ent = WeBee::Enterprise.find_by_name('QA')
+qa_ent = WeBee::Enterprise.find_by_name('QA').first
 
 #
 # List enterprise 'QA' users
 #
 qa_ent.users.each do |u|
-  puts u.name
+  # print user name
+  # puts u.name
 end
 
 
@@ -60,35 +86,84 @@ user = qa_ent.create_user :name => 'Sergio Rubio',
                    :active => 'true'  #optional
 
 # delete the user
-user.delete
+# user.delete
 
 #
-# Create a new datacenter
-# FIXME: not implemented in WeBee
+# List WeBee::OVFPackage available in enterprise QA
 #
-# WeBee::Datacenter.create :name => 'Test DC'
+qa_ent.ovf_packages.each do |pkg|
+  # print package info
+  # puts "#{pkg.product_name} (#{pkg.category_name})"
+end
 
 #
-# List WeBee::OVFPackage available in enterprise QA
+# List Datacenter Racks
 #
-qa_ent.ovf_packages.each do |pkg|
-  puts "#{pkg.product_name} (#{pkg.category_name})"
+dc.racks.each do |r|
+  # print rack name
+  # puts r.name
 end
 
 #
 # Create a new Rack
 #
-dc = WeBee::Datacenter.find_by_name('BCN').first
-rack = WeBee::Rack.create dc.datacenter_id,
-                          :name => 'rack_1',
-                          :ha_enabled => false,
-                          :vlan_min_id => 100,
-                          :vlan_max_id => 2048,
-                          :vlan_per_vdc_expected => 6,
-                          :nrsq => 80
+rack = dc.add_rack :name => 'rack_1',
+                   :ha_enabled => false,
+                   :vlan_min_id => 100,
+                   :vlan_max_id => 2048,
+                   :vlan_per_vdc_expected => 6,
+                   :nrsq => 80
 
 #
+# Hypervisor (Machine) stuff
+#
+machine = dc.discover_machine :ip => '10.60.1.24', :hypervisortype => 'kvm'
+# Use the first virtual switch we find
+machine.virtual_switch = machine.virtual_switches.first
+# Enable the first datastore found
+machine.datastores.first.enabled = true 
+# Add the hypervisor to the rack
+rack.add_machine(machine)
 # Delete the rack
 # FIXME: Not supported in Abiquo right now
-#
 #rack.delete
+
+#
+# Create a Virtual Datacenter with default limits and network
+#
+qa = WeBee::Enterprise.find_by_name('QA').first
+# We need to set limits for the enterprise to be able to use a datacenter
+qa.set_limits_for_datacenter dc
+#vdc = qa.create_vdc :name => 'kvm-vdc', :hypervisortype => 'KVM', :datacenter => dc
+
+#
+# Advanced VDC Creation
+#
+vdc = qa.create_vdc :datacenter => dc,
+                    :name => 'kvm-vdc',
+                    :hypervisortype => 'KVM', 
+                    :ramSoft => 19456,
+                    :ramHard => 20480,
+                    :cpuSoft => 18,
+                    :cpuHard => 20,
+                    :storageSoft => 28991029248,
+                    :storageHard => 32212254720,
+                    :publicIpsSoft => 2,
+                    :publicIpsHard => 4,
+                    :hdSoft => 27917287424,
+                    :hdHard => 32212254720,
+                    :vlanSoft => 5,
+                    :vlanHard => 10
+
+# Find VDC by name
+vdc = WeBee::VDC.find_by_name 'kvm-vdc'
+
+#
+# List all VDCs for my Enterprise
+WeBee::VDC.all 
+
+#
+# List all VDCs from a specific Enterprise/Datacenter
+# Needs Cloud operator privileges
+# 
+WeBee::VDC.all :datacenter_id => WeBee::Datacenter.all.first.datacenter_id, :enterprise_id => 3

data/examples/test.rb

@@ -0,0 +1,20 @@
+$: << '../lib'
+require 'webee'
+require 'md5'
+require 'active_support'
+
+WeBee::Api.user = ENV['user'] || 'admin'
+WeBee::Api.password = ENV['pass'] || 'xabiquo'
+WeBee::Api.url = 'http://10.60.1.24/api'
+
+#rs = WeBee::RemoteService.create_for_host("10.60.1.24")
+
+WeBee::Datacenter.create :name => 'BCN'
+#                         :remote_services => rs
+#
+WeBee::Enterprise.create :name => 'QA'
+
+WeBee::
+    
+
+

data/examples/test2.rb

@@ -0,0 +1,12 @@
+$: << '../lib'
+require 'webee'
+require 'md5'
+require 'active_support'
+include WeBee
+
+WeBee::Api.user = ENV['user'] || 'admin'
+WeBee::Api.password = ENV['pass'] || 'xabiquo'
+WeBee::Api.url = 'http://10.60.1.24/api'
+
+require 'pp'
+pp VDC.all :datacenter_id => 2, :enterprise_id => 3

data/lib/webee.rb

@@ -4,10 +4,32 @@ require 'sax-machine'
 require 'nokogiri'
 require 'active_support/core_ext/hash'
 require 'uri'
+require 'json'
+require 'builder'
+
+#
+# Monkeypatch SAXMachine to keep the raw XMK
+#
+# Ugly but fun, isn't it? This may blow up at some point
+#
+module SAXMachine
+
+  alias_method :old_parse, :parse
+
+  def parse(xml, on_error = nil, on_warning = nil)
+    obj = old_parse(xml, on_error, on_warning)
+    obj.instance_variable_set :@raw, xml
+    obj.class.send :define_method, 'raw' do
+      @raw
+    end
+    obj
+  end
+end
 
 module WeBee 
 
-  VERSION = '0.1'
+  VERSION = '0.2'
+
 
   module RestResource
     
@@ -46,10 +68,16 @@ module WeBee
 
   end
 
+  class Config
+      def self.add_license(hash)
+        RestClient.post Api.url + "/config/licenses" , "<license><code>#{hash}</code></license>", :content_type => :xml
+      end
+  end
+
 
   class Api
     class << self
-      attr_accessor :user, :password, :url, :port
+      attr_accessor :user, :password, :url, :port, :host
 
       def url=(url)
         @url = build_url(url)
@@ -59,6 +87,7 @@ module WeBee
       def build_url(url)
         port ||= 80
         uri = URI.parse(url)
+        @host = uri.host
         "http://#{user}:#{password}@#{uri.host}:#{uri.port}#{uri.path}"
       end
     end
@@ -120,25 +149,54 @@ module WeBee
 
     element :id, :as => :datacenter_id
     element :name
-    element :ramSoft
-    element :ramHard
-    element :cpuSoft
-    element :cpuHard
-    element :storageSoft
-    element :storageHard
-    element :repositorySoft
-    element :repositoryHard
-    element :publicIPSoft
-    element :publicIPHard
-    element :hdSoft
-    element :hdHard
-    element :vlanSoft
-    element :vlanHard
+    element :ramSoft, :as => :ram_soft
+    element :ramHard, :as => :ram_hard
+    element :cpuSoft, :as => :cpu_soft
+    element :cpuHard, :as => :cpu_hard
+    element :storageSoft, :as => :storage_soft
+    element :storageHard, :as => :storage_hard
+    element :repositorySoft, :as => :repository_soft
+    element :repositoryHard, :as => :repository_hard
+    element :publicIpsSoft, :as => :public_ip_soft
+    element :publicIpsHard, :as => :public_ip_hard
+    element :hdSoft, :as => :hd_soft
+    element :hdHard, :as => :hd_hard
+    element :vlanSoft, :as => :vlan_soft
+    element :vlanHard, :as => :vlan_hard
     element :location
 
     def self.create(attributes)
-      xml = attributes.to_xml(:root => 'datacenter')
-      res = RestClient.post(Api.url + '/admin/datacenters', xml, :content_type => :xml, :accept => :xml)
+      if attributes[:remote_services].nil?
+        attributes[:remote_services] = WeBee::RemoteService.create_for_host(Api.host)
+      end
+      xm = Builder::XmlMarkup.new
+      xm.datacenter {
+        xm.name attributes[:name]
+        xm.location(attributes[:location] ||  'California, USA')
+        xm.cpuSoft(attributes[:cpu_soft] || "0")
+        xm.cpuHard(attributes[:cpu_hard] || "0")
+        xm.vlanSoft(attributes[:vlan_soft] || "0")
+        xm.vlanHard(attributes[:vlan_hard] || "0")
+        xm.ramSoft(attributes[:ram_soft] || "0")
+        xm.ramHard(attributes[:ram_hard] || "0")
+        xm.repositorySoft(attributes[:repository_soft] || "0")  
+        xm.repositoryHard(attributes[:repository_hard] || "0") 
+        xm.publicIpsSoft(attributes[:public_ip_soft] || "0" ) 
+        xm.publicIpsHard(attributes[:public_ip_hard] || "0" ) 
+        xm.hdSoft(attributes[:hd_soft] || "0")
+        xm.hdHard(attributes[:hd_hard] || "0")
+        xm.storageSoft(attributes[:storage_soft] || "0")
+        xm.storageHard(attributes[:storage_hard] || "0")
+        xm.remoteServices {
+          attributes[:remote_services].each do |rs|
+            xm.remoteService {
+              xm.uri  rs.uri
+              xm.type rs.rs_type
+            }
+          end
+        }
+      }
+      res = RestClient.post(Api.url + '/admin/datacenters', xm.target!, :content_type => :xml)
       Datacenter.parse(res)
     end
 
@@ -154,11 +212,83 @@ module WeBee
       doc = Nokogiri.parse(RestClient.get(Api.url + "/admin/datacenters/#{@datacenter_id}/racks", :accept => :xml))
       doc.search 
       doc.search('//rack').each do |node|
-        items << Rack.parse(node.to_s)
+        rack = Rack.parse(node.to_s)
+        rack.datacenter_id = @datacenter_id
+        items << rack
       end
       items 
     end
 
+    def add_rack(params)
+      Rack.create datacenter_id, params
+    end
+
+    def discover_machine(params)
+      p = {}
+      p[:ip] = params[:ip]
+      p[:hypervisortype] = params[:hypervisortype] || 'kvm'
+      p[:user] = params[:user] || 'user'
+      p[:password] = params[:secret] || 'secret'
+      p[:port] = params[:port] || '8889'
+      p[:virtual_switch] = params[:virtual_switch]
+      res = RestClient.get Api.url + "/admin/datacenters/#{datacenter_id}/action/discover", :params => p, :content_type => :xml
+      machine = Machine.parse res
+    end
+
+  end
+
+  class RemoteService
+    attr_reader :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def uri
+      @attributes[:uri]
+    end
+
+    def rs_type
+      @attributes[:rs_type]
+    end
+
+    def self.from_type(address, type, use_ssl = false)
+      rs_type_map = {
+        'STORAGE_SYSTEM_MONITOR' => 'ssm',
+        'VIRTUAL_FACTORY' => 'virtualfactory',
+        'VIRTUAL_SYSTEM_MONITOR' => 'vsm',
+        'NODE_COLLECTOR' => 'nodecollector',
+        'APPLIANCE_MANAGER' => 'am',
+      }
+      case type
+        when RemoteServiceType::BPM_SERVICE
+          RemoteService.new :uri => "tcp://#{address}:61616", :rs_type => type
+        when RemoteServiceType::DHCP_SERVICE
+          RemoteService.new :uri => "omapi://#{address}:7911", :rs_type => type
+        else
+          if use_ssl
+            RemoteService.new :uri => "https://#{address}:443", :rs_type => type
+          else
+            RemoteService.new :uri => "http://#{address}:80/#{rs_type_map[type]}", :rs_type => type
+          end
+      end
+    end
+
+    def self.create_for_host(address, use_ssl = false)
+      items = []
+      %w(
+        STORAGE_SYSTEM_MONITOR
+        VIRTUAL_FACTORY
+        VIRTUAL_SYSTEM_MONITOR
+        NODE_COLLECTOR
+        APPLIANCE_MANAGER
+        DHCP_SERVICE
+        BPM_SERVICE
+      ).each do |t|
+        items << RemoteService.from_type(address, t, use_ssl)
+      end
+      items
+    end
   end
 
   class Rack
@@ -189,6 +319,268 @@ module WeBee
       RestClient.delete(Api.url + "/admin/datacenters/#{datacenter_id}/racks/#{rack_id}", :content_type => :xml)
     end
 
+    def add_machine(machine)
+      res = RestClient.post Api.url + "/admin/datacenters/#{datacenter_id}/racks/#{rack_id}/machines", machine.to_xml, :content_type => :xml
+    end
+
+    def machines
+      u = []
+      doc = Nokogiri.parse(RestClient.get(Api.url + "/admin/datacenters/#{datacenter_id}/racks/#{rack_id}/machines", :content_type => :xml))
+      doc.search('//machine').each do |node|
+        u << Machine.parse(node.to_s)
+      end
+      u
+    end
+
+  end
+
+  class Datastore
+    include SAXMachine
+
+    element :id, :as => :datastore_id
+    element :directory
+    element :rootPath, :as => :root_path
+    element :enabled
+    element :name
+    element :size
+    element :usedSize, :as => :used_size
+
+    def to_xml
+      xm = Builder::XmlMarkup.new
+      xm.datastore {
+        xm.name name
+        xm.directory directory
+        xm.rootPath root_path
+        xm.enabled enabled
+        xm.size size
+        xm.usedSize used_size
+      }
+    end
+
+  end
+
+  class Machine
+    include SAXMachine
+
+    attr_accessor :raw
+    attr_accessor :datacenter_id
+
+    element :id, :as => :machine_id
+    element :description
+    element :ip
+    element :ipService, :as => :ip_service
+    element :name
+    element :password
+    element :user
+    element :realCpu, :as => :real_cpu
+    element :realHd, :as => :real_hd
+    element :realRam, :as => :real_ram
+    element :state
+    element :type, :as => :hypervisortype
+    element :cpu
+    element :cpuRatio, :as => :cpu_ratio
+    element :cpuUsed, :as => :cpu_used
+    element :hd
+    element :hdUsed, :as => :hd_used
+    element :ram
+    element :ramUsed, :as => :ram_used
+    element :virtualSwitch, :as => :virtual_switch
+    elements :datastore, :as => :datastores, :class => Datastore
+
+    def virtual_switches
+      virtual_switch.split('/')
+    end
+
+    def to_xml
+      xm = Builder::XmlMarkup.new
+      xm.machine {
+        xm.name name
+        xm.description description
+        xm.ip ip
+        xm.ipService ip_service
+        xm.user user
+        xm.password password
+        xm.realCpu real_cpu
+        xm.realHd real_hd
+        xm.realRam real_ram
+        xm.state state
+        xm.type hypervisortype
+        xm.cpu cpu
+        xm.cpuRatio cpu_ratio
+        xm.cpuUsed cpu_used
+        xm.hd hd
+        xm.hdUsed hd_used
+        xm.ram ram
+        xm.ramUsed ram_used
+        xm.virtualSwitch virtual_switch
+        xm.datastores {
+          datastores.each do |ds|
+            xm.datastore {
+              xm.name ds.name
+              xm.directory ds.directory
+              xm.rootPath ds.root_path
+              xm.enabled ds.enabled
+              xm.size ds.size
+              xm.usedSize ds.used_size
+            }
+          end
+        }
+      }
+      xm.target!
+    end
+
+  end
+
+  class RemoteServiceType
+    VIRTUAL_FACTORY = 'VIRTUAL_FACTORY'
+    STORAGE_SYSTEM_MONITOR = 'STORAGE_SYSTEM_MONITOR'
+    VIRTUAL_SYSTEM_MONITOR = 'VIRTUAL_SYSTEM_MONITOR'
+    NODE_COLLECTOR = 'NODE_COLLECTOR'
+    APPLIANCE_MANAGER = 'APPLIANCE_MANAGER'
+    DHCP_SERVICE = 'DHCP_SERVICE'
+    BPM_SERVICE = 'BPM_SERVICE'
+  end
+
+  #
+  # A Virtual Datacenter Network
+  # FIXME: Unimplemented
+  #
+  class VDCNetwork
+    include SAXMachine
+    element :id, :as => :vdc_id
+    element :name
+    element :gateway
+    element :address
+    element :mask
+    element :defaultNetwork, :as => :default_network
+
+    def self.create(attributes)
+      xml = attributes.to_xml(:root => 'network')
+      VDCNetwork.parse(xml)
+    end
+
+    def to_xml
+    end
+  end
+  
+  #
+  # A virtual datacenter
+  # FIXME: Unimplemented
+  class VDC
+    include SAXMachine
+    element :id, :as => :vdc_id
+    element :name
+    element :ramSoft, :as => :ram_soft
+    element :ramHard, :as => :ram_hard
+    element :cpuSoft, :as => :cpu_soft
+    element :cpuHard, :as => :cpu_hard
+    element :storageSoft, :as => :storage_soft
+    element :storageHard, :as => :storage_hard
+    element :publicIpsSoft, :as => :public_ip_soft
+    element :publicIpsHard, :as => :public_ip_hard
+    element :hdSoft, :as => :hd_soft
+    element :hdHard, :as => :hd_hard
+    element :vlanSoft, :as => :vlan_soft
+    element :vlanHard, :as => :vlan_hard
+    element :hypervisorType, :as => :hypervisortype
+    element :network, :class => VDCNetwork
+
+    def self.create(attributes)
+      datacenter = attributes[:datacenter].datacenter_id
+      enterprise = attributes[:enterprise].resource_id
+      if attributes[:network].nil?
+        net = VDCNetwork.new
+        net.name = 'defaultNetwork'
+        net.gateway = '192.168.1.1'
+        net.address = '192.168.1.0'
+        net.mask = '24'
+        net.default_network = true
+        attributes[:network] = net
+      end
+      xm = Builder::XmlMarkup.new
+      xm.virtualDatacenter {
+        xm.name attributes[:name]
+        xm.cpuSoft(attributes[:cpu_soft] || "0")
+        xm.cpuHard(attributes[:cpu_hard] || "0")
+        xm.vlanSoft(attributes[:vlan_soft] || "0")
+        xm.vlanHard(attributes[:vlan_hard] || "0")
+        xm.ramSoft(attributes[:ram_soft] || "0")
+        xm.ramHard(attributes[:ram_hard] || "0")
+        xm.publicIpsSoft(attributes[:public_ip_soft] || "0" ) 
+        xm.publicIpsHard(attributes[:public_ip_hard] || "0") 
+        xm.hdSoft(attributes[:hd_soft] || "0")
+        xm.hdHard(attributes[:hd_hard] || "0" )
+        xm.storageSoft(attributes[:storage_soft] || "0")
+        xm.storageHard(attributes[:storage_hard] || "0")
+        xm.hypervisorType attributes[:hypervisortype]
+        xm.network {
+          xm.name(attributes[:network].name || 'defaultNetwork')
+          xm.gateway(attributes[:network].gateway || '192.168.1.1')
+          xm.address(attributes[:network].address || '192.168.1.0')
+          xm.mask(attributes[:network].mask || '24')
+          xm.defaultNetwork(attributes[:network].default_network || true)
+        }
+      }
+      res = RestClient.post(Api.url + "/cloud/virtualdatacenters/?datacenter=#{datacenter}&enterprise=#{enterprise}", xm.target!, :content_type => :xml)
+      VDC.parse(res)
+    end
+
+    def to_xml
+      xm = Builder::XmlMarkup.new
+      xm.virtualDatacenter {
+        xm.name name
+        xm.cpuSoft(cpu_soft || "0")
+        xm.cpuHard(cpu_hard || "0")
+        xm.vlanSoft(vlan_soft || "0")
+        xm.vlanHard(vlan_hard || "0")
+        xm.ramSoft(ram_soft || "0")
+        xm.ramHard(ram_hard || "0")
+        xm.repositorySoft(repository_soft || "0")  
+        xm.repositoryHard(repository_hard || "0") 
+        xm.publicIpsSoft(public_ip_soft || "0" ) 
+        xm.publicIpsHard(public_ip_hard || "0" ) 
+        xm.hdSoft(hd_soft || "0")
+        xm.hdHard(hd_hard || "0")
+        xm.storageSoft(storage_soft || "0")
+        xm.storageHard(storage_hard || "0")
+        xm.network {
+          xm.name(network.name || 'defaultNetwork')
+          xm.gateway(network.gateway || '192.168.1.1')
+          xm.address(network.address || '192.168.1.0')
+          xm.mask(network.mask || '24')
+          xm.defaultNetwork(netowork.default_network || true)
+        }
+      }
+      xm.target!
+    end
+
+    def self.all(params = {})
+      items = []
+      if params.empty?
+        doc = Nokogiri.parse(RestClient.get(Api.url + "/cloud/virtualdatacenters", :accept => :xml))
+        doc.search('//virtualDatacenter').each do |node|
+          items << VDC.parse(node.to_s)
+        end
+      else
+        extra = []
+        if params[:enterprise_id]
+          extra << "enterprise=#{params[:enterprise_id]}"
+        end
+        if params[:datacenter_id]
+          extra << "datacenter=#{params[:datacenter_id]}"
+        end
+        doc = Nokogiri.parse(RestClient.get(Api.url + "/cloud/virtualdatacenters?#{extra.join('&')}", :accept => :xml))
+        doc.search('//virtualDatacenter').each do |node|
+          items << VDC.parse(node.to_s)
+        end
+      end
+      items
+    end
+
+    def self.find_by_name(name, options = {})
+      VDC.all(options).find_all { |vdc| vdc.name =~ /#{name}/ }
+    end
+
   end
 
   class Enterprise
@@ -200,6 +592,22 @@ module WeBee
 
     element :id, :as => :resource_id
     element :name
+    element :ramSoft, :as => :ram_soft
+    element :ramHard, :as => :ram_hard
+    element :cpuSoft, :as => :cpu_soft
+    element :cpuHard, :as => :cpu_hard
+    element :storageSoft, :as => :storage_soft
+    element :storageHard, :as => :storage_hard
+    element :repositorySoft, :as => :repository_soft
+    element :repositoryHard, :as => :repository_hard
+    element :publicIpsSoft, :as => :public_ip_soft
+    element :publicIpsHard, :as => :public_ip_hard
+    element :hdSoft, :as => :hd_soft
+    element :hdHard, :as => :hd_hard
+    element :vlanSoft, :as => :vlan_soft
+    element :vlanHard, :as => :vlan_hard
+    element :isReservationRestricted, :as => :is_reservation_restricted
+    
 
     def delete
       RestClient.delete(Api.url + "/admin/enterprises/#{resource_id}")
@@ -209,13 +617,30 @@ module WeBee
     # may raise Exception if recuest is not successful
     #
     def self.create(attributes = {})
-      xml = attributes.to_xml(:root => 'enterprise')
-      res = RestClient.post(Api.url + '/admin/enterprises', xml, :content_type => :xml, :accept => :xml)
+      xm = Builder::XmlMarkup.new
+      xm.enterprise {
+        xm.name attributes[:name]
+        xm.cpuSoft(attributes[:cpu_soft] || "0")
+        xm.cpuHard(attributes[:cpu_hard] || "0")
+        xm.vlanSoft(attributes[:vlan_soft] || "0")
+        xm.vlanHard(attributes[:vlan_hard] || "0")
+        xm.ramSoft(attributes[:ram_soft] || "0")
+        xm.ramHard(attributes[:ram_hard] || "0")
+        xm.repositorySoft(attributes[:repository_soft] || "0")  
+        xm.repositoryHard(attributes[:repository_hard] || "0") 
+        xm.publicIpsSoft(attributes[:public_ip_soft] || "0" ) 
+        xm.publicIpsHard(attributes[:public_ip_hard] || "0" ) 
+        xm.hdSoft(attributes[:hd_soft] || "0")
+        xm.hdHard(attributes[:hd_hard] || "0")
+        xm.storageSoft(attributes[:storage_soft] || "0")
+        xm.storageHard(attributes[:storage_hard] || "0")
+      }
+      res = RestClient.post(Api.url + '/admin/enterprises', xm.target!, :content_type => :xml)
       Enterprise.parse(res)
     end
 
     def self.find_by_name(name, options = {})
-      Enterprise.all(options).find { |e| e.name =~ /#{name}/ }
+      Enterprise.all(options).find_all { |e| e.name =~ /#{name}/ }
     end
 
     def ovf_packages
@@ -231,9 +656,44 @@ module WeBee
       col 
     end
 
-    def create_user(attributes)
-      attributes[:enterprise] = self
-      User.create attributes
+    def create_user(params)
+      params[:enterprise] = self
+      User.create params
+    end
+
+    def create_vdc(params)
+      params[:enterprise] = self
+      VDC.create(params)
+    end
+
+    def set_limits_for_datacenter(dc, params = {})
+      datacenter = dc.datacenter_id
+      xm = Builder::XmlMarkup.new
+      xm.limit {
+        xm.cpuSoft(params[:cpu_soft] || "0")
+        xm.cpuHard(params[:cpu_hard] || "0")
+        xm.vlanSoft(params[:vlan_soft] || "0")
+        xm.vlanHard(params[:vlan_hard] || "0")
+        xm.ramSoft(params[:ram_soft] || "0")
+        xm.ramHard(params[:ram_hard] || "0")
+        xm.repositorySoft(params[:repository_soft] || "0")  
+        xm.repositoryHard(params[:repository_hard] || "0") 
+        xm.publicIpsSoft(params[:public_ip_soft] || "0" ) 
+        xm.publicIpsHard(params[:public_ip_hard] || "0" ) 
+        xm.hdSoft(params[:hd_soft] || "0")
+        xm.hdHard(params[:hd_hard] || "0")
+        xm.storageSoft(params[:storage_soft] || "0")
+        xm.storageHard(params[:storage_hard] || "0")
+      }
+      res = RestClient.post(Api.url + "/admin/enterprises/#{resource_id}/limits?datacenter=#{datacenter}", xm.target!, :content_type => :xml)
+    end
+
+    def vdcs
+      VDC.all(:enterprise_id => resource_id)
+    end
+
+    def enterprise_id
+      resource_id
     end
 
   end
@@ -253,14 +713,14 @@ module WeBee
     #
     # May raise exception if request is not successful
     #
-    def self.create(attributes)
-      if attributes[:role]
-        role = "<link rel='role' href='#{attributes[:role]}'/>"
-        attributes.delete :role
+    def self.create(params)
+      if params[:role]
+        role = "<link rel='role' href='#{params[:role]}'/>"
+        params.delete :role
       end
-      eid = attributes[:enterprise].resource_id
-      attributes.delete :enterprise
-      xml = attributes.to_xml(:root => 'user')
+      eid = params[:enterprise].resource_id
+      params.delete :enterprise
+      xml = params.to_xml(:root => 'user')
       xml = xml.gsub('</user>', "#{role}</user>")
       res = RestClient.post(Api.url + "/admin/enterprises/#{eid}/users", xml, :content_type => :xml, :accept => :xml)
       user = User.parse(res)

data/test/test_appliance_manager.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestWebee < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: webee
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: 
   segments: 
   - 0
-  - 1
-  version: "0.1"
+  - 2
+  version: "0.2"
 platform: ruby
 authors: 
 - Sergio Rubio
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-29 00:00:00 Z
+date: 2011-09-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sax-machine
@@ -95,6 +95,9 @@ files:
 - lib/webee/commands/user.rb
 - test/helper.rb
 - test/test_webee.rb
+- examples/test.rb
+- examples/test2.rb
+- test/test_appliance_manager.rb
 homepage: http://github.com/rubiojr/webee
 licenses: 
 - MIT
@@ -124,9 +127,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: Abiquo API Ruby Implementation
-test_files: []
-
+test_files: 
+- examples/basics.rb
+- examples/test.rb
+- examples/test2.rb
+- test/helper.rb
+- test/test_appliance_manager.rb
+- test/test_webee.rb