#!/usr/bin/env ruby
#
# Copyright (C) 2013 Red Hat, GmbH
# 
# Simple XML metadata creation tool
#

require 'optparse'
require 'pathname'

#----------------------------------------------------------------

$prg = Pathname.new($0).basename

def init_units
  units = {}
  units[:bytes_per_sector] = 512
  units[:chars] = "bsKkMmGgTtPpEeZzYy"
  units[:strings] = [ 'bytes', 'sectors',
                      'kilobytes', 'kibibytes', 'megabytes',  'mebibytes',
                      'gigabytes', 'gibibytes', 'terabytes',  'tebibytes',
                      'petabytes', 'pebibytes', 'exabytes',   'ebibytes',
                      'zetabytes', 'zebibytes', 'yottabytes', 'yobibytes' ]
  units[:factors] = [ 1, units[:bytes_per_sector] ]
  1.step(8) { |e| units[:factors] += [ 1000**e, 1024**e ] }
  units
end

def get_index(unit_char, units)
  unit_char ? units[:chars].index(unit_char) : 1
end

def to_sectors(size, units)
  a = size.split(/[#{units[:chars]}]/)
  s = size.to_i.to_s
  abort "#{$prg} - only one unit character allowed!" if a.length > 1 || size.length - s.length > 1
  abort "#{$prg} - invalid unit specifier!" if s != a[0]
  size.to_i * units[:factors][get_index(size[a[0].length], units)] / units[:bytes_per_sector]
end

def check_opts(opts)
  abort "#{$prg} - 3 arguments required!" if opts.length < 3
  abort "#{$prg} - size must be much greater/equal blocksize" if opts[:thinsize] < opts[:blocksize]
  abort "#{$prg} - number of thin provisioned devices or snapshots must be > 0" if opts[:thins].nil? || opts[:thins] == 0
end

def parse_command_line(argv, units)
  opts = {}

  os = OptionParser.new do |o|
    o.banner = "Thin Provisioning XML Test Metadata Generator.\nUsage: #{$prg} [opts]"
    o.on("-b", "--block-size BLOCKSIZE[#{units[:chars]}]", String,
         "Block size of thin provisioned devices.") do |bs|
      opts[:blocksize] = to_sectors(bs, units)
    end
    o.on("-s", "--thin-size SIZE[#{units[:chars]}]", String, "Average size of thin devices and snapshots.") do |sz|
      opts[:thinsize] = to_sectors(sz, units)
    end
    o.on("-r", "--range-mappings", "Create range mappings") do
      opts[:range] = true
    end
    o.on("-t", "--thins #THINS", Integer, "Sum of thin devices and snapshots.") do |mt|
      opts[:thins] = mt
    end
    o.on("-h", "--help", "Output this help.") do
      puts o
      exit
    end
  end

  begin
    os.parse!(argv)
  rescue OptionParser::ParseError => e
    abort "#{$prg} #{e}\n#{$prg} #{os}"
  end

  check_opts(opts)
  opts
end

def begin_superblock(blocksize, nr_data_blocks)
  "<superblock uuid=\"\" time=\"0\" transaction=\"0\" data_block_size=\"#{blocksize}\" nr_data_blocks=\"#{nr_data_blocks}\">\n"
end

def end_superblock
  "</superblock>\n"
end

def begin_device(devid, size)
  "  <device dev_id =\"#{devid}\" mapped_blocks=\"#{size}\" transaction=\"0\" creation_time=\"0\" snap_time=\"0\">\n"
end

def end_device
  "  </device>\n"
end

def single_mapping(from, to = 4711)
  "    <single_mapping time=\"0\" origin_block=\"#{from}\" data_block=\"#{to}\"/>\n"
end

def range_mapping(from, to, length)
  "    <range_mapping time=\"0\" origin_begin=\"#{from}\" data_begin=.\"#{to}\" length=\"#{length}\"/>\n"
end

def xml_metadata(opts, units)
  blocks, to = opts[:thinsize] / opts[:blocksize], 0

  puts begin_superblock(opts[:blocksize], blocks)
  0.step(opts[:thins] - 1) do |devid|
    puts begin_device(devid, opts[:thinsize])
    if opts[:range]
        puts range_mapping(0, to, blocks)
        to += blocks
    else
      0.step(blocks - 1) do |from|
        puts single_mapping(from, to)
        to += 1
      end
    end
    puts end_device
  end
  puts end_superblock
end


#----------------------------------------------------------------
# Main
#
xml_metadata(parse_command_line(ARGV, (units = init_units)), units)