# 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.

class SSLErrorMgt

   def initialize(iMaxRetry = 5)
      @iRetry = 0
      @iMaxRetry = iMaxRetry
   end

   def ErrorDetected(message,backtrace, e)
      if message.match('SSLv2/v3 read server hello A: unknown protocol')
         if @iRetry <@iMaxRetry
            sleep(2)
            @iRetry+=1
            print "%s/%s try... 'unknown protocol' SSL Error\r" % [@iRetry, @iMaxRetry] if $FORJ_LOGGER.level == 0
            return false
         else
            Logging.error('Too many retry. %s' % message)
            return true
         end
      elsif e.is_a?(Excon::Errors::InternalServerError)
         if @iRetry <@iMaxRetry
            sleep(2)
            @iRetry+=1
            print "%s/%s try... %s\n" % [@iRetry, @iMaxRetry, ANSI.red(e.class)] if $FORJ_LOGGER.level == 0
            return false
         else
            Logging.error('Too many retry. %s' % message)
            return true
         end
      else
         Logging.error("Exception %s: %s\n%s" % [e.class, message,backtrace.join("\n")])
         return true
      end
   end

end


class CloudProcess < BaseProcess
   def connect(sCloudObj, hParams)
      oSSLError = SSLErrorMgt.new # Retry object
      Logging.debug("%s:%s Connecting to '%s' - Project '%s'" % [self.class, sCloudObj, config.get(:provider), hParams[:tenant]])
      begin
         controler.connect(sCloudObj)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
         end
         Logging.error('%s:%s: Unable to connect.\n%s' % [self.class, sCloudObj, e.message ])
         nil
      end
   end
end

# ---------------------------------------------------------------------------
# Keypair management
# ---------------------------------------------------------------------------
class CloudProcess
   def forj_get_or_create_keypair(sCloudObj, hParams)
      sKeypair_name = hParams[:keypair_name]
      # setup has configured and copied the appropriate key to forj keypairs.

      hKeys = keypair_detect(sKeypair_name, File.expand_path(hParams[:keypair_path]))
      if hKeys[:private_key_exist? ]
         hParams[:private_key_file] = File.join(hKeys[:keypair_path], hKeys[:private_key_name])
         Logging.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
         Logging.fatal("Public key file is not found. Please run 'forj setup %s'" % config[:account_name])
      end

      Logging.state("Searching for keypair '%s'" % [sKeypair_name] )

      keypairs = forj_query_keypair(sCloudObj, {:name => sKeypair_name}, hParams)
      if keypairs.length > 0
         keypair = keypairs[0]
         # Check the public key with the one found here, locally.
         if not keypair[:public_key].nil? and keypair[:public_key] != ""
            begin
               local_pub_key = File.read(hParams[:public_key_file])
            rescue => e
               Logging.error("Unable to read '%s'.\n%s",[hParams[:public_key_file], e.message] )
               keypair[:coherent] = false
            else
               if local_pub_key.split(' ')[1].strip == keypair[:public_key].split(' ')[1].strip
                  Logging.info("keypair '%s' local files are coherent with keypair in your cloud service. You will be able to connect to your box over SSH." % sKeypair_name)
                  keypair[:coherent] = true
               else
                  keypair[:coherent] = false
                  Logging.warning("Your local keypair file '%s' are incoherent with public key '%s' found in your cloud. You won't be able to access your box with this keypair.\nPublic key found in the cloud:\n%s" % [hParams[:public_key_file], sKeypair_name, keypair[:public_key]])
               end
            end
         else
            keypair[:coherent] = false
            Logging.warning("Unable to verify keypair coherence between your cloud and your local SSH keys. The cloud controller did not provided ':public_key'")
         end
      else
         config[:public_key] = File.read(hParams[:public_key_file])
         keypair = create_keypair(sCloudObj, hParams)
         if not hKeys[:private_key_exist? ]
            keypair[:coherent] = false
         else
            keypair[:coherent] = true
         end
      end
      # Adding information about key files.
      keypair[:private_key_file] = hParams[:private_key_file]
      keypair[:public_key_file] = hParams[:public_key_file]
      keypair
   end

   def forj_query_keypair(sCloudObj, sQuery, hParams)
      key_name = hParams[:keypair_name]
      oSSLError = SSLErrorMgt.new
      begin
         oList = controler.query(sCloudObj, sQuery)
         query_single(sCloudObj, oList, sQuery, key_name)
      rescue => e
         if not oSSLError.ErrorDetected(e.message, e.backtrace, e)
            retry
         end
      end

   end

   def create_keypair(sCloudObj, hParams)
      key_name = hParams[:keypair_name]
      Logging.state("Importing keypair '%s'" % [key_name])
      oSSLError=SSLErrorMgt.new
      begin
         keypair = controler.create(sCloudObj)
         Logging.info("Keypair '%s' imported." % [keypair[:name]])
      rescue StandardError => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
         end
         Logging.error "error importing keypair '%s'" % [key_name]
      end
      keypair
   end

   def keypair_detect(keypair_name, key_fullpath)
      # Build key data information structure.
      # Take care of priv with or without .pem and pubkey with pub.

      key_basename = File.basename(key_fullpath)
      key_path = File.expand_path(File.dirname(key_fullpath))

      mObj = key_basename.match(/^(.*?)(\.pem|\.pub)?$/)
      key_basename = mObj[1]

      private_key_ext = nil
      private_key_ext = "" if File.exists?(File.join(key_path, key_basename))
      private_key_ext = '.pem' if File.exists?(File.join(key_path, key_basename + '.pem'))
      if private_key_ext
         private_key_exist = true
         private_key_name = key_basename + private_key_ext
      else
         private_key_exist = false
         private_key_name = key_basename
      end

      public_key_exist = File.exists?(File.join(key_path, key_basename + '.pub'))
      public_key_name = key_basename + '.pub'


      {:keypair_name     => keypair_name,
       :keypair_path     => key_path,         :key_basename       => key_basename,
       :private_key_name => private_key_name, :private_key_exist? => private_key_exist,
       :public_key_name  => public_key_name,  :public_key_exist?  => public_key_exist,
      }
   end

end

# ---------------------------------------------------------------------------
# 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)
      sFlavor_name = hParams[:flavor_name]
      Logging.state("Searching for flavor '%s'" % [sFlavor_name] )

      flavors = query_flavor(sCloudObj, {:name => sFlavor_name}, hParams)
      if flavors.length == 0
         if not hParams[:create]
            Logging.error("Unable to create %s '%s'. Creation is not supported." % [sCloudObj, sFlavor_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)
      sFlavor_name = hParams[:flavor_name]
      oList = forj_query_flavor(sCloudObj, sQuery, hParams)
      query_single(sCloudObj, oList, sQuery, sFlavor_name)
   end

   # Should return 1 or 0 flavor.
   def forj_query_flavor(sCloudObj, sQuery, hParams)
      sFlavor_name = hParams[:flavor_name]
      oSSLError = SSLErrorMgt.new
      begin
         oList = controler.query(sCloudObj, sQuery)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
         end
      end
      oList
   end
end

# ---------------------------------------------------------------------------
# Image management
# ---------------------------------------------------------------------------
class CloudProcess < BaseProcess
   def forj_get_or_create_image(sCloudObj, hParams)
      sImage_name = hParams[:image_name]
      Logging.state("Searching for image '%s'" % [sImage_name] )

      search_the_image(sCloudObj, {:name => sImage_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
          Logging.info("No image '%s' found" % [ image_name ] )
          nil
        else
          Logging.info("Found image '%s'." % [ image_name ])
          images[0]
      end
   end

   def forj_query_image(sCloudObj, sQuery, hParams)
      oSSLError = SSLErrorMgt.new
      begin
         controler.query(sCloudObj, sQuery)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
           retry
         end
      end
   end
end

# ---------------------------------------------------------------------------
# Server management
# ---------------------------------------------------------------------------
class CloudProcess < BaseProcess
   # Process Handler functions
   def forj_get_or_create_server(sCloudObj, hParams)
      sServer_name = hParams[:server_name]
      Logging.state("Searching for server '%s'" % [sServer_name] )
      servers = forj_query_server(sCloudObj, {:name => sServer_name}, hParams)
      if servers.length > 0
         # Get server details
         forj_get_server(sCloudObj, servers[0][:attrs][:id], hParams)
      else
         create_server(sCloudObj, hParams)
      end
   end

   def forj_query_server(sCloudObj, sQuery, hParams)
      server_name = "Undefined"
      server_name = sQuery[:name] if sQuery.key?(:name)
      oSSLError = SSLErrorMgt.new
      begin
         oList = controler.query(sCloudObj, sQuery)
         query_single(sCloudObj, oList, sQuery, server_name)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
           retry
         end
      end
   end

   def forj_get_server(sCloudObj, sId, hParams)
      oSSLError = SSLErrorMgt.new
      begin
         controler.get(sCloudObj, sId)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
           retry
         end
      end
   end

   # Internal Process function
   def create_server(sCloudObj, hParams)
      name = hParams[:server_name]
      begin
         Logging.info("boot: meta-data provided.") if hParams[:meta_data]
         Logging.info("boot: user-data provided.") if hParams[:user_data]
         Logging.state('creating server %s' % [name])
         server = controler.create(sCloudObj)
         Logging.info("%s '%s' created." % [sCloudObj, name])
      rescue => e
         Logging.fatal(1, "Unable to create server '%s'" % name, e)
      end
      server
   end

   def forj_get_server_log(sCloudObj, sId, hParams)
      oSSLError = SSLErrorMgt.new
      begin
         controler.get(sCloudObj, sId)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
           retry
         end
      end
   end
end
# ---------------------------------------------------------------------------
# Addresses management
# ---------------------------------------------------------------------------
class CloudProcess < BaseProcess
   # Process Handler functions
   def forj_get_or_assign_public_address(sCloudObj, hParams)
      # Function which to assign a public IP address to a server.
      sServer_name = hParams[:server, :name]

      Logging.state("Searching public IP for server '%s'" % [sServer_name] )
      addresses = controler.query(sCloudObj, {:server_id => hParams[:server, :id]})
      if addresses.length == 0
         assign_address(sCloudObj, hParams)
      else
         addresses[0]
      end
   end

   def forj_query_public_address(sCloudObj, sQuery, hParams)
      server_name = hParams[:server, :name]
      oSSLError = SSLErrorMgt.new
      begin
         sInfo = {
         :notfound   => "No %s for '%s' found",
         :checkmatch => "Found 1 %s. checking exact match for server '%s'.",
         :nomatch    => "No %s for '%s' match",
         :found      => "Found %s '%s' for #{server_name}.",
         :more       => "Found several %s. Searching for '%s'.",
         :items      => :public_ip
         }
         oList = controler.query(sCloudObj, sQuery)
         query_single(sCloudObj, oList, sQuery, server_name, sInfo)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
           retry
         end
      end
   end

   def forj_get_public_address(sCloudObj, sId, hParams)
      oSSLError = SSLErrorMgt.new
      begin
         controler.get(sCloudObj, sId)
      rescue => e
         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
           retry
         end
      end
   end

   # Internal Process function
   def assign_address(sCloudObj, hParams)
      name = hParams[:server, :name]
      begin
         Logging.state('Getting public IP for server %s' % [name])
         ip_address = controler.create(sCloudObj)
         Logging.info("Public IP '%s' for server '%s' assigned." % [ip_address[:public_ip], name])
      rescue => e
         Logging.fatal(1, "Unable to assign a public IP to server '%s'" % name, e)
      end
      ip_address
   end
end