lorj_cloud 0.1.0

data/lib/providers/openstack/openstack.rb

@@ -0,0 +1,410 @@
+# 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 :error, 'ERROR'
+
+  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

data/lib/providers/openstack/openstack_create.rb

@@ -0,0 +1,206 @@
+# 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)
+      return if server.state == 'ERROR'
+    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