thinp_xml 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWQzNjRkODNhYmI1NjMzZTUzNjk3OGRiNjIxY2M0NTI1ODdjYTcwYQ==
+  data.tar.gz: !binary |-
+    ZmZiYjljNmJkNmRiYzQ4MDQ2M2Q5MTZkMzVhODI3ZGZiMjkwMjk5MQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MmYzZDJjYTZmNGQ1NDkyOGNiODBlOGIzOWJiZGE5NzM3NDZkNTkxYjlmMjdh
+    MWQ2ODlhNTkzZjQwYzE5MzQ3MjVhMjA5OTJjNTA4NDU5ZTNjNjI0N2NiYzk2
+    YmI0ZmRmZWVlMDY3YWYzNzQwZWE3NjdmMzBlMTlkMzgzYjljODA=
+  data.tar.gz: !binary |-
+    ZWIxYzZmMWJkMTNiMDAwZDE5ZjA4ZDdkM2U3NWM3ZWU5MGMwNTQxOGRjYjMz
+    OGVjNzUwMGM3NTVlMTU2MjhhNTkyYjg2NDkxMDRlYjY0MTFiYzAwOGJkMzU0
+    YTc3OWZkNjIxZGJkZmJiOThiZGE0NDBhYzA4NTk3YzllNDJlYzc=

data/.gitignore

@@ -0,0 +1,18 @@
+*~
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in thinp_xml.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joe Thornber
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ThinpXml
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'thinp_xml'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install thinp_xml
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["--color"]
+end
+

data/bin/thinp_xml

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require 'thinp_xml'
+require 'thinp_xml/distribution'
+require 'ejt_command_line'
+
+#----------------------------------------------------------------
+
+XMLCommandLine = CommandLine::Parser.new do
+  value_type :string do |str|
+    str
+  end
+
+  value_type :int do |str|
+    Integer(str)
+  end
+
+  UNIFORM_REGEX = /uniform\[(\d+)..(\d+)\]/
+
+  value_type :int_distribution do |str|
+    m = UNIFORM_REGEX.match(str)
+    if m
+      ThinpXML::UniformDistribution.new(m[1].to_i, m[2].to_i + 1)
+    else
+      Integer(str)
+    end
+  end
+
+  simple_switch :help, '--help', '-h'
+  value_switch :uuid, :string, '--uuid'
+  value_switch :nr_thins, :int_distribution, '--nr-thins'
+  value_switch :nr_mappings, :int_distribution, '--nr-mappings'
+
+  global do
+    switches :help
+  end
+
+  command :create do
+    switches :uuid, :nr_thins, :nr_mappings
+  end
+end
+
+class Dispatcher
+  include ThinpXML
+
+  def global_command(opts, args)
+    if args.size > 0
+      die "unknown command '#{args[0]}'"
+    else
+      if opts[:help]
+        help(STDOUT)
+      else
+        die "no command given"
+      end
+    end
+  end
+
+  def create(opts, args)
+    b = ThinpXML::Builder.new
+    b.uuid = opts.fetch(:uuid, '')
+    b.nr_thins = opts.fetch(:nr_thins, 0)
+    b.nr_mappings = opts.fetch(:nr_mappings, 0)
+    md = b.generate
+    write_xml(md, STDOUT)
+  end
+
+  private
+  def die(msg)
+    STDERR.puts msg
+    exit(1)
+  end
+
+  def help(out)
+    out.write <<EOF
+Manipulation of thin provisioning xml format metadata
+  --help, -h:	Show this message
+EOF
+  end
+end
+
+def parse_command_line(dispatcher, *args)
+  XMLCommandLine.parse(dispatcher, *args)
+end
+
+def top_level_handler(&block)
+  begin
+    block.call
+  rescue => e
+    STDERR.puts e.message
+    exit 1
+  end
+
+  exit 0
+end
+
+#----------------------------------------------------------------
+
+top_level_handler do
+  dispatcher = Dispatcher.new
+  parse_command_line(dispatcher, *ARGV)
+end
+
+#----------------------------------------------------------------

data/features/create.feature

@@ -0,0 +1,57 @@
+Feature: I can create new metadata
+
+  Scenario: Create a valid superblock with no devices
+    When I thinp_xml create
+    Then the stdout should contain:
+    """
+    <superblock uuid="" time="0" transaction="1" data_block_size="128" nr_data_blocks="100">
+    </superblock>
+    """
+
+  Scenario: Create a valid superblock with specified uuid
+    When I thinp_xml create --uuid 'one two three'
+    Then the stdout should contain:
+    """
+    <superblock uuid="one two three" time="0" transaction="1" data_block_size="128" nr_data_blocks="100">
+    </superblock>
+    """
+
+  Scenario: Take an expression for the number of devices
+    When I thinp_xml create --nr-thins 3
+    Then the stdout should contain:
+    """
+    <superblock uuid="" time="0" transaction="1" data_block_size="128" nr_data_blocks="100">
+      <device dev_id="0" mapped_blocks="0" transaction="0" creation_time="0" snap_time="0">
+      </device>
+      <device dev_id="1" mapped_blocks="0" transaction="0" creation_time="0" snap_time="0">
+      </device>
+      <device dev_id="2" mapped_blocks="0" transaction="0" creation_time="0" snap_time="0">
+      </device>
+    </superblock>
+    """
+
+  Scenario: Take an expression for the number of mappings per device
+    When I thinp_xml create --nr-thins 1 --nr-mappings 67
+    Then the stdout should contain:
+    """
+    <superblock uuid="" time="0" transaction="1" data_block_size="128" nr_data_blocks="100">
+      <device dev_id="0" mapped_blocks="67" transaction="0" creation_time="0" snap_time="0">
+        <range_mapping origin_begin="0" data_begin="0" length="67" time="1"/>
+      </device>
+    </superblock>
+    """
+
+  Scenario: A uniform distribution can be given for nr thins
+    When I thinp_xml create --nr-thins uniform[4..7]
+    Then it should pass
+
+  Scenario: An unknown distrubution should fail for the nr thins
+    When I thinp_xml create --nr-thins fred[1..2]
+    Then it should fail
+
+  Scenario: A uniform distribution can be given for nr mappings
+    When I thinp_xml create --nr-thins 1 --nr-mappings uniform[40..100]
+    Then it should pass
+
+
+

data/features/step_definitions/thinp_xml.rb

@@ -0,0 +1,12 @@
+When(/^I thinp_xml (.*)$/) do |cmd|
+  run_simple(unescape("thinp_xml #{cmd}"), false)
+end
+
+Then(/^it should pass$/) do
+  assert_success(true)
+end
+
+Then(/^it should fail$/) do
+  assert_success(false)
+end
+

data/features/support/env.rb

@@ -0,0 +1,5 @@
+ENV['RUBYLIB'] = "#{Dir.pwd}"
+ENV['PATH'] = "#{Dir::pwd}:#{ENV['PATH']}"
+
+require 'thinp_xml'
+require 'aruba/cucumber'

data/features/usage.feature

@@ -0,0 +1,18 @@
+Feature: The tool should be helpful
+
+  Scenario: --help prints usage to stdout
+    When I thinp_xml --help
+    Then the stdout should contain:
+      """
+      Manipulation of thin provisioning xml format metadata
+        --help, -h:	Show this message
+      """
+
+  Scenario: Unknown sub commands cause fail
+    When I thinp_xml unleashtheearwigs
+    Then it should fail
+    And the stderr should contain:
+    """
+    unknown command 'unleashtheearwigs'
+    """
+

data/lib/thinp_xml/builder.rb

@@ -0,0 +1,39 @@
+require 'thinp_xml/metadata'
+
+#----------------------------------------------------------------
+
+module ThinpXML
+  class Builder
+    attr_accessor :uuid, :nr_thins, :nr_mappings
+
+    def initialize
+      @uuid = ''
+      @nr_thins = 0
+      @nr_mappings = 0
+    end
+
+    def generate
+      nr_thins = @nr_thins.to_i
+      nr_mappings = @nr_mappings.to_i
+
+      superblock = Superblock.new(@uuid, 0, 1, 128, 100)
+
+      devices = Array.new
+      offset = 0
+      0.upto(nr_thins - 1) do |dev|
+        mappings = Array.new
+
+        if nr_mappings > 0
+          mappings << Mapping.new(0, offset, nr_mappings, 1)
+          offset += nr_mappings
+        end
+
+        devices << Device.new(dev, nr_mappings, 0, 0, 0, mappings)
+      end
+
+      Metadata.new(superblock, devices)
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/distribution.rb

@@ -0,0 +1,28 @@
+#----------------------------------------------------------------
+
+module ThinpXML
+  class Distribution
+    def to_i
+      generate
+    end
+  end
+
+  class UniformDistribution
+    attr_accessor :start, :stop
+
+    def initialize(start, stop)
+      @start = start
+      @stop = stop
+    end
+
+    def generate
+      @start + rand(@stop - @start)
+    end
+
+    def to_i
+      generate
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/emit.rb

@@ -0,0 +1,69 @@
+require 'thinp_xml/metadata'
+
+#----------------------------------------------------------------
+
+module ThinpXML
+  class Emitter
+    def initialize(out)
+      @out = out
+      @indent = 0
+    end
+
+    def emit_tag(obj, tag, *fields, &block)
+      expanded = fields.map {|fld| "#{fld}=\"#{obj.send(fld)}\""}
+      if block.nil?
+        emit_line "<#{tag} #{expanded.join(' ')}/>"
+      else
+        emit_line "<#{tag} #{expanded.join(' ')}>"
+        push
+        yield unless block.nil?
+        pop
+        emit_line "</#{tag}>"
+      end
+    end
+
+    def emit_line(str)
+      @out.puts((' ' * @indent) + str)
+    end
+
+    def push
+      @indent += 2
+    end
+
+    def pop
+      @indent -= 2
+    end
+  end
+
+  def emit_superblock(e, sb, &block)
+    e.emit_tag(sb, 'superblock', :uuid, :time, :transaction, :data_block_size, :nr_data_blocks, &block)
+  end
+
+  def emit_device(e, dev, &block)
+    e.emit_tag(dev, 'device', :dev_id, :mapped_blocks, :transaction, :creation_time, :snap_time, &block)
+  end
+
+  def emit_mapping(e, m)
+    if m.length == 1
+      e.emit_line("<single_mapping origin_block=\"#{m.origin_begin}\" data_block=\"#{m.data_begin}\" time=\"#{m.time}\"/>")
+    else
+      e.emit_tag(m, 'range_mapping', :origin_begin, :data_begin, :length, :time)
+    end
+  end
+
+  def write_xml(metadata, io)
+    e = Emitter.new(io)
+
+    emit_superblock(e, metadata.superblock) do
+      metadata.devices.each do |dev|
+        emit_device(e, dev) do
+          dev.mappings.each do |m|
+            emit_mapping(e, m)
+          end
+        end
+      end
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/metadata.rb

@@ -0,0 +1,28 @@
+module ThinpXML
+  SUPERBLOCK_FIELDS = [[:uuid, :string],
+                       [:time, :int],
+                       [:transaction, :int],
+                       [:data_block_size, :int],
+                       [:nr_data_blocks, :int]]
+
+  MAPPING_FIELDS = [[:origin_begin, :int],
+                    [:data_begin, :int],
+                    [:length, :int],
+                    [:time, :int]]
+
+  DEVICE_FIELDS = [[:dev_id, :int],
+                   [:mapped_blocks, :int],
+                   [:transaction, :int],
+                   [:creation_time, :int],
+                   [:snap_time, :int],
+                   [:mappings, :object]]
+
+  def self.field_names(flds)
+    flds.map {|p| p[0]}
+  end
+
+  Superblock = Struct.new(*field_names(SUPERBLOCK_FIELDS))
+  Mapping = Struct.new(*field_names(MAPPING_FIELDS))
+  Device = Struct.new(*field_names(DEVICE_FIELDS))
+  Metadata = Struct.new(:superblock, :devices)
+end

data/lib/thinp_xml/parse.rb

@@ -0,0 +1,85 @@
+require 'thinp_xml/metadata'
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module ThinpXML
+  module ParseDetail
+    include REXML
+
+    class Listener
+      include REXML::StreamListener
+
+      attr_reader :metadata
+
+      def initialize
+        @metadata = Metadata.new(nil, Array.new)
+      end
+
+      def to_hash(pairs)
+        r = Hash.new
+        pairs.each do |p|
+          r[p[0].intern] = p[1]
+        end
+        r
+      end
+
+      def get_fields(attr, flds)
+        flds.map do |n,t|
+          case t
+          when :int
+            attr[n].to_i
+
+          when :string
+            attr[n]
+
+          when :object
+            attr[n]
+
+          else
+            raise "unknown field type"
+          end
+        end
+      end
+
+      def tag_start(tag, args)
+        attr = to_hash(args)
+
+        case tag
+        when 'superblock'
+          @metadata.superblock = Superblock.new(*get_fields(attr, SUPERBLOCK_FIELDS))
+
+        when 'device'
+          attr[:mappings] = Array.new
+          @current_device = Device.new(*get_fields(attr, DEVICE_FIELDS))
+          @metadata.devices << @current_device
+
+        when 'single_mapping'
+          @current_device.mappings << Mapping.new(attr[:origin_block].to_i, attr[:data_block].to_i, 1, attr[:time])
+
+        when 'range_mapping'
+          @current_device.mappings << Mapping.new(*get_fields(attr, MAPPING_FIELDS))
+
+        else
+          puts "unhandled tag '#{tag} #{attr.map {|x| x.inspect}.join(', ')}'"
+        end
+      end
+
+      def tag_end(tag)
+      end
+
+      def text(data)
+        return if data =~ /^\w*$/ # ignore whitespace
+        abbrev = data[0..40] + (data.length > 40 ? "..." : "")
+        puts "  text    :    #{abbrev.inspect}"
+      end
+    end
+  end
+
+  def read_xml(io)
+    l = ParseDetail::Listener.new
+    REXML::Document.parse_stream(io, l)
+    l.metadata
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/utils.rb

@@ -0,0 +1,115 @@
+require 'thinp_xml/metadata'
+
+#----------------------------------------------------------------
+
+module ThinpXML
+  def get_device(md, dev_id)
+    md.devices.each do |dev|
+      if dev.dev_id == dev_id
+        return dev
+      end
+    end
+  end
+
+  # Turns 2 lists of mappings, into a list of pairs of mappings.
+  # These pairs cover identical regions.  nil is used for the
+  # data_begin if that region isn't mapped.
+  def expand_mappings(left, right)
+    pairs = Array.new
+    i1 = 0
+    i2 = 0
+
+    m1 = left[i1]
+    m2 = right[i2]
+
+    # look away now ...
+    loop do
+      if !m1 && !m2
+        return pairs
+      elsif !m1
+        pairs << [Mapping.new(m2.origin_begin, nil, m2.length, m2.time),
+                  m2]
+        m2 = nil
+      elsif !m2
+        pairs << [m1,
+                  Mapping.new(m1.origin_begin, nil, m1.length, m1.time)]
+        m1 = nil
+      elsif m1.origin_begin < m2.origin_begin
+        if m1.origin_begin + m1.length <= m2.origin_begin
+          pairs << [Mapping.new(m1.origin_begin, m1.data_begin, m1.length, m1.time),
+                    Mapping.new(m1.origin_begin, nil, m1.length, m1.time)]
+          i1 += 1
+          m1 = left[i1]
+        else
+          len = m2.origin_begin - m1.origin_begin
+          pairs << [Mapping.new(m1.origin_begin, m1.data_begin, len, m1.time),
+                    Mapping.new(m1.origin_begin, nil, len, m1.time)]
+          m1 = Mapping.new(m1.origin_begin + len, m1.data_begin + len, m1.length - len, m1.time)
+        end
+      elsif m2.origin_begin < m1.origin_begin
+        if m2.origin_begin + m2.length <= m1.origin_begin
+          pairs << [Mapping.new(m2.origin_begin, nil, m2.length, m2.time),
+                    Mapping.new(m2.origin_begin, m2.data_begin, m2.length, m2.time)]
+          i2 += 1
+          m2 = right[i2]
+        else
+          len = m1.origin_begin - m2.origin_begin
+          pairs << [Mapping.new(m2.origin_begin, nil, len, m2.time),
+                    Mapping.new(m2.origin_begin, m2.data_begin, len, m2.time)]
+          m2 = Mapping.new(m2.origin_begin + len, m2.data_begin + len, m2.length - len, m2.time)
+        end
+      else
+        len = [m1.length, m2.length].min
+        pairs << [Mapping.new(m1.origin_begin, m1.data_begin, len, m1.time),
+                  Mapping.new(m1.origin_begin, m2.data_begin, len, m2.time)]
+        if m1.length < m2.length
+          i1 += 1
+          m1 = left[i1]
+          m2 = Mapping.new(m2.origin_begin + len, m2.data_begin + len, m2.length - len, m2.time)
+        elsif m2.length < m1.length
+          i2 += 1
+          m1 = Mapping.new(m1.origin_begin + len, m1.data_begin + len, m1.length - len, m1.time)
+          m2 = right[i2]
+        else
+          i1 += 1
+          i2 += 1
+          m1 = left[i1]
+          m2 = right[i2]
+        end
+      end
+    end
+  end
+
+  # returns 3 arrays of mappings: unique to first arg, common, unique
+  # to second arg
+  def compare_devs(md_dev1, md_dev2)
+    m1 = md_dev1.mappings
+    m2 = md_dev2.mappings
+
+    left = Array.new
+    center = Array.new
+    right = Array.new
+
+    expand_mappings(m1, m2).each do |pair|
+      if pair[0].data_begin == pair[1].data_begin &&
+          pair[0].time == pair[1].time
+        # mappings are the same
+        center << pair[0]
+      else
+        left << pair[0]
+        right << pair[1]
+      end
+    end
+
+    [left, center, right].each {|a| a.reject {|e| e.data_begin == nil}}
+    [left, center, right]
+  end
+
+  def compare_thins(md1, md2, dev_id)
+    compare_devs(get_device(md1, dev_id),
+                 get_device(md2, dev_id))
+  end
+end
+
+#----------------------------------------------------------------
+

data/lib/thinp_xml/version.rb

@@ -0,0 +1,3 @@
+module ThinpXml
+  VERSION = "0.0.1"
+end

data/lib/thinp_xml/xml_format.rb

@@ -0,0 +1,286 @@
+# The thin_dump and thin_restore use an xml based external
+# representation of the metadata.  This module gives the test suite
+# access to this xml data.
+
+#----------------------------------------------------------------
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module XMLFormat
+  include REXML
+
+  SUPERBLOCK_FIELDS = [[:uuid, :string],
+                       [:time, :int],
+                       [:transaction, :int],
+                       [:data_block_size, :int],
+                       [:nr_data_blocks, :int]]
+
+  MAPPING_FIELDS = [[:origin_begin, :int],
+                    [:data_begin, :int],
+                    [:length, :int],
+                    [:time, :int]]
+
+  DEVICE_FIELDS = [[:dev_id, :int],
+                   [:mapped_blocks, :int],
+                   [:transaction, :int],
+                   [:creation_time, :int],
+                   [:snap_time, :int],
+                   [:mappings, :object]]
+
+  def self.field_names(flds)
+    flds.map {|p| p[0]}
+  end
+
+  Superblock = Struct.new(*field_names(SUPERBLOCK_FIELDS))
+  Mapping = Struct.new(*field_names(MAPPING_FIELDS))
+  Device = Struct.new(*field_names(DEVICE_FIELDS))
+  Metadata = Struct.new(:superblock, :devices)
+
+  class Listener
+    include REXML::StreamListener
+
+    attr_reader :metadata
+
+    def initialize
+      @metadata = Metadata.new(nil, Array.new)
+    end
+
+    def to_hash(pairs)
+      r = Hash.new
+      pairs.each do |p|
+        r[p[0].intern] = p[1]
+      end
+      r
+    end
+
+    def get_fields(attr, flds)
+      flds.map do |n,t|
+        case t
+        when :int
+          attr[n].to_i
+
+        when :string
+          attr[n]
+
+        when :object
+          attr[n]
+
+        else
+          raise "unknown field type"
+        end
+      end
+    end
+
+    def tag_start(tag, args)
+      attr = to_hash(args)
+
+      case tag
+      when 'superblock'
+        @metadata.superblock = Superblock.new(*get_fields(attr, SUPERBLOCK_FIELDS))
+
+      when 'device'
+        attr[:mappings] = Array.new
+        @current_device = Device.new(*get_fields(attr, DEVICE_FIELDS))
+        @metadata.devices << @current_device
+
+      when 'single_mapping'
+        @current_device.mappings << Mapping.new(attr[:origin_block].to_i, attr[:data_block].to_i, 1, attr[:time])
+
+      when 'range_mapping'
+        @current_device.mappings << Mapping.new(*get_fields(attr, MAPPING_FIELDS))
+
+      else
+        puts "unhandled tag '#{tag} #{attr.map {|x| x.inspect}.join(', ')}'"
+      end
+    end
+
+    def tag_end(tag)
+    end
+
+    def text(data)
+      return if data =~ /^\w*$/ # ignore whitespace
+      abbrev = data[0..40] + (data.length > 40 ? "..." : "")
+      puts "  text    :    #{abbrev.inspect}"
+    end
+  end
+
+  def read_xml(io)
+    l = Listener.new
+    Document.parse_stream(io, l)
+    l.metadata
+  end
+
+  class Emitter
+    def initialize(out)
+      @out = out
+      @indent = 0
+    end
+
+    def emit_tag(obj, tag, *fields, &block)
+      expanded = fields.map {|fld| "#{fld}=\"#{obj.send(fld)}\""}
+      if block.nil?
+        emit_line "<#{tag} #{expanded.join(' ')}/>"
+      else
+        emit_line "<#{tag} #{expanded.join(' ')}>"
+        push
+        yield unless block.nil?
+        pop
+        emit_line "</#{tag}>"
+      end
+    end
+
+    def emit_line(str)
+      @out.puts((' ' * @indent) + str)
+    end
+
+    def push
+      @indent += 2
+    end
+
+    def pop
+      @indent -= 2
+    end
+  end
+
+  def emit_superblock(e, sb, &block)
+    e.emit_tag(sb, 'superblock', :uuid, :time, :transaction, :data_block_size, :nr_data_blocks, &block)
+  end
+
+  def emit_device(e, dev, &block)
+    e.emit_tag(dev, 'device', :dev_id, :mapped_blocks, :transaction, :creation_time, :snap_time, &block)
+  end
+
+  def emit_mapping(e, m)
+    if m.length == 1
+      e.emit_line("<single_mapping origin_block=\"#{m.origin_begin}\" data_block=\"#{m.data_begin}\" time=\"#{m.time}\"/>")
+    else
+      e.emit_tag(m, 'range_mapping', :origin_begin, :data_begin, :length, :time)
+    end
+  end
+
+  def write_xml(metadata, io)
+    e = Emitter.new(io)
+
+    emit_superblock(e, metadata.superblock) do
+      metadata.devices.each do |dev|
+        emit_device(e, dev) do
+          dev.mappings.each do |m|
+            emit_mapping(e, m)
+          end
+        end
+      end
+    end
+  end
+
+  #--------------------------------------------------------------
+
+  def get_device(md, dev_id)
+    md.devices.each do |dev|
+      if dev.dev_id == dev_id
+        return dev
+      end
+    end
+  end
+
+  # Turns 2 lists of mappings, into a list of pairs of mappings.
+  # These pairs cover identical regions.  nil is used for the
+  # data_begin if that region isn't mapped.
+  def expand_mappings(left, right)
+    pairs = Array.new
+    i1 = 0
+    i2 = 0
+
+    m1 = left[i1]
+    m2 = right[i2]
+
+    # look away now ...
+    loop do
+      if !m1 && !m2
+        return pairs
+      elsif !m1
+        pairs << [Mapping.new(m2.origin_begin, nil, m2.length, m2.time),
+                  m2]
+        m2 = nil
+      elsif !m2
+        pairs << [m1,
+                  Mapping.new(m1.origin_begin, nil, m1.length, m1.time)]
+        m1 = nil
+      elsif m1.origin_begin < m2.origin_begin
+        if m1.origin_begin + m1.length <= m2.origin_begin
+          pairs << [Mapping.new(m1.origin_begin, m1.data_begin, m1.length, m1.time),
+                    Mapping.new(m1.origin_begin, nil, m1.length, m1.time)]
+          i1 += 1
+          m1 = left[i1]
+        else
+          len = m2.origin_begin - m1.origin_begin
+          pairs << [Mapping.new(m1.origin_begin, m1.data_begin, len, m1.time),
+                    Mapping.new(m1.origin_begin, nil, len, m1.time)]
+          m1 = Mapping.new(m1.origin_begin + len, m1.data_begin + len, m1.length - len, m1.time)
+        end
+      elsif m2.origin_begin < m1.origin_begin
+        if m2.origin_begin + m2.length <= m1.origin_begin
+          pairs << [Mapping.new(m2.origin_begin, nil, m2.length, m2.time),
+                    Mapping.new(m2.origin_begin, m2.data_begin, m2.length, m2.time)]
+          i2 += 1
+          m2 = right[i2]
+        else
+          len = m1.origin_begin - m2.origin_begin
+          pairs << [Mapping.new(m2.origin_begin, nil, len, m2.time),
+                    Mapping.new(m2.origin_begin, m2.data_begin, len, m2.time)]
+          m2 = Mapping.new(m2.origin_begin + len, m2.data_begin + len, m2.length - len, m2.time)
+        end
+      else
+        len = [m1.length, m2.length].min
+        pairs << [Mapping.new(m1.origin_begin, m1.data_begin, len, m1.time),
+                  Mapping.new(m1.origin_begin, m2.data_begin, len, m2.time)]
+        if m1.length < m2.length
+          i1 += 1
+          m1 = left[i1]
+          m2 = Mapping.new(m2.origin_begin + len, m2.data_begin + len, m2.length - len, m2.time)
+        elsif m2.length < m1.length
+          i2 += 1
+          m1 = Mapping.new(m1.origin_begin + len, m1.data_begin + len, m1.length - len, m1.time)
+          m2 = right[i2]
+        else
+          i1 += 1
+          i2 += 1
+          m1 = left[i1]
+          m2 = right[i2]
+        end
+      end
+    end
+  end
+
+  # returns 3 arrays of mappings: unique to first arg, common, unique
+  # to second arg
+  def compare_devs(md_dev1, md_dev2)
+    m1 = md_dev1.mappings
+    m2 = md_dev2.mappings
+
+    left = Array.new
+    center = Array.new
+    right = Array.new
+
+    expand_mappings(m1, m2).each do |pair|
+      if pair[0].data_begin == pair[1].data_begin &&
+          pair[0].time == pair[1].time
+        # mappings are the same
+        center << pair[0]
+      else
+        left << pair[0]
+        right << pair[1]
+      end
+    end
+
+    [left, center, right].each {|a| a.reject {|e| e.data_begin == nil}}
+    [left, center, right]
+  end
+
+  def compare_thins(md1, md2, dev_id)
+    compare_devs(get_device(md1, dev_id),
+                 get_device(md2, dev_id))
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml.rb

@@ -0,0 +1,18 @@
+module ThinpXML
+  THINP_TOOLS_VERSION = '0.1.5'
+
+  def self.tools_are_installed
+    true
+  end
+end
+
+unless ThinpXML::tools_are_installed
+  raise "please install the thin provisioning tools version #{THINP_TOOLS_VERSION}"
+end
+
+require 'thinp_xml/builder'
+require 'thinp_xml/emit'
+require 'thinp_xml/metadata'
+require 'thinp_xml/parse'
+require 'thinp_xml/utils'
+require 'thinp_xml/version'

data/spec/builder_spec.rb

@@ -0,0 +1,96 @@
+require 'thinp_xml/builder'
+
+#----------------------------------------------------------------
+
+describe "ThinpXML::Builder" do
+  before :each do
+    @b = ThinpXML::Builder.new
+  end
+
+  def total_mapped(device)
+    device.mappings.inject(0) {|sum, m| sum + m.length}
+  end
+
+  describe "uuid" do
+    it "should be an empty string by default" do
+      @b.uuid.should == ''
+    end
+
+    it "should reflect any changes" do
+      uuid = 'one two three'
+      @b.uuid = uuid
+      @b.uuid.should == uuid
+    end
+
+    it "should generate the correct uuid" do
+      uuid = 'one two three'
+      @b.uuid = uuid
+      md = @b.generate
+      md.superblock.uuid.should == uuid
+    end
+  end
+
+  describe "nr of thins" do
+    it "zero by default" do
+      @b.nr_thins.should == 0
+    end
+
+    it "should reflect any changes" do
+      @b.nr_thins = 5
+      @b.nr_thins.should == 5
+    end
+
+    it "should generate the correct nr" do
+      @b.nr_thins = 5
+      md = @b.generate
+
+      md.should have(5).devices
+      0.upto(4) do |n|
+        md.devices[n].should_not == nil
+      end
+    end
+
+    it "should take a distribution" do
+      @b.nr_thins = UniformDistribution.new(2, 6)
+      md = @b.generate
+
+      md.should have_at_most(5).devices
+      md.should have_at_least(2).devices
+    end
+  end
+
+  describe "nr of mappings" do
+    it "none by default" do
+      @b.nr_thins = 1
+      @b.generate.devices[0].should have(0).mappings
+    end
+
+    it "should reflect any changes" do
+      @b.nr_mappings = 101
+      @b.nr_mappings.should == 101
+    end
+
+    it "should generate the correct nr" do
+      @b.nr_thins = 5
+      @b.nr_mappings = 101
+      md = @b.generate
+
+      0.upto(@b.nr_thins - 1) do |n|
+        dev = md.devices[n]
+        total = total_mapped(dev)
+        total.should == 101
+        dev.mapped_blocks.should == 101
+      end
+    end
+
+    it "should generate a single mapping" do
+      @b.nr_thins = 1
+      @b.nr_mappings = 101
+      md = @b.generate
+
+      md.devices[0].should have(1).mappings
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/spec/distribution_spec.rb

@@ -0,0 +1,63 @@
+require 'thinp_xml/distribution'
+
+include ThinpXML
+
+#----------------------------------------------------------------
+
+module ApproxInt
+  def approx?(target, delta)
+    (self.to_i >= target - delta) && (self.to_i <= target + delta)
+  end
+end
+
+class Fixnum
+  include ApproxInt
+end
+
+class Bignum
+  include ApproxInt
+end
+
+#----------------------------------------------------------------
+
+describe "random distributions" do
+  describe UniformDistribution do
+    it "should be constructed with a range of values" do
+      dist = UniformDistribution.new(1, 10)
+    end
+
+    it "should generate a number from this range every time generate is called" do
+      dist = UniformDistribution.new(1, 10)
+
+      buckets = Array.new(11, 0)
+
+      10000.times do
+        buckets[dist.generate] += 1
+      end
+
+      buckets[0].should == 0
+      buckets[10].should == 0
+
+      1.upto(9) do |n|
+        buckets[n].should be_approx(1000, 200)
+      end
+    end
+
+    it "should have a to_i method that just calls generate" do
+      dist = UniformDistribution.new(1, 10)
+
+      # redefine generate
+      $called456 = false
+      class << dist
+        def generate
+          $called456 = true
+        end
+      end
+
+      dist.to_i
+      $called456.should be_true
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/thinp_xml.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'thinp_xml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "thinp_xml"
+  spec.version       = ThinpXml::VERSION
+  spec.authors       = ["Joe Thornber"]
+  spec.email         = ["ejt@redhat.com"]
+  spec.description   = %q{Ruby library for parsing and generating the Linux thin-provisioning xml metadata format.}
+  spec.summary       = %q{Thin provisioning xml}
+  spec.homepage      = ""
+  spec.license       = "GPL"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ejt_command_line", "0.0.2"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'json', '~> 1.7.7'
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "aruba"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: thinp_xml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe Thornber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ejt_command_line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby library for parsing and generating the Linux thin-provisioning xml
+  metadata format.
+email:
+- ejt@redhat.com
+executables:
+- thinp_xml
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/thinp_xml
+- features/create.feature
+- features/step_definitions/thinp_xml.rb
+- features/support/env.rb
+- features/usage.feature
+- lib/thinp_xml.rb
+- lib/thinp_xml/builder.rb
+- lib/thinp_xml/distribution.rb
+- lib/thinp_xml/emit.rb
+- lib/thinp_xml/metadata.rb
+- lib/thinp_xml/parse.rb
+- lib/thinp_xml/utils.rb
+- lib/thinp_xml/version.rb
+- lib/thinp_xml/xml_format.rb
+- spec/builder_spec.rb
+- spec/distribution_spec.rb
+- thinp_xml.gemspec
+homepage: ''
+licenses:
+- GPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Thin provisioning xml
+test_files:
+- features/create.feature
+- features/step_definitions/thinp_xml.rb
+- features/support/env.rb
+- features/usage.feature
+- spec/builder_spec.rb
+- spec/distribution_spec.rb