openstack_activeresource 0.1.1

data/lib/open_stack/nova/compute/network.rb

@@ -0,0 +1,45 @@
+# This file is part of the OpenStack-ActiveResource
+#
+# Copyright (C) 2012 Unidata S.p.A. (Davide Guerri - d.guerri@unidata.it)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module OpenStack
+  module Nova
+    module Compute
+
+      class Network < Base
+        self.collection_name = "os-networks"
+
+        schema do
+          attribute :bridge, :string
+          attribute :bridge_interface, :string
+          attribute :cidr, :string
+          attribute :label, :string
+          attribute :multi_host, :boolean
+          attribute :vlan, :integer
+          attribute :project_id, :string
+        end
+
+        validates :bridge, :format => {:with => /\A[a-z][a-z0-9]{1,8}\Z/i}
+        validates :bridge_interface, :format => {:with => /\A[a-z]{1,5}[a-z0-9]{1,5}(\.[0-9]{1,4})?\Z/i}
+        validates :cidr, :presence => true
+        validates :label, :presence => true, :format => {:with => /\A[\w\s\d]{1,20}\Z/i}
+        validates :vlan, :presence => true, :numericality => {:greater_than_or_equal_to => 2, :less_than_or_equal_to => 4096}
+
+      end
+
+    end
+  end
+end

data/lib/open_stack/nova/compute/security_group.rb

@@ -0,0 +1,117 @@
+# This file is part of the OpenStack-ActiveResource
+#
+# Copyright (C) 2012 Unidata S.p.A. (Davide Guerri - d.guerri@unidata.it)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module OpenStack
+  module Nova
+    module Compute
+
+      class SecurityGroup < Base
+        self.element_name = "os-security-group"
+        self.collection_name = "os-security-groups"
+
+        schema do
+          attribute :tenant_id, :string
+          attribute :name, :string
+          attribute :description, :string
+        end
+
+        validates :name, :presence => true
+        validates :description, :presence => true
+
+      end
+
+      class SecurityGroup::Rule < Base
+        self.element_name = "os-security-group-rule"
+        self.collection_name = "os-security-group-rules"
+
+        schema do
+          attribute :ip_protocol, :string
+          attribute :from_port, :integer
+          attribute :to_port, :integer
+          attribute :parent_group_id, :string
+          attribute :cidr, :string
+        end
+
+        validates :ip_protocol, :presence => true, :inclusion => {:in => %w(tcp udp icmp)}
+        validates :cidr, :presence => true, :format => {:with => OpenStack::IPV4_CIDR_REGEX}
+        validates :parent_group_id, :presence => true
+        validates :from_port, :presence => true, :numericality => {:only_integer => true}
+        validates :to_port, :presence => true, :numericality => {:only_integer => true}
+
+        validates_numericality_of :from_port, :less_than_or_equal_to => 255, :greater_than_or_equal_to => -1, :if => Proc.new { |rule| rule.icmp? }
+        validates_numericality_of :from_port, :less_than_or_equal_to => 65535, :greater_than_or_equal_to => 1, :if => Proc.new { |rule| rule.udp? or rule.tcp? }
+
+        validates_numericality_of :to_port, :less_than_or_equal_to => 255, :greater_than_or_equal_to => -1, :if => Proc.new { |rule| rule.icmp? }
+        validates_numericality_of :to_port, :less_than_or_equal_to => 65535, :greater_than_or_equal_to => 1, :if => Proc.new { |rule| rule.udp? or rule.tcp? }
+        validates_numericality_of :to_port, :greater_than_or_equal_to => :from_port, :if => Proc.new { |rule| rule.udp? or rule.tcp? }
+
+
+        def initialize(attributes = {}, persisted = false)
+          attributes = attributes.with_indifferent_access
+          new_attributes = {
+              :id => attributes[:id],
+              :ip_protocol => attributes[:ip_protocol],
+              :from_port => attributes[:from_port],
+              :to_port => attributes[:to_port],
+              :cidr => attributes[:cidr] || attributes[:ip_range][:cidr],
+              :parent_group_id => attributes[:parent_group].present? ? attributes[:parent_group].id : nil
+          }
+          super(new_attributes, persisted)
+        end
+
+        # Overload ActiveRecord::encode method
+        # Custom encoding to deal with openstack API
+        def encode(options={})
+          to_encode = {
+              :security_group_rule => {
+                  :ip_protocol => ip_protocol,
+                  :from_port => from_port,
+                  :to_port => to_port,
+                  :cidr => cidr,
+                  :parent_group_id => parent_group_id,
+              }
+          }
+          to_encode.send("to_#{self.class.format.extension}", options)
+        end
+
+        def parent_group=(group)
+          parent_group_id = group.id
+        end
+
+        def parent_group
+          return nil if parent_group_id.nil?
+          SecurityGroup.find(parent_group_id)
+        end
+
+        def icmp?
+          ip_protocol == 'icmp'
+        end
+
+        def udp?
+          ip_protocol == 'udp'
+        end
+
+        def tcp?
+          ip_protocol == 'tcp'
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/open_stack/nova/compute/server.rb

@@ -0,0 +1,313 @@
+# This file is part of the OpenStack-ActiveResource
+#
+# Copyright (C) 2012 Unidata S.p.A. (Davide Guerri - d.guerri@unidata.it)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module OpenStack
+  module Nova
+    module Compute
+
+      class Server < BaseDetail
+
+        schema do
+          attribute :name, :string
+          attribute :status, :string
+          attribute :updated_at, :datetime
+          attribute :created_at, :datetime
+          attribute :vm_state, :string
+          attribute :task, :string
+          attribute :power_state, :integer
+          attribute :host_id, :string
+          attribute :tenant_id, :string
+          attribute :user_id, :string
+          attribute :image_id, :string
+          attribute :flavor_id, :string
+          attribute :key_pair_id, :string
+        end
+
+        validates :name, :format => {:with => /\A[\w\.\-\_]{2,}\Z/}, :length => {:maximum => 255}
+        validates :image, :presence => true
+        validates :flavor, :presence => true
+
+        def self.all_by_tenant(tenant)
+          tenant_id = tenant.is_a?(OpenStack::Keystone::Admin::Tenant) ? tenant.id : tenant
+
+          find(:all, :params => {:tenant_id => tenant_id})
+        end
+
+        def initialize(attributes = {}, persisted = false)
+          attributes = attributes.with_indifferent_access
+          new_attributes = {
+              :id => attributes[:id],
+              :name => attributes[:name],
+              :status => attributes[:status],
+              :updated_at => attributes[:updated].present? ? DateTime.strptime(attributes[:updated], OpenStack::DATETIME_FORMAT) : nil,
+              :created_at => attributes[:created].present? ? DateTime.strptime(attributes[:created], OpenStack::DATETIME_FORMAT) : nil,
+              :vm_state => attributes[:'OS-EXT-STS:vm_state'],
+              :task => attributes[:'OS-EXT-STS:task_state'],
+              :power_state => attributes['OS-EXT-STS:power_state'],
+              :host_id => attributes[:hostId],
+              :user_data => attributes[:user_data],
+              # :tenant_id => attributes[:tenant_id],
+              # :user_id => attributes[:user_id],
+              :addresses => attributes[:addresses] || []
+          }
+
+          if attributes[:key_pair].present?
+            new_attributes[:key_pair_id] = attributes[:key_pair].name
+          else
+            new_attributes[:key_pair_id] = attributes[:key_name]
+          end
+
+          if attributes[:image].present?
+            new_attributes[:image_id] = attributes[:image].is_a?(Image) ? attributes[:image].id : attributes[:image][:id]
+          elsif attributes[:image_id].present?
+            new_attributes[:image_id] = attributes[:image_id]
+          end
+
+          if attributes[:flavor].present?
+            new_attributes[:flavor_id] = attributes[:flavor].is_a?(Flavor) ? attributes[:flavor].id : attributes[:flavor][:id]
+          elsif attributes[:flavor_id].present?
+            new_attributes[:flavor_id] = attributes[:flavor_id]
+          end
+
+          super(new_attributes, persisted)
+
+          @attributes[:security_group_ids] = get_security_group_ids(attributes[:security_groups])
+
+          self
+        end
+
+        # Overload ActiveRecord::encode method
+        # Custom encoding to deal with openstack API
+        def encode(options={})
+          to_encode = {
+              :server => {
+                  :name => name,
+                  :imageRef => image_id,
+                  :flavorRef => flavor_id,
+              }
+          }
+
+          # Optional attributes (openstack will not accept empty attribute for update/create)
+          to_encode[:server][:user_data] = Base64.encode64(user_data) if user_data.present?
+          to_encode[:server][:key_name] = key_pair_id if key_pair_id.present?
+          to_encode[:server][:security_groups] = get_security_groups.map { |sg| {:name => sg.name} } || []
+
+          to_encode.send("to_#{self.class.format.extension}", options)
+        end
+
+        # Accessors
+
+        def image
+          Image.find(image_id) if image_id.present?
+        end
+
+        def image=(image)
+          self.image_id = image.id
+        end
+
+        def flavor
+          Flavor.find(flavor_id) if flavor_id.present?
+        end
+
+        def flavor=(flavor)
+          self.flavor_id = flavor.id
+        end
+
+        def key_pair
+          KeyPair.find(key_pair_id) if key_pair_id.present?
+        end
+
+        def key_pair=(key_pair)
+          self.key_pair_id = key_pair.name
+        end
+
+        def security_groups
+          get_security_groups
+        end
+
+        def security_groups=(security_groups)
+          return if persisted? # Do Nothing (it's a read-only attribute for OpenStack)
+
+          @attributes[:security_group_ids] = get_security_group_ids(security_groups)
+        end
+
+        def addresses
+          addresses = {}
+          if persisted?
+            response = get('ips')
+            response.each { |net, address|
+              addresses[net] = address
+            }
+          else
+            attributes[:addresses]
+          end
+        end
+
+        def addresses=(something)
+          # Do Nothing (it's a read-only attribute for OpenStack)
+        end
+
+        def volume_attachments(scope = :all)
+          VolumeAttachment.find(scope, :params => {:server_id => self.id})
+        end
+
+        # Misc...
+
+        # Return the list of attached volumes
+        def attached_volumes
+          volume_attachments.present? ? volume_attachments.map { |va| va.volume } : []
+        end
+
+        # Attach a volume
+        def attach_volume!(volume, device_name)
+          VolumeAttachment.create(:volume => volume, :device => device_name, :server => self)
+        end
+
+        # Refresh server status
+        def refresh_status!
+          updated = Server.find(self.id)
+          self.progress = updated.progress
+          self.status = updated.status
+          self.task = updated.task
+
+          self
+        end
+
+        SERVER_STATUSES = {
+            :ACTIVE => I18n.t(:active),
+            :BUILD => I18n.t(:builing),
+            :DELETED => I18n.t(:deleted),
+            :ERROR => I18n.t(:in_error),
+            :HARD_REBOOT => I18n.t(:hard_rebooting),
+            :PASSWORD => I18n.t(:resetting_password),
+            :REBOOT => I18n.t(:soft_rebooting),
+            :REBUILD => I18n.t(:rebuilding_from_image),
+            :RESCUE => I18n.t(:in_rescue_mode),
+            :RESIZE => I18n.t(:resizing),
+            :REVERT_RESIZE => I18n.t(:revert_resizing),
+            :SHUTOFF => I18n.t(:user_powered_down),
+            :SUSPENDED => I18n.t(:suspended),
+            :PAUSED => I18n.t(:paused),
+            :UNKNOWN => I18n.t(:unknown),
+            :VERIFY_RESIZE => I18n.t(:awaiting_verification)
+        }.with_indifferent_access
+
+        # Returns an extended description for the server status
+        def status_description
+          SERVER_STATUSES[status]
+        end
+
+        ## Actions
+
+        # Assign a floating IP to the server.
+        # Params:
+        # +floating_ip+:: a FloatingIP to be attached to the server.
+        def add_floating_ip(floating_ip)
+          post(:action, {}, {:addFloatingIp => {:address => floating_ip.ip}}.to_json)
+        end
+
+        # Reboot the server.
+        # Params:
+        # +type+:: type of reboot. Should be 'hard' or 'soft' (defaults to 'hard', may be nil)
+        def reboot(type=:hard)
+          post(:action, {}, {:reboot => {:type => type}}.to_json)
+        end
+
+        # Creates a new snapshot of server.
+        # Params:
+        # +name+:: name of the new snapshot image
+        # +metadata+::  hash of metadata (may be nil)
+        def create_new_image(name, metadata={})
+          post(:action, {}, {:createImage => {:name => name, :metadata => metadata}}.to_json)
+        end
+
+        # Gets the output from the console log for a server.
+        # Params:
+        # +length+:: numbers of lines to get (defaults to 50, may be nil)
+        def console_output(length=50)
+          response = post(:action, {}, {:'os-getConsoleOutput' => {:length => length}}.to_json)
+
+          ActiveSupport::JSON.decode(response.body)['output']
+        end
+
+        # Accesses a VNC console for a specific server.
+        # Params:
+        # +length+:: numbers of lines to get (defaults to 50, may be nil)
+        def vnc_console(type='novnc')
+          response = post(:action, {}, {:'os-getVNCConsole' => {:type => type}}.to_json)
+
+          ActiveSupport::JSON.decode(response.body)['console']['url']
+        end
+
+        # Halts a running server. Changes status to STOPPED.
+        def stop
+          post(:action, {}, {:'os-stop' => nil}.to_json)
+        end
+
+        # Returns a STOPPED server to ACTIVE status.
+        def start
+          post(:action, {}, {:'os-start' => nil}.to_json)
+        end
+
+        # PAUSE a server.
+        def pause
+          post(:action, {}, {:'pause' => nil}.to_json)
+        end
+
+        # Returns a PAUSED server to ACTIVE status.
+        def unpause
+          post(:action, {}, {:'unpause' => nil}.to_json)
+        end
+
+        # Suspend a running server. Changes status to SUSPENDED.
+        def suspend
+          post(:action, {}, {:'suspend' => nil}.to_json)
+        end
+
+        # Resume a SUSPENDED server.
+        def resume
+          post(:action, {}, {:'resume' => nil}.to_json)
+        end
+
+        private
+
+        def get_security_groups
+          security_group_ids.map { |sg_id|
+            SecurityGroup.find sg_id
+          }
+        end
+
+        def get_security_group_ids(security_groups=nil)
+          if security_groups.nil?
+            if persisted?
+
+              get('os-security-groups').map { |security_group| security_group.with_indifferent_access[:id] }
+            else
+
+              []
+            end
+          else
+
+            security_groups.map { |security_group| security_group.id }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/open_stack/nova/compute/simple_tenant_usage.rb

@@ -0,0 +1,128 @@
+# This file is part of the OpenStack-ActiveResource
+#
+# Copyright (C) 2012 Unidata S.p.A. (Davide Guerri - d.guerri@unidata.it)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module OpenStack
+  module Nova
+    module Compute
+
+      class SimpleTenantUsage < Base
+        self.element_name = "os-simple-tenant-usage"
+        self.collection_name = "os-simple-tenant-usage"
+
+        schema do
+          attribute :total_hours, :float
+          attribute :total_vcpus_usage, :float
+          attribute :total_memory_mb_usage, :float
+          attribute :total_local_gb_usage, :float
+          attribute :stop, :datetime
+          attribute :start, :datetime
+        end
+
+        def self.find(*arguments)
+          scope = arguments.slice!(0)
+          options = arguments.slice!(0) || {}
+
+          # Add "detailed => 1" to the query_options because of broken RESTful
+          # (see: http://api.openstack.org @"Simple Usage") - DG - 09/07/2012
+          if options[:params].nil?
+            options[:params] = {:detailed => 1}
+          else
+            options[:params].merge! :detailed => 1
+          end
+
+          # If there is no data for the given date intervals, an empty usage will be returned.
+          # we "filter out" these entries
+          case scope
+            when :all then
+              find_every(options).select { |su| su.attributes[:tenant_id].present? }
+            when :first then
+              su = find_every(options).first
+              su && su.attributes[:tenant_id].present? ? su : nil
+            when :last then
+              su = find_every(options).last
+              su && su.attributes[:tenant_id].present? ? su : nil
+            when :one then
+              su = find_one(options)
+              su && su.attributes[:tenant_id].present? ? su : nil
+            else
+              su = find_single(scope, options)
+              su && su.attributes[:tenant_id].present? ? su : nil
+          end
+        end
+
+        def server_usages
+          @attributes[:server_usages].present? ? @attributes[:server_usages] : []
+        end
+
+        def start
+          DateTime.parse(@attributes[:start] + ' UTC')
+        end
+
+        def stop
+          DateTime.parse(@attributes[:stop] + ' UTC')
+        end
+
+        def self.find_from_date(scope, from_date)
+          now = Time.now.utc
+
+          find(scope, :params => {
+              :start => from_date.utc.strftime(OpenStack::DATETIME_FORMAT),
+              :end => now.strftime(OpenStack::DATETIME_FORMAT)
+          })
+
+        end
+
+        def self.find_between_dates(scope, from_date, to_date)
+          find(scope, :params => {
+              :start => from_date.utc.strftime(OpenStack::DATETIME_FORMAT),
+              :end => to_date.utc.strftime(OpenStack::DATETIME_FORMAT)
+          })
+
+        end
+
+      end
+
+      class ServerUsage < Base
+
+        schema do
+          attribute :name, :string
+          attribute :vcpus, :integer
+          attribute :uptime, :integer
+          attribute :hours, :float
+          attribute :local_gb, :integer
+          attribute :tenant_id, :string
+          attribute :flavor, :string
+          attribute :state, :string
+          attribute :memory_mb, :integer
+          attribute :started_at, :datetime
+          attribute :ended_at, :datetime
+        end
+
+        def started_at
+          DateTime.parse(@attributes[:started_at] + ' UTC')
+        end
+
+        def ended_at
+          return nil if @attributes[:ended_at].blank?
+          DateTime.parse(@attributes[:ended_at] + ' UTC')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/open_stack/nova/compute/volume_attachment.rb

@@ -0,0 +1,98 @@
+# This file is part of the OpenStack-ActiveResource
+#
+# Copyright (C) 2012 Unidata S.p.A. (Davide Guerri - d.guerri@unidata.it)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module OpenStack
+  module Nova
+    module Compute
+
+      class VolumeAttachment < Base
+        self.element_name = "volumeAttachment"
+        self.collection_name = "os-volume_attachments"
+
+        def self.site
+          superclass.site + "servers/:server_id"
+        end
+
+        schema do
+          attribute :device, :string
+          attribute :volume_id, :string
+          attribute :server_id, :string
+        end
+
+        validates :device, :presence => true, :format => {:with => /\A[\/\\a-zA-Z0-9]+\Z/}
+        validates :volume, :presence => true
+        validates :server, :presence => true
+
+        def initialize(attributes = {}, persisted = false)
+          attributes = attributes.with_indifferent_access
+          new_attributes = {
+              :device => attributes[:device],
+          }
+
+          new_attachment = super(new_attributes, persisted)
+
+          if attributes[:volume].present?
+            new_attachment.volume_id = attributes[:volume].id
+          else
+            new_attachment.volume_id = attributes[:volumeId]
+          end
+
+          if attributes[:server].present?
+            new_attachment.server_id = attributes[:server].id
+          else
+            new_attachment.server_id = attributes[:serverId]
+          end
+
+          new_attachment.prefix_options[:server_id] = new_attachment.server_id
+
+          new_attachment
+        end
+
+        # Overload ActiveRecord::encode method
+        # Custom encoding to deal with openstack API
+        def encode(options={})
+          to_encode = {
+              VolumeAttachment.element_name => {
+                  :device => device,
+                  :volumeId => volume_id,
+                  :serverId => server_id
+              }
+          }
+          to_encode.send("to_#{self.class.format.extension}", options)
+        end
+
+        def server
+          Server.find(server_id) if server_id.present?
+        end
+
+        def server=(server)
+          @attributes[:server_id] = server.id unless !persisted?
+        end
+
+        def volume
+          Volume::Volume.find(volume_id) if volume_id.present?
+        end
+
+        def volume=(volume)
+          @attributes[:volume_id] = volume.id unless !persisted?
+        end
+
+      end
+
+    end
+  end
+end