# coding: utf-8
# -------------------------------------------------------------------------- #
# Copyright 2002-2016, OpenNebula Project, OpenNebula Systems                #
#                                                                            #
# 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.                                             #
#--------------------------------------------------------------------------- #

require 'nokogiri'

module OneDBPatch
  VERSION = "4.90.0"
  LOCAL_VERSION = "4.90.0"

  IMAGE_TYPE = %w[hd cdrom]

  class NoImageError < StandardError
  end

  def is_hot_patch(ops)
    return false
  end

  def check_db_version(ops)
    db_version = read_db_version()

    if ( db_version[:version] != VERSION ||
         db_version[:local_version] != LOCAL_VERSION )

      raise <<-EOT
Version mismatch: patch file is for version
Shared: #{VERSION}, Local: #{LOCAL_VERSION}

Current database is version
Shared: #{db_version[:version]}, Local: #{db_version[:local_version]}
EOT
    end
  end

  # Modify template boot order to match disk# and nic# instead of HD, CDROM and NETWORK
  # Params:
  # +ops+:: Options
  def patch(ops)
    init_log_time()

    #

    @db.transaction do
      @db.fetch("SELECT oid,body FROM template_pool") do |row|
        doc = Nokogiri::XML(row[:body],nil,NOKOGIRI_ENCODING){|c| c.default_xml.noblanks}
        template_name = doc.root.at_css("NAME").content

        # Rename VMMMAD -> VM_MAD and TMMAD -> TM_MAD
        boot = doc.root.at_xpath("TEMPLATE/OS/BOOT")
        if boot.nil?
          # No boot entry for template
          next
        end

        # Convert each boot device
        # Skip template if:
        # * the image referenced by a DISK is not found
        # * a boot device in BOOT does not match any DISK
        devs=[]
        nic_id=0

        begin
          boot.content.split(",").each do |dev|
            case dev.downcase

              when "hd", "cdrom"
                id = get_first_disk_id(dev, doc)
                if id.nil?
                  puts "Warning template #{row[:oid]} #{template_name}: skip nonexistent boot device '#{dev}'"
                  next
                end
                devs.push("disk#{id}")

              when "network"
                devs.push("nic#{nic_id}")
                nic_id += 1

              when /^(?:nic|disk)[0-9]+/
                devs.push(dev)

            end
          end
        rescue NoImageError => error
          puts "Skipping template #{row[:oid]} #{template_name}: #{error.message}"
          next
        end

        if boot.content != devs.join(",")
          # Avoid updating unchanged lines
          new_boot = devs.join(",")

          if ops[:verbose]
            puts "Template #{row[:oid]} #{template_name}: '#{boot.content}' -> '#{new_boot}'"
          end

          boot.content = new_boot

          @db[:template_pool].where(:oid => row[:oid]).update(
            :body => doc.root.to_s)

        end
      end

    end

    log_time()

    return true
  end

  # Returns the ID of the first disk of a type
  # Params:
  # +type+:: type name of the disk, can be “hd” or “cdrom”
  # +doc+:: Nokogiri::XML::Node describing the VM template
  def get_first_disk_id(type, doc)
    doc.root.xpath("TEMPLATE/DISK").each_with_index do |disk, index|
      id = disk.at_css("IMAGE_ID")
      if ! id.nil?
        image = get_image_from_id(id.content)
      else
        image = get_image_from_name(disk)
      end

      if is_image_type_matching?(image.at_css("TYPE").content, type)
        return index
      end
    end
    return nil # Skip this type of device
  end

  # Returns a Nokogiri::XML::Node describing an image
  # Params:
  # +id+:: ID of the image
  def get_image_from_id(id)
    @db.transaction do
      row = @db.fetch("SELECT body from image_pool where oid=#{id}").first
      # No image found, so unable to get image TYPE
      raise NoImageError, "No image with ID '#{id}'" if row.nil?
      image = Nokogiri::XML(row[:body], nil,NOKOGIRI_ENCODING){|c| c.default_xml.noblanks}
      return image
    end
  end

  # Returns a Nokogiri::XML::Node describing an image
  # Params:
  # +disk+:: Nokogiri::XML::Node describing a disk used by a template
  def get_image_from_name(disk)
    name = disk.at_css("IMAGE").content # always defined
    uid = disk.at_css("IMAGE_UID")
    uname = disk.at_css("IMAGE_UNAME")

    if ! name.nil? and (! uid.nil? or ! uname.nil?)
      if uid.nil?
        uid = get_user_id(uname.content)
      else
        uid = uid.content
      end

      @db.transaction do
        row = @db.fetch("SELECT body from image_pool where name=\"#{name}\" and uid=#{uid}").first
        # No image found, so unable to get image TYPE
        raise NoImageError, "No image named '#{name}' for uid '#{uid}'" if row.nil?
        image = Nokogiri::XML(row[:body], nil,NOKOGIRI_ENCODING){|c| c.default_xml.noblanks}
        return image
      end
    end
  end

  # Returns the ID of a user name
  # Params:
  # +name+:: name of a user
  def get_user_id(name)
    @db.transaction do
      row = @db.fetch("SELECT uid from user_pool where name=\"#{name}\"").first
      return row[:uid]
    end
  end

  # Check if an image type match the type used in template BOOT
  # Params:
  # +image_type+:: numerical type of an image
  # +wanted_type+:: string type extracted from VM template BOOT
  def is_image_type_matching?(image_type, wanted_type)
    Integer(image_type) == IMAGE_TYPE.index(wanted_type.downcase)
  end

end