lorj 1.0.3 → 1.0.4

data/lib/prc_section_config.rb

@@ -18,45 +18,73 @@ require 'rubygems'
 require 'yaml'
 
 module PRC
-  # SectionConfig class layer
+  # SectionConfig class layer based on BaseConfig.
+  #
+  # It supports a data_options :section for #[], #[]=, etc...
+  #
   class SectionConfig < PRC::BaseConfig
     # Get the value of a specific key under a section.
+    # You have to call #data_options(:section => 'MySection')
     #
     # * *Args*    :
     #   - +keys+  : keys to get values from a section set by data_options.
-    #               If section is set, it will use :default
+    #     If section is not set, it will use :default
     # * *Returns* :
     #   - key value.
     # * *Raises* :
     #   Nothing
     def [](*keys)
       return nil if keys.length == 0
-      return _get(:default, *keys) if @data_options[:section].nil?
-      _get(@data_options[:section], *keys)
+      return p_get(:default, *keys) if @data_options[:section].nil?
+      p_get(@data_options[:section], *keys)
     end
 
+    # Set the value of a specific key under a section.
+    # You have to call #data_options(:section => 'MySection')
+    #
+    # * *Args*    :
+    #   - +keys+  : keys to get values from a section set by data_options.
+    #     If section is not set, it will use :default
+    # * *Returns* :
+    #   - key value.
+    # * *Raises* :
+    #   Nothing
     def []=(*keys, value)
       return nil if keys.length == 0
-      return _set(:default, *keys, value) if @data_options[:section].nil?
-      _set(@data_options[:section], *keys, value)
+      return p_set(:default, *keys, value) if @data_options[:section].nil?
+      p_set(@data_options[:section], *keys, value)
     end
 
+    # Check key existence under a section.
+    # You have to call #data_options(:section => 'MySection')
+    #
+    # * *Args*    :
+    #   - +keys+  : keys to get values from a section set by data_options.
+    #     If section is not set, it will use :default
+    # * *Returns* :
+    #   - key value.
+    # * *Raises* :
+    #   Nothing
     def exist?(*keys)
       return nil if keys.length == 0
-      return _exist?(:default, *keys) if @data_options[:section].nil?
-      _exist?(@data_options[:section], *keys)
-    end
-
-    def where?(*keys)
-      return nil if keys.length == 0
-      return _exist?(:default, *keys) if @data_options[:section].nil?
-      _where?(@data_options[:section], *keys)
+      return p_exist?(:default, *keys) if @data_options[:section].nil?
+      p_exist?(@data_options[:section], *keys)
     end
 
+    # remove the key under a section.
+    # You have to call #data_options(:section => 'MySection')
+    #
+    # * *Args*    :
+    #   - +keys+  : keys to get values from a section set by data_options.
+    #     If section is not set, it will use :default
+    # * *Returns* :
+    #   - key value.
+    # * *Raises* :
+    #   Nothing
     def del(*keys)
       return nil if keys.length == 0
-      return _del(:default, *keys) if @data_options[:section].nil?
-      _del(@data_options[:section], *keys)
+      return p_del(:default, *keys) if @data_options[:section].nil?
+      p_del(@data_options[:section], *keys)
     end
   end
 end

data/lib/providers/hpcloud/hpcloud.rb

@@ -61,7 +61,7 @@ class Hpcloud
   # If the query is not push through and Hash object, the Provider
   # will needs to create his own mapping function.
   define_obj :network
-  query_mapping :external, :router_external
+  def_attr_mapping :external, :router_external
 
   define_obj :rule
   obj_needs :data, :dir,        :mapping => :direction

data/lib/providers/openstack/openstack.rb

@@ -16,30 +16,287 @@
 
 # This class describes how to process some actions, and will do everything prior
 # this task to make it to work.
-class Openstack < BaseDefinition
-  def initialize
-    superclass.provides([:compute, :network])
+require 'fog'
+require 'uri'
+
+hpcloud_path = File.expand_path(File.dirname(__FILE__))
+
+require File.join(hpcloud_path, 'openstack_query.rb')
+require File.join(hpcloud_path, 'openstack_get.rb')
+require File.join(hpcloud_path, 'openstack_delete.rb')
+require File.join(hpcloud_path, 'openstack_create.rb')
+require File.join(hpcloud_path, 'openstack_update.rb')
+
+# Defines Meta Openstack object
+class Openstack
+  process_default :use_controller => true
+
+  define_obj :services
+  # Define Data used by service
+
+  obj_needs :data, :account_id,  :mapping => :openstack_username
+  obj_needs :data, :account_key, :mapping => :openstack_api_key
+  obj_needs :data, :auth_uri,    :mapping => :openstack_auth_uri
+  obj_needs :data, :tenant,      :mapping => :openstack_tenant
+  obj_needs :data, ':excon_opts/:connect_timeout', :default_value => 30
+  obj_needs :data, ':excon_opts/:read_timeout',    :default_value => 240
+  obj_needs :data, ':excon_opts/:write_timeout',   :default_value => 240
+
+  define_obj :compute_connection
+  # Defines Data used by compute.
+
+  obj_needs :data, :account_id,  :mapping => :openstack_username
+  obj_needs :data, :account_key, :mapping => :openstack_api_key,
+                                 :decrypt => true
+  obj_needs :data, :auth_uri,    :mapping => :openstack_auth_url
+  obj_needs :data, :tenant,      :mapping => :openstack_tenant
+  obj_needs :data, :compute,     :mapping => :openstack_region
+
+  define_obj :network_connection
+  obj_needs :data, :account_id,  :mapping => :openstack_username
+  obj_needs :data, :account_key, :mapping => :openstack_api_key,
+                                 :decrypt => true
+  obj_needs :data, :auth_uri,    :mapping => :openstack_auth_url
+  obj_needs :data, :tenant,      :mapping => :openstack_tenant
+  obj_needs :data, :network,     :mapping => :openstack_region
+
+  # Openstack tenants object
+  define_obj(:tenants, :create_e => :openstack_get_tenant)
+  obj_needs :CloudObject, :compute_connection
+  obj_needs :data, :tenant
+
+  # Openstack Network
+  define_obj :network
+  def_hdata :network_name, :mapping => :name
+  def_attr_mapping :external, :router_external
+
+  define_obj :keypairs
+
+  undefine_attribute :id    # Do not return any predefined ID
+
+  define_obj :server_log
+
+  # Excon::Response object type
+  def_attr_mapping :output, 'output'
+
+  define_obj :security_groups
+  # Added tenant data to add in queries.
+  obj_needs :CloudObject, :tenants
+
+  define_obj :rule
+  obj_needs :data, :dir,        :mapping => :direction
+  attr_value_mapping :IN,  'ingress'
+  attr_value_mapping :OUT, 'egress'
+
+  obj_needs :data, :proto,      :mapping => :protocol
+  obj_needs :data, :port_min,   :mapping => :port_range_min
+  obj_needs :data, :port_max,   :mapping => :port_range_max
+  obj_needs :data, :addr_map,   :mapping => :remote_ip_prefix
+  obj_needs :data, :sg_id,      :mapping => :security_group_id
+
+  def_attr_mapping :dir,      :direction
+  def_attr_mapping :proto,    :protocol
+  def_attr_mapping :port_min, :port_range_min
+  def_attr_mapping :port_max, :port_range_max
+  def_attr_mapping :addr_map, :remote_ip_prefix
+  def_attr_mapping :sg_id,    :security_group_id
+
+  define_data(:account_id,
+              :account => true,
+              :desc => 'Openstack Username',
+              :validate => /^.+/
+  )
+
+  define_data(:account_key,
+              :account => true,
+              :desc => 'Openstack Password',
+              :validate => /^.+/
+  )
+  define_data(:auth_uri,
+              :account => true,
+              :explanation => "The authentication service is identified as '"\
+                "identity' under your horizon UI - Project/Compute then "\
+                'Access & security.',
+              :desc => 'Openstack Authentication service URL. '\
+                'Ex: https://mycloud:5000/v2.0/tokens',
+              :validate => %r{^http(s)?:\/\/.*\/tokens$}
+  )
+  define_data(:tenant,
+              :account => true,
+              :explanation => 'The Project name is shown from your horizon UI'\
+                ', on top left, close to the logo',
+              :desc => 'Openstack Tenant Name',
+              :validate => /^.+/
+  )
+
+  define_data(:compute,
+              :account => true,
+              :explanation => 'Depending on your installation, you may need to'\
+                ' provide a Region name. This information shown under your '\
+                'horizon UI - close right to the project name (top left).'\
+                "\nIf there is no region shown, you can ignore it.",
+              :desc => 'Openstack Compute Region (Ex: regionOne)'
+  )
+
+  define_data(:network,
+              :account => true,
+              :desc => 'Openstack Network Region (Ex: regionOne)',
+              :explanation => 'Depending on your installation, you may need to'\
+                ' provide a Region name. This information shown under your '\
+                'horizon UI - close right to the project name (top left).'\
+                "\nIf there is no region shown, you can ignore it."
+  )
+
+  define_obj :server
+  def_attr_mapping :status, :state
+  attr_value_mapping :create, 'BUILD'
+  attr_value_mapping :boot,   :boot
+  attr_value_mapping :active, 'ACTIVE'
+  attr_value_mapping :active, 'ACTIVE'
+
+  def_attr_mapping :private_ip_address, :accessIPv4
+  def_attr_mapping :public_ip_address, :accessIPv4
+  def_attr_mapping :image_id, [:image, 'id']
+
+  define_obj :router
+  obj_needs_optional
+  obj_needs :data, :router_name, :mapping => :name
+
+  # The FORJ gateway_network_id is extracted
+  # from Fog::HP::Network::Router[:external_gateway_info][:network_id]
+
+  obj_needs :data,
+            :external_gateway_id,
+            :mapping => [:external_gateway_info, 'network_id']
+
+  def_attr_mapping :gateway_network_id, [:external_gateway_info, 'network_id']
+
+  # Port attributes used specifically by openstack fog API.
+  define_obj :port
+  def_attribute :device_owner
+  def_attribute :network_id
+
+  define_obj :public_ip
+  def_attr_mapping :server_id, :instance_id
+  def_attr_mapping :public_ip, :ip
+
+  define_obj :image
+  def_attr_mapping :image_name, :name
+end
+
+# Following class describe how FORJ should handle Openstack Cloud objects.
+class OpenstackController
+  def self.def_cruds(*crud_types)
+    crud_types.each do |crud_type|
+      case crud_type
+      when :create, :delete
+        base_method(crud_type)
+      when :query, :get
+        query_method(crud_type)
+      when :update
+        update_method(crud_type)
+      end
+    end
+  end
+
+  def self.update_method(crud_type)
+    define_method(crud_type) do |sObjectType, obj, hParams|
+      method_name = "#{crud_type}_#{sObjectType}"
+      if self.class.method_defined? method_name
+        send(method_name, obj, hParams)
+      else
+        controller_error "'%s' is not a valid object for '%s'",
+                         sObjectType, crud_type
+      end
+    end
   end
 
-  def compute
-    Fog::Compute.new(
-      :provider => :openstack,
-      :openstack_api_key => superclass.oForjAccount.get(:account_id),
-      :openstack_username => superclass.oForjAccount.get(:account_key),
-      :openstack_auth_url => superclass.oForjAccount.get(:auth_uri),
-      :openstack_tenant => superclass.oForjAccount.get(:tenant_id),
-      :openstack_region => superclass.oForjAccount.get(:compute)
-       )
+  def self.query_method(crud_type)
+    define_method(crud_type) do |sObjectType, sCondition, hParams|
+      method_name = "#{crud_type}_#{sObjectType}"
+      if self.class.method_defined? method_name
+        send(method_name, hParams, sCondition)
+      else
+        controller_error "'%s' is not a valid object for '%s'",
+                         sObjectType, crud_type
+      end
+    end
   end
 
-  def network
-    Fog::Network.new(
-      :provider => :openstack,
-      :openstack_api_key => superclass.oForjAccount.get(:account_id),
-      :openstack_username => superclass.oForjAccount.get(:account_key),
-      :openstack_auth_url => superclass.oForjAccount.get(:auth_uri),
-      :openstack_tenant => superclass.oForjAccount.get(:tenant_id),
-      :openstack_region => superclass.oForjAccount.get(:network)
-       )
+  def self.base_method(crud_type)
+    define_method(crud_type) do |sObjectType, hParams|
+      method_name = "#{crud_type}_#{sObjectType}"
+      if self.class.method_defined? method_name
+        send(method_name, hParams)
+      else
+        controller_error "'%s' is not a valid object for '%s'",
+                         sObjectType, crud_type
+      end
+    end
+  end
+
+  # Define the Openstack controller handlers
+  def_cruds :create, :delete, :get, :query, :update
+
+  def connect(sObjectType, hParams)
+    case sObjectType
+    when :services
+      # Fog use URI type for auth uri: URI.parse(:auth_uri)
+      # Convert openstack_auth_uri to type URI
+      hParams[:hdata][:openstack_auth_uri] =
+          URI.parse(hParams[:hdata][:openstack_auth_uri])
+      retrieve_result =
+          Fog::OpenStack.retrieve_tokens_v2(hParams[:hdata],
+                                            hParams[:excon_opts])
+      creds = format_retrieve_result(retrieve_result)
+      return creds
+    when :compute_connection
+      Fog::Compute.new(
+        hParams[:hdata].merge(:provider => :openstack)
+      )
+    when :network_connection
+      Fog::Network::OpenStack.new(hParams[:hdata])
+    else
+      controller_error "'%s' is not a valid object for 'connect'", sObjectType
+    end
+  end
+
+  def set_attr(oControlerObject, key, value)
+    if oControlerObject.is_a?(Excon::Response)
+      controller_error "No set feature for '%s'", oControlerObject.class
+    end
+
+    attributes = oControlerObject.attributes
+
+    controller_error "attribute '%s' is unknown in '%s'. Valid one are : '%s'",
+                     key[0],
+                     oControlerObject.class,
+                     oControlerObject.class.attributes unless
+                     oControlerObject.class.attributes.include?(key[0])
+
+    attributes.rh_set(value, key)
+  rescue => e
+    controller_error "Unable to map '%s' on '%s'. %s",
+                     key, oControlerObject, e.message
+  end
+
+  def get_attr(oControlerObject, key)
+    if oControlerObject.is_a?(Excon::Response)
+      oControlerObject.data.rh_get(:body, key)
+    else
+      attributes = oControlerObject.attributes
+      controller_error "attribute '%s' is unknown in '%s'."\
+                       " Valid one are : '%s'",
+                       key[0],
+                       oControlerObject.class,
+                       oControlerObject.class.attributes unless
+                       oControlerObject.class.attributes.include?(key[0])
+
+      return attributes.rh_get(key) if attributes.rh_exist?(key)
+      return oControlerObject.send(key[0]) if key.length == 1
+      oControlerObject.send(key[0]).rh_get(key[1..-1])
+    end
+  rescue => e
+    controller_error "==>Unable to map '%s'. %s", key, e.message
   end
 end

data/lib/providers/openstack/openstack_create.rb

@@ -0,0 +1,205 @@
+# encoding: UTF-8
+
+# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# Defined Openstack object create.
+class OpenstackController
+  def create_security_groups(hParams)
+    required?(hParams, :network_connection)
+    required?(hParams, :tenants)
+    required?(hParams, :security_group)
+
+    service = hParams[:network_connection]
+
+    service.security_groups.create(:name => hParams[:security_group],
+                                   :tenant_id => hParams[:tenants].id)
+  end
+
+  def create_network(hParams)
+    required?(hParams, :network_connection)
+    required?(hParams, :network_name)
+
+    hParams[:network_connection].networks.create(hParams[:hdata])
+  end
+
+  def create_subnetwork(hParams)
+    required?(hParams, :network_connection)
+    required?(hParams, :network)
+
+    netconn = hParams[:network_connection]
+    netconn.subnets.create(
+      :network_id => hParams[:network].id,
+      :name => hParams[:subnetwork_name],
+      :cidr => get_next_subnet(netconn),
+      :ip_version => '4'
+    )
+  end
+
+  def create_rule(hParams)
+    required?(hParams, :network_connection)
+    required?(hParams, :security_groups)
+    hParams[:network_connection].security_group_rules.create(hParams[:hdata])
+  end
+
+  def create_router(hParams)
+    required?(hParams, :network_connection)
+    required?(hParams, :router_name)
+
+    # Forcelly used admin_status_up to true. Coming from HPCloud.
+    # But not sure if we need it or not.
+    #  hParams[:hdata] = hParams[:hdata].merge(:admin_state_up => true)
+
+    hParams[:network_connection].routers.create(hParams[:hdata])
+  end
+
+  def create_router_interface(hParams)
+    required?(hParams, :network_connection)
+    required?(hParams, :router)
+    required?(hParams, :subnetwork)
+
+    service = hParams[:network_connection]
+    router = hParams[:router]
+    result = service.add_router_interface(router.id, hParams[:subnetwork].id)
+    fail if result.status != 200
+    result
+  end
+
+  def create_keypairs(hParams)
+    required?(hParams, :compute_connection)
+    required?(hParams, :keypair_name)
+    required?(hParams, :public_key)
+
+    # API:
+    # https://github.com/fog/fog/blob/master/lib/fog/openstack/docs/compute.md
+    service = hParams[:compute_connection]
+    service.key_pairs.create(:name => hParams[:keypair_name],
+                             :public_key => hParams[:public_key])
+  end
+
+  def create_server(hParams)
+    [:compute_connection, :image,
+     :network, :flavor, :keypairs,
+     :security_groups, :server_name].each do |required_param|
+      required?(hParams, required_param)
+    end
+
+    options = {
+      :name             => hParams[:server_name],
+      :flavor_ref       => hParams[:flavor].id,
+      :image_ref        => hParams[:image].id,
+      :key_name         => hParams[:keypairs].name,
+      :security_groups  => [hParams[:security_groups].name],
+      :nics             => [{ :net_id => hParams[:network].id }]
+    }
+
+    if hParams[:user_data]
+      options[:user_data_encoded] =
+        Base64.strict_encode64(hParams[:user_data])
+    end
+    options[:metadata] = hParams[:meta_data] if hParams[:meta_data]
+
+    compute_connect = hParams[:compute_connection]
+
+    server = compute_connect.servers.create(options)
+    compute_connect.servers.get(server.id) if server
+  end
+
+  def create_public_ip(hParams)
+    required?(hParams, :compute_connection)
+    required?(hParams, :server)
+
+    compute_connect = hParams[:compute_connection]
+    server = hParams[:server]
+
+    while server.state != 'ACTIVE'
+      sleep(5)
+      server = compute_connect.servers.get(server.id)
+    end
+
+    addresses = compute_connect.addresses.all
+    address = nil
+    # Search for an available IP
+    addresses.each do |elem|
+      if elem.fixed_ip.nil?
+        address = elem
+        break
+      end
+    end
+
+    address = allocate_new_ip(compute_connect) if address.nil?
+    if address.nil?
+      controller_error("No Public IP to assign to server '%s'", server.name)
+    end
+
+    address.server = server # associate the server
+    address.reload
+    # This function needs to returns a list of object.
+    # This list must support the each function.
+    address
+  end
+
+  def allocate_new_ip(compute_connect)
+    # Create a new public IP to add in the pool.
+    pools = compute_connect.addresses.get_address_pools
+    controller_error('No IP Pool found') if pools.length == 0
+    # TODO: Be able to support choice of pool at setup time.
+    if pools.length > 1
+      Lorj.warning('Several pools found. Selecting the first one.')
+    end
+    compute_connect.addresses.create 'pool' => pools[0]['name']
+  end
+
+  def get_next_subnet(oNetworkConnect)
+    subnet_values = []
+    subnets = oNetworkConnect.subnets.all
+
+    subnets.each do|s|
+      subnet_values.push(s.cidr)
+    end
+
+    gap = false
+    count = 0
+    range_used = []
+    new_subnet = 0
+    new_cidr = ''
+
+    subnet_values = subnet_values.sort!
+
+    subnet_values.each do|value|
+      range_used.push(value[5])
+    end
+
+    range_used.each do |n|
+      if count.to_i == n.to_i
+      else
+      new_subnet = count
+      gap = true
+      break
+      end
+      count += 1
+    end
+
+    if gap
+      new_cidr = format('10.0.%s.0/24', count)
+    else
+      max_value = range_used.max
+      new_subnet = max_value.to_i + 1
+      new_cidr  = format('10.0.%s.0/24', new_subnet)
+    end
+    new_cidr
+  rescue => e
+    Logging.error("%s\n%s", e.message, e.backtrace.join("\n"))
+  end
+end

data/lib/providers/openstack/openstack_delete.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# Defined Openstack object delete.
+class OpenstackController
+  def delete_server(hParams)
+    required?(hParams, :compute_connection)
+    required?(hParams, :server)
+
+    compute_connect = hParams[:compute_connection]
+    server = hParams[:server]
+
+    compute_connect.servers.get(server.id).destroy
+  end
+end

data/lib/providers/openstack/openstack_get.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# Defined Openstack object get.
+class OpenstackController
+  def self.def_get(connection, name, property_name = nil)
+    property_name = property_name.nil? ? "#{name}s" : property_name.to_s
+    define_method("get_#{name}") do |hParams, sUniqId|
+      required?(hParams, connection)
+      hParams[connection].send(property_name).get(sUniqId)
+    end
+  end
+
+  def_get :compute_connection, :server
+
+  def_get :compute_connection, :image
+
+  def_get :network_connection, :network
+
+  def_get :compute_connection, :keypairs, :key_pairs
+
+  def get_server_log(hParams, sUniqId)
+    required?(hParams, :server)
+    hParams[:server].console(sUniqId)
+  end
+end