lorj 0.2.0 → 1.0.0

data/lib/providers/hpcloud/hpcloud.rb

@@ -0,0 +1,462 @@
+# 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.
+
+# This class describes how to process some actions, and will do everything prior
+# this task to make it to work.
+
+require 'fog' # We use fog to access HPCloud
+
+hpcloud_path = File.expand_path(File.dirname(__FILE__))
+
+require File.join(hpcloud_path, 'compute.rb')
+require File.join(hpcloud_path, 'network.rb')
+require File.join(hpcloud_path, 'security_groups.rb')
+
+# Defines Meta HPCloud object
+class Hpcloud
+  define_obj :services
+  obj_needs :data, :account_id,      :mapping => :hp_access_key
+  obj_needs :data, :account_key,     :mapping => :hp_secret_key
+  obj_needs :data, :auth_uri,        :mapping => :hp_auth_uri
+  obj_needs :data, :tenant,          :mapping => :hp_tenant_id
+  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
+
+  # Defines Object structure and function stored on the Hpcloud class object.
+  # Compute Object
+  define_obj :compute_connection
+  # Defines Data used by compute.
+
+  obj_needs :data, :account_id,  :mapping => :hp_access_key
+  obj_needs :data, :account_key, :mapping => :hp_secret_key
+  obj_needs :data, :auth_uri,    :mapping => :hp_auth_uri
+  obj_needs :data, :tenant,      :mapping => :hp_tenant_id
+  obj_needs :data, :compute,     :mapping => :hp_avl_zone
+
+  define_obj :network_connection
+  obj_needs :data, :account_id,  :mapping => :hp_access_key
+  obj_needs :data, :account_key, :mapping => :hp_secret_key
+  obj_needs :data, :auth_uri,    :mapping => :hp_auth_uri
+  obj_needs :data, :tenant,      :mapping => :hp_tenant_id
+  obj_needs :data, :network,     :mapping => :hp_avl_zone
+
+  # Forj predefine following query mapping, used by ForjProcess
+  # id => id, name => name
+  # If we need to add another mapping, add
+  # query_mapping :id => :MyID
+  # 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
+
+  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
+
+  get_attr_mapping :dir,      :direction
+  get_attr_mapping :proto,    :protocol
+  get_attr_mapping :port_min, :port_range_min
+  get_attr_mapping :port_max, :port_range_max
+  get_attr_mapping :addr_map, :remote_ip_prefix
+  get_attr_mapping :sg_id,    :security_group_id
+
+  define_obj :keypairs
+
+  undefine_attribute :id    # Do not return any predefined ID
+
+  # ************************************ Router Object
+  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']
+
+  get_attr_mapping :gateway_network_id, [:external_gateway_info, 'network_id']
+
+  # ************************************ SERVER Object
+  define_obj :server
+  get_attr_mapping :status, :state
+  attr_value_mapping :create, 'BUILD'
+  attr_value_mapping :boot,   :boot
+  attr_value_mapping :active, 'ACTIVE'
+
+  # ************************************ SERVER log Object
+  define_obj :server_log
+
+  # Excon::Response object type
+  get_attr_mapping :output,  'output'
+
+  # ************************************* Public IP Object
+  define_obj :public_ip
+  get_attr_mapping :server_id, :instance_id
+  get_attr_mapping :public_ip, :ip
+
+  # defines setup Cloud data (:account => true for setup)
+  define_data(:account_id,
+              :account => true,
+              :desc => 'HPCloud Access Key (From horizon, user drop down, '\
+                       'manage keys)',
+              :validate => /^[A-Z0-9]*$/
+  )
+  define_data(:account_key,
+              :account => true,
+              :desc => 'HPCloud secret Key (From horizon, user drop down, '\
+                       'manage keys)',
+              :encrypted => false,
+              :validate => /^.+/
+  )
+  define_data(:auth_uri,
+              :account => true,
+              :desc => 'HPCloud Authentication service URL (default is HP '\
+                       'Public cloud)',
+              :validate => %r{^http(s)?://.*$},
+              :default_value => 'https://region-a.geo-1.identity.hpcloudsvc'\
+                                '.com:35357/v2.0/'
+  )
+  define_data(:tenant,
+              :account => true,
+              :desc => 'HPCloud Tenant ID (from horizon, identity, projecs,'\
+                       ' Project ID)',
+              :validate => /^[0-9]+$/
+  )
+
+  define_data(:compute,
+              :account => true,
+              :desc => 'HPCloud Compute service zone (Ex: region-a.geo-1)',
+              :depends_on => [:account_id, :account_key, :auth_uri, :tenant],
+              :list_values => {
+                :query_type => :controller_call,
+                :object => :services,
+                :query_call => :get_services,
+                :query_params => { :list_services => [:Compute, :compute] },
+                :validate => :list_strict
+              }
+  )
+
+  define_data(:network,
+              :account => true,
+              :desc => 'HPCloud Network service zone (Ex: region-a.geo-1)',
+              :depends_on => [:account_id, :account_key, :auth_uri, :tenant],
+              :list_values => {
+                :query_type => :controller_call,
+                :object => :services,
+                :query_call => :get_services,
+                :query_params => { :list_services => [:Networking, :network] },
+                :validate => :list_strict
+              }
+  )
+
+  data_value_mapping 'xsmall', 'standard.xsmall'
+  data_value_mapping 'small',  'standard.small'
+  data_value_mapping 'medium', 'standard.medium'
+  data_value_mapping 'large',  'standard.large'
+  data_value_mapping 'xlarge', 'standard.xlarge'
+end
+
+# Following class describe how FORJ should handle HP Cloud objects.
+# Except Cloud connection, all HPCloud objects management are described/called
+# in HP* modules.
+class HpcloudController # rubocop: disable Metrics/ClassLength
+  def connect(sObjectType, hParams)
+    case sObjectType
+    when :services
+      Fog::HP.authenticate_v2(hParams[:hdata], hParams[:excon_opts])
+    when :compute_connection
+      Fog::Compute.new hParams[:hdata].merge(:provider => :hp, :version => 'v2')
+    when :network_connection
+      Fog::HP::Network.new(hParams[:hdata])
+    else
+      controller_error "'%s' is not a valid object for 'connect'", sObjectType
+    end
+  end
+
+  # rubocop: disable MethodLength, CyclomaticComplexity, AbcSize
+
+  # Create controller for Hpcloud
+  def create(sObjectType, hParams)
+    case sObjectType
+    when :public_ip
+      required?(hParams, :compute_connection)
+      required?(hParams, :server)
+      HPCompute.server_assign_address(hParams[:compute_connection],
+                                      hParams[:server])
+    when :server
+      required?(hParams, :compute_connection)
+      required?(hParams, :image)
+      required?(hParams, :network)
+      required?(hParams, :flavor)
+      required?(hParams, :keypairs)
+      required?(hParams, :security_groups)
+      required?(hParams, :server_name)
+
+      options = {
+        :name => hParams[:server_name],
+        :flavor_id => hParams[:flavor].id,
+        :image_id => hParams[:image].id,
+        :key_name => hParams[:keypairs].name,
+        :security_groups => [hParams[:security_groups].name],
+        :networks => [hParams[:network].id]
+      }
+
+      HPCompute.create_server(hParams[:compute_connection], options,
+                              hParams[:user_data], hParams[:meta_data])
+    when :image
+      required?(hParams, :compute_connection)
+      required?(hParams, :image_name)
+
+      HPCompute.get_image(hParams[:compute_connection], hParams[:image_name])
+    when :network
+      required?(hParams, :network_connection)
+      required?(hParams, :network_name)
+
+      HPNetwork.create_network(hParams[:network_connection],
+                               hParams[:network_name])
+    when :subnetwork
+      required?(hParams, :network_connection)
+      required?(hParams, :network)
+      required?(hParams, :subnetwork_name)
+
+      HPNetwork.create_subnetwork(hParams[:network_connection],
+                                  hParams[:network],
+                                  hParams[:subnetwork_name])
+    when :security_groups
+      required?(hParams, :network_connection)
+      required?(hParams, :security_group)
+
+      HPSecurityGroups.create_sg(hParams[:network_connection],
+                                 hParams[:security_group], hParams[:sg_desc])
+    when :keypairs
+      required?(hParams, :compute_connection)
+      required?(hParams, :keypair_name)
+      required?(hParams, :public_key)
+
+      HPKeyPairs.create_keypair(hParams[:compute_connection],
+                                hParams[:keypair_name], hParams[:public_key])
+    when :router
+      required?(hParams, :network_connection)
+      required?(hParams, :router_name)
+
+      # Forcelly used admin_status_up to true.
+      hParams[:hdata] = hParams[:hdata].merge(:admin_state_up => true)
+
+      HPNetwork.create_router(hParams[:network_connection], hParams[:hdata])
+    when :rule
+      required?(hParams, :network_connection)
+      required?(hParams, :security_groups)
+      HPSecurityGroups.create_rule(hParams[:network_connection],
+                                   hParams[:hdata])
+    when :router_interface
+      required?(hParams, :router)
+      required?(hParams, :subnetwork)
+      HPNetwork.add_interface(hParams[:router], hParams[:subnetwork])
+    else
+      controller_error "'%s' is not a valid object for 'create'", sObjectType
+    end
+  end
+
+  # This function return a collection which have to provide:
+  # functions: [], length, each
+  # Used by network process.
+  def query(sObjectType, sQuery, hParams)
+    case sObjectType
+    when :public_ip
+      required?(hParams, :compute_connection)
+      required?(hParams, :server)
+      HPCompute.query_server_assigned_addresses(hParams[:compute_connection],
+                                                hParams[:server], sQuery)
+    when :server
+      required?(hParams, :compute_connection)
+      HPCompute.query_server(hParams[:compute_connection], sQuery)
+    when :image
+      required?(hParams, :compute_connection)
+      HPCompute.query_image(hParams[:compute_connection], sQuery)
+    when :network
+      required?(hParams, :network_connection)
+      HPNetwork.query_network(hParams[:network_connection], sQuery)
+    when :subnetwork
+      required?(hParams, :network_connection)
+      HPNetwork.query_subnetwork(hParams[:network_connection], sQuery)
+    when :router
+      required?(hParams, :network_connection)
+      HPNetwork.query_router(hParams[:network_connection], sQuery)
+    when :port
+      required?(hParams, :network_connection)
+      HPNetwork.query_port(hParams[:network_connection], sQuery)
+    when :security_groups
+      required?(hParams, :network_connection)
+      HPSecurityGroups.query_sg(hParams[:network_connection], sQuery)
+    when :rule
+      required?(hParams, :network_connection)
+      HPSecurityGroups.query_rule(hParams[:network_connection], sQuery)
+    when :keypairs
+      required?(hParams, :compute_connection)
+      HPKeyPairs.query_keypair(hParams[:compute_connection], sQuery)
+    when :flavor
+      required?(hParams, :compute_connection)
+      HPCompute.query_flavor(hParams[:compute_connection], sQuery)
+    else
+      controller_error "'%s' is not a valid object for 'query'", sObjectType
+    end
+  end
+  # rubocop: enable CyclomaticComplexity, MethodLength
+
+  def delete(sObjectType, hParams)
+    case sObjectType
+    when :network
+      HPNetwork.delete_network(hParams[:network_connection],
+                               hParams[:network])
+    when :rule
+      HPSecurityGroups.delete_rule(hParams[:network_connection],
+                                   hParams[:id])
+      obj = hParams[:network_connection]
+      obj.security_group_rules.get(hParams[:id]).destroy
+    when :server
+      required?(hParams, :compute_connection)
+      required?(hParams, :server)
+      HPCompute.delete_server(hParams[:compute_connection],
+                              hParams[:server])
+    end
+  end
+
+  def get(sObjectType, sUniqId, hParams)
+    case sObjectType
+    when :server_log
+      required?(hParams, :server)
+
+      hParams[:server].console_output(sUniqId)
+    when :server
+      required?(hParams, :compute_connection)
+      HPCompute.get_server(hParams[:compute_connection], sUniqId)
+    when :image
+      required?(hParams, :compute_connection)
+      HPCompute.get_image(hParams[:compute_connection], sUniqId)
+    when :network
+      required?(hParams, :network_connection)
+      HPNetwork.get_network(hParams[:network_connection], sUniqId)
+    when :keypairs
+      required?(hParams, :compute_connection)
+      HPKeyPairs.get_keypair(hParams[:compute_connection], sUniqId)
+    else
+      forjError "'%s' is not a valid object for 'get'", sObjectType
+    end
+  end
+
+  def query_each(oFogObject)
+    case oFogObject.class.to_s
+    when 'Fog::HP::Network::Networks'
+      oFogObject.each { | value | yield(value) }
+    else
+      controller_error "'%s' is not a valid list for 'each'",
+                       oFogObject.class
+    end
+  end
+
+  def get_attr(oControlerObject, key)
+    if oControlerObject.is_a?(Excon::Response)
+      oControlerObject.data.rh_get(:body, key)
+    else
+      attributes = oControlerObject.attributes
+      def_attributes = oControlerObject.class.attributes
+      controller_error "attribute '%s' is unknown in '%s'. "\
+                       "Valid one are : '%s'",
+                       key[0], oControlerObject.class,
+                       def_attributes unless def_attributes.include?(key[0])
+      attributes.rh_get(key)
+    end
+  rescue => e
+    controller_error "Unable to map '%s'. %s", key, e.message
+  end
+
+  def set_attr(oControlerObject, key, value)
+    controller_class = oControlerObject.class
+
+    controller_error "No set feature for '%s'",
+                     controller_class if oControlerObject.is_a?(Excon::Response)
+
+    attributes = oControlerObject.attributes
+    def_attributes = oControlerObject.class.attributes
+    controller_error "attribute '%s' is unknown in '%s'. Valid one are : '%s'",
+                     key[0], oControlerObject.class,
+                     def_attributes unless def_attributes.include?(key[0])
+    attributes.rh_set(value, key)
+  rescue => e
+    controller_error "Unable to map '%s' on '%s'\n%s",
+                     key, sObjectType, e.message
+  end
+
+  def update(sObjectType, oObject, _hParams)
+    case sObjectType
+    when :router
+      controller_error 'Object to update is nil' if oObject.nil?
+
+      HPNetwork.update_router(oObject[:object])
+    else
+      controller_error "'%s' is not a valid list for 'update'",
+                       oFogObject.class
+    end
+  end
+
+  # This function requires to return an Array of values or nil.
+  def get_services(sObjectType, oParams)
+    case sObjectType
+    when :services
+      # oParams[sObjectType] will provide the controller object.
+      # This one can be interpreted only by controller code,
+      # except if controller declares how to map with this object.
+      # Processes can deal only process mapped data.
+      # Currently there is no services process function. No need to map.
+      services = oParams[:services]
+      if !oParams[:list_services].is_a?(Array)
+        service_to_find = [oParams[:list_services]]
+      else
+        service_to_find = oParams[:list_services]
+      end
+      # Search for service. Ex: Can be :Networking or network. I currently do
+      # not know why...
+      search_services = services.rh_get(:service_catalog)
+      service = nil
+      service_to_find.each do | sServiceElem |
+        if search_services.key?(sServiceElem)
+          service = sServiceElem
+          break
+        end
+      end
+
+      controller_error 'Unable to find services %s',
+                       service_to_find if service.nil?
+      result = services.rh_get(:service_catalog, service).keys
+      result.delete('name')
+      result.each_index do | iIndex |
+        result[iIndex] = result[iIndex].to_s if result[iIndex].is_a?(Symbol)
+      end
+      return result
+    else
+      controller_error "'%s' is not a valid object for 'get_services'",
+                       sObjectType
+    end
+  end
+end

data/lib/providers/hpcloud/network.rb

@@ -14,104 +14,102 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-
+# HPcloud network class
 module HPNetwork
-   # Network driver
-   def HPNetwork.query_network(oNetworkConnect, sQuery)
-      oNetworkConnect.networks.all(sQuery)
-   end
-
-   def HPNetwork.create_network(oNetworkConnect, name)
-      oNetworkConnect.networks.create(:name => name)
-   end
-
-   def HPNetwork.delete_network(oNetworkConnect, oNetwork)
-      oNetworkConnect.networks.get(oNetwork.id).destroy
-   end
-
-   # SubNetwork driver
-   def HPNetwork.query_subnetwork(oNetworkConnect, sQuery)
-      oNetworkConnect.subnets.all(sQuery)
-   end
-
-   def HPNetwork.create_subnetwork(oNetworkConnect, oNetwork, name)
-      oNetworkConnect.subnets.create(
-         :network_id => oNetwork.id,
-         :name => name,
-         :cidr => get_next_subnet(oNetworkConnect),
-         :ip_version => '4'
-      )
-   end
-
-   def HPNetwork.delete_subnetwork(oNetworkConnect, oSubNetwork)
-      oNetworkConnect.subnets.get(oSubNetwork.id).destroy
-   end
-
-   def HPNetwork.get_next_subnet(oNetworkConnect)
-      begin
-         subnet_values = Array.new
-         subnets = oNetworkConnect.subnets.all
-
-         subnets.each do|s|
-            subnet_values.push(s.cidr)
-         end
-
-         gap = false
-         count = 0
-         range_used = Array.new
-         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 = '10.0.%s.0/24' % [count]
-         else
-            max_value = range_used.max
-            new_subnet = max_value.to_i + 1
-            new_cidr  = '10.0.%s.0/24' % [new_subnet]
-         end
-         new_cidr
-      rescue => e
-         Logging.error("%s\n%s" % [e.message, e.backtrace.join("\n")])
+  # Network driver
+  def self.query_network(oNetworkConnect, sQuery)
+    oNetworkConnect.networks.all(sQuery)
+  end
+
+  def self.create_network(oNetworkConnect, name)
+    oNetworkConnect.networks.create(:name => name)
+  end
+
+  def self.delete_network(oNetworkConnect, oNetwork)
+    oNetworkConnect.networks.get(oNetwork.id).destroy
+  end
+
+  # SubNetwork driver
+  def self.query_subnetwork(oNetworkConnect, sQuery)
+    oNetworkConnect.subnets.all(sQuery)
+  end
+
+  def self.create_subnetwork(oNetworkConnect, oNetwork, name)
+    oNetworkConnect.subnets.create(
+       :network_id => oNetwork.id,
+       :name => name,
+       :cidr => get_next_subnet(oNetworkConnect),
+       :ip_version => '4'
+    )
+  end
+
+  def self.delete_subnetwork(oNetworkConnect, oSubNetwork)
+    oNetworkConnect.subnets.get(oSubNetwork.id).destroy
+  end
+
+  def self.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
-   end
-
-   # router driver
-   def HPNetwork.query_router(oNetworkConnect, sQuery)
-      oNetworkConnect.routers.all(sQuery)
-   end
-
-   def HPNetwork.update_router(oRouters)
-      oRouters.save
-   end
-
-   def HPNetwork.create_router(oNetwork, hOptions)
-      oNetwork.routers.create(hOptions)
-   end
-
-   # router interface
-
-   def HPNetwork.add_interface(oRouter, oSubNetwork)
-      oRouter.add_interface(oSubNetwork.id, nil)
-   end
-
-   # Port driver
-   def HPNetwork.query_port(oNetworkConnect, sQuery)
-      oNetworkConnect.ports.all(sQuery)
-   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
+
+  # router driver
+  def self.query_router(oNetworkConnect, sQuery)
+    oNetworkConnect.routers.all(sQuery)
+  end
+
+  def self.update_router(oRouters)
+    oRouters.save
+  end
+
+  def self.create_router(oNetwork, hOptions)
+    oNetwork.routers.create(hOptions)
+  end
+
+  # router interface
+
+  def self.add_interface(oRouter, oSubNetwork)
+    oRouter.add_interface(oSubNetwork.id, nil)
+  end
+
+  # Port driver
+  def self.query_port(oNetworkConnect, sQuery)
+    oNetworkConnect.ports.all(sQuery)
+  end
 end