netconfgen 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e74877df80cf028688b27e0712cc3d56b15caa44
+  data.tar.gz: 37c95750d391b9f41217cd724f1e08e8e21f5184
+SHA512:
+  metadata.gz: 12e26b6ae98233cca7b0534c3affcf99405410c02adb99cf60ea167feba85865e6d294c182709e036ccdd79c342688f2fe4ec19f2b9a84c65c29310eef39616c
+  data.tar.gz: e334f1c2070bde07d19a111362fc19ceb87a9778c63da993524ed5d2d5d5cebdbf8d5d8f304ddbed051f155203250b34893c52958895c9ea0c4585601535a8b1

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/vendor/
+/.ruby-version
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake/testtask'
+
+begin
+  require 'rubygems/tasks'
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+  task :doc => :yard
+rescue LoadError => e
+  warn e.message
+end
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs = ['lib', 'test']
+  t.name = 'test'
+  t.warning = true
+  t.test_files = FileList['test/*.rb']
+end
+
+FileList['test/*.rb'].each do |p|
+  name = p.split('/').last.split('.').first
+  Rake::TestTask.new do |t|
+    t.libs = ['lib', 'test']
+    t.name = "test:#{name}"
+    t.warning = true
+    t.test_files = [p]
+  end
+end

data/bin/confgen

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'logger'
+require 'optparse'
+require 'netconfgen'
+require 'pp'
+require 'yaml'
+require 'json'
+
+CONFIG_FILE = ["/etc/netconfgen.yaml", "~/.netconfgen.yaml", "netconfgen.yaml"]
+config = {}
+CONFIG_FILE.each do |fname|
+  fname = File.expand_path(fname)
+  if File.exists?(fname)
+    config = YAML::load_file(fname)
+    config = config.each_with_object({}) { |(k,v),memo| memo[k.to_sym] = v }
+    break
+  end
+end
+
+config[:variables] ||= {}
+config[:root] ||= 'test/data'
+
+# Defaults
+op = OptionParser.new do |o|
+  o.banner = "Usage: #{$PROGRAM_NAME} [OPTIONS] MAIN_BLOCK_NAME"
+  o.on('-l', '--listen', 'Run a listening server instead') do
+    config[:listen] = true
+  end
+  o.on('-o [OPTION]', 'Pass a template variable') do |arg|
+    if m = arg.match(/(.+?)=(.+)/)
+      config[:variables][m[1]] = m[2]
+    end
+  end
+  o.on('--json=[VARIABLE=FILE]', 'Load json into a variable') do |arg|
+    if m = arg.match(/(.+?)=(.+)/)
+      data = File.read(m[2])
+      config[:variables][m[1]] = JSON.parse(data)
+    end
+  end
+  o.on('-a', '--address ADDRESS', String,
+    'Address to listen on (default: 0.0.0.0)') do |address|
+    config[:address] = address
+  end
+  o.on('-h', '--http PORT', Integer,
+    'Port to listen on for http (default: 8080)') do |port|
+    abort 'Invalid port' if port < 1 || port > 65535
+    config[:http] = http
+  end
+  o.on('-v', '--verbose', 'Enable verbose output') do
+    config[:verbose] = true
+  end
+end
+
+config[:name] = op.parse!.first
+abort 'Last argument must be the main block name' unless config[:name]
+
+if config[:listen] && config[:port] < 1024 && !Process.euid.zero?
+  abort 'Please run tftpd as root via sudo!'
+end
+
+log = Logger.new(STDOUT)
+log.level = config[:verbose] ? "DEBUG" : "INFO"
+log.formatter = lambda do |s, d, p, m|
+  "#{d.strftime('%Y-%m-%d %H:%M:%S.%3N')} | #{s.ljust(5)} | #{m}\n"
+end
+config[:logger] = log
+
+if config[:verbose]
+  PP.pp(config, STDERR)
+end
+
+if !config[:listen]
+  STDERR.puts "Rendering block #{config[:name]}" if config[:verbose]
+  br = NetConfGen::BlockEngine.new(config[:root])
+
+  config[:variables].each do |k, v|
+    br.set(k, v)
+  end
+  block = br.load(config[:name])
+  puts block.render
+  exit(0)
+end
+
+begin
+  log.info "Serving from and to #{config[:path]}"
+  srv = TFTP::Server::RWSimple.new(config[:path], config)
+  srv.run!
+rescue SignalException => e
+  puts if e.is_a? Interrupt
+  srv.stop
+end
+
+if Thread.list.length > 1
+  log.info 'Waiting for outstanding connections'
+  Thread.stop
+end

data/lib/netconfgen/netconfgen.rb

@@ -0,0 +1,469 @@
+# After https://www.ietf.org/rfc/rfc1350.txt
+#
+
+require 'erb'
+
+
+module NetConfGen
+
+
+  class Block
+    attr_accessor :code, :blockengine
+
+    def initialize(name)
+      @name = name
+    end
+
+    def render
+      t = ERB.new(@code)
+      str = t.result(@blockengine.context.instance_eval { binding })
+      return str
+    end
+
+    def to_s
+      self.render
+    end
+
+  end
+
+  class BlockContext
+    def initialize(blockengine)
+      @blockengine = blockengine
+    end
+
+    def include(name)
+      block = @blockengine.load(name)
+      return block.render
+    end
+  end
+
+  class BlockEngine
+    attr_reader :context
+    def initialize(basepath)
+      @basepath = basepath
+      if !File.directory?(basepath)
+        raise "Basepath #{basepath} does not exists"
+      end
+      @suffix = '.txt'
+
+      @blocks = {}
+
+      @context = BlockContext.new(self)
+    end
+
+    def set(key, value)
+      @context.instance_variable_set("@" + key, value)
+    end
+
+    def load(name)
+      if @blocks[name]
+        return @blocks[name]
+      end
+
+      @code = '';
+      File.open(@basepath + '/' + name + @suffix, "r") do |f|
+        code_started = false
+        code = ''
+        f.each_line do |line|
+          if line == "<code>\n"
+            code_started = true
+          elsif line == "</code>\n" || line == "</code>"
+            code_started = false
+          elsif code_started == true
+            code += line
+          end
+        end
+
+        block = Block.new(name)
+        block.code = code
+        block.blockengine = self
+        @blocks[name] = block
+
+        return block
+      end
+    end
+  end
+
+
+  # TFTP-specific errors.
+  class Error < Exception; end
+  # Packet parsing exception.
+  class ParseError < Error; end
+
+  # Packet can parse a binary string into a lightweight object representation.
+  module Packet
+    # Base is a thin layer over a Struct.
+    class Base < Struct
+      # Encode the packet back to binary string.
+      # It uses the #to_str method to properly format each packet, and then forces
+      # 8bit encoding.
+      def encode; to_str.force_encoding('ascii-8bit'); end
+    end
+
+    # Read Request
+    RRQ = Base.new(:filename, :mode)
+    class RRQ
+      # Convert to binary string.
+      def to_str; "\x00\x01" + self.filename + "\x00" + self.mode.to_s + "\x00"; end
+    end
+
+    # Write Request
+    WRQ = Base.new(:filename, :mode)
+    class WRQ
+      def to_str; "\x00\x02" + self.filename + "\x00" + self.mode.to_s + "\x00"; end
+    end
+
+    # Data
+    DATA = Base.new(:seq, :data)
+    class DATA
+      def to_str; "\x00\x03" + [self.seq].pack('n') + self.data; end
+      # Check if this is the last data packet for this session.
+      def last?; self.data.length < 512; end
+    end
+
+    # Acknowledgement
+    ACK = Base.new(:seq)
+    class ACK
+      def to_str; "\x00\x04" + [self.seq].pack('n'); end
+    end
+
+    # Error
+    ERROR = Base.new(:code, :msg)
+    class ERROR
+      def to_str; "\x00\x05" + [self.code].pack('n') + self.msg + "\x00"; end
+    end
+
+    # Parse a binary string into a packet.
+    # Does some sanity checking, can raise a ParseError.
+    def self.parse(data)
+      data = data.force_encoding('ascii-8bit')
+
+      opcode = data.unpack('n').first
+      if opcode < 1 || opcode > 5
+        raise ParseError, "Unknown packet opcode '#{opcode.inspect}'"
+      end
+
+      payload = data.slice(2, data.length - 2)
+      case opcode
+      when 1, 2 # rrq, wrq
+        raise ParseError, 'Not null terminated' if payload.slice(payload.length - 1) != "\x00"
+        xs = payload.split("\x00")
+        raise ParseError, "Not enough elements: #{xs.inspect}" if xs.length < 2
+        filename = xs[0]
+        mode = xs[1].downcase.to_sym
+        raise ParseError, "Unknown mode '#{xs[1].inspect}'" unless [:netascii, :octet].member? mode
+        return RRQ.new(filename, mode) if opcode == 1
+        return WRQ.new(filename, mode)
+      when 3 # data
+        seq = payload.unpack('n').first
+        block = payload.slice(2, payload.length - 2) || ''
+        raise ParseError, "Exceeded block length with #{block.length} bytes" if block.length > 512
+        return DATA.new(seq, block)
+      when 4 # ack
+        raise ParseError, "Wrong payload length with #{payload.length} bytes" if payload.length != 2
+        seq = payload.unpack('n').first
+        return ACK.new(seq)
+      when 5 # error
+        raise ParseError, 'Not null terminated' if payload.slice(payload.length - 1) != "\x00"
+        code = payload.unpack('n').first
+        raise ParseError, "Unknown error code '#{code.inspect}'" if code < 0 || code > 7
+        msg = payload.slice(2, payload.length - 3) || ''
+        return ERROR.new(code, msg)
+      end
+    end
+  end
+
+  # Handlers implement session-handling logic.
+  module Handler
+    # Base handler contains the common methods for real handlers.
+    class Base
+      # Initialize the handler.
+      #
+      # Options:
+      #
+      #  - :logger  => logger object (e.g. a Logger instance)
+      #  - :timeout => used while waiting for next DATA/ACK packets (default: 5s)
+      #
+      # All given options are saved in @opts.
+      #
+      # @param opts [Hash] Options
+      def initialize(opts = {})
+        @logger = opts[:logger]
+        @timeout = opts[:timeout] || 5
+        @opts = opts
+      end
+
+      # Send data over an established connection.
+      #
+      # Doesn't close neither sock nor io.
+      #
+      # @param tag  [String]    Tag used for logging
+      # @param sock [UDPSocket] Connected socket
+      # @param io   [IO]        Object to send data from
+      def send(tag, sock, io)
+        seq = 1
+        begin
+          while not io.eof?
+            block = io.read(512)
+            sock.send(Packet::DATA.new(seq, block).encode, 0)
+            unless IO.select([sock], nil, nil, @timeout)
+              log :warn, "#{tag} Timeout at block ##{seq}"
+              return
+            end
+            msg, _ = sock.recvfrom(4, 0)
+            pkt = Packet.parse(msg)
+            if pkt.class != Packet::ACK
+              log :warn, "#{tag} Expected ACK but got: #{pkt.class}"
+              return
+            end
+            if pkt.seq != seq
+              log :warn, "#{tag} Seq mismatch: #{seq} != #{pkt.seq}"
+              return
+            end
+            # Increment with wrap around at 16 bit boundary,
+            # because of tftp block number field size limit.
+            seq = (seq + 1) & 0xFFFF
+          end
+          sock.send(Packet::DATA.new(seq, '').encode, 0) if io.size % 512 == 0
+        rescue ParseError => e
+          log :warn, "#{tag} Packet parse error: #{e.to_s}"
+          return
+        end
+        log :info, "#{tag} Sent file"
+      end
+
+      # Receive data over an established connection.
+      #
+      # Doesn't close neither sock nor io.
+      # Returns true if whole file has been received, false otherwise.
+      #
+      # @param tag  [String]    Tag used for logging
+      # @param sock [UDPSocket] Connected socket
+      # @param io   [IO]        Object to write data to
+      # @return [Boolean]
+      def recv(tag, sock, io)
+        sock.send(Packet::ACK.new(0).encode, 0)
+        seq = 1
+        begin
+          loop do
+            unless IO.select([sock], nil, nil, @timeout)
+              log :warn, "#{tag} Timeout at block ##{seq}"
+              return false
+            end
+            msg, _ = sock.recvfrom(516, 0)
+            pkt = Packet.parse(msg)
+            if pkt.class != Packet::DATA
+              log :warn, "#{tag} Expected DATA but got: #{pkt.class}"
+              return false
+            end
+            if pkt.seq != seq
+              log :warn, "#{tag} Seq mismatch: #{seq} != #{pkt.seq}"
+              return false
+            end
+            io.write(pkt.data)
+            sock.send(Packet::ACK.new(seq).encode, 0)
+            break if pkt.last?
+            seq = (seq + 1) & 0xFFFF
+          end
+        rescue ParseError => e
+          log :warn, "#{tag} Packet parse error: #{e.to_s}"
+          return false
+        end
+        log :info, "#{tag} Received file"
+        true
+      end
+
+      private
+      def log(level, msg)
+        @logger.send(level, msg) if @logger
+      end
+    end
+
+    # Basic read-write session over a 'physical' directory.
+    class RWSimple < Base
+      # Initialize the handler.
+      #
+      # Options:
+      #
+      #  - :no_read  => deny read access if true
+      #  - :no_write => deny write access if true
+      #
+      # @param path [String]  Path to serving root directory
+      # @param opts [Hash]    Options
+      def initialize(path, opts = {})
+        @path = path
+        super(opts)
+      end
+
+      # Handle a session.
+      #
+      # Has to close the socket (and any other resources).
+      # Note that the current version 'guards' against path traversal by a simple
+      # substitution of '..' with '__'.
+      #
+      # @param tag  [String]    Tag used for logging
+      # @param req  [Packet]    The initial request packet
+      # @param sock [UDPSocket] Connected socket
+      # @param src  [UDPSource] Initial connection information
+      def run!(tag, req, sock, src)
+        name = req.filename.gsub('..', '__')
+        path = File.join(@path, name)
+
+        case req
+        when Packet::RRQ
+          if @opts[:no_read]
+            log :info, "#{tag} Denied read request for #{req.filename}"
+            sock.send(Packet::ERROR.new(2, 'Access denied.').encode, 0)
+            sock.close
+            return
+          end
+          log :info, "#{tag} Read request for #{req.filename} (#{req.mode})"
+          unless File.exist? path
+            log :warn, "#{tag} File not found"
+            sock.send(Packet::ERROR.new(1, 'File not found.').encode, 0)
+            sock.close
+            return
+          end
+          mode = 'r'
+          mode += 'b' if req.mode == :octet
+          io = File.open(path, mode)
+          send(tag, sock, io)
+          sock.close
+          io.close
+        when Packet::WRQ
+          if @opts[:no_write]
+            log :info, "#{tag} Denied write request for #{req.filename}"
+            sock.send(Packet::ERROR.new(2, 'Access denied.').encode, 0)
+            sock.close
+            return
+          end
+          log :info, "#{tag} Write request for #{req.filename} (#{req.mode})"
+          mode = 'w'
+          mode += 'b' if req.mode == :octet
+          io = File.open(path, mode)
+          ok = recv(tag, sock, io)
+          sock.close
+          io.close
+          unless ok
+            log :warn, "#{tag} Removing partial file #{req.filename}"
+            File.delete(path)
+          end
+        end
+      end
+    end
+  end
+
+  # Servers customize the Basic server and perhaps combine it with a handler.
+  module Server
+    # Basic server utilizing threads for handling sessions.
+    #
+    # It lacks a mutex around access to @clients, in case you'd want to stress
+    # test it for 10K or something.
+    #
+    # @attr handler [Handler] Session handler
+    # @attr address [String]  Address to listen to
+    # @attr port    [Integer] Session dispatcher port
+    # @attr clients [Hash]    Current sessions
+    class Base
+      attr_reader :handler, :address, :port, :clients
+
+      # Initialize the server.
+      #
+      # Options:
+      #
+      #  - :address => address to listen to (default: '0.0.0.0')
+      #  - :port    => dispatcher port (default: 69)
+      #  - :logger  => logger instance
+      #
+      # @param handler  [Handler]  Initialized session handler
+      # @param opts     [Hash]     Options
+      def initialize(handler, opts = {})
+        @handler = handler
+
+        @address = opts[:address] || '0.0.0.0'
+        @port    = opts[:port] || 69
+        @logger  = opts[:logger]
+
+        @clients = Hash.new
+        @run = false
+      end
+
+      # Run the main server loop.
+      #
+      # This is obviously blocking.
+      def run!
+        log :info, "UDP server loop at #{@address}:#{@port}"
+        @run = true
+        Socket.udp_server_loop(@address, @port) do |msg, src|
+          break unless @run
+
+          addr = src.remote_address
+          tag = "[#{addr.ip_address}:#{addr.ip_port.to_s.ljust(5)}]"
+          log :info, "#{tag} New initial packet received"
+
+          begin
+            pkt = Packet.parse(msg)
+          rescue ParseError => e
+            log :warn, "#{tag} Packet parse error: #{e.to_s}"
+            next
+          end
+
+          log :debug, "#{tag} -> PKT: #{pkt.inspect}"
+          tid = get_tid
+          tag = "[#{addr.ip_address}:#{addr.ip_port.to_s.ljust(5)}:#{tid.to_s.ljust(5)}]"
+          sock = addr.connect_from(@address, tid)
+          @clients[tid] = tag
+
+          unless pkt.is_a?(Packet::RRQ) || pkt.is_a?(Packet::WRQ)
+            log :warn, "#{tag} Bad initial packet: #{pkt.class}"
+            sock.send(Packet::ERROR.new(4, 'Illegal TFTP operation.').encode, 0)
+            sock.close
+            next
+          end
+
+          Thread.new do
+            @handler.run!(tag, pkt, sock, src)
+            @clients.delete(tid)
+            log :info, "#{tag} Session ended"
+          end
+        end
+        log :info, 'UDP server loop has stopped'
+      end
+
+      # Stop the main server loop.
+      #
+      # This will allow the currently pending sessions to finish.
+      def stop
+        log :info, 'Stopping UDP server loop'
+        @run = false
+        UDPSocket.new.send('break', 0, @address, @port)
+      end
+
+      private
+      # Get the server's TID.
+      #
+      # The TID is basically a random port number we will use for a session.
+      # This actually tries to get a unique TID per session.
+      # It uses only ports 1024 - 65535 as not to require root.
+      def get_tid
+        tid = 1024 + rand(64512)
+        tid = 1024 + rand(64512) while @clients.has_key? tid
+        tid
+      end
+
+      def log(level, msg)
+        @logger.send(level, msg) if @logger
+      end
+    end
+
+    # Basic read-write TFTP server.
+    #
+    # This is what most other TFTPd implementations give you.
+    class RWSimple < Base
+      def initialize(path, opts = {})
+        handler = Handler::RWSimple.new(path, opts)
+        super(handler, opts)
+      end
+    end
+  end
+end

data/lib/netconfgen/version.rb

@@ -0,0 +1,4 @@
+module TFTP
+  # Current version string.
+  VERSION = '1.1'
+end

data/lib/netconfgen.rb

@@ -0,0 +1 @@
+require 'netconfgen/netconfgen'

data/netconfgen.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+#
+
+Gem::Specification.new do |s|
+  s.name          = 'netconfgen'
+  s.version       = '0.0.1'
+  s.date          = Time.now
+
+  s.summary       = %q{Template based config generation}
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = ['confgen']
+  s.test_files    = s.files.grep(%r{^test/})
+  s.require_paths = ['lib']
+  s.authors       = "Juho Mäkinen juho.makinen@gmail.com"
+
+  s.required_ruby_version = '>= 2.1.0'
+
+  s.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  s.add_development_dependency 'minitest', '~> 5.4'
+  s.add_development_dependency 'rake', '~> 10.0'
+end

data/netconfgen.yaml

@@ -0,0 +1,4 @@
+verbose: true
+variables:
+  foo: 2
+  test: test

data/test/blockreader.rb

@@ -0,0 +1,37 @@
+require 'minitest/autorun'
+
+require 'netconfgen'
+
+class BlockEngine < Minitest::Test
+
+  def test_block_loading
+
+    br = NetConfGen::BlockEngine.new('test/data')
+    block = br.load('file1')
+    assert_equal block.code, "! this is a code module\n"
+  end
+
+  def test_block_variables
+
+    br = NetConfGen::BlockEngine.new('test/data')
+
+    br.set('foo', 1)
+    br.set('bar', 'hello')
+    block = br.load('variables')
+    assert_equal block.render, "foo: 1\nbar: hello\n"
+  end
+
+
+  def test_recursive_block_rendering
+    br = NetConfGen::BlockEngine.new('test/data')
+    block = br.load('file2')
+
+    assert_equal block.render,
+%{! main
+! this is a code module
+
+! main again
+}
+
+  end
+end

data/test/data/file1.txt

@@ -0,0 +1,6 @@
+This is a wiki file
+
+<code>
+! this is a code module
+</code>
+Some other comments

data/test/data/file2.txt

@@ -0,0 +1,9 @@
+test
+
+<code>
+! main
+<%= include "file1" %>
+! main again
+</code>
+
+test

data/test/data/variables.txt

@@ -0,0 +1,4 @@
+<code>
+foo: <%= @foo %>
+bar: <%= @bar %>
+</code>

data/test/data.json

@@ -0,0 +1,10 @@
+{
+  "message": "Hello, World!",
+  "list": [
+    1, 2, 3
+  ],
+  "map": {
+    "A": 1,
+    "B": 2
+  }
+}

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: netconfgen
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Juho Mäkinen juho.makinen@gmail.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email: 
+executables:
+- confgen
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Rakefile
+- bin/confgen
+- lib/netconfgen.rb
+- lib/netconfgen/netconfgen.rb
+- lib/netconfgen/version.rb
+- netconfgen.gemspec
+- netconfgen.yaml
+- test/blockreader.rb
+- test/data.json
+- test/data/file1.txt
+- test/data/file2.txt
+- test/data/variables.txt
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Template based config generation
+test_files:
+- test/blockreader.rb
+- test/data.json
+- test/data/file1.txt
+- test/data/file2.txt
+- test/data/variables.txt