vzcdn 0.1.4 → 0.1.5

data/lib/test_options.rb

@@ -0,0 +1,16 @@
+require_relative 'cloptions'
+
+options = [ { short_name: 'd', long_name: 'debug', method: :set_debug, takes_value: false},
+            { short_name: 'o', long_name: 'output-file', method: :set_output, takes_value: true}]
+
+$debug=false
+def set_debug
+  $debug = true
+end
+def set_output(file_name)
+  puts "file name = " + file_name
+end
+opts = ClOptions.new(self, options)
+args = opts.handle(ARGV)
+puts "args are:" + args.to_s
+puts "$debug = " + $debug.to_s

data/lib/util.rb

@@ -1,4 +1,14 @@
 class Util
+
+  def self.parse_line(line)
+    idx = line.index('=')
+    if (idx)
+      return line[0...idx], line[idx+1..-1]
+    else
+      line
+    end
+  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) }

data/lib/vzcdn.rb

@@ -1,26 +1,43 @@
 #!/usr/bin/env ruby
-require_relative 'command_proc'
+require_relative 'command'
+require_relative 'args'
 require_relative 'clui_config'
 require_relative 'zone'
+require_relative 'vzcdn/version'
 
-class VzcdnApp
-  include CommandProc
+$debug = false
 
-  def initialize(name)
-    @usage = {
-      :zone => "zone related command",
-      :config => "config related command"
-    }
-    @argtree = [ {:name => "zone", :usage => "zone related commands", :args=>[]},
-                 {:name => "config", :usage => "config related commands", :args=>[]}]
+class VzcdnApp < Command
+  def add_options
+    add_option({ short_name: 'v', long_name: 'version', method: :print_version, takes_value: false})
+    add_option({ short_name: 'd', long_name: 'debug', method: :set_debug, takes_value: false})
   end
 
-  def zone(args)
-    Zone.invoke(args)
+  def print_version
+    puts "vzcdn version:" + Vzcdn::VERSION
   end
 
-  def config(args)
-    ConfigCommand.invoke(args)
+  def set_debug
+    $debug = true
+  end
+
+  def create_args
+    add_arg(:zone, Zone.new("zone", "zone"))
+    add_arg(:config, ConfigCommand.new("config", "config description"))
+  end
+
+  def create_flows
+    add_flow_from_args(:zone)
+    add_flow_from_args(:config)
+  end
+
+  def execute(args, subargs)
+    command = args["command"]
+    if command
+      command.run(subargs)
+    else
+      puts "command is nil"
+    end
   end
 end
 

data/lib/vzcdn/version.rb

@@ -1,3 +1,3 @@
 module Vzcdn
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/zone.rb

@@ -1,100 +1,119 @@
 require_relative 'route'
 require_relative 'util'
-require_relative 'table_print'
+require_relative 'print'
+require_relative 'command'
+require_relative 'args'
 
-class Zone
-  include CommandProc
-  include ConfigReader
+class ZoneList < Command
+  def execute zone
+    zone.list
+  end
+end
 
-  def initialize(name)
-    @zname = name
-    @usage = { :list => "list zones"}
-    @argflows = [ {:name => "list", :usage => "list zones", :args=>[]},
-                 {:name => "add", :usage => "", :args=>[]}]      
+class ZonePull < Command
+  def execute zone
+    zone.pull
   end
-  
-  def list(args)
-    if @zname
-      puts "unimplemented"
+end
+
+class ZonePrint < Command
+  attr_writer :struct, :level, :sep_char
+
+  def create_flows
+    add_flow(Flow.new)
+  end
+
+  def add_options 
+    add_option({ short_name: 'j', long_name: 'json', method: :set_format, takes_value: false})
+    # add_option({ short_name: 'f', long_name: 'force-online', method: :force_online, takes_value: false})
+  end
+
+  def set_format
+    @format = :json
+  end
+
+  def execute(args, subargs)
+    if @format == :json
+      puts JSON.pretty_generate(@struct)
     else
-      zones = Route.do.get_all_zones
-      table = TablePrint.new("ZONE", "ID", "STATUS")
-      zones.each {|zone|
-        table.append(zone["DomainName"],  zone["ZoneId"].to_s, Route.do.xlate_id(:zone_status, zone["Status"]))
-      }
-      table.print_table
+      StructurePrint.new(@sep_char).structure_print(@struct, @level)
     end
   end
+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
+class ZonePush < Command
+  def execute zone
+    zone.push
+  end
+end
+
+class Zone < Command
+  include ConfigReader
+
+  def create_args
+    add_arg(:list, ZoneList.new("list", "list all owned zones"))
+    add_arg(:pull, ZonePull.new(:pull, "retrieve local copy of zone data"))
+    add_arg(:push, ZonePush.new(:push, "push local changes to server"))
+    arg = ZonePrint.new(:print, "print zone data.  ~~~~ online, ---- local copy")
+    arg.required = false
+    add_arg(:print, arg)
+    add_arg(:zname, Arg.new("zname", desc: "name or id of zone to pull", required: true, validator: /[[:alnum:]]+/))
+    add_arg(:zname2, Arg.new("zname", desc: "name or id of zone to pull", required: true, validator: /[[:alnum:]]+/))
+    add_arg(:drill_down, Arg.new("drill-down-param", desc: "drill down the zone structure", required: true, repeatable: true, validator: :ddverify ))
   end
 
-  def structure_print(struct, args, header)
-    if (struct.class == Array)
-      # puts "printing array of " + struct.length.to_s + " elts"
-      struct.each { |elt|
-        # puts "calling struct_print with header = " + header.to_s + ", and elt = " + elt.to_s
-        structure_print(elt, args, header)
-        header = false
-      }
-    elsif (struct.class == Hash)
-      if (args.length == 0)
-        # print top level elements of hash
-        if (header)
-          @table = TablePrint.new(*struct.keys)
-        end
-        values = []
-        struct.keys.each { |key|
-          value = struct[key]
-          if (value.nil?)
-            value = "null"
-          elsif (value.class == Array)
-            value = value.length.to_s + " elements"
-          elsif (value.class == String)
-          elsif (value.class == Fixnum)
-            value = value.to_s
-          elsif (value.class == Hash)
-            value = "<object>"
-          else
-            value = "<" + value.class.to_s + ">"
-          end
-          values << value
-        }
-        @table.append(*values)
+  def create_flows
+    add_flow_from_args(:list)
+    add_flow_from_args(:zname, :pull)
+    add_flow_from_args(:zname2, :push)
+    add_flow_from_args(:drill_down, :print)
+  end
+
+  def ddverify(value)
+    test = value =~ /[[:alnum:]]+/
+    if test
+      if @arghash[value.to_sym].is_a? Command
+        return "name of command", false
       else
-        args = args.clone
-        key = args.shift
-        fullkey = match_key(key, struct)
-        raise "no (unique) key matches " + key if ! fullkey
-        structure_print(struct[fullkey], args, header)
+        return nil, true
       end
-    else
-      if (args.length == 0)
-        puts struct.to_s
-      else
-        puts "unknown class <" + struct.class.to_s + ">"
+    end
+    return "invalid argument", false
+  end
+
+  def execute(args, subargs)
+    @zname = args["zname"]
+    command = args["command"]
+    ddparams = args["drill-down-param"]
+    if ddparams
+      @zname = ddparams.shift
+      zone = get_zone
+      @struct, @level = drill_down(zone, ddparams, "zone")
+      if command.nil?
+        command = @arghash[:print]
       end
+      command.struct = @struct
+      command.level = @level
+      command.sep_char = @sep_char
+    end
+    if command.class == ZonePrint
+      command.run subargs
+    elsif command
+      command.execute self
+    else
+      raise "error"
     end
   end
 
+  def list
+    zones = Route.do.get_all_zones
+    StructurePrint.new('~').structure_print(zones, "zonelist")
+  end
+
+
   def id_and_name
     id = name = nil
-    if  @zname.full_match /\d+/
+    if  @zname.to_s.full_match /\d+/
       id = @zname
     else
       name = @zname
@@ -104,7 +123,8 @@ class Zone
   end
 
   def get_zone(forceRest = false)
-    zonedir = mkdir("zones")
+    @sep_char = "-"
+    zonedir = mk_user_dir("zones")
     zone = nil
     id, name = id_and_name
     if @zname
@@ -116,57 +136,113 @@ class Zone
         end
         regex = Regexp.new(r)
         Dir.new(zonedir).each { |file|
-          if file.full_match regex
+          if (file.full_match regex) && (! @force_online)
             path = File.join(zonedir, file)
             zone = JSON.parse(File.open(path).read)
           end
         }
       end
       if (zone.nil?)
+        dputs "getting zone with id=#{id} and name=#{name}"
+        @sep_char = "~"
         zone = Route.do.get_zone(id, name)
+        if zone.nil?
+          raise "zone doesn't exist or is empty"
+        end
+        File.open("raw.zone","w").write(zone)
         Route.do.translate_zone(zone)
       end
     end
     zone
   end
 
-  def push(args)
+  def push
+    puts "in zone.push"
     zone = get_zone
     Route.do.untranslate_zone(zone)
     File.open("untranslated.zone","w").write(JSON.pretty_generate zone)
     Route.do.update_zone(zone)
   end
 
-  def pull(args)
-    raise("Illegal arguments:" + args.to_s)  if args.length != 0
-    raise("Must specify zone") if @zname.nil?
+  def pull
     zone = get_zone(true)
     file_name = zone["DomainName"].sub(/\.\Z/, '')
     file_name = file_name + '.' + zone["ZoneId"].to_s
-    file_name = config_file("zones", file_name)
+    file_name = user_file("zones", file_name)
     File.delete(file_name) if File.exists?(file_name)
     File.open(file_name, "w").write(JSON.pretty_generate zone)
+    puts "'#{file_name}' saved locally"
   end
 
-  def print(args)
-    if @zname
-      zone = get_zone
-      if (zone.nil?)
-        puts "zone empty"
-        return
+  # 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
+  end
+
+  def drill_down(struct, args, level)
+    if struct.class == Array && struct.length > 1 && level =~ /\[\]/
+      raise "too many arrays"
+    end
+    return struct,level if args.length == 0
+    if (struct.class == Array)
+      if args[0] == 'all'
+        result = [ ]
+        result_level = nil
+        args.shift
+        struct.each { |elt|
+          drilled_elt, drilled_level = drill_down(elt, args, level + "[]")
+          result << drilled_elt
+          result_level = drilled_level
+        }
+        return result, result_level
       end
-      if (args.length == 1 && args[0] == "-l")
-        puts JSON.pretty_generate(zone)
+      if args[0] =~ /\A\d+\Z/
+        index = args.shift.to_i
+        if index > struct.length || index <= 0
+          raise "index #{index} out of bounds"
+        end
+      elsif struct.length == 1
+        index = 1
       else
-        @table = nil
-        structure_print(zone, args, true)
-        @table.print_table if @table
+        args.unshift "all"
+        return drill_down(struct, args, level)
+        # raise "argument #{args[0]} not understood"
       end
+      drill_down(struct[index - 1], args, level + "[#{index}]")
+    elsif (struct.class == Hash)
+      args = args.clone
+      key = args.shift
+      fullkey = match_key(key, struct)
+      raise "no (unique) key matches " + key if ! fullkey
+      drill_down(struct[fullkey], args, level + ".#{fullkey}")
     else
-      puts "need zone name or id"
+      raise "argument #{args[0]} not understood"
     end
   end
 
+  def set_format
+    puts "in zone.set_format"
+    @format = :json
+  end
+
+  def force_online
+    @force_online = true
+  end
+
+
   def add(args)
     if @zname 
       puts "unimplemented"

data/test/test_all.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require_relative 'test_reporting'

data/test/test_reporting.rb

@@ -0,0 +1,142 @@
+require 'reporting.rb'
+require 'test/unit'
+require 'pp'
+
+class TestRestApi < Test::Unit::TestCase
+  def phasharray(name, arr)
+    puts name
+    PP.pp arr
+  end
+
+  def setup
+    @now = Time.new
+    puts ""
+    @media_fhh = [{:Name => "media: flash media, ", :id => MediaType::FLASH_MEDIA},
+                  {:Name => "media: http large, ", :id => MediaType::HTTP_LARGE},
+                  {:Name => "media: http small, ", :id =>  MediaType::HTTP_SMALL}]
+    @media_fhha = @media_fhh.clone.push({:Name => "media: adn, ", :id =>  MediaType::ADN})
+    @media_hha = @media_fhha.clone
+    @media_hha.shift
+    @media_fha = @media_fhh[0,2]
+    @media_fha.push(@media_fhha[3])
+    @media_afhha = [{:Name => "media: all, ", :id => nil}]
+    @media_fhha.each { |elt|
+      @media_afhha << elt
+    }
+
+    @units = [{:Name => "units: mbps, ", :id => TrafficUnits::MBPS},
+              {:Name => "units: GB, ", :id => TrafficUnits::GB}]
+  end
+
+  def test_traffic_usage
+    billing_month = @now - 50*24*60*60
+    puts "traffic usage for billing month in " + billing_month.strftime("%Y-%m-01")
+    @media_fhha.each { |media|
+      get_billing_regions.each { |region|
+        region_name = region["Name"]
+        if (region_name != "Global")
+          @units.each { |units|
+            puts media[:Name] + "region: " + region_name + ", " + units[:Name] + 
+              get_traffic_usage(media[:id], region["Id"], units[:id], billing_month).to_s
+          }
+        end
+      }
+    }
+  end
+
+  def test_report_codes
+    puts "report codes"
+    @media_afhha.each { |media|
+      puts media[:Name] + get_report_codes(media[:id]).to_s
+    }
+  end
+    
+  def test_maximum_storage_usage
+    puts "maximum storage usage"
+    puts get_maximum_storage_usage(@now-7*24*60*60, @now)
+  end
+
+  def test_download_activity
+    puts "download activity"
+    @media_fha.each { |media|
+      puts media[:Name] + get_download_activity(media[:id], @now-24*60*60, @now).to_s
+    }
+  end
+
+  def test_directory_activity
+    puts "directory activity"
+    @media_fha.each { |media|
+      puts media[:Name] + get_directory_activity(media[:id], @now-24*60*60, @now).to_s
+    }
+  end
+
+  def test_xferred_interval
+    puts "all regions: " + get_data_transferred_by_platform_and_interval(nil, @now-30*60, @now, nil, nil).to_s 
+    regions = get_billing_regions
+    regions.each { |region|
+      puts "region: " + region["Name"] + ", " + get_data_transferred_by_platform_and_interval(nil, @now-30*60, @now, region["Id"], nil).to_s 
+    }
+    puts "every 5 minutes: " + get_data_transferred_by_platform_and_interval(nil, @now-30*60, @now, nil, Interval::FIVE_MINUTE).to_s 
+    puts "every hour: " + get_data_transferred_by_platform_and_interval(nil, @now-10*60*60, @now, nil, Interval::HOURLY).to_s 
+    puts "every day: " + get_data_transferred_by_platform_and_interval(nil, @now-5*24*60*60, @now, nil, Interval::DAILY).to_s 
+    puts "flash media: " + get_data_transferred_by_platform_and_interval(MediaType::FLASH_MEDIA, @now-30*60, @now, nil, nil).to_s 
+    puts "http large: " + get_data_transferred_by_platform_and_interval(MediaType::HTTP_LARGE, @now-30*60, @now, nil, nil).to_s 
+    puts "http large ssl only: " + get_data_transferred_by_platform_and_interval(MediaType::HTTP_LARGE_SSL, @now-30*60, @now, nil, nil).to_s 
+    puts "http large dfw: " + get_data_transferred_by_platform_and_interval(MediaType::HTTP_LARGE, @now-30*60, @now, nil, nil, "dfw").to_s 
+    puts "http large lax, dca, mia, dfw: " + get_data_transferred_by_platform_and_interval(MediaType::HTTP_LARGE, @now-30*60, @now, nil, nil, "lax", "dca", "mia", "dfw").to_s 
+    puts "http small: " + get_data_transferred_by_platform_and_interval(MediaType::HTTP_SMALL, @now-30*60, @now, nil, nil).to_s 
+    puts "http small ssl only: " + get_data_transferred_by_platform_and_interval(MediaType::HTTP_SMALL_SSL, @now-30*60, @now, nil, nil).to_s 
+    puts "adn: " + get_data_transferred_by_platform_and_interval(MediaType::ADN, @now-30*60, @now, nil, nil).to_s
+    puts "adn ssl only: " + get_data_transferred_by_platform_and_interval(MediaType::ADN_SSL, @now-30*60, @now, nil, nil).to_s
+  end
+
+  def test_xferred
+    puts "flash media: " + get_data_transferred_by_platform(MediaType::FLASH_MEDIA, @now-24*60*60, @now).to_s 
+    puts "http large: " + get_data_transferred_by_platform(MediaType::HTTP_LARGE, @now-24*60*60, @now).to_s 
+    # puts "http large ssl only: " + get_data_transferred_by_platform(MediaType::HTTP_LARGE_SSL, @now-24*60*60, @now).to_s 
+    puts "http large dfw: " + get_data_transferred_by_platform(MediaType::HTTP_LARGE, @now-24*60*60, @now, "dfw").to_s 
+    puts "http large lax, dca, mia, dfw: " + get_data_transferred_by_platform(MediaType::HTTP_LARGE, @now-24*60*60, @now, "lax", "dca", "mia", "dfw").to_s 
+    puts "http small: " + get_data_transferred_by_platform(MediaType::HTTP_SMALL, @now-24*60*60, @now).to_s 
+    # puts "http small ssl only: " + get_data_transferred_by_platform(MediaType::HTTP_SMALL_SSL, @now-24*60*60, @now).to_s 
+    puts "adn: " + get_data_transferred_by_platform(MediaType::ADN, @now-24*60*60, @now).to_s
+    # puts "adn ssl only: " + get_data_transferred_by_platform(MediaType::ADN_SSL, @now-24*60*60, @now).to_s
+  end
+
+  def test_xferred_codes
+    puts "flash media: " + get_data_transferred_and_hits_by_custom_report_codes(MediaType::FLASH_MEDIA, @now-24*60*60, @now).to_s 
+    puts "http large: " + get_data_transferred_and_hits_by_custom_report_codes(MediaType::HTTP_LARGE, @now-24*60*60, @now).to_s 
+    puts "http small: " + get_data_transferred_and_hits_by_custom_report_codes(MediaType::HTTP_SMALL, @now-24*60*60, @now).to_s 
+    puts "adn: " + get_data_transferred_and_hits_by_custom_report_codes(MediaType::ADN, @now-24*60*60, @now).to_s 
+  end
+
+  def test_xferred_all
+    puts get_all_data_transferred(@now-24*60*60, @now)
+    puts get_all_data_transferred(@now-4*60*60, @now, "dfw")
+    puts get_all_data_transferred(@now-60*60, @now, "lax", "dca", "mia", "dfw")
+  end
+
+  def test_customer_name
+    puts "customer name: " + get_customer_name.to_s
+  end
+
+  def test_account_number
+    # puts "account number: " + get_customer_account_number("NMK01").to_s
+  end
+
+  def test_assec_activity
+    puts "flash media: " + get_asset_activity(MediaType::FLASH_MEDIA, @now-24*60*60, @now).to_s
+    puts "http large: " + get_asset_activity(MediaType::HTTP_LARGE, @now-24*60*60, @now).to_s
+    puts "http small: " + get_asset_activity(MediaType::HTTP_SMALL, @now-24*60*60, @now).to_s
+    puts "ADN: " + get_asset_activity(MediaType::ADN, @now-24*60*60, @now).to_s
+  end
+
+  def test_status_activity
+    puts "http large: " + get_cache_status_activity(MediaType::HTTP_LARGE, @now-24*60*60, @now).to_s
+    puts "http small: " + get_cache_status_activity(MediaType::HTTP_SMALL, @now-24*60*60, @now).to_s
+    puts "ADN: " + get_cache_status_activity(MediaType::ADN, @now-24*60*60, @now).to_s
+  end
+
+  def test_storage_usage
+    puts "current_storage_usage: " + get_current_storage_usage.to_s
+  end
+end