lorj 1.0.9 → 1.0.10

data/lib/core_process/cloud/process/flavor.rb

@@ -1,97 +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.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-# ---------------------------------------------------------------------------
-# flavor management
-# ---------------------------------------------------------------------------
-class CloudProcess
-  # Depending on clouds/rights, we can create flavor or not.
-  # Usually, flavor records already exists, and the controller may map them
-  # CloudProcess predefines some values. Consult CloudProcess.rb for details
-  def forj_get_or_create_flavor(sCloudObj, hParams)
-    flavor_name = hParams[:flavor_name]
-    PrcLib.state("Searching for flavor '%s'", flavor_name)
-
-    flavors = query_flavor(sCloudObj, { :name => flavor_name }, hParams)
-    if flavors.length == 0
-      if !hParams[:create]
-        PrcLib.error("Unable to create %s '%s'. Creation is not "\
-                     'supported.', sCloudObj, flavor_name)
-        ForjLib::Data.new.set(nil, sCloudObj)
-      else
-        create_flavor(sCloudObj, hParams)
-      end
-    else
-      flavors[0]
-    end
-  end
-
-  # Should return 1 or 0 flavor.
-  def query_flavor(sCloudObj, sQuery, hParams)
-    flavor_name = hParams[:flavor_name]
-    #  list = forj_query_flavor(sCloudObj, sQuery, hParams)
-    #  query_single(sCloudObj, list, sQuery, flavor_name)
-    query_single(sCloudObj, sQuery, flavor_name)
-  end
-
-  # Should return 1 or 0 flavor.
-  def forj_query_flavor(sCloudObj, sQuery, _hParams)
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      list = controller_query(sCloudObj, sQuery)
-    rescue => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-    end
-    list
-  end
-end
-
-# Flavor Object
-# Identify flavor
-class Lorj::BaseDefinition # rubocop: disable ClassAndModuleChildren
-  define_obj(:flavor,
-
-             :create_e => :forj_get_or_create_flavor,
-             :query_e => :forj_query_flavor
-             #         :get_e      => :forj_get_flavor,
-             #         :update_e   => :forj_update_flavor,
-             #         :delete_e   => :forj_delete_flavor
-             )
-
-  obj_needs :CloudObject,  :compute_connection
-  obj_needs :data,         :flavor_name,         :for => [:create_e]
-  # Cloud provider will need to map to one of those predefined flavors.
-  # limitation values may match exactly or at least ensure those limitation
-  # are under provider limitation
-  # ie, at least the CloudProcess limitation can less than the
-  # Cloud provider defines.
-  # CloudProcess EHD = 160, then Provider EHD = 200 is ok
-  # but Provider EHD = 150 is not ok.
-  predefine_data_value('tiny',    :desc => 'VCU: 1,  RAM:512M, HD:1G,   '\
-                                           'EHD: 0G,   Swap: 0G')
-  predefine_data_value('xsmall',  :desc => 'VCU: 1,  RAM:1G,   HD:10G,  '\
-                                           'EHD: 10G,  Swap: 0G')
-  predefine_data_value('small',   :desc => 'VCU: 2,  RAM:2G,   HD:30G,  '\
-                                           'EHD: 10G,  Swap: 0G')
-  predefine_data_value('medium',  :desc => 'VCU: 2,  RAM:4G,   HD:30G,  '\
-                                           'EHD: 50G,  Swap: 0G')
-  predefine_data_value('large',   :desc => 'VCU: 4,  RAM:8G,   HD:30G,  '\
-                                           'EHD: 100G, Swap: 0G')
-  predefine_data_value('xlarge',  :desc => 'VCU: 8,  RAM:16G,  HD:30G,  '\
-                                           'EHD: 200G, Swap: 0G')
-end

data/lib/core_process/cloud/process/images.rb

@@ -1,99 +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.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-# ---------------------------------------------------------------------------
-# Image management
-# ---------------------------------------------------------------------------
-class CloudProcess
-  def forj_get_or_create_image(sCloudObj, hParams)
-    image_name = hParams[:image_name]
-    PrcLib.state("Searching for image '%s'", image_name)
-
-    search_the_image(sCloudObj, { :name => image_name }, hParams)
-    # No creation possible.
-  end
-
-  def search_the_image(sCloudObj, sQuery, hParams)
-    image_name = hParams[:image_name]
-    images = forj_query_image(sCloudObj, sQuery, hParams)
-    case images.length
-    when 0
-      PrcLib.info("No image '%s' found", image_name)
-      nil
-    when 1
-      PrcLib.info("Found image '%s'.", image_name)
-      images[0, :ssh_user] = ssh_user(images[0, :name])
-      images[0]
-    else
-      PrcLib.info("Found several images '%s'. Selecting the first "\
-                  "one '%s'", image_name, images[0, :name])
-      images[0, :ssh_user] = ssh_user(images[0, :name])
-      images[0]
-    end
-  end
-
-  def forj_query_image(sCloudObj, sQuery, _hParams)
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      images = controller_query(sCloudObj, sQuery)
-    rescue => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-    end
-    add_ssh_user(images)
-    images
-  end
-
-  def add_ssh_user(images)
-    images.each do |image|
-      image[:ssh_user] = ssh_user(image[:name])
-    end
-  end
-
-  def ssh_user(image_name)
-    return 'fedora' if image_name =~ /fedora/i
-    return 'centos' if image_name =~ /centos/i
-    'ubuntu'
-  end
-
-  def forj_get_image(sCloudObj, sId, _hParams)
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      image = controller_get(sCloudObj, sId)
-    rescue => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-    end
-    add_ssh_user([image])
-    image
-  end
-end
-
-# ************************************ Image Object
-# Identify image
-class Lorj::BaseDefinition # rubocop: disable Style/ClassAndModuleChildren
-  define_obj(:image,
-
-             :create_e => :forj_get_or_create_image,
-             :query_e => :forj_query_image,
-             :get_e => :forj_get_image
-             #         :update_e   => :forj_update_image
-             #         :delete_e   => :forj_delete_image
-             )
-
-  obj_needs :CloudObject,  :compute_connection
-  obj_needs :data,         :image_name,          :for => [:create_e]
-end

data/lib/core_process/cloud/process/internet_network.rb

@@ -1,33 +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.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-# rubocop: disable Style/ClassAndModuleChildren
-
-# Internet network Object
-# Define Internet network
-#
-# This object contains the logic to ensure the router's network has a gateway
-# to the external network (internet)
-# is capable to connect to internet
-# And to create this connection if possible.
-class Lorj::BaseDefinition # rubocop: disable ClassAndModuleChildren
-  define_obj(:internet_network,    :nohandler => true)
-
-  obj_needs :CloudObject,  :external_network # External network to connect if
-  # needed.
-end

data/lib/core_process/cloud/process/internet_server.rb

@@ -1,29 +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.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-# rubocop: disable Style/ClassAndModuleChildren
-
-# Internet SERVER Object
-# internet server is a server connected to the internet network.
-class Lorj::BaseDefinition
-  define_obj(:internet_server,    :nohandler => true)
-
-  obj_needs :CloudObject,  :internet_network
-  obj_needs :CloudObject,  :server
-  obj_needs :CloudObject,  :public_ip
-end

data/lib/core_process/cloud/process/keypairs.rb

@@ -1,332 +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.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-# rubocop: disable Style/ClassAndModuleChildren
-
-# Keypair management
-class CloudProcess
-  # KeyPair Create Process Handler
-  # The process implemented is:
-  # * Check local SSH keypairs with given ':keypair_name'
-  # * Check remote keypair existence
-  # * Compare and warn if needed.
-  # * Import public key found if missing remotely and name it.
-  #
-  # Return:
-  # - keypair : Lorj::Data keypair object. Following additional data should be
-  #             found in the keypair attributes
-  #   - :coherent        : Boolean. True, if the local keypair (public AND
-  #                        private) is coherent with remote keypair found in
-  #                        the cloud
-  #   - :private_key_file: String. Path to local private key file
-  #   - :public_key_file : String. Path to local public key file
-  #   - :public_key      : String. Public key content. (config[:public_key] is
-  #                        also set - Used to import it)
-  #
-  def forj_get_or_create_keypair(sCloudObj, hParams)
-    keypair_name = hParams[:keypair_name]
-    PrcLib.state("Searching for keypair '%s'", keypair_name)
-
-    keypair = forj_get_keypair(sCloudObj, keypair_name, hParams)
-    if keypair.empty?
-      loc_kpair = keypair_detect(keypair_name, hParams[:keypair_path],
-                                 hParams[:keypair_base])
-      keypair = keypair_import(hParams, loc_kpair)
-    else
-      keypair_display(keypair)
-    end
-    keypair
-  end
-
-  # Query cloud keypairs and check coherence with local files
-  # of same name in forj files located by :keypair_path
-  def forj_query_keypairs(sCloudObj, sQuery, hParams)
-    keypair_path = File.expand_path(hParams[:keypair_path])
-    keypair_base = File.expand_path(hParams[:keypair_base])
-
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      keypairs = controller_query(sCloudObj, sQuery)
-    rescue => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-    end
-    # Looping on keypairs to identify if they have a valid local ssh key.
-    keypairs.each do |keypair|
-      loc_kpair = keypair_detect(keypair_name, keypair_path, keypair_base)
-      keypair_files_detected(keypair, loc_kpair)
-    end
-    keypairs
-  end
-
-  # Get cloud keypair and check coherence with local files
-  # of same name in forj files
-  def forj_get_keypair(sCloudObj, keypair_name, hParams)
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      keypair = controller_get(sCloudObj, keypair_name)
-    rescue => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-    end
-
-    keypair_path = File.expand_path(hParams[:keypair_path])
-    loc_kpair = keypair_detect(keypair_name, keypair_path, keypair_name)
-    keypair_files_detected(keypair, loc_kpair) unless keypair.empty?
-    keypair
-  end
-end
-
-# ************************************ keypairs Object
-# Identify keypairs
-class Lorj::BaseDefinition
-  define_obj(:keypairs,
-
-             :create_e => :forj_get_or_create_keypair,
-             :query_e => :forj_query_keypairs,
-             :get_e => :forj_get_keypair
-             #         :delete_e   => :forj_delete_keypair
-             )
-
-  obj_needs :CloudObject,  :compute_connection
-  obj_needs :data,         :keypair_name,        :for => [:create_e]
-  obj_needs :data,         :keypair_path
-  obj_needs :data,         :keypair_base
-
-  # By default optional. But required by the import case if needed.
-  obj_needs_optional
-  obj_needs :data,         :public_key,          :for => [:create_e]
-
-  def_attribute :public_key
-end
-
-# Keypair management: Internal process functions
-class CloudProcess
-  # Function to display information about keypair object found.
-  #
-  def keypair_display(keypair)
-    PrcLib.info("Found keypair '%s'.", keypair[:name])
-
-    private_key_file = File.join(keypair[:keypair_path],
-                                 keypair[:private_key_name])
-    public_key_file = File.join(keypair[:keypair_path],
-                                keypair[:public_key_name])
-
-    PrcLib.info("Found openssh private key file '%s'.",
-                private_key_file) if keypair[:private_key_exist?]
-    PrcLib.info("Found openssh public key file '%s'.",
-                public_key_file) if keypair[:public_key_exist?]
-
-    unless keypair[:public_key_exist?]
-      name = keypair[:name]
-      PrcLib.warning("The local public key file '%s' is missing.\n"\
-                     "As the keypair name '%s' already exists in your cloud, "\
-                     'you will need to get the original SSH keypair files '\
-                     "used to create the keypair name '%s'. Otherwise, you "\
-                     "won't be able to use it to connect to a box configured"\
-                     " with '%s'."\
-                     "\nPublic key found in the cloud:\n%s",
-                     public_key_file, name, name, name,
-                     keypair[:public_key])
-      return
-    end
-
-    if keypair[:coherent]
-      PrcLib.info("keypair '%s' local files are coherent with keypair in "\
-                  'your cloud service. You will be able to use your local '\
-                  'keys to connect to any box configured with this keypair '\
-                  'name, over SSH.', keypair[:name])
-    else
-      PrcLib.warning("Your local public key file '%s' is incoherent with "\
-                     "public key attached to the keypair '%s' in your cloud."\
-                     " You won't be able to access your box with this keypair."\
-                     "\nPublic key found in the cloud:\n%s",
-                     public_key_file, keypair[:name], keypair[:public_key])
-    end
-  end
-end
-
-# Keypair management: Internal process functions
-class CloudProcess
-  # Function to update a keypair object with ssh files found in :keypair_path
-  #
-  def keypair_files_detected(keypair, loc_kpair)
-    keypair[:private_key_exist?] = loc_kpair[:private_key_exist?]
-    keypair[:public_key_exist?] = loc_kpair[:public_key_exist?]
-    keypair[:private_key_name] = loc_kpair[:private_key_name]
-    keypair[:public_key_name] = loc_kpair[:public_key_name]
-    keypair[:keypair_path] = loc_kpair[:keypair_path]
-    keypair[:coherent] = coherent_keypair?(loc_kpair, keypair)
-  end
-
-  def keypair_import(hParams, loc_kpair)
-    PrcLib.fatal(1, "Unable to import keypair '%s'. "\
-                    'Public key file is not found. '\
-                    "Please run 'forj setup %s'",
-                 hParams[:keypair_name],
-                 config[:account_name]) unless loc_kpair[:public_key_exist?]
-    public_key_file = File.join(loc_kpair[:keypair_path],
-                                loc_kpair[:public_key_name])
-
-    begin
-      public_key = File.read(public_key_file)
-    rescue => e
-      PrcLib.fatal(1, "Unable to import keypair '%s'. '%s' is "\
-                      "unreadable.\n%s", hParams[:keypair_name],
-                   loc_kpair[:public_key_file],
-                   e.message)
-    end
-    keypair = create_keypair(:keypairs, :public_key => public_key)
-
-    return nil if keypair.nil?
-
-    # Adding information about SSH key files.
-    keypair_files_detected(keypair, loc_kpair)
-
-    keypair
-  end
-
-  def create_keypair(sCloudObj, hParams)
-    key_name = hParams[:keypair_name]
-    PrcLib.state("Importing keypair '%s'", key_name)
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      keypair = controller_create(sCloudObj, hParams)
-      PrcLib.info("Keypair '%s' imported.", keypair[:name])
-    rescue StandardError => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-      PrcLib.error "error importing keypair '%s'", key_name
-    end
-    keypair
-  end
-
-  # Build keypair data information structure with files found in
-  # local filesystem. Take care of priv with or without .pem
-  # and pubkey with pub.
-  # :keypair_path data settings is changing to become just a path to
-  # the keypair files, the base keypair.
-  # Which will introduce a :keypair_base in the setup.
-  def keypair_detect(keypair_name, key_fullpath, key_basename = nil)
-    # When uses key_basename, we switch to the new model
-    # using :keypair_path and :keypair_base in setup
-    if key_basename.nil?
-      key_basename = File.basename(key_fullpath)
-      key_path = File.expand_path(File.dirname(key_fullpath))
-    else
-      key_path = File.expand_path(key_fullpath)
-    end
-
-    obj_match = key_basename.match(/^(.*?)(\.pem|\.pub)?$/)
-    key_basename = obj_match[1]
-
-    private_key_ext, files = _check_key_file(key_path, key_basename,
-                                             ['', '.pem'])
-
-    if private_key_ext
-      priv_key_exist = true
-      priv_key_name = key_basename + private_key_ext
-    else
-      files.each do |temp_file|
-        PrcLib.warning('keypair_detect: Private key file name detection has '\
-                       "detected '%s' as a directory. Usually, it should be a "\
-                       'private key file. Please check.',
-                       temp_file) if File.directory?(temp_file)
-      end
-      priv_key_exist = false
-      priv_key_name = key_basename
-    end
-
-    pub_key_exist = File.exist?(File.join(key_path, key_basename + '.pub'))
-    pub_key_name = key_basename + '.pub'
-
-    # keypair basic structure
-    { :keypair_name     => keypair_name,
-      :keypair_path     => key_path,      :key_basename       => key_basename,
-      :private_key_name => priv_key_name, :private_key_exist? => priv_key_exist,
-      :public_key_name  => pub_key_name,  :public_key_exist?  => pub_key_exist
-    }
-  end
-
-  def _check_key_file(key_path, key_basename, extensions)
-    found_ext = nil
-    files = []
-    extensions.each do |ext|
-      temp_file = File.join(key_path, key_basename + ext)
-      if File.exist?(temp_file) && !File.directory?(temp_file)
-        found_ext = ext
-        files << temp_file
-      end
-    end
-    [found_ext, files]
-  end
-
-  def get_keypairs_path(hParams, hKeys)
-    keypair_name = hParams[:keypair_name]
-
-    if hKeys[:private_key_exist?]
-      hParams[:private_key_file] = File.join(hKeys[:keypair_path],
-                                             hKeys[:private_key_name])
-      PrcLib.info("Openssh private key file '%s' exists.",
-                  hParams[:private_key_file])
-    end
-    if hKeys[:public_key_exist?]
-      hParams[:public_key_file] = File.join(hKeys[:keypair_path],
-                                            hKeys[:public_key_name])
-    else
-      PrcLib.fatal(1, 'Public key file is not found. Please run'\
-                      " 'forj setup %s'", config[:account_name])
-    end
-
-    PrcLib.state("Searching for keypair '%s'", keypair_name)
-
-    hParams
-  end
-
-  # Check if 2 keypair objects are coherent (Same public key)
-  # Parameters:
-  # - +loc_kpair+ : Keypair structure representing local files existence.
-  #                     see keypair_detect
-  # - +keypair+       : Keypair object to check.
-  #
-  # return:
-  # - coherent : Boolean. True if same public key.
-  def coherent_keypair?(loc_kpair, keypair)
-    # send keypairs by parameter
-    is_coherent = false
-
-    pub_keypair = keypair[:public_key]
-
-    # Check the public key with the one found here, locally.
-    if !pub_keypair.nil? && pub_keypair != ''
-      return false unless loc_kpair[:public_key_exist?]
-      begin
-        loc_pubkey = File.read(File.join(loc_kpair[:keypair_path],
-                                         loc_kpair[:public_key_name]))
-     rescue => e
-       PrcLib.error("Unable to read '%s'.\n%s",
-                    loc_kpair[:public_key_file], e.message)
-      else
-        if loc_pubkey.split(' ')[1].strip == pub_keypair.split(' ')[1].strip
-          is_coherent = true
-        end
-      end
-    else
-      PrcLib.warning('Unable to verify keypair coherence with your local '\
-                     'SSH keys. No public key (:public_key) provided.')
-    end
-    is_coherent
-  end
-end

data/lib/core_process/cloud/process/network.rb

@@ -1,107 +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.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-# rubocop: disable Style/ClassAndModuleChildren
-
-# Network Management
-class CloudProcess
-  # Process Create handler
-  def forj_get_or_create_network(sCloudObj, hParams)
-    PrcLib.state("Searching for network '%s'", hParams[:network_name])
-    networks = find_network(sCloudObj, hParams)
-    if networks.length == 0
-      network = create_network(sCloudObj, hParams)
-    else
-      network = networks[0]
-    end
-    register(network)
-
-    # Attaching if missing the subnet.
-    # Creates an object subnet, attached to the network.
-    params = {}
-    unless hParams[:subnetwork_name]
-      params[:subnetwork_name] = 'sub-' + hParams[:network_name]
-    end
-
-    process_create(:subnetwork, params)
-
-    network
-  end
-
-  # Process Delete handler
-  def forj_delete_network(sCloudObj, hParams)
-    oProvider.delete(sCloudObj, hParams)
- rescue => e
-   PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
-  end
-
-  def forj_get_network(sCloudObj, sID, hParams)
-    oProvider.get(sCloudObj, sID, hParams)
-  rescue => e
-    PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
-  end
-end
-
-# Network Object
-# Identify the network
-class Lorj::BaseDefinition
-  define_obj(:network,
-             :create_e => :forj_get_or_create_network,
-             :query_e => :controller_query,
-             :get_e => :forj_get_network,
-             :delete_e => :forj_delete_network
-            )
-  obj_needs :CloudObject,  :network_connection
-  obj_needs :data,         :network_name,        :for => [:create_e]
-
-  obj_needs_optional
-  obj_needs :data,         :subnetwork_name,     :for => [:create_e]
-
-  # Any attribute are queriable
-  def_attribute :external # true if network is external or not.
-end
-
-# Network Process internal functions #
-class CloudProcess
-  # Network creation
-  # It returns:
-  # nil or Provider Object
-  def create_network(sCloudObj, hParams)
-    name = hParams[:network_name]
-    begin
-      PrcLib.state("Creating network '%s'", name)
-      network = controller_create(sCloudObj)
-      PrcLib.info("Network '%s' created", network[:name])
-   rescue => e
-     PrcLib.fatal(1, "Unable to create network '%s'", name, e)
-    end
-    network
-  end
-
-  # Search for a network from his name.
-  # Name may be unique in project context, but not in the cloud system
-  # It returns:
-  # nil or Provider Object
-  def find_network(sCloudObj, hParams)
-    query = { :name => hParams[:network_name] }
-
-    query_single(sCloudObj, query, hParams[:network_name])
- rescue => e
-   PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
-  end
-end