lorj 1.0.9 → 1.0.10

data/lib/providers/hpcloud/network.rb

@@ -1,115 +0,0 @@
-# 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.
-
-# HPcloud network class
-module HPNetwork
-  # 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
-      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

data/lib/providers/hpcloud/security_groups.rb

@@ -1,68 +0,0 @@
-# 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.
-
-# HPCloud security groups
-module HPSecurityGroups
-  def self.query_sg(oNetworkConnect, sQuery)
-    oNetworkConnect.security_groups.all(sQuery)
-  end
-
-  def self.create_sg(oNetwork, name, description)
-    params = { :name => name }
-    params[:description] = description if description
-    oNetwork.security_groups.create(params)
-  end
-
-  def self.create_rule(oNetwork, hData)
-    oNetwork.security_group_rules.create(hData)
-  end
-
-  def self.query_rule(oNetwork, sQuery)
-    oNetwork.security_group_rules.all(sQuery)
-  end
-
-  def self.delete_rule(oNetwork, rule_id)
-    oNetwork.security_group_rules.get(rule_id).destroy
-  end
-end
-
-# HPCloud keypairs
-module HPKeyPairs
-  def self.query_keypair(oComputeConnect, sQuery)
-    keypairs = oComputeConnect.key_pairs.all
-    results = []
-    keypairs.each do |sElem|
-      is_selected = true
-      attributes = sElem.instance_variable_get(:@attributes)
-      sQuery.each do |key, value|
-        if attributes[key] != value
-          is_selected = false
-          break
-        end
-      end
-      results.push sElem if is_selected
-    end
-    results
-  end
-
-  def self.get_keypair(oComputeConnect, sId)
-    oComputeConnect.key_pairs.get(sId)
-  end
-
-  def self.create_keypair(oComputeConnect, name, pubkey)
-    oComputeConnect.key_pairs.create(:name => name, :public_key => pubkey)
-  end
-end

data/lib/providers/openstack/openstack.rb

@@ -1,410 +0,0 @@
-# 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'
-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,
-                                 :decrypt => true
-  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,
-              :default_value => '<%= config[:network] %>',
-              :explanation => 'Depending on your installation, you may need to'\
-                ' provide a Region name. This information is shown under your '\
-                'horizon UI - close right to the project name (top left).'\
-                "\nYou can also get it from Project-Compute-Access & Security-"\
-                'API, then download the Openstack RC file. The Region name is '\
-                'set as OS_REGION_NAME.'\
-                "\nIf there is no region shown, you can ignore it.",
-              :desc => 'Openstack Compute Region (Ex: RegionOne)',
-              :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,
-              :default_value => '<%= config[:compute] %>',
-              :desc => 'Openstack Network Region (Ex: RegionOne)',
-              :explanation => 'Depending on your installation, you may need to'\
-                ' provide a Region name. This information is shown under your '\
-                'horizon UI - close right to the project name (top left).'\
-                "\nYou can also get it from Project-Compute-Access & Security-"\
-                'API, then download the Openstack RC file. The Region name is '\
-                'set as OS_REGION_NAME.'\
-                "\nIf there is no region shown, you can ignore it.",
-              :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
-              }
-  )
-
-  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 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 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)
-      _get_instance_attr(oControlerObject, key)
-    end
-  rescue => e
-    controller_error "==>Unable to map '%s'. %s", key, e.message
-  end
-
-  def _get_instance_attr(oControlerObject, key)
-    return nil if oControlerObject.send(key[0]).nil?
-    return oControlerObject.send(key[0]) if key.length == 1
-    oControlerObject.send(key[0]).rh_get(key[1..-1])
-  end
-end
-
-# Following class describe how FORJ should handle Openstack Cloud objects.
-class OpenstackController
-  # 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
-
-  def format_retrieve_result(retrieve_result)
-    {
-      :auth_token => retrieve_result['access']['token']['id'],
-      :expires => retrieve_result['access']['token']['expires'],
-      :service_catalog =>
-          get_service_catalog(retrieve_result['access']['serviceCatalog']),
-      :endpoint_url => nil,
-      :cdn_endpoint_url => nil
-    }
-  end
-
-  def get_service_catalog(body)
-    fail 'Unable to parse service catalog.' unless body
-    service_catalog = {}
-    body.each do |s|
-      type = s['type']
-      next if type.nil?
-      type = type.to_sym
-      next if s['endpoints'].nil?
-      service_catalog[type] = {}
-      service_catalog[type]['name'] = s['name']
-      service_catalog = parse_service_catalog_endpoint(s, type, service_catalog)
-    end
-    service_catalog
-  end
-
-  def parse_service_catalog_endpoint(s, type, service_catalog)
-    s['endpoints'].each do |ep|
-      next if ep['region'].nil?
-      next if ep['publicURL'].nil?
-      next if ep['publicURL'].empty?
-      service_catalog[type][ep['region'].to_sym] = ep['publicURL']
-    end
-    service_catalog
-  end
-end