vzcdn 0.1.9 → 0.2.0

data/lib/diff.rb

@@ -0,0 +1,80 @@
+require 'json'
+
+class Diff
+  def initialize(old, new)
+    @old = old
+    @new = new
+    @diffs = Hash.new([ ])   # entries will be "level" => [{ old: old_value, new: new_value, desc: description }, ...]
+  end
+
+  def sprint_struct(struct)
+    if (struct.class == Array)
+      output = "[#{struct.length}]"
+    elsif (struct.class == Hash)
+      values = []
+      # print top level elements of hash
+      struct.keys.each { |key|
+        value = struct[key]
+        value = sprint_struct(value)
+        values << "#{key}=#{value}"
+      }
+      output = values.join(", ")
+    elsif (struct.nil?)
+        return "null"
+    else
+      output = "#{struct}"
+    end
+    output
+  end
+
+  def add_diff(old, new, level)
+    diffs = @diffs[level].clone
+    diffs << {old: sprint_struct(old), new: sprint_struct(new)}
+    @diffs[level] = diffs
+  end
+
+  def idiff(old, new, level)
+    if old.class != new.class
+      add_diff(old, new, level)
+      return
+    end
+    case [old.class]
+    when [Array]
+      num_to_check = [old.length, new.length].max
+      for i in 0...num_to_check
+        idiff(old[i], new[i], level + "[#{i+1}]")
+      end
+    when [Hash]
+      old.keys.each { |key|
+        idiff(old[key], new[key], level + ".#{key}")
+      }
+    else
+      if old != new
+        add_diff(old, new, level)
+      end
+    end  
+  end
+
+  def print_diffs
+    @diffs.each { |level, diffs|
+      puts "at level #{level}"
+      diffs.each { |diff|
+        puts "    old: #{diff[:old]} | new: #{diff[:new]}"
+      }
+    }
+  end
+
+  def run
+    idiff(@old, @new, "base")
+    print_diffs
+  end
+end
+
+file1 = ARGV[0]
+file2 = ARGV[1]
+
+old = JSON.parse(File.open(file1).read)
+new = JSON.parse(File.open(file2).read)
+
+diff = Diff.new(old, new)
+diff.run

data/lib/print.rb

@@ -22,11 +22,6 @@ class TablePrint
     @width = nil
     @sep_char = sep_char
     @lines << titles
-    separator = [ ]
-    titles.each { |title|
-      separator << char_repeat(title.length, @sep_char)
-    }
-    @lines << separator
   end
 
   def append(*columns)
@@ -87,16 +82,31 @@ class TablePrint
     maxwidth
   end
 
+  def print_line_normally(maxwidth, line)
+    output = ""
+    line.each_with_index { |value, index|
+      output = output + value.to_s + spaces(maxwidth[index] - value.to_s.length + 2)
+    }
+    puts output[0...-2]
+  end
+
+  def generate_separator_line(maxwidth)
+    line = []
+    maxwidth.each { |width|
+      line << separator(width)
+    }
+    line
+  end
+
   def print_table_normally(maxwidth, header)
     @lines.each_with_index { |line, lineno|
-      if lineno < 2 && ! header
+      if lineno == 0 && ! header
         next
       end
-      output = ""
-      line.each_with_index { |value, index|
-        output = output + value.to_s + spaces(maxwidth[index] - value.to_s.length + 2)
-      }
-      puts output[0...-2]
+      print_line_normally(maxwidth, line)
+      if lineno == 0 && header
+        print_line_normally(maxwidth, generate_separator_line(maxwidth))
+      end
     }
   end
 
@@ -114,7 +124,6 @@ class TablePrint
     @width = minw
     puts separator(term_width)
     @lines.each_with_index { |line, lineno|
-      next if lineno == 1   # skip line of separators
       if lineno == 0 && ! header
         next
       end
@@ -163,7 +172,6 @@ class TablePrint
     }
   end
 
-  # TODO: suppress headers
   def print_table(header = true)
     return if @lines.nil?
     return if @ncols == 0
@@ -176,7 +184,7 @@ class TablePrint
     # will lines fit in terminal
     width_needed = maxwidth.reduce(:+) + (@ncols-1) * 2
     term_width, h = Util.detect_terminal_size
-    if width_needed <= term_width
+    if (width_needed <= term_width) || (not header)
       print_table_normally(maxwidth, header)
     else
       print_staggered(maxwidth, term_width, header)
@@ -221,7 +229,7 @@ class StructurePrint
 
   def structure_print(struct, level, header = true)
     istructure_print(struct, level, header)
-    if $debug
+    if $debug > 0
       puts "level = #{level}"
     end
     @table.print_table(header) if @table

data/lib/route.rb

@@ -98,6 +98,7 @@ class Route
   end
 
   def untranslate_groups(group_array)
+    return if group_array.nil?
     group_array.each { |group|
       group_element = group["Group"]
       ["A", "AAAA", "CNAME"].each { |record_type|
@@ -114,16 +115,89 @@ class Route
     }
   end
 
+  def each_record(group, &block)
+    group['Group'].each { |rtype, array|
+      # elements of array have <HealthCheck>, <Record> and either <IsPrimary> or <Weight>
+      array.each { |entry|
+        yield entry
+      }
+    }
+  end
+
+  def normalize_group(group_arr)
+    group_arr.each { |group|
+      ttl = -1
+      each_record(group) { |entry|
+        record = entry['Record']
+        if ttl == -1 then ttl = record['TTL'] end
+        entry['Rdata'] = record['Rdata']
+        entry.delete('Record')
+      }
+      group['TTL'] = ttl
+    }
+  end
+
+  def denormalize_group(group_arr)
+    return if group_arr.nil?
+    group_arr.each { |group|
+      ttl = group['TTL']
+      name = group['Name']
+      each_record(group) { |entry|
+        rdata = entry['Rdata']
+        entry.delete('Rdata')
+        entry['Record'] = { 'Name' => name, 'Rdata' => rdata, 'TTL' => ttl }
+      }
+      group.delete('TTL')
+    }
+  end
+
+  def denormalize_zone(zone)
+    records = zone['Records']
+    empty = true
+    if records
+      records.keys.each { |key|
+        if records[key].length > 0
+          empty = false
+          break
+        end
+      }
+      if empty
+        zone.delete('Records')
+      end
+    end
+    denormalize_group(zone['LoadBalancingGroups'])
+    denormalize_group(zone['FailoverGroups'])
+  end
+
+  def normalize_zone(zone)
+    if zone['Records'].nil?
+      zone['Records'] = {
+        "A"=> [ ],
+        "AAAA"=> [ ],
+        "CNAME"=> [ ],
+        "MX"=> [ ],
+        "NS"=> [ ],
+        "SPF"=> [ ],
+        "SRV"=> [ ],
+        "TXT"=> [ ]
+      }
+    end
+    normalize_group(zone['LoadBalancingGroups'])
+    normalize_group(zone['FailoverGroups'])
+  end
+
   def translate_zone(zone)
     return nil if zone.nil?
     translate_value(:zone_status, zone, "Status")
     translate_value(:zone_type, zone, "ZoneType")
     translate_groups zone["LoadBalancingGroups"]
     translate_groups zone["FailoverGroups"]
+    normalize_zone(zone)
   end
 
   def untranslate_zone(zone)
     return nil if zone.nil?
+    denormalize_zone(zone)
     untranslate_value(:zone_status, zone, "Status")
     untranslate_value(:zone_type, zone, "ZoneType")
     untranslate_groups zone["LoadBalancingGroups"]

data/lib/util.rb

@@ -1,7 +1,7 @@
 class Util
 
-  def self.parse_line(line)
-    idx = line.index('=')
+  def self.parse_line(line, char='=')
+    idx = line.index(char)
     if (idx)
       return line[0...idx], line[idx+1..-1]
     else
@@ -9,6 +9,24 @@ class Util
     end
   end
 
+  # let user lowercase and abbreviate key; abbreviation must match one key
+  def self.match_key(abbrev, struct)
+    abbrev = abbrev.downcase
+    key = nil
+    struct.keys.each { |fullkey|
+      testkey = fullkey.downcase
+      return fullkey if abbrev == testkey
+      if fullkey.downcase.start_with?(abbrev)
+        if (! key)
+          key = fullkey
+        else
+          return nil
+        end
+      end
+    }
+    key
+  end
+
   # Determines if a shell command exists by searching for it in ENV['PATH'].
   def self.command_exists?(command)
     ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
@@ -34,6 +52,10 @@ end
 class String
   def full_match(re)
     m = re.match(self)
-    m && (m.begin(0) == 0) && (m.end(0) == self.length)
+    if m && (m.begin(0) == 0) && (m.end(0) == self.length)
+      m
+    else
+      nil
+    end
   end
 end

data/lib/vzcdn.rb

@@ -5,8 +5,6 @@ require_relative 'clui_config'
 require_relative 'zone'
 require_relative 'vzcdn/version'
 
-$debug = false
-
 class VzcdnApp < Command
   def add_options
     add_option({ short_name: 'v', long_name: 'version', method: :print_version, takes_value: false})
@@ -19,7 +17,7 @@ class VzcdnApp < Command
   end
 
   def set_debug
-    $debug = true
+    $debug += 1
   end
 
   def create_args

data/lib/vzcdn/version.rb

@@ -1,3 +1,3 @@
 module Vzcdn
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/lib/zone.rb

@@ -4,19 +4,57 @@ require_relative 'print'
 require_relative 'command'
 require_relative 'args'
 require_relative 'zone_add'
+require_relative 'zone_update'
+require_relative 'zone_delete'
+require_relative 'zone_hc'
+
+ZONEDIR="zones"
 
 class ZoneList < Command
+  include ConfigReader
+  
+  LOCAL_STATUS = { 1 => "-", 3 => "*", 5 => "!", 7 => "!*"}
+
   def execute(args, rest)
+    zone_instance = @input['zone']
     zones = Route.do.get_all_zones
     Route.do.translate_zonelist(zones)
+    zones.each { | zone |
+      file_name = zone_instance.local_filename(zone['DomainName'], zone['ZoneId']) 
+      local_status = 0
+      if File.exists? (file_name)
+        local_status += 1
+        if not FileUtils.compare_file(file_name, config_file(file_name))
+          local_status += 2
+        end
+        contents = File.open(file_name).read
+        local_zone = JSON.parse(File.open(file_name).read)
+        if local_zone['Version'] != zone['Version']
+          local_status += 4
+        end
+        local_status = LOCAL_STATUS[local_status]
+      else
+        local_status = ''
+      end
+      zone["DomainName"] = sprintf("%-2s %s", local_status, zone["DomainName"])
+    }
     StructurePrint.new('~').structure_print(zones, "zonelist")
   end
 end
 
 class ZonePull < Command
+
+  def save_zone_to_file(file)
+    @zone_file = file
+  end
+
+  def add_options 
+    add_option({ short_name: 'f', long_name: 'file', method: :save_zone_to_file, takes_value: true})
+  end
+
   def execute(args, rest)
     zone = @input["zone"]
-    zone.pull
+    zone.pull @zone_file
   end
 end
 
@@ -27,19 +65,24 @@ class ZonePush < Command
   end
 end
 
-class ZoneDelete < Command
+class ZoneAudit< Command
   def execute(args, rest)
     zone = @input["zone"]
-    zone.delete
+    zone.show_audit
   end
 end
 
 class ZonePrint < Command
   def add_options 
     add_option({ short_name: 'j', long_name: 'json', method: :set_format, takes_value: false})
+    add_option({ short_name: 'n', long_name: 'no-header', method: :unset_header, takes_value: false})
     # add_option({ short_name: 'f', long_name: 'force-online', method: :force_online, takes_value: false})
   end
 
+  def unset_header
+    @no_header = true
+  end
+
   def set_format
     @format = :json
   end
@@ -51,7 +94,7 @@ class ZonePrint < Command
     if @format == :json
       puts JSON.pretty_generate(struct)
     else
-      StructurePrint.new(sep_char).structure_print(struct, level)
+      StructurePrint.new(sep_char).structure_print(struct, level, (not @no_header))
     end
   end
 end
@@ -70,6 +113,7 @@ class ZoneCreate < Command
 
   def execute(arghash, rest)
     name = arghash["name"]
+    zone_command = @input["zone"]
     if name[-1] != '.'
       name = name + '.'
     end
@@ -78,23 +122,31 @@ class ZoneCreate < Command
     comment = "" if comment.nil?
     type = arghash["type"]
     dputs "name = #{name}, comment=#{comment}, status=#{status}, type=#{type}"
-    zone = { "Comment" => comment, "DomainName" => name, "Status" => status, "ZoneType" => type, "Records" => {"A" => [] } }
+    zone = { "Comment" => comment, "DomainName" => name, "Status" => status, "ZoneType" => type }
     puts "creating zone on server"
-    Route.do.add_zone(zone)
+    Route.do.untranslate_zone(zone)
+    new_zone = Route.do.add_zone(zone)
+    Route.do.translate_zone(new_zone)
+    zone_command.write_new_zone(new_zone)
   end
 end
 
 class Zone < Command
   include ConfigReader
 
+  attr_reader :zone_file
+
   def create_args
-    add_cmd(ZoneList, "list", "list all owned zones")
+    add_cmd(ZoneList, "list", "list all owned zones. ! outdated, * edited, - pulled")
     add_cmd(ZonePull, "pull", "retrieve local copy of zone data")
     add_cmd(ZonePush, "push", "push local changes to server")
+    add_cmd(ZoneAudit, "audit", "show the edits done on the zone locally")
     add_cmd(ZonePrint, "print", "print zone data.  ~~~~ online, ---- local copy")
     add_cmd(ZoneAdd, "add", "add record/group/healthcheck")
+    add_cmd(ZoneUpdate, "update", "update field")
     add_cmd(ZoneCreate, "create", "create new zone")
     add_cmd(ZoneDelete, "delete", "delete zone")
+    add_cmd(ZoneSetHealthCheck, "sethc", "set health check for group member")
     add_arg("zname", "name or id of zone", :alnum_not_command)
     add_arg("drill-down-param", "names of fields, or indexes of items, for drilling down", :alnum_not_command)
   end
@@ -105,8 +157,12 @@ class Zone < Command
     add_flow_from_usage("<zname> pull")
     add_flow_from_usage("<zname> push")
     add_flow_from_usage("<zname> delete")
+    add_flow_from_usage("<zname> audit")
     add_flow_from_usage("<zname> [<drill-down-param>...] add")
+    add_flow_from_usage("<zname> [<drill-down-param>...] update")
+    add_flow_from_usage("<zname> <drill-down-param>... delete")
     add_flow_from_usage("<zname> [<drill-down-param>...] [print]")
+    add_flow_from_usage("<zname> <drill-down-param>... sethc")
   end
 
   def alnum_not_command(value)
@@ -121,8 +177,67 @@ class Zone < Command
     return "invalid argument", false
   end
 
+  def set_zone_file(zone = nil)
+    if zone
+      @zone_id = zone["ZoneId"]
+      @zone_file = local_filename(zone["DomainName"], @zone_id)
+      return
+    end
+    return if @zname.nil?
+    if File.exists?(@zname)
+      @zone_file = @zname
+      @standard_zone_file = false
+      return
+    end
+    @standard_zone_file = true
+    id, name = id_and_name
+    if id.nil?
+      r = name + '\.(\d+)'
+    else
+      r = '.*\.(' + id + ')'
+    end
+    regex = Regexp.new(r)
+    Dir.new(user_file(ZONEDIR)).each { |file|
+      if (m = file.full_match(regex))
+        @zone_file = user_file(ZONEDIR, file)
+        @zone_id = m[1]
+        break
+      end
+    }
+    unless @zone_file
+      zones = Route.do.get_all_zones
+      zones.each { |zonehash|
+        zonehash_name = zonehash['DomainName'].sub!(/\.\Z/, '')
+        if name && zonehash_name  == name
+          id = zonehash['ZoneId']
+          break
+        elsif id && zonehash['ZoneId'].to_s == id
+          name = zonehash_name
+          puts "set_zone_file, name = #{name}, id = #{id}"
+          break
+        end
+      }
+      if name && id
+        @zone_file = local_filename(name, id)
+        @zone_id = id
+      else
+        raise "Bad zname or id (#{@zname})"
+      end
+    end
+  end
+
+  def write_new_zone(zone)
+    set_zone_file(zone)
+    @standard_zone_file = true
+    write_zone_file(zone, true)
+    zonelist = ZoneList.new(nil, nil)
+    zonelist.add_input("zone", self)
+    zonelist.execute(nil, nil)
+  end
+
   def execute(args, rest)
     @zname = args["zname"]
+    set_zone_file
     command = args["command"]
     ddparams = args["drill-down-param"]
     if ddparams
@@ -132,6 +247,7 @@ class Zone < Command
       command.add_input("level", level)
       command.add_input("sep_char", @sep_char)
       command.add_input("toplevel", zone)
+      command.add_input("rest", rest)
     end
     if command
       command.add_input("zone", self)
@@ -141,57 +257,132 @@ class Zone < Command
     end
   end
 
+  def group_sanity_check(zone, groupname)
+    zone[groupname].each_with_index { | group, index |
+      numRecords = 0
+      primaries = 0
+      grouppath = "#{groupname}[#{index+1}]"
+      group['Group'].each { |rtype, array|
+        if array.length > 0
+          if array.length > 0
+            numRecords +=  array.length
+            if array.length < 2 
+              @errors << "need 2 '#{rtype}' records in #{grouppath}"
+            end
+          end
+          array.each { | element |
+            if element['IsPrimary']
+              primaries += 1
+            end
+          }
+        end
+      }
+      if numRecords == 0
+        @errors << "empty group: #{grouppath}"
+      end
+      if groupname == 'FailoverGroups' 
+        if numRecords != 2 
+          @errors << "failover group #{grouppath} must have exactly 2 records"
+        end
+        if primaries != 1
+          @errors << "failover group #{grouppath} must have exactly 1 primary"
+        end
+      end
+    }
+  end
+
+  def sanity_check(zone)
+    @errors = [ ]
+    group_sanity_check(zone, 'LoadBalancingGroups')
+    group_sanity_check(zone, 'FailoverGroups')
+    if @errors.length > 0
+      raise @errors.join("\n")
+    end
+  end
+
   def push
-    puts "pushing zone to server"
     zone = get_zone
+    sanity_check(zone)
+    puts "pushing zone to server"
     Route.do.untranslate_zone(zone)
-    if $debug
+    if $debug > 1
       File.open("untranslated.zone","w").write(JSON.pretty_generate zone)
     end
-    Route.do.update_zone(zone)
+    dputs "in push, version before update = #{zone["Version"]}"
+    zone = Route.do.update_zone(zone)
+    Route.do.translate_zone(zone)
+    dputs "in push, version after update = #{zone["Version"]}"
+    write_zone_file(zone, true)
+    remove_audit
+  end
+
+  def local_filename(name, id)
+    name.sub!(/\.\Z/, '')
+    user_file(ZONEDIR, "#{name}.#{id}")
+  end
+
+  def write_zone_to_single_file(zone, filename)
+    File.delete(filename) if File.exists?(filename)
+    File.open(filename, "w") { |file|
+      file.write(JSON.pretty_generate zone)
+    }
+  end
+
+  def write_zone_file(zone, save_backup_ok)
+    write_zone_to_single_file(zone, @zone_file)
+    audit
+    if save_backup_ok && @standard_zone_file
+      write_zone_to_single_file(zone, config_file(@zone_file))
+    end
   end
 
-  def local_filename(zone)
-    file_name = zone["DomainName"].sub(/\.\Z/, '')
-    file_name = file_name + '.' + zone["ZoneId"].to_s
+  def audit
+    audit_file = config_file( "audit",  @zone_file)
+    File.open(audit_file, 'a') { | file |
+      file.write($USER_ENTERED_COMMAND)
+      file.write("\n")
+    }
   end
 
-  def write_zone_file(zone, hide_dup = false)
-    basename = local_filename(zone)
-    if hide_dup
-      mk_config_dir("zones")
-      file_name = config_file("zones", basename)
-      File.delete(file_name) if File.exists?(file_name)
-      File.open(file_name, "w").write(JSON.pretty_generate zone)
+  def remove_audit
+    audit_file = config_file( "audit",  @zone_file)
+    File.delete(audit_file)
+  end
+
+  def show_audit
+    audit_file = config_file( "audit",  @zone_file)
+    if File.exists? audit_file
+      puts File.read(audit_file)
+    else
+      puts "no edits on the zone"
     end
-    file_name = user_file("zones", basename)
-    File.delete(file_name) if File.exists?(file_name)
-    File.open(file_name, "w").write(JSON.pretty_generate zone)
-    file_name
   end
 
-  def pull
+  def pull(target_file)
     zone = get_zone(true)
-    file_name = write_zone_file(zone, true)
-    puts "'#{file_name}' saved locally"
+    if target_file
+      @zone_file = target_file   # user supplied file with -f option
+    end
+    dputs "in zone.pull, @zname=#{@zname}, zone_file=#{@zone_file}"
+    if @zone_file == @zname
+      raise "zone filename can't be same as zone name"
+    end            
+    write_zone_file(zone, true)
+    remove_audit
+    puts "'#{@zone_file}' saved locally"
   end
 
   def delete_local_zone_files(id)
-    files = Dir.glob(File.join("#{config_dir}", "zones", "*.#{id}"))
+    files = Dir.glob(config_file(ZONEDIR, "*.#{id}"))
     files.each { |file| File.delete(file) }
-    files = Dir.glob(File.join("zones", "*.#{id}"))
+    files = Dir.glob(user_file(ZONEDIR, "*.#{id}"))
     files.each { |file| File.delete(file) }
   end
 
   def delete
-    id, name = id_and_name
-    if (id.nil?)
-      zone = get_zone(true)
-      id = zone["ZoneId"]
-    end
-    puts "deleting zone with id #{id}"
-    delete_local_zone_files(id)
-    Route.do.delete_zone(id)
+    puts "deleting zone with id #{@zone_id}"
+    delete_local_zone_files(@zone_id)
+    Route.do.delete_zone(@zone_id)
   end
 
   def id_and_name
@@ -206,69 +397,26 @@ class Zone < Command
   end
 
   def get_zone(forceRest = false)
-    @sep_char = "-"
-    zonedir = mk_user_dir("zones")
     zone = nil
-    id, name = id_and_name
-    if @zname
-      if ! forceRest
-        if id.nil?
-          r = name + '\.\d+'
-        else
-          r = '.*\.' + id
-        end
-        regex = Regexp.new(r)
-        Dir.new(zonedir).each { |file|
-          if (file.full_match regex) && (! @force_online)
-            path = File.join(zonedir, file)
-            zone = JSON.parse(File.open(path).read)
-          end
-        }
+    if forceRest || (not File.exists?(@zone_file))
+      @sep_char = "~"
+      if @zone_id.nil?
+        raise "unable to calculate zone id"
       end
-      if (zone.nil?)
-        dputs "getting zone with id=#{id} and name=#{name}"
-        @sep_char = "~"
-        zone = Route.do.get_zone(id, name)
-        if zone['Records'].nil?
-          zone['Records'] = {
-            "A"=> [ ],
-            "AAAA"=> [ ],
-            "CNAME"=> [ ],
-            "MX"=> [ ],
-            "NS"=> [ ],
-            "SPF"=> [ ],
-            "SRV"=> [ ],
-            "TXT"=> [ ]
-          }
-        end
-        if zone.nil?
-          raise "zone doesn't exist or is empty"
-        end
-        if $debug
-          File.open("raw.zone","w").write(zone)
-        end
-        Route.do.translate_zone(zone)
+      zone = Route.do.get_zone(@zone_id, nil)
+      if $debug > 1
+        File.open("raw.zone","w").write(zone)
       end
+      Route.do.translate_zone(zone)
+    else
+      @sep_char = "-"
+      zone = JSON.parse(File.open(@zone_file).read)
     end
-    zone
-  end
 
-  # let user lowercase and abbreviate key; abbreviation must match one key
-  def match_key(abbrev, struct)
-    abbrev = abbrev.downcase
-    key = nil
-    struct.keys.each { |fullkey|
-      testkey = fullkey.downcase
-      return fullkey if abbrev == testkey
-      if fullkey.downcase.start_with?(abbrev)
-        if (! key)
-          key = fullkey
-        else
-          return nil
-        end
-      end
-    }
-    key
+    if zone.nil?
+      raise "zone doesn't exist or is empty"
+    end
+    zone
   end
 
   def drill_down(struct, args, level)
@@ -288,6 +436,9 @@ class Zone < Command
         }
         return result, result_level
       end
+      if struct.length == 0
+        raise "cannot drill down empty array"
+      end
       if args[0] =~ /\A\d+\Z/
         index = args.shift.to_i
         if index > struct.length || index <= 0
@@ -304,7 +455,7 @@ class Zone < Command
     elsif (struct.class == Hash)
       args = args.clone
       key = args.shift
-      fullkey = match_key(key, struct)
+      fullkey = Util.match_key(key, struct)
       raise "no (unique) key matches " + key if ! fullkey
       drill_down(struct[fullkey], args, level + ".#{fullkey}")
     else
@@ -313,7 +464,6 @@ class Zone < Command
   end
 
   def set_format
-    puts "in zone.set_format"
     @format = :json
   end