thinp_xml 0.0.7 → 0.0.8

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NThkNzE3MWRlMTA1YjQxZDUyOTQ2NWQ3Yjk2YTU1ZWExYjRkNGIyZA==
+    ZTdjOGQ5NDUyYzJiYzY2MzExMjU4MzhjNWZkMjg5MzcyOTVlZDU1ZA==
   data.tar.gz: !binary |-
-    MjZiNDliOTczYjEyNTk3NTA4YjhmNTBkYmJmY2EwMmIxY2M1OTVlMw==
+    ODNkZmU4YzE2OTQxZThjYmFlZjkxZTZjOTdkMTBhOWYyOTgwNmY0Mw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZGE1ZWU2YWIxZDI3ZDNmODAzMDc4YjJjMTk2YWQ5ZTMyMzM3MmMyZWQzNDBl
-    MTlhZTZiYzBhZDc1NmVjMDc4OWY4ODAwZTQzNzMzOWJhNzE3MGQ3ODI1NTgz
-    YWE1YmRkN2VkOTU0YTE2ZWYyOWY3MzEwNmMwMjdkNzkzMGZiZTk=
+    ZWI5OWZjNTEzZjUyYzQ5YzM1YTViYmIxMzcyMjZjYTg1ZDU4MzYyNjc3MzI4
+    NTAwNDU4ZjYzMGNhOGU2Njg0MWYzZjQxZWU1OWUyYjhmZTBkYWY4YzBjMjNh
+    ODJmNzAxMmYyOWY4ZDVjYTEwMTZkMGU5NGJkMWIzY2U0ZGE1MGM=
   data.tar.gz: !binary |-
-    YTM5Yjk2ZjkyZmY3YzY3ZWM2ZTFkZmM1ZDEzNWE1ZjRhMmZiNGMxOTNkY2Nl
-    OGY4NjQyMzE2NzliNWRkZjZkYjNjNzY4Njg5ZjE3YzIzNWRiMzFlZWQ3MmYw
-    MzVhYzJlOWYyZjEzYjg4MjhmODcyZGQ5YWVlYzg2ZjJmYTljM2U=
+    NTNlOGY3NDU4MWYzYWY3YjViNjJkYjE5ZTNiMmM2Y2NkZmM5NGYwMTdhZjRj
+    NzdjMTI1NjM1NWU1ZDI3ODU3ZjkxZGYzZGUyN2RlMjMwNmM3YTg4Mjg3NWQ4
+    NDBkYWZlMjA5NmU3MmFhOGE3Nzk2NzZlNGM0YTljOTZjNTgwMzc=

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/bin/cache_xml

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require 'thinp_xml/cache_xml'
+require 'thinp_xml/distribution'
+require 'ejt_command_line'
+
+include ThinpXML
+
+#----------------------------------------------------------------
+
+CacheCommandLine = CommandLine::Parser.new do
+  value_type :string do |str|
+    str
+  end
+
+  value_type :int do |str|
+    Integer(str)
+  end
+
+  value_type :distribution do |str|
+    parse_distribution(str)
+  end
+
+  value_type :layout do |str|
+    case str
+    when 'random'
+      :random
+
+    when 'linear'
+      :linear
+
+    else
+      raise "unknown mapping layout '#{str}'"
+    end
+  end
+
+  value_type :percentage do |str|
+    i = Integer(str)
+    raise "invalid percentage value (#{i})" if i < 0 || i > 100
+    i
+  end
+
+  simple_switch :help, '--help', '-h'
+  value_switch :uuid, :string, '--uuid'
+  value_switch :block_size, :int, '--block-size'
+  value_switch :nr_cache_blocks, :distribution, '--nr-cache-blocks'
+  value_switch :nr_mappings, :distribution, '--nr-mappings'
+  value_switch :mapping_policy, :layout, '--layout'
+  value_switch :dirty_percentage, :percentage, '--dirty-percent'
+
+  global do
+    switches :help
+  end
+
+  command :create do
+    switches :nr_cache_blocks, :uuid, :block_size, :nr_mappings, :mapping_policy, :dirty_percentage
+  end
+end
+
+#--------------------------------
+
+class Dispatcher
+  include CacheXML
+
+  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 = Builder.new
+    b.uuid = opts.fetch(:uuid, '')
+    b.nr_cache_blocks = opts.fetch(:nr_cache_blocks, 0).to_i
+    b.block_size = opts.fetch(:block_size, 128)
+    b.nr_mappings = opts.fetch(:nr_mappings, 0)
+    b.mapping_policy = opts.fetch(:mapping_policy, :random)
+    b.dirty_percentage = opts.fetch(:dirty_percentage, 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 cache xml format metadata
+  --help, -h:	Show this message
+EOF
+  end
+end
+
+def parse_command_line(dispatcher, *args)
+  CacheCommandLine.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/bin/thinp_xml

@@ -4,6 +4,8 @@ require 'thinp_xml'
 require 'thinp_xml/distribution'
 require 'ejt_command_line'
 
+include ThinpXML
+
 #----------------------------------------------------------------
 
 XMLCommandLine = CommandLine::Parser.new do
@@ -15,15 +17,8 @@ XMLCommandLine = CommandLine::Parser.new do
     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
+    parse_distribution(str)
   end
 
   simple_switch :help, '--help', '-h'
@@ -41,6 +36,8 @@ XMLCommandLine = CommandLine::Parser.new do
   end
 end
 
+#--------------------------------
+
 class Dispatcher
   include ThinpXML
 

data/features/cache_create.feature

@@ -0,0 +1,65 @@
+Feature: I can create new metadata
+
+  Scenario: Create a valid superblock with no mappings
+    When I cache_xml create
+    Then the stdout should contain:
+    """
+    <superblock uuid="" block_size="128" nr_cache_blocks="0">
+    </superblock>
+    """
+
+  Scenario: Create a valid superblock with specified uuid
+    When I cache_xml create --uuid 'one two three'
+    Then the stdout should contain:
+    """
+    <superblock uuid="one two three" block_size="128" nr_cache_blocks="0">
+    </superblock>
+    """
+
+  Scenario: Create a valid superblock with specified block size
+    When I cache_xml create --block-size 512
+    Then the stdout should contain:
+    """
+    <superblock uuid="" block_size="512" nr_cache_blocks="0">
+    </superblock>
+    """
+
+  Scenario: Take an integer for the number of cached blocks
+    When I cache_xml create --nr-cache-blocks 345
+    Then the stdout should contain:
+    """
+    <superblock uuid="" block_size="128" nr_cache_blocks="345">
+    </superblock>
+    """
+
+  Scenario: Take a uniform distribution  for the number of cached blocks
+    When I cache_xml create --nr-cache-blocks uniform[123..124]
+    Then the stdout should contain:
+    """
+    <superblock uuid="" block_size="128" nr_cache_blocks="123">
+    </superblock>
+    """
+
+  Scenario: Take an integer for the number of mappings
+    When I cache_xml create --nr-cache-blocks 3 --nr-mappings 3 --layout linear
+    Then the stdout should contain:
+    """
+    <superblock uuid="" block_size="128" nr_cache_blocks="3">
+      <mapping cache_block="0" origin_block="0" dirty="false"/>
+      <mapping cache_block="1" origin_block="1" dirty="false"/>
+      <mapping cache_block="2" origin_block="2" dirty="false"/>
+    </superblock>
+    """
+
+  Scenario: Take a percentage for the number of dirty mappings
+    When I cache_xml create --nr-cache-blocks 3 --nr-mappings 3 --layout linear --dirty-percent 100
+    Then the stdout should contain:
+    """
+    <superblock uuid="" block_size="128" nr_cache_blocks="3">
+      <mapping cache_block="0" origin_block="0" dirty="true"/>
+      <mapping cache_block="1" origin_block="1" dirty="true"/>
+      <mapping cache_block="2" origin_block="2" dirty="true"/>
+    </superblock>
+    """
+
+    

data/features/cache_usage.feature

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

data/features/step_definitions/thinp_xml.rb

@@ -2,6 +2,10 @@ When(/^I thinp_xml (.*)$/) do |cmd|
   run_simple(unescape("thinp_xml #{cmd}"), false)
 end
 
+When(/^I cache_xml (.*)$/) do |cmd|
+  run_simple(unescape("cache_xml #{cmd}"), false)
+end
+
 Then(/^it should pass$/) do
   assert_success(true)
 end

data/lib/thinp_xml/cache/builder.rb

@@ -0,0 +1,92 @@
+require 'thinp_xml/cache/metadata'
+
+#----------------------------------------------------------------
+
+module CacheXML
+  class Builder
+    attr_accessor :uuid, :block_size, :nr_cache_blocks, :policy_name
+    attr_reader :mapping_policy, :nr_mappings, :dirty_percentage
+
+    def initialize
+      @uuid = ''
+      @block_size = 128
+      @nr_cache_blocks = 0
+      @policy_name = 'mq'
+      @mapping_policy = :random
+      @nr_mappings = 0
+      @dirty_percentage = 0
+    end
+
+    def generate
+      superblock = Superblock.new(@uuid, @block_size.to_i, @nr_cache_blocks.to_i, @policy_name)
+      mappings = []
+
+      case @mapping_policy
+      when :linear
+        cb = 0
+        ob = safe_rand(@nr_cache_blocks - @nr_mappings)
+
+        @nr_mappings.times do
+          dirty = safe_rand(100) < @dirty_percentage
+          mappings << Mapping.new(cb, ob, dirty)
+          cb += 1
+          ob += 1
+        end
+
+      when :random
+        origin_blocks = []
+
+        ob = 0
+        @nr_mappings.times do
+          origin_blocks << ob
+          ob += 1
+        end
+
+        0.upto(@nr_mappings - 1) do |n|
+          tmp = origin_blocks[n]
+
+          index = n + rand(@nr_mappings - n)
+          origin_blocks[n] = origin_blocks[index]
+          origin_blocks[index] = tmp
+
+          dirty = safe_rand(100) < @dirty_percentage
+          mappings << Mapping.new(n, origin_blocks[n], dirty)
+        end
+
+      else
+        raise "unknown mapping policy"
+      end
+
+      hints = []
+
+      Metadata.new(superblock, mappings, hints)
+    end
+
+    def mapping_policy=(sym)
+      raise "mapping policy must be :random or :linear" unless valid_policy(sym)
+      @mapping_policy = sym
+    end
+
+    def nr_mappings=(n)
+      n = n.to_i
+      #raise "nr_mappings must not exceed nr_cache_blocks" if n > @nr_cache_blocks
+      @nr_mappings = n
+    end
+
+    def dirty_percentage=(n)
+      raise "invalid percentage (#{n})" if n < 0 || n > 100
+      @dirty_percentage = n
+    end
+
+    private
+    def valid_policy(sym)
+      [:random, :linear].member?(sym)
+    end
+
+    def safe_rand(n)
+      n == 0 ? 0 : rand(n)
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/cache/emit.rb

@@ -0,0 +1,43 @@
+require 'thinp_xml/cache/metadata'
+require 'thinp_xml/emitter'
+
+#----------------------------------------------------------------
+
+module CacheXML
+  module CacheEmitterDetail
+    class CacheEmitter
+      def initialize(out)
+        @e = ThinpXML::Base::Emitter.new(out)
+      end
+
+      def emit_superblock(sb, &block)
+        @e.emit_tag(sb, 'superblock', :uuid, :block_size, :nr_cache_blocks, &block)
+      end
+
+      def emit_mapping(m)
+        @e.emit_tag(m, 'mapping', :cache_block, :origin_block, :dirty)
+      end
+
+      def emit_hint(h)
+        @e.emit_line("<hint cache_block=\"#{m.cache_block}\" data=\"#{h.encoded_data}\"\>")
+      end
+    end
+  end
+
+  #--------------------------------
+
+  def write_xml(metadata, io)
+    e = CacheEmitterDetail::CacheEmitter.new(io)
+    e.emit_superblock(metadata.superblock) do
+      metadata.mappings.each do |m|
+        e.emit_mapping(m)
+      end
+
+      metadata.hints.each do |h|
+        e.emit_hint(h)
+      end
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/cache/metadata.rb

@@ -0,0 +1,22 @@
+module CacheXML
+  SUPERBLOCK_FIELDS = [[:uuid, :string],
+                       [:block_size, :int],
+                       [:nr_cache_blocks, :int],
+                       [:policy_name, :string]]
+
+  MAPPING_FIELDS = [[:cache_block, :int],
+                    [:origin_block, :int],
+                    [:dirty, :bool]]
+
+  HINT_FIELDS = [[:cache_block, :int],
+                 [:encoded_data, :string]]
+
+  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))
+  Hint = Struct.new(*field_names(HINT_FIELDS))
+  Metadata = Struct.new(:superblock, :mappings, :hints)
+end

data/lib/thinp_xml/cache/parse.rb

@@ -0,0 +1,53 @@
+require 'thinp_xml/listener'
+require 'thinp_xml/cache/metadata'
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+#----------------------------------------------------------------
+
+module ThinpXML
+  module CacheParseDetail
+    class Listener
+      include Base::ListenerUtils
+      include REXML::StreamListener
+
+      attr_reader :metadata
+
+      def initialize
+        @metadata = Metdadata.new(nil, [], [])
+      end
+
+      def tag_start(tag, args)
+        attr = to_hash(args)
+
+        case tag
+        when 'superblock'
+          @metadata.superblock = Superblock.new(*get_fields(attr, SUPERBLOCK_FIELDS))
+
+        when 'mapping'
+          m = Mapping.new(*get_fields(attr, MAPPING_FIELDS))
+          @metadata.mappings << m
+
+        when 'hint'
+          h = Hint.new(*get_fields(attr, HINT_FIELDS))
+          @metadata.hints << h
+
+        else
+          raise "unhandled tag '#{tag} #{attr.map {|x| x.inspect}.join(' ')}'"
+        end
+      end
+
+      def tag_end(tag)
+      end
+    end
+  end
+
+  def read_xml(io)
+    l = CacheParseDetail::Listener.new
+    REXML::Document.parse_stream(io, l)
+    l.metadata
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/cache_xml.rb

@@ -0,0 +1,5 @@
+require 'thinp_xml/cache/builder'
+require 'thinp_xml/cache/emit'
+require 'thinp_xml/cache/metadata'
+require 'thinp_xml/cache/parse'
+require 'thinp_xml/version'

data/lib/thinp_xml/distribution.rb

@@ -7,10 +7,23 @@ module ThinpXML
     end
   end
 
-  class UniformDistribution
+  class ConstDistribution < Distribution
+    def initialize(v)
+      raise "ConstDistribution must be constructed with an integer" if !v.kind_of?(Integer)
+      @v = v
+    end
+
+    def generate
+      @v
+    end
+  end
+
+  class UniformDistribution < Distribution
     attr_accessor :start, :stop
 
     def initialize(start, stop)
+      raise "invalid range [#{start}..#{stop})" unless start < stop
+
       @start = start
       @stop = stop
     end
@@ -18,9 +31,18 @@ module ThinpXML
     def generate
       @start + rand(@stop - @start)
     end
+  end
 
-    def to_i
-      generate
+  #--------------------------------
+
+  UNIFORM_REGEX = /uniform\[(\d+)..(\d+)\]/
+
+  def parse_distribution(str)
+    m = UNIFORM_REGEX.match(str)
+    if m
+      ThinpXML::UniformDistribution.new(m[1].to_i, m[2].to_i)
+    else
+      ConstDistribution.new(Integer(str))
     end
   end
 end

data/lib/thinp_xml/emitter.rb

@@ -0,0 +1,40 @@
+#----------------------------------------------------------------
+
+module ThinpXML
+  module Base
+    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
+
+      private
+      def emit_line(str)
+        @out.puts((' ' * @indent) + str)
+      end
+
+      def push
+        @indent += 2
+      end
+
+      def pop
+        @indent -= 2
+      end
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/listener.rb

@@ -0,0 +1,51 @@
+#----------------------------------------------------------------
+
+module ThinpXML
+  module Base
+    module ListenerUtils
+      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 :bool
+            case attr[n]
+            when 'true'
+              true
+            when 'false'
+              false
+            else
+              raise "bad boolean value '#{attr[n]}'"
+            end
+
+          when :string
+            attr[n]
+
+          when :object
+            attr[n]
+
+          else
+            raise "unknown field type"
+          end
+        end
+      end
+
+      def text(data)
+        return if data =~ /^\w*$/ # ignore whitespace
+        abbrev = data[0..40] + (data.length > 40 ? "..." : "")
+        puts "  text    :    #{abbrev.inspect}"
+      end
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/{builder.rb → thinp/builder.rb}

@@ -1,4 +1,4 @@
-require 'thinp_xml/metadata'
+require 'thinp_xml/thinp/metadata'
 
 #----------------------------------------------------------------
 

data/lib/thinp_xml/thinp/emit.rb

@@ -0,0 +1,48 @@
+require 'thinp_xml/thinp/metadata'
+require 'thinp_xml/emitter'
+
+#----------------------------------------------------------------
+
+module ThinpXML
+  module EmitterDetail
+    class ThinpEmitter
+      def initialize(out)
+        @e = ThinpXML::Base::Emitter.new(out)
+      end
+
+      def emit_superblock(sb, &block)
+        @e.emit_tag(sb, 'superblock', :uuid, :time, :transaction, :data_block_size, :nr_data_blocks, &block)
+      end
+
+      def emit_device(dev, &block)
+        @e.emit_tag(dev, 'device', :dev_id, :mapped_blocks, :transaction, :creation_time, :snap_time, &block)
+      end
+
+      def emit_mapping(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
+    end
+  end
+
+  #--------------------------------
+
+  def write_xml(metadata, io)
+    e = EmitterDetail::ThinpEmitter.new(io)
+
+    e.emit_superblock(metadata.superblock) do
+      metadata.devices.each do |dev|
+        e.emit_device(dev) do
+          dev.mappings.each do |m|
+            e.emit_mapping(m)
+          end
+        end
+      end
+    end
+  end
+end
+
+#----------------------------------------------------------------

data/lib/thinp_xml/{parse.rb → thinp/parse.rb}

@@ -1,12 +1,17 @@
-require 'thinp_xml/metadata'
+require 'thinp_xml/thinp/metadata'
+require 'thinp_xml/listener'
+
 require 'rexml/document'
 require 'rexml/streamlistener'
 
+#----------------------------------------------------------------
+
 module ThinpXML
   module ParseDetail
     include REXML
 
     class Listener
+      include Base::ListenerUtils
       include REXML::StreamListener
 
       attr_reader :metadata
@@ -15,31 +20,6 @@ module ThinpXML
         @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)
@@ -60,18 +40,12 @@ module ThinpXML
           @current_device.mappings << Mapping.new(*get_fields(attr, MAPPING_FIELDS))
 
         else
-          puts "unhandled tag '#{tag} #{attr.map {|x| x.inspect}.join(', ')}'"
+          raise "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
 

data/lib/thinp_xml/{utils.rb → thinp/utils.rb}

@@ -1,4 +1,4 @@
-require 'thinp_xml/metadata'
+require 'thinp_xml/thinp/metadata'
 
 #----------------------------------------------------------------
 

data/lib/thinp_xml/version.rb

@@ -1,3 +1,3 @@
 module ThinpXml
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/thinp_xml.rb

@@ -10,9 +10,9 @@ 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/thinp/builder'
+require 'thinp_xml/thinp/emit'
+require 'thinp_xml/thinp/metadata'
+require 'thinp_xml/thinp/parse'
+require 'thinp_xml/thinp/utils'
 require 'thinp_xml/version'

data/spec/builder_spec.rb

@@ -1,4 +1,4 @@
-require 'thinp_xml/builder'
+require 'thinp_xml/thinp/builder'
 
 #----------------------------------------------------------------
 

data/spec/cache_builder_spec.rb

@@ -0,0 +1,240 @@
+require 'thinp_xml/cache/builder'
+
+#----------------------------------------------------------------
+
+describe "CacheXML::Builder" do
+  def as_percentage(n, tot)
+    (n * 100) / tot
+  end
+
+  def approx_percentage(n, tot, target)
+    actual = as_percentage(n, tot)
+    (actual - target).abs < 3
+  end
+
+  before :each do
+    @b = CacheXML::Builder.new
+  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 "block_size" do
+    it "should be 128 by default" do
+      @b.block_size.should == 128
+    end
+
+    it "should reflect any changes" do
+      @b.block_size = 512
+      @b.block_size.should == 512
+    end
+
+    it "should generate the correct block size" do
+      bs = 1024
+      @b.block_size = bs
+      md = @b.generate
+      md.superblock.block_size.should == bs
+    end
+  end
+
+  describe "nr cache blocks" do
+    it "should be zero by default" do
+      @b.nr_cache_blocks.should == 0
+      @b.generate.should have(0).mappings
+    end
+
+    it "should reflect any changes" do
+      n = rand(1000)
+      @b.nr_cache_blocks = n
+      @b.nr_cache_blocks.should == n
+      @b.generate.superblock.nr_cache_blocks.should == n
+    end
+  end
+
+  describe "policy name" do
+    it "should be 'mq' by default" do
+      @b.policy_name.should == 'mq'
+      @b.generate.superblock.policy_name.should == 'mq'
+    end
+
+    it "should reflect changes" do
+      n = 'most_recently_not_used_least'
+      @b.policy_name = n
+      @b.policy_name.should == n
+      @b.generate.superblock.policy_name.should == n
+    end
+  end
+
+  describe "mappings" do
+    describe "mapping policy" do
+      it "should default to :random" do
+        @b.mapping_policy.should == :random
+      end
+
+      it "should only accept :random, or :linear" do
+        [:foo, :bar, :jumpy].each do |p|
+          expect {@b.mapping_policy = p}.to raise_error
+        end
+      end
+    end
+
+    describe "nr mappings" do
+      it "should default to zero" do
+        @b.nr_mappings.should == 0
+      end
+
+      it "should never be bigger than the nr_cache_blocks" do
+        100.times do
+          nr_cache = rand(1000)
+          @b.nr_cache_blocks = nr_cache
+          expect {@b.nr_mappings = nr_cache + rand(20) + 1}.to raise_error
+        end
+      end
+
+      it "should generate the given number of mappings" do
+        100.times do
+          @b.nr_cache_blocks = rand(1000)
+          @b.nr_mappings = rand(@b.nr_cache_blocks)
+          @b.generate.should have(@b.nr_mappings).mappings
+        end
+      end
+    end
+
+    describe "dirty percentage" do
+      it "should default to zero" do
+        @b.dirty_percentage.should == 0
+      end
+
+      it "should throw if set to a negative number" do
+        expect do
+          @b.dirty_percentage = -20
+        end.to raise_error(RuntimeError, /-20/)
+      end
+
+      it "should throw if set to a > 100 number" do
+        expect do
+          @b.dirty_percentage = 101
+        end.to raise_error(RuntimeError, /101/)
+      end
+
+      it "should accept a valid value" do
+        [0, 1, 34, 78, 99, 100].each do |valid_value|
+          @b.dirty_percentage = valid_value
+          @b.dirty_percentage.should == valid_value
+        end
+      end
+
+      it "should generate the required percentage" do
+        n_mappings = 10000
+        @b.nr_cache_blocks = n_mappings
+        @b.nr_mappings = n_mappings
+
+        [0, 1, 34, 78, 99, 100].each do |p|
+          @b.dirty_percentage = p
+          metadata = @b.generate
+          nr_dirty = 0
+          metadata.mappings.each do |m|
+            nr_dirty += 1 if m.dirty
+          end
+
+          approx_percentage(nr_dirty, n_mappings, p).should be_true
+        end
+      end
+    end
+
+    describe "linear layout" do
+      before :each do
+        @b.mapping_policy = :linear
+      end
+
+      it "should allocate cache blocks in order" do
+        @b.nr_cache_blocks = 100
+        @b.nr_mappings = rand(@b.nr_cache_blocks)
+        mappings = @b.generate.mappings
+
+        cb = 0
+        mappings.each do |m|
+          m.cache_block.should == cb
+          cb += 1
+        end
+      end
+
+      it "should allocate origin blocks in order" do
+        @b.nr_cache_blocks = 100
+        @b.nr_mappings = 100
+        mappings = @b.generate.mappings
+
+        b = nil
+        mappings.each do |m|
+          if b.nil?
+            b = m.origin_block
+          else
+            m.origin_block.should == b
+          end
+
+          b += 1
+        end
+      end
+    end
+
+    describe "random mapping" do
+      before :each do
+        @b.mapping_policy = :random
+      end
+
+      it "should allocate cache blocks in order" do
+        @b.nr_cache_blocks = 100
+        @b.nr_mappings = rand(@b.nr_cache_blocks)
+        mappings = @b.generate.mappings
+
+        cb = 0
+        mappings.each do |m|
+          m.cache_block.should == cb
+          cb += 1
+        end
+      end
+
+      it "should allocate origin blocks out of order" do
+        @b.nr_cache_blocks = 100
+        @b.nr_mappings = 100
+        mappings = @b.generate.mappings
+
+        in_order = true
+        b = nil
+        mappings.each do |m|
+          if b.nil?
+            b = m.origin_block
+          else
+            if m.origin_block != b
+              in_order = false
+            end
+          end
+
+          b += 1
+        end
+
+        in_order.should be_false
+      end
+
+    end
+  end
+end
+
+#----------------------------------------------------------------
+

data/spec/distribution_spec.rb

@@ -20,12 +20,52 @@ end
 
 #----------------------------------------------------------------
 
-describe "random distributions" do
+describe "integer distributions" do
+  describe ConstDistribution do
+    it "should be constructed with a single value" do
+      expect do
+        dist = ConstDistribution.new
+      end.to raise_error
+
+      expect do
+        dist = ConstDistribution.new(1, 2)
+      end.to raise_error
+    end
+
+    it "should always return it's given value" do
+      dist = ConstDistribution.new(5)
+      10.times do
+        dist.generate.should == 5
+      end
+
+      dist = ConstDistribution.new(11)
+      10.times do
+        dist.generate.should == 11
+      end
+    end
+
+    it "should be passed an integer" do
+      expect do
+        dist = ConstDistribution.new('fish')
+      end.to raise_error
+    end
+  end
+
+  #--------------------------------
+
   describe UniformDistribution do
     it "should be constructed with a range of values" do
       dist = UniformDistribution.new(1, 10)
     end
 
+    it "should only accept start and stop if they're different" do
+      expect {UniformDistribution.new(45, 45)}.to raise_error
+    end
+
+    it "should only accept start if it's lower than stop" do
+      expect {UniformDistribution.new(45, 35)}.to raise_error
+    end
+
     it "should generate a number from this range every time generate is called" do
       dist = UniformDistribution.new(1, 10)
 
@@ -39,6 +79,7 @@ describe "random distributions" do
       buckets[10].should == 0
 
       1.upto(9) do |n|
+        buckets[n].should_not == 0
         buckets[n].should be_approx(1000, 200)
       end
     end
@@ -58,6 +99,51 @@ describe "random distributions" do
       $called456.should be_true
     end
   end
+
+  #--------------------------------
+
+  describe "parsing" do
+    describe "constant expression" do
+      it "should parse a const expression" do
+        10.times do
+          n = rand(50)
+          parse_distribution(n.to_s).to_i.should == n
+          parse_distribution(n.to_s).to_i.should == n
+        end
+      end
+    end
+
+    describe "uniform expression" do
+      def check_range(b, e, n)
+        n.should >= b
+        n.should < e
+      end
+
+      it "should accept well formed expressions" do
+        10.times do
+          b, e = [rand(100), rand(100)].sort
+          e += 1
+          d = parse_distribution("uniform[#{b}..#{e}]")
+
+          100.times do
+            check_range(b, e, d.to_i)
+          end
+        end
+      end
+
+      it "should reject badly formed expressions" do
+        bad = ['fred[1..20]',
+               'uniform[1..]',
+               'uniform[..20]',
+               'uniform 1..20',
+               'uniform[1..20',
+               'uniform1..20]']
+        bad.each do |b|
+          expect {parse_distribution(b)}.to raise_error
+        end
+      end
+    end
+  end
 end
 
 #----------------------------------------------------------------

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thinp_xml
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Joe Thornber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-06 00:00:00.000000000 Z
+date: 2013-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ejt_command_line
@@ -114,32 +114,45 @@ email:
 - ejt@redhat.com
 executables:
 - analyse_metadata
+- cache_xml
 - thinp_xml
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/analyse_metadata
+- bin/cache_xml
 - bin/thinp_xml
-- features/create.feature
+- features/cache_create.feature
+- features/cache_usage.feature
 - features/step_definitions/thinp_xml.rb
 - features/support/env.rb
-- features/usage.feature
+- features/thinp_create.feature
+- features/thinp_usage.feature
 - lib/thinp_xml.rb
-- lib/thinp_xml/analysis.rb
-- lib/thinp_xml/builder.rb
+- lib/thinp_xml/cache/builder.rb
+- lib/thinp_xml/cache/emit.rb
+- lib/thinp_xml/cache/metadata.rb
+- lib/thinp_xml/cache/parse.rb
+- lib/thinp_xml/cache_xml.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/emitter.rb
+- lib/thinp_xml/listener.rb
+- lib/thinp_xml/thinp/analysis.rb
+- lib/thinp_xml/thinp/builder.rb
+- lib/thinp_xml/thinp/emit.rb
+- lib/thinp_xml/thinp/metadata.rb
+- lib/thinp_xml/thinp/parse.rb
+- lib/thinp_xml/thinp/utils.rb
+- lib/thinp_xml/thinp/xml_format.rb
 - lib/thinp_xml/version.rb
-- lib/thinp_xml/xml_format.rb
 - spec/builder_spec.rb
+- spec/cache_builder_spec.rb
 - spec/distribution_spec.rb
 - thinp_xml.gemspec
 homepage: ''
@@ -167,9 +180,12 @@ signing_key:
 specification_version: 4
 summary: Thin provisioning xml
 test_files:
-- features/create.feature
+- features/cache_create.feature
+- features/cache_usage.feature
 - features/step_definitions/thinp_xml.rb
 - features/support/env.rb
-- features/usage.feature
+- features/thinp_create.feature
+- features/thinp_usage.feature
 - spec/builder_spec.rb
+- spec/cache_builder_spec.rb
 - spec/distribution_spec.rb

data/lib/thinp_xml/emit.rb

@@ -1,69 +0,0 @@
-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
-
-#----------------------------------------------------------------