abiquo-api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1304f42a84ccb9a8c9f92e6b8e6b41e9f4a4c509
+  data.tar.gz: 0ebab054e7d0e287045ac821e171c8d2e6cbe969
+SHA512:
+  metadata.gz: 85c7aa06dafb2cf62ca1c6f6312c2134e469919acd2233421ea5446847b2d292a7b8ff1005b3976ab566b54c59bc36f0c0580317e024e54d8910c04a4d7223e0
+  data.tar.gz: 8828b536738f0d636ef4ec1426b4392b4a4682e7452c72b0f2fc2b74246470e41b3908335afeef567c0bc996fd1562287023f70aeba7a907e8b090f5a8dd2a58

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,166 @@
+# Abiquo API client for Ruby
+
+Basic API browsing and raw object manipulation for Ruby.
+
+## Installation
+
+To get the client installed just issue:
+
+```gem install abiquo-api```
+
+Or if you are using a Gemfile, add:
+
+```gem 'abiquo-api'```
+
+An example usage would be:
+
+```ruby
+require 'abiquo-api'
+
+a = AbiquoAPI.new(:abiquo_api_url => 'https://10.60.13.40/api', 
+                  :abiquo_username => "admin", 
+                  :abiquo_password => "xabiquo")
+```
+
+Or, if you want to force a specific API version:
+
+```ruby
+require 'abiquo-api'
+
+a = AbiquoAPI.new(:abiquo_api_url => 'https://10.60.13.40/api', 
+                  :abiquo_username => "admin", 
+                  :abiquo_password => "xabiquo",
+                  :version => "2.9")
+```
+
+Then you can start browsing the API:
+
+```ruby
+l = AbiquoAPI::Link.new(:href => '/api/cloud/virtualdatacenters', 
+              :type => 'application/vnd.abiquo.virtualdatacenters+json')
+
+a.get(l)
+```
+
+## Client object
+
+The client object contains 3 objects that allow API browsing.
+
+- **user.** The user object returned by the ```/api/login``` call.
+- **enterprise.** The user's enterprise link to be used in new objects.
+- **properties.** A hash containing all the system properties in the system. Useful to get default values for some objects (ie. VLAN parameters in VDC creation).
+
+## Link object
+
+Represents an Abiquo API Link. Issuing ```get``` on them will retrieve link destination. This allows for things like:
+
+```ruby
+vapp = vdc.link(:virtualappliances).get.first
+```
+
+## Generic model object
+
+This is used to map Abiquo API objects.
+
+## Examples
+
+### Browse the API
+
+#### Initialize connection
+
+```ruby
+a = AbiquoAPI.new(:abiquo_api_url => 'https://10.60.13.40/api', 
+                     :abiquo_username => "admin", 
+                     :abiquo_password => "xabiquo")
+```
+
+
+#### User object
+
+Is the User object returned by the API at login. You can browse the links provided like:
+
+```ruby
+a.user
+
+vm = a.user.link(:virtualmachines).get.first
+
+vm.name
+=> "ABQ_6b6d9856-c05f-425e-8916-1ff7de1683e3"
+
+vm.id
+=> 18
+```
+
+### Create a VDC using an existing one as reference
+
+#### Initialize connection
+
+```ruby
+a = AbiquoAPI.new(:abiquo_api_url => 'https://10.60.13.40/api', 
+                     :abiquo_username => "admin", 
+                     :abiquo_password => "xabiquo")
+```
+
+#### Create a Link object to issue a request
+
+```ruby
+l = AbiquoAPI::Link.new(:href => '/api/cloud/virtualdatacenters', 
+              :type => 'application/vnd.abiquo.virtualdatacenters+json')
+```
+
+#### Get on the link
+
+```ruby
+v = a.get(l).first
+```
+
+#### Create a new object
+
+```ruby
+v1 = a.new_object(:name => "vdctest", 
+                  :hypervisorType => "VMX_04", 
+                  :vlan => v.vlan, 
+                  :links => [v.link(:location), a.enterprise])
+v1.vlan.delete("links")
+v1.vlan.delete("id")
+v1.vlan.delete("tag")
+```
+
+#### Create a link where to post data
+
+```ruby
+l1 = AbiquoAPI::Link.new(:href => '/api/cloud/virtualdatacenters', 
+              :type => 'application/vnd.abiquo.virtualdatacenter+json')
+```
+
+#### Post data
+
+```ruby
+v2 = a.post(l1, v1)
+```
+
+#### Modify the created object
+
+```ruby
+v2.name = "SomeValue"
+v2 = a.put(v2.edit, v2)
+```
+
+Or:
+
+```ruby
+v2.name = "SomeValue"
+v2.update
+```
+
+#### Delete it
+
+```ruby
+a.delete(v2.edit)
+```
+
+Or:
+
+```ruby
+v2.delete
+```

data/abiquo-api.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'abiquo-api/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "abiquo-api"
+  gem.version       = AbiquoAPIClient::VERSION
+  gem.authors       = ["Marc Cirauqui"]
+  gem.email         = ["marc.cirauqui@abiquo.com"]
+  gem.description   = %q{Simple Abiquo API client}
+  gem.homepage      = "https://github.com/abiquo/api-ruby"
+  gem.summary       = gem.description
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "excon", '~> 0.43', '>= 0.43.0'
+  gem.add_runtime_dependency "formatador", '~> 0.2', '>= 0.2.5'
+  gem.add_runtime_dependency "json", '~> 1.8', '>= 1.8.0'
+end

data/lib/abiquo-api.rb

@@ -0,0 +1,237 @@
+require 'abiquo-api/errors.rb'
+require 'abiquo-api/httpclient.rb'
+require 'abiquo-api/link.rb'
+require 'abiquo-api/model.rb'
+
+##
+# Ruby Abiquo API client main class
+#
+class AbiquoAPI
+  include AbiquoAPIClient
+
+  ##
+  # The {AbiquoAPIClient::HTTPClient} used by
+  # this instance.
+  #
+  attr_reader :http_client
+
+  ##
+  # A hash of the enterprise to which the user
+  # belongs to.
+  #
+  attr_accessor :enterprise
+
+  ##
+  # An instance of {AbiquoAPIClient::LinkModel} representing
+  # the current user.
+  #
+  attr_accessor :user
+
+  ##
+  # The config properties for the UI.
+  #
+  attr_accessor :properties
+
+  ##
+  # The Abiquo API version used by this client.
+  #
+  attr_accessor :version
+
+  ##
+  # Initializes a new AbiquoAPI instance.
+  #
+  # Required options:
+  #
+  #   :abiquo_api_url  => The URL of the Abiquo API. ie. https://yourserver/api
+  #   :abiquo_username => The username used to connect to the Abiquo API.
+  #   :abiquo_password => The password for your user.
+  #   :version         => The Abiquo API version to include in each request.
+  #                       Defaults to whatever is returned in the /api/version resource
+  #
+  def initialize(options = {})
+    api_url = options[:abiquo_api_url]
+    api_username = options[:abiquo_username]
+    api_password = options[:abiquo_password]
+
+    raise "You need to set :abiquo_api_url, :abiquo_username and :abiquo_password" if api_url.nil? or api_username.nil? or api_password.nil?
+
+    @http_client = AbiquoAPIClient::HTTPClient.new(api_url,
+                                                  api_username,
+                                                  api_password)
+    api_path = URI.parse(api_url).path
+
+    loginresp = @http_client.request(
+      :expects  => [200],
+      :method   => 'GET',
+      :path     => "#{api_path}/login",
+      :accept   => 'application/vnd.abiquo.user+json'
+      )
+    @enterprise = AbiquoAPIClient::Link.new(loginresp['links'].select {|l| l['rel'] == 'enterprise'}.first)
+    @user = AbiquoAPIClient::LinkModel.new(loginresp.merge({:client => self}))
+
+    @properties = @http_client.request(
+      :expects  => [200],
+      :method   => 'GET',
+      :path     => "#{api_path}/config/properties",
+      :accept   => 'application/vnd.abiquo.systemproperties+json'
+      )
+
+    if options.has_key? :version
+      @version = options[:version][0..2]
+    else
+      @version = @http_client.request(
+            :expects  => [200],
+            :method   => 'GET',
+            :path     => "#{api_path}/version",
+            :accept   => 'text/plain'
+      ).delete("\n")[0..2]
+    end
+
+    self
+  end
+  
+  ##
+  # Returns a new instance of the {AbiquoAPIClient::LinkModel} class.
+  # 
+  # Parameters:
+  #   A hash of attributes to set in the object.
+  #
+  def new_object(hash)
+    AbiquoAPIClient::LinkModel.new(hash.merge({ :client => self}))
+  end
+
+  ##
+  # Executes an HTTP GET over the {AbiquoAPIClient::Link} passed as parameter.
+  # 
+  # Required parameters:
+  # [link]   An instance 
+  #          of an {AbiquoAPIClient::Link}.
+  #
+  # Optional parameters:
+  # [options]   A hash of key/values that will 
+  #             be sent as query.
+  #
+  # **NOTE:** The option :accept will override Accept header sent in
+  # the request.
+  #
+  # Returns an instance of the {AbiquoAPIClient::LinkModel} class representing
+  # the requested resource.
+  #
+  def get(link, options = {})
+    accept = options[:accept].nil? ? link.type : options.delete(:accept)
+
+    req_hash = {
+      :expects  => [200],
+      :method   => 'GET',
+      :path     => link.href,
+      :query    => options
+    }
+
+    req_hash[:accept] = "#{accept}; version=#{@version};" unless accept.eql? ""
+    
+    resp = @http_client.request(req_hash)
+
+    if resp.is_a? Array
+      tmp_a = []
+      resp.each do |r|
+        tmp_r = AbiquoAPIClient::LinkModel.new(r.merge({:client => self}))
+        tmp_a << tmp_r
+      end
+      tmp_a
+    else
+      AbiquoAPIClient::LinkModel.new(resp.merge({ :client => self}))
+    end
+  end
+
+  ##
+  # Executes an HTTP POST over the {AbiquoAPIClient::Link} passed as parameter.
+  # 
+  # Required parameters:
+  # [link]   An instance of an {AbiquoAPIClient::Link}.
+  # [data]   The data to send in the HTTP request. Usually an instance
+  #          of the {AbiquoAPIClient::LinkModel} instance. Will be 
+  #          serialized to JSON before sending.
+  #
+  # Optional parameters:
+  # [options]   A hash of key/values that will be sent as query.
+  #
+  # **NOTE:** The option :accept and :content options will override Accept 
+  # and Content-Type headers sent in the request.
+  #
+  # Returns an instance of the {AbiquoAPIClient::LinkModel} class representing
+  # the requested resource or nil if the request returned empty.
+  #
+  def post(link, data, options = {})
+    ctype = options[:content].nil? ? link.type : options.delete(:content)
+    accept = options[:accept].nil? ? link.type : options.delete(:accept)
+
+    req_hash = {
+      :method   => 'POST',
+      :path     => link.href,
+      :body     => data.to_json,
+      :query    => options
+    }
+
+    req_hash[:accept] = "#{accept}; version=#{@version};" unless accept.eql? ""
+    req_hash[:content] = "#{ctype}; version=#{@version};" unless ctype.eql? ""
+
+    resp = @http_client.request(req_hash)
+    resp.nil? ? nil : AbiquoAPIClient::LinkModel.new({ :client => self}.merge(resp))
+  end
+
+  ##
+  # Executes an HTTP PUT over the {AbiquoAPIClient::Link} passed as parameter.
+  # 
+  # Required parameters:
+  # [link]     An instance of an {AbiquoAPIClient::Link}.
+  # [data]     The data to send in the HTTP request. Usually an instance
+  #            of the {AbiquoAPIClient::LinkModel} instance. Will be 
+  #            serialized to JSON before sending.
+  #
+  # Optional parameters:
+  # [options]  A hash of key/values that will be sent as query.
+  #
+  # **NOTE:** The option :accept and :content options will override Accept 
+  # and Content-Type headers sent in the request.
+  #
+  # Returns an instance of the {AbiquoAPIClient::LinkModel} class representing
+  # the requested resource or nil if the request returned empty.
+  #
+  def put(link, data, options = {})
+    ctype = options[:content].nil? ? link.type : options.delete(:content)
+    accept = options[:accept].nil? ? link.type : options.delete(:accept)
+
+    req_hash = {
+      :method   => 'PUT',
+      :path     => link.href,
+      :body     => data.to_json,
+      :query    => options
+    }
+
+    req_hash[:accept] = "#{accept}; version=#{@version};" unless accept.eql? ""
+    req_hash[:content] = "#{ctype}; version=#{@version};" unless ctype.eql? ""
+
+    resp = @http_client.request(req_hash)
+    resp.nil? ? nil : AbiquoAPIClient::LinkModel.new({ :client => self}.merge(resp))
+  end
+
+  ##
+  # Executes an HTTP DELETE over the {AbiquoAPIClient::Link} passed as parameter.
+  # 
+  # Required parameters:
+  # [link]     An instance of an {AbiquoAPIClient::Link}.
+  #
+  # Optional parameters:
+  # [options]  A hash of key/values that will be sent as query.
+  #
+  # Returns nil
+  #
+  def delete(link, options = {})
+    @http_client.request(
+      :expects  => [204],
+      :method   => 'DELETE',
+      :path     => link.href
+    )
+    nil
+  end
+end

data/lib/abiquo-api/errors.rb

@@ -0,0 +1,41 @@
+module AbiquoAPIClient
+  ##
+  # Common error exception
+  #
+  class Error < Exception; end
+  
+  ##
+  # InvalidCredentials exception.
+  # Raised whenever the API responds with
+  # a 401 HTTP code.
+  #
+  class InvalidCredentials < AbiquoAPIClient::Error; end
+  
+  ##
+  # Forbidden exception
+  # Raised whenever the API responds with
+  # a 403 HTTP code.
+  #
+  class Forbidden < AbiquoAPIClient::Error; end
+  
+  ##
+  # Badrequest exception
+  # Raised whenever the API responds with
+  # a 400 or 406 HTTP code.
+  #
+  class BadRequest < AbiquoAPIClient::Error; end
+
+  ##
+  # NotFound exception
+  # Raised whenever the API responds with
+  # a 404 HTTP code.
+  #
+  class NotFound < AbiquoAPIClient::Error; end
+  
+  ##
+  # UnsupportedMediaType exception
+  # Raised whenever the API responds with
+  # a 415 HTTP code.
+  #
+  class UnsupportedMediaType < AbiquoAPIClient::Error; end
+end

data/lib/abiquo-api/httpclient.rb

@@ -0,0 +1,165 @@
+require 'excon'
+require 'uri'
+require 'json'
+
+module AbiquoAPIClient
+  ##
+  # HTTPClient class.
+  #
+  # Does the actual HTTP requests to the server.
+  #
+  class HTTPClient
+    ##
+    # Excon connection object.
+    #
+    attr_reader :connection
+
+    ##
+    # Cookies returned by the API. Contains the auth
+    # cookie that will be used after the first call.
+    #
+    attr_reader :cookies
+
+    ##
+    # Constructor. Recieves the parameters to establish
+    # a connection to the Abiquo API.
+    #
+    # Parameters:
+    #   :abiquo_api_url:: The URL of the Abiquo API. ie. https://yourserver/api
+    #   :abiquo_username:: The username used to connect to the Abiquo API.
+    #   :abiquo_password:: The password for your user.
+    #
+    def initialize(api_url, api_username, api_password)
+      Excon.defaults[:ssl_verify_peer] = false
+      @connection = Excon.new(api_url, 
+                            :user => api_username, 
+                            :password => api_password )
+      self
+    end
+
+    ##
+    # The public method called by the client.
+    #
+    # Parameters:
+    # [params]   A hash of options to be passed to the 
+    #            Excon connection.
+    # 
+    # Returns a hash resulting of parsing the response
+    # body as JSON, or nil if the response is "No 
+    # content" (HTTP code 204).
+    #
+    def request(params)
+      # Remove nil params
+      params.reject!{|k,v| v.nil?}
+
+      # Setup Accept and Content-Type headers
+      headers={}
+      headers.merge!('Accept' => params.delete(:accept)) if params.has_key?(:accept)
+      headers.merge!('Content-Type' => params.delete(:content)) if params.has_key?(:content)
+
+      # Set Auth cookie and delete user and password if present
+      @connection.data.delete(:user) unless @connection.data[:user].nil?
+      @connection.data.delete(:password) unless @connection.data[:password].nil?
+      headers.merge!(@cookies) unless @cookies.nil?
+      
+      params[:headers] = headers
+
+      # Correct API path
+      path = URI.parse(params[:path]).path
+      params[:path] = path
+      
+      response = issue_request(params)
+      return nil if response.nil?
+      
+      begin
+        response = JSON.parse(response.body) unless response.body.empty?
+      rescue
+        response = response.body
+      end
+
+      # Handle pagination
+      if not response['links'].nil? and response['links'].select {|l| l['rel'].eql? "next" }.count > 0
+        items = []
+        items = items + response['collection'] if not response['collection'].nil?
+        
+        loop do
+          next_url = response['links'].select {|l| l['rel'].eql? "next" }.first['href']
+          uri = URI.parse(next_url)
+          params[:path] = uri.path
+          params[:query] = uri.query
+          params[:headers] = headers
+          response = issue_request(params)
+          response = JSON.parse(response.body) unless response.body.empty?
+          items = items + response['collection'] if not response['collection'].nil?
+          
+          break if response['links'].select {|l| l['rel'].eql? "next" }.count == 0
+        end
+
+        items
+      else
+        if not response['collection'].nil?
+          response['collection']
+        else
+          response.nil? ? nil : response
+        end
+      end
+    end
+
+    private
+
+    ##
+    # Issues the HTTP request using the Excon connection
+    # object.
+    # 
+    # Handles API error codes.
+    #
+    def issue_request(options)
+      begin
+        resp = @connection.request(options)
+
+        # Save cookies
+        # Get all "Set-Cookie" headers and replace them with "Cookie" header.
+        @cookies = Hash[resp.headers.select{|k| k.eql? "Set-Cookie" }.map {|k,v| ["Cookie", v] }]
+
+        if resp.data[:status] == 204
+          nil
+        else
+          resp
+        end
+      rescue Excon::Errors::HTTPStatusError => error
+        case error.response.status
+        when 401
+          raise AbiquoAPIClient::InvalidCredentials, "Wrong username or password"
+        when 403
+          raise AbiquoAPIClient::Forbidden, "Not Authorized"
+        when 406, 400
+          raise AbiquoAPIClient::BadRequest, "Bad request"
+        when 415
+          raise AbiquoAPIClient::UnsupportedMediaType, "Unsupported mediatype"
+        when 404
+          begin
+            error_response = JSON.parse(error.response.body)
+
+            error_code = error_response['collection'][0]['code']
+            error_text = error_response['collection'][0]['message']
+
+          rescue
+            raise AbiquoAPIClient::NotFound, "Not Found; #{error_code} - #{error_text}"
+          end
+          raise AbiquoAPIClient::NotFound, "Not Found"
+        else
+          begin
+            error_response = JSON.parse(error.response.body)
+
+            error_code = error_response['collection'][0]['code']
+            error_text = error_response['collection'][0]['message']
+
+          rescue
+            raise AbiquoAPIClient::Error, error.response.body
+          end
+          raise AbiquoAPIClient::Error, "#{error_code} - #{error_text}"
+        end
+      end
+    end
+  end
+end

data/lib/abiquo-api/link.rb

@@ -0,0 +1,94 @@
+require 'formatador'
+
+module AbiquoAPIClient
+  ##
+  # Represents a link on the Abiquo API.
+  #
+  class Link
+    ##
+    # The target URL of the link
+    #
+    attr_accessor :href
+    ##
+    # The 'rel' attribute of the link
+    #
+    attr_accessor :rel
+    ##
+    # The title of the link
+    #
+    attr_accessor :title
+    ##
+    # The media type of the link
+    #
+    attr_accessor :type
+
+    ##
+    # Constructor.
+    #
+    # Accepts a hash reprsenting a link, usually returned
+    # after parsing the JSON response.
+    #
+    # If the hash contains :client key, the value will be used
+    # as an {AbiquoAPI} client allowing the get method to retrieve
+    # the target resource.
+    #
+    def initialize(hash)
+      @client = hash.delete(:client) if hash.keys.include?(:client)
+
+      h = Hash[hash.map {|k, v| [k.to_sym, v ] }]
+
+      @href = h[:href].nil? ? '' : h[:href]
+      @rel = h[:rel].nil? ? '' : h[:rel]
+      @title = h[:title].nil? ? '' : h[:title]
+      @type = h[:type].nil? ? '' : h[:type]
+    end
+
+    ##
+    # If the :client attribute is not nil, will retrieve
+    # the resource that this link represents, or nil otherwise
+    #
+    def get
+      if @client.nil?
+        return nil
+      else
+        @client.get(self)
+      end
+    end
+
+    ##
+    # Converts an instance to its hash form, so it can be
+    # serialized as JSON.
+    #
+    def to_hash
+      h = self.href.nil? ? '' : self.href
+      r = self.rel.nil? ? '' : self.rel
+      t = self.title.nil? ? '' : self.title
+      y = self.type.nil? ? '' : self.type
+
+      { 
+        "href"  => h,
+        "type"  => y,
+        "rel"   => r,
+        "title" => t
+      }
+    end
+
+    ##
+    # Pretty print the object.
+    #
+    def inspect
+      Thread.current[:formatador] ||= Formatador.new
+      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}"
+      Thread.current[:formatador].indent do
+        unless self.instance_variables.empty?
+          vars = self.instance_variables.clone
+          vars.delete(:@client)
+          data << " "
+          data << vars.map { |v| "#{v}=#{instance_variable_get(v.to_s).inspect}" }.join(", ")
+        end
+      end
+      data << " >"
+      data
+    end
+  end
+end

data/lib/abiquo-api/model.rb

@@ -0,0 +1,194 @@
+require 'formatador'
+
+module AbiquoAPIClient
+  ##
+  # Represents a resource in the Abiquo API.
+  #
+  class LinkModel
+    ##
+    # Constructor
+    #
+    # Accepts a hash of key values representing the resource, plus
+    # an instance of the AbiquoAPI class to be used to execute
+    # the HTTP requests, specified as the :client attribute.
+    #
+    def initialize(attrs={})
+      raise "Needs a connection!" if attrs[:client].nil? 
+      @client = attrs.delete(:client)
+
+      attributes = Hash[attrs.clone.map {|k, v| [k.to_s, v ] }]
+      
+      if not attributes['links'].nil?
+        links = []
+
+        attributes['links'].each do |link|
+          link = link.to_hash if link.is_a? AbiquoAPIClient::Link
+          new_lnk = {}
+
+          if 'edit'.eql?(link['rel']) or 'self'.eql?(link['rel'])
+            # Create a URL string attribute
+            rel = 'url'
+            create_attr(rel, true)
+            instance_variable_set("@#{rel}", link['href'])
+          end
+
+          # Create new getters and setters
+          # Also sets value to a Link object
+          rel = "#{link['rel'].gsub(/\//, '_')}"
+          new_lnk[rel.to_sym] = Link.new(link.merge({:client => @client}))
+          links << new_lnk
+          
+          # For every link that points to an ID
+          # create a getter
+          if link['href'].split('/').last.is_a? Integer
+            idrel = "#{link['rel'].gsub(/\//, '_')}_id"
+            create_attr(idrel, true)
+            instance_variable_set("@#{idrel}", link['href'].split('/').last.to_i)
+          end
+        end
+        attributes.delete('links')
+
+        create_attr("links")
+        instance_variable_set("@links", links)
+        
+        # Now create getters and setters for every method
+        attributes.keys.each do |k|
+          create_attr(k)
+          instance_variable_set("@#{k}", attributes[k])
+        end
+      end
+    end
+
+    ##
+    # Serializes the object into a valid JSON for the Abiquo API.
+    #
+    def to_json
+      att = self.instance_variables.map {|v| v.to_s }
+      links = []
+      data = {}
+
+      att.delete("@url")
+      att.delete("@client")
+
+      self.links.each do |l|
+        links << l.values.first.to_hash
+      end
+      att.delete("@links")
+
+      att.each do |opt|
+        data[opt.delete("@")] = instance_variable_get(opt)
+      end
+      data['links'] = links
+      data.to_json
+    end
+
+    ##
+    # Pretty print an instance object.
+    #
+    def inspect
+      Thread.current[:formatador] ||= Formatador.new
+      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}"
+      Thread.current[:formatador].indent do
+        unless self.instance_variables.empty?
+          vars = self.instance_variables.clone
+          vars.delete(:@client)
+          data << "\n"
+          data << vars.map { |v| "#{v}=#{instance_variable_get(v.to_s).inspect}" }.join(",\n#{Thread.current[:formatador].indentation}")
+        end
+      end
+      data << "\n#{Thread.current[:formatador].indentation}>"
+      data
+    end
+
+    ##
+    # Retrieves the link that has the 'rel' attribute specified
+    # as parameter.
+    #
+    # Parameters:
+    # [link_rel]  The 'rel' value to look for, symbolized.
+    #
+    # Returns the first link found with the 'rel' attribute 
+    # specified or nil if not found.
+    #
+    def link(link_rel)
+      self.links.select {|l| l[link_rel] }.first[link_rel]
+    end
+
+    ##
+    # Checks if the object has a link with the 'rel' attribute
+    # specified as parameter.
+    #
+    # Parameters:
+    # [link_rel]  The 'rel' value to look for, symbolized.
+    #
+    # Returns the true if the object has a link with the 
+    # specified 'rel' or false otherwhise.
+    #
+    def has_link?(link_rel)
+      c = self.links.select {|l| l[link_rel] }.count
+      c == 0 ? false : true
+    end
+
+    ##
+    # Executes an HTTP PUT over the resource in Abiquo API,
+    # sending the current attributes as data.
+    #
+    # Returns a new instance representing the updated resource.
+    #
+    def update
+      @client.put(self.link(:edit), self)
+    end
+
+    ##
+    # Executes an HTTP DELETE over the resource in Abiquo API,
+    # deleting the current resource.
+    #
+    # Returns nil on success.
+    #
+    def delete
+      @client.delete(self.link(:edit))
+    end
+
+    ##
+    # Executes an HTTP GET over the resource in Abiquo API.
+    #
+    # Returns a new instance representing resource.
+    #
+    def refresh
+      self.link(:edit).get
+    end
+
+    private
+
+    ##
+    # Creates a new method in the instance object.
+    #
+    # Parameters:
+    # [name]    The name of the method to be created.
+    # [&block]  The block of code for that method.
+    #
+    def create_method( name, &block )
+      self.class.send( :define_method, name, &block )
+    end
+
+    ##
+    # Creates a new attribute for the instance object.
+    #
+    # Parameters:
+    # [name]  The name of the attribute to be created.
+    # [ro]    Boolean that specifies if the attribute will
+    #         read only or read write. Defaults to false (rw)
+    #
+    def create_attr( name , ro = false)
+      unless ro
+        create_method( "#{name}=".to_sym ) { |val| 
+          instance_variable_set( "@" + name, val)
+        }
+      end
+
+      create_method( name.to_sym ) { 
+        instance_variable_get( "@" + name )
+      }
+    end
+  end
+end

data/lib/abiquo-api/version.rb

@@ -0,0 +1,3 @@
+module AbiquoAPIClient
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: abiquo-api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marc Cirauqui
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.43'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.43.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.43'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.43.0
+- !ruby/object:Gem::Dependency
+  name: formatador
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+description: Simple Abiquo API client
+email:
+- marc.cirauqui@abiquo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- abiquo-api.gemspec
+- lib/abiquo-api.rb
+- lib/abiquo-api/errors.rb
+- lib/abiquo-api/httpclient.rb
+- lib/abiquo-api/link.rb
+- lib/abiquo-api/model.rb
+- lib/abiquo-api/version.rb
+homepage: https://github.com/abiquo/api-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple Abiquo API client
+test_files: []
+has_rdoc: