vzcdn 0.1.4 → 0.1.5

data/lib/config_reader.rb

@@ -8,14 +8,25 @@ module ConfigReader
     ConfigHandler::CONFIG_DIRECTORY
   end
 
-  def mkdir(*dirs)
-    path = config_file(*dirs)
+  def imkdir(path)
     if ! Dir.exists?(path)
       Dir.mkdir path
     end
     path
   end
 
+  def mk_user_dir(*dirs)
+    imkdir user_file(*dirs)
+  end
+
+  def mk_config_dir(*dirs)
+    imkdir config_file(*dirs)
+  end
+
+  def user_file(*dirs_file)
+    File.join(*dirs_file)
+  end
+
   def config_file(*dirs_file)
     File.join(config_dir, *dirs_file)
   end

data/lib/makeBind.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+ usage(){
+        echo "requires 2 arguments"  
+	echo "Usage: $0 Input_filename[as argument] Output_Filename[as argument]"
+          exit 1
+  }
+
+
+osarch(){
+                case $(uname -m) in
+                x86_64) echo 64bit;;
+                *) echo 32bit;;
+                esac
+                }
+
+ ostype(){
+                case $(uname -s) in
+                Linux) 
+		if [[ "$(osarch)" == 64bit ]]; then
+                        `curl -O --silent http://stedolan.github.io/jq/download/linux64/jq`
+                else
+                        `curl -O --silent http://stedolan.github.io/jq/download/linux32/jq`
+                fi
+                `chmod +x jq`	
+		;;
+                Darwin)
+		if [[ "$(osarch)" == 64bit ]]; then
+                        `curl -O --silent http://stedolan.github.io/jq/download/osx64/jq`
+                else
+                        `curl -O --silent http://stedolan.github.io/jq/download/osx32/jq`
+                fi
+                `chmod +x jq`	 
+		;;
+                *) echo not supported;;
+                esac
+                }
+
+
+overwrite_yes_or_no(){
+	read -p "$1 ([y]es or [N]o): "
+	case $(echo $REPLY | tr '[A-Z]' '[a-z]') in
+		y|yes) echo "yes";;
+		*)	echo "no";;
+	esac
+}
+
+if [ -f $2 ]; then
+	if [[ "yes" == $(overwrite_yes_or_no "$2 exists. Do you want to overwrite?") ]]; then
+		`cat /dev/null > $2`
+	else
+		echo "exiting out"
+		exit 1
+	fi
+fi
+
+if [ ! -f jq ]; then
+	ostype
+fi
+
+if [ "$#" -ne "2" ]
+        then
+		usage
+fi
+RECORDS=`cat $1 |./jq '.Records'`
+printf "%s\t%s\t%s\n" "\$TTL" "86400" "; 24 hours could have been written as 24h or 1d" >> $2
+printf "%s\t%s\n" "\$ORIGIN" `cat $1 |./jq '.DomainName'|tr -d '"'` >> $2
+printf "%s\t%s\t%s\t%s\t%s\t%s\n" "@" "IN" "SOA" "ns1.`cat $1 |./jq '.DomainName'|tr -d '"'`" "ns2.`cat $1 |./jq '.DomainName'|tr -d '"'`(" >> $2
+printf "%s\t%s\t%s\t%s\t%s\t%s\n" "" "" "" "2014041501" "; Serial yyyymmddnn" >> $2
+printf "%s\t%s\t%s\t%s\t%s\t%s\n" "" "" "" "3600" "; Refresh after 3 hours" >> $2
+printf "%s\t%s\t%s\t%s\t%s\t%s\n" "" "" "" "600" "; Retry after 1 hour" >> $2
+printf "%s\t%s\t%s\t%s\t%s\t%s\n" "" "" "" "604800" "; Expire after 1 week" >> $2
+printf "%s\t%s\t%s\t%s\t%s\t%s\n" "" "" "" "600)" "; Minimum negative caching of 1 hour" >> $2
+
+if [ `echo $RECORDS|./jq 'length'` -ne "0" ]
+	then
+		for record in A AAAA CNAME MX NS SPF SRV TXT
+		do
+		#	echo `cat $1 |./jq '.Records.'$record''`
+			if [ `echo $RECORDS |./jq '.'$record'|length'` -ne "0" ]
+                                then
+					printf "\n" >> $2
+					printf "; $record Records\n" >> $2
+                                        for(( i=0; i <= `echo $RECORDS |./jq '.'$record'|length'` -1; i++ ))
+                                        do
+                                                printf "%s\t%s\t%s\t%s\t%s\n" `echo $RECORDS |./jq '.'$record'['$i'].Name'|tr -d '"'` `echo $RECORDS |./jq '.'$record'['$i'].TTL'|tr -d '"'` "IN" $record `echo $RECORDS |./jq '.'$record'['$i'].Rdata'|tr -d '"'` >> $2
+                                        done
+                        fi
+		done
+fi
+

data/lib/method.rb

@@ -0,0 +1,5 @@
+class Method
+  def initialize(args)
+    
+  end
+end

data/lib/print.rb

@@ -0,0 +1,270 @@
+require_relative 'util'
+require_relative 'config_reader'
+
+class TablePrint
+  DELIM = '|'
+
+  def char_repeat(n, char)
+    result = ""
+    (1..n).each { |i|
+      result = result + char
+    }
+    result
+  end
+
+  def spaces(n)
+    char_repeat(n, ' ')
+  end
+
+  def initialize(sep_char, *titles)
+    @ncols = titles.length
+    @lines = [ ]
+    @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)
+    @lines << columns
+  end
+
+  def indent(column)
+    if column == 0
+      ""
+    else
+      segment = spaces(@width-1) + DELIM
+      segment * column
+    end
+  end
+
+  def strip(line)
+    regexp = Regexp.new(' *' + Regexp.escape(DELIM) + '*\Z')
+    line.sub(regexp, "")
+  end
+
+  def calc_column(line)
+    line.length / @width
+  end
+
+  def fill_to_next_column(line)
+    tab = @width - (line.length % @width)
+    line = line + spaces(tab-1) + DELIM
+  end
+
+  # prints a line with DELIMs following in proper columns
+  def println(line)
+    column = calc_column(line)
+    if (column < @ncols)
+      line = fill_to_next_column(line)
+      column = calc_column(line)
+    end
+    if (column < @ncols)
+      segment = spaces(@width-1) + DELIM
+      line = line + segment * (@ncols - column)
+    end
+    puts strip(line)
+  end
+
+  def next_unprinted_column(col_array, start=0)
+    for i in (start...col_array.length)
+      return i if col_array[i]
+    end
+    nil
+  end
+
+  def calc_max_widths
+    maxwidth = Array.new(@ncols, 0)
+    @lines.each { |line|
+      line.each_with_index { |value, index|
+        maxwidth[index] = [value.to_s.length, maxwidth[index]].max
+      }
+    }
+    maxwidth
+  end
+
+  def print_table_normally(maxwidth, header)
+    @lines.each_with_index { |line, lineno|
+      if lineno < 2 && ! 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]
+    }
+  end
+
+  def separator(width)
+    char_repeat(width, @sep_char)
+  end
+
+  def print_staggered(maxwidth, term_width, header)
+    minw = term_width
+    maxwidth.each_with_index { |w, index|
+      next if index == 0
+      width = (term_width - w) / index
+      minw = [width, minw].min
+    }
+    @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
+      output = ""
+      cols_left = Array.new(@ncols, true)
+      while column = next_unprinted_column(cols_left)
+        output = indent(column) if output.length == 0
+        while column
+          value = line[column].to_s
+          cols_left[column] = false   # indicate this column has been printed
+          output = output + value
+          output = fill_to_next_column(output)
+          next_column = calc_column(output)
+          column = next_unprinted_column(cols_left, next_column)
+          if column && (column > next_column)
+            output = output + (spaces(@width-1) + DELIM) * (column - next_column)
+          end
+        end
+        println(output)
+        output = ""
+      end
+      puts separator(term_width)
+    }
+  end
+
+  def print_old_staggered(maxwidth, term_width)
+    puts separator(term_width)
+    @lines.each_with_index { |line, index|
+      next if index == 1
+      output = ""
+      column = 0
+      line.each_with_index { |value, column|
+        value = value.to_s
+        output = indent(column) if output.length == 0
+        if value.length > (@width - 1)
+          output = output + value
+          println(output)
+          output = ""
+        else
+          output = output + value + spaces(@width - value.length - 1) + DELIM
+        end
+        column += 1
+      }
+      println(output) if output.length > 0
+      puts separator(term_width)
+    }
+  end
+
+  # TODO: suppress headers
+  def print_table(header = true)
+    return if @lines.nil?
+    return if @ncols == 0
+    if @ncols == 1
+      @lines.each { |line| puts line }
+      return
+    end
+
+    maxwidth = calc_max_widths
+    # will lines fit in terminal
+    width_needed = maxwidth.reduce(:+) + (@ncols-1) * 2
+    term_width, h = Util.detect_terminal_size
+    if width_needed <= term_width
+      print_table_normally(maxwidth, header)
+    else
+      print_staggered(maxwidth, term_width, header)
+    end
+  end
+
+end
+
+class StructurePrint 
+  include ConfigReader
+
+  def initialize(sep_char)
+    @sep_char = sep_char
+  end
+
+  def get_indexes(level, key_array)
+    print_config_file = config_file("print.cfg")
+    if File.exists? print_config_file
+      level.gsub!(/\[\d*\]/, '')
+      level_map = JSON.parse(File.open(print_config_file).read)
+      if level_map.has_key? level
+        column_names = level_map[level]
+        result = []
+        column_names.each { |name|
+          index = key_array.index name
+          result << index
+        }
+        return result
+      end
+    end
+    (0...key_array.length).to_a
+  end
+
+  def extract_printed_columns(indexes, values, index_value, add_index = false)
+    print_values = []
+    print_values << index_value.to_s if add_index
+    indexes.each { |index|
+      print_values << values[index]
+    }
+    print_values
+  end
+
+  def structure_print(struct, level, header = true)
+    istructure_print(struct, level, header)
+    if $debug
+      puts "level = #{level}"
+    end
+    @table.print_table(header) if @table
+  end
+
+  def istructure_print(struct, level, header, add_index = false)
+    if (struct.class == Array)
+      struct.each_with_index { |elt, index|
+        istructure_print(elt, level, header, struct.length > 1)
+        header = false
+      }
+    elsif (struct.class == Hash)
+      # print top level elements of hash
+      indexes = get_indexes(level, struct.keys)
+      if @table.nil?
+        @table = TablePrint.new(@sep_char, *extract_printed_columns(indexes, struct.keys, "item", add_index))
+        @rownum = 0
+      end
+      values = []
+      struct.keys.each { |key|
+        value = struct[key]
+        if (value.nil?)
+          value = "null"
+        elsif (value.class == Array)
+          value = "[" + value.length.to_s + "]"
+        elsif (value.class == String)
+        elsif (value.class == Fixnum)
+          value = value.to_s
+        elsif (value.class == Hash)
+          value = "..."
+        elsif value.class == TrueClass
+          value = "true"
+        elsif value.class == FalseClass
+          value = "false"
+        else
+          value = "<" + value.class.to_s + ">"
+        end
+        values << value
+      }
+      @rownum += 1
+      @table.append(*extract_printed_columns(indexes, values, @rownum, add_index))
+    else
+      puts struct.to_s
+    end
+  end
+end

data/lib/route.rb

@@ -69,6 +69,7 @@ class Route
   def translate_hc(rec_array)
     rec_array.each { |rec|
       hc = rec["HealthCheck"]
+      return nil unless hc
       translate_value(:hc_type, hc, "CheckTypeId")
       translate_value(:http_method, hc, "HTTPMethodId")
       translate_value(:ip_version, hc, "IPVersion")
@@ -79,6 +80,7 @@ class Route
   def untranslate_hc(rec_array)
     rec_array.each { |rec|
       hc = rec["HealthCheck"]
+      return nil unless hc
       untranslate_value(:hc_type, hc, "CheckTypeId")
       untranslate_value(:http_method, hc, "HTTPMethodId")
       untranslate_value(:ip_version, hc, "IPVersion")
@@ -153,6 +155,7 @@ class Route
         return hash["Name"]
       end
     }
+    return nil
   end
 
   def cache_filename(data)
@@ -195,30 +198,30 @@ class Route
   end  
 
   def get_available_record_types()
-    get_available(:record_type, "routezonerecordtypes")
+    get_available(:record_type)
   end  
 
   def get_available_zone_statuses()
-    get_available(:zone_status, "routezonestatus")
+    get_available(:zone_status)
   end
 
   def get_available_route_groups()
-    get_available(:route_group, "routegrouptypes")
+    get_available(:route_group)
   end
 
   def get_available_http_methods()
-    get_available(:http_method, "routehttpmethodtypes")
+    get_available(:http_method)
   end
 
   def get_available_ip_versions()
-    get_available(:ip_version, "routehealthcheckipversion")
+    get_available(:ip_version)
   end
 
   def get_available_hc_types()
-    get_available(:hc_type, "routehealthchecktypes")
+    get_available(:hc_type)
   end
 
   def get_available_hc_rm()
-    get_available(:hc_rm, "routereintegrationmethodtypes")
+    get_available(:hc_rm)
   end
 end