framework_gem 0.1.0

data/lib/end_iteration.rb

@@ -0,0 +1,4 @@
+require './lib/test_wrapper.rb'
+
+# Pass arguments to test wrapper to end an iteration
+TestWrapper.new(ARGV).end_iteration

data/lib/lib/data_services/channel.rb

@@ -0,0 +1,39 @@
+class Channel
+
+=begin
+# Arriving from nns as a json structure which is parsed by the Lineup class
+# example:
+# {"ncsServiceId":"5118","tmsId":"20293","entitlementId":"5118","networkName":"ABC (KMGH) HD","networkId":"466","callSign":"KMGHDT","streamUri":"/ipvs/api/smarttv/stream/live/v1/5118","logoUrl":"http://services.timewarnercable.com/imageserver/guide/20293","genres":["Broadcasters"],"availableOutOfHome":false,"favorite":false,"cdvrRecordable":true,"blockEas":true,"hd":true,"channels":[7],"streams":[{"type":"hls","drm":true,"dai":false,"uri":"/ipvs/api/smarttv/stream/live/v1/5118?encoding=hls&drm-supported=true&dai-supported=false","cdnUrl":"http://hls-lin-325.timewarnercable.com/hls/ae/KMGH/index.m3u8"},{"type":"smooth","drm":false,"dai":false,"uri":"/ipvs/api/smarttv/stream/live/v1/5118?encoding=hss&drm-supported=false&dai-supported=false","cdnUrl":"http://hls-lin-325.timewarnercable.com/ss/un/KMGH.isml/Manifest"},{"type":"smooth","drm":true,"dai":false,"uri":"/ipvs/api/smarttv/stream/live/v1/5118?encoding=hss&drm-supported=true&dai-supported=false","cdnUrl":"http://hls-lin-325.timewarnercable.com/ss/pr/KMGH.isml/Manifest"},{"type":"hls","drm":false,"dai":false,"uri":"/ipvs/api/smarttv/stream/live/v1/5118?encoding=hls&drm-supported=false&dai-supported=false","cdnUrl":"http://hls-lin-325.timewarnercable.com/hls/un/KMGH/index.m3u8"}],"parentallyBlocked":false}
+=end
+  attr_accessor(:channel_numbers, :call_sign, :tms_id, :entitlement_id, :network_name, :genres, :available_out_of_home, :favorite,  :cdvr_recordable, :block_eas, :number, :hd, :parentally_blocked)
+
+  def initialize(logger)
+    @logger = logger
+    @call_sign = "";
+    @cdvr_recordable = false;
+    @number = "";
+    @tms_id = "";
+    @parentally_blocked = false;
+  end
+
+  def populate channel_hashmap
+    @channel_numbers = channel_hashmap["channels"]
+    ncs_service_id = channel_hashmap ["ncsServiceId"]
+    @tms_id = channel_hashmap["tmsId"]
+    @entitlement_id = channel_hashmap["entitlementId"]
+    @network_name = channel_hashmap["networkName"]
+    network_id = channel_hashmap["networkId"]
+    @call_sign = channel_hashmap["callSign"]
+    stream_uri = channel_hashmap["streamUri"]
+    logo_url = channel_hashmap["logoUrl"]
+    @genres = channel_hashmap["genres"]
+    @available_out_of_home = channel_hashmap["availableOutOfHome"]
+    @favorite = channel_hashmap["favorite"]
+    @cdvr_recordable = channel_hashmap["cdvrRecordable"]
+    @block_eas = channel_hashmap["blockEas"]
+    @hd = channel_hashmap["hd"]
+    streams = channel_hashmap["streams"]
+    @parentally_blocked = channel_hashmap["parentallyBlocked"]
+  end
+
+end

data/lib/lib/data_services/data_services.rb

@@ -0,0 +1,14 @@
+require "./lib/data_services/guide"
+require "./lib/data_services/lineup"
+
+
+class DataServices
+
+  attr_reader(:guide, :lineup)
+  def initialize(logger)
+    @logger = logger
+
+    @guide = Guide.new logger
+    @lineup = Lineup.new logger
+  end
+end

data/lib/lib/data_services/guide.rb

@@ -0,0 +1,104 @@
+require "./program"
+require 'json'
+
+class Guide
+
+  attr_accessor( :channels, :schedule)
+  def initialize(logger)
+    @logger = logger
+
+    @channels = {}
+    @schedule = []
+  end
+
+
+  def fake_it
+
+    t = Time.now
+
+    p = Program.new(@logger)
+    p.start_time = t -100
+    p.end_time = t + 1800
+    p.tms_guide_id = 59373
+    p.title = "Sinister 2"
+    p.short_desc = "A woman and her sons encounter the evil spirit of Bughuul."
+    @schedule.push p
+
+    p3 = Program.new(@logger)
+    p3.start_time = t -100
+    p3.end_time = t + 1700
+    p3.tms_guide_id = 58646
+    p3.title = "At This Hour with Berman and Bolduan"
+    p3.short_desc = nil
+    @schedule.push p3
+
+    p1 = Program.new(@logger)
+    p1.start_time = t + 1801
+    p1.end_time = t + 3000
+    p1.tms_guide_id = 59373
+    p1.title = "A Little Chaos"
+    p1.short_desc = "A widow becomes a gardener at Louis XIV's Versailles."
+    @schedule.push p1
+
+    p4 = Program.new(@logger)
+    p4.start_time = t + 1701
+    p4.end_time = t + 3600
+    p4.tms_guide_id = 58646
+    p4.title = "CNN Newsroom With Brianna Keilar"
+    p4.short_desc = nil
+    @schedule.push p4
+
+
+    p2 = Program.new(@logger)
+    p2.start_time = t + 3001
+    p2.end_time = t + 5400
+    p2.tms_guide_id = 59373
+    p2.title = "Evan Almighty"
+    p2.short_desc = "God commands a former newscaster to build an ark."
+    @schedule.push p2
+
+    p5 = Program.new(@logger)
+    p5.start_time = t + 3601
+    p5.end_time = t + 5400
+    p5.tms_guide_id = 58646
+    p5.title = "Wolf"
+    p5.short_desc = nil
+    @schedule.push p5
+  end
+
+  def walk_guide
+    @schedule.each do |p|
+#      @logger.info( "#{p.tms_guide_id}   #{p.title}")
+      puts( "#{p.tms_guide_id}   #{p.title}  S #{p.season} E #{p.episode} #{p.episode_title}")
+    end
+  end
+
+  def programs_on_channel
+    @schedule.group_by(&:tms_guide_id)
+  end
+
+  def current_program_on_channel tms_guide_id
+    now = Time.now
+    @schedule.select { |s| s.tms_guide_id == tms_guide_id  && s.start_time < now  &&  s.end_time > now}.first
+  end
+
+
+  # TODO: store as flat or nested?
+  def process_programs jsonString
+    programs_hashmap = JSON.parse(jsonString)
+    programs_hashmap.each do |tmsid|
+      program_array = tmsid[1]
+      # puts "Processing " + program_array.length.to_s + " programs"
+      program_array.each do |program_hashmap|
+        # puts program_hashmap
+        program = Program.new(@logger)
+        program.populate program_hashmap
+        @schedule.push program
+      end
+    end
+  end
+end
+
+# g = Guide.new
+# g.fake_it
+# puts g.inspect

data/lib/lib/data_services/lineup.rb

@@ -0,0 +1,114 @@
+require './channel'
+require '../data_services/splunk_connector'
+require 'net/http'
+require 'json'
+
+class Lineup
+
+  attr_accessor(:by_call_sign, :by_channel_num)
+  def initialize(logger)
+    @logger = logger
+
+    @channels = []
+    @real_channels = {}
+  end
+
+  # Public: make some fake data
+  #
+  # returns nothing
+  def fake_it()
+    @logger.info("fake_it")
+    channelA = Channel.new(@logger)
+
+    # "{"cdvrrecordable":true,"channelnumber":202,"ncsserviceid":"82","networkname":"CNN HD","tmsid":"58646"}"
+    channelA.call_sign = "CNNHD"
+    channelA.number = "202"
+    channelA.parentally_blocked = false
+    channelA.tms_guide_id = 58646
+    @channels.push channelA
+
+    channelB = Channel.new(@logger)
+    # "{"cdvrrecordable":true,"channelnumber":533,"ncsserviceid":"62","networkname":"Cinemax MoreMax HD","tmsid":"59373"}"
+    channelB.call_sign = "MOMAXHD"
+    channelB.number = "533"
+    channelB.parentally_blocked = true
+    channelB.tms_guide_id = 59373
+    @channels.push channelB
+
+  end
+
+  def by_call_sign
+    @logger.info("by_call_sign")
+    Hash[@channels.map{ |c| [c.call_sign,c]}]
+  end
+
+  def by_channel_num
+    @logger.info("by_channel_num")
+    Hash[@channels.map{ |c| [c.number,c]}]
+  end
+
+  def walk_channels
+    by_channel_num.each do |c, chan|
+      @logger.info "#{chan.number}  #{chan.call_sign}"
+    end
+  end
+
+  def get_tms_guide_id channel_num
+    @channels.select { |c| c.number == channel_num}.first.tms_guide_id
+  end
+
+  def process_string_lineup jsonString
+    json = JSON.parse(jsonString)
+    process_json_lineup json
+  end
+
+  def process_json_lineup json
+    json.each do |k, v|
+      puts "k = #{k}"
+      if k == "channels" && v.is_a?(Array)
+        puts "v is an array"
+        j_channels = v.map
+        j_channels.each do |v_channel|
+          new_channel = Channel.new(@logger)
+          new_channel.populate v_channel
+          new_channel.channel_numbers.each do |channel_number|
+            @real_channels[channel_number] = new_channel
+            puts new_channel.inspect
+          end
+        end
+      end
+    end
+  end
+
+  def peek
+    puts @real_channels[7].inspect
+    puts @real_channels[87].inspect
+    puts @real_channels[132].inspect
+  end
+
+  def get_file_as_string(filename)
+    data = ''
+    f = File.open(filename, "r")
+    f.each_line do |line|
+      data += line
+    end
+    return data
+  end
+
+end
+
+lineup = Lineup.new @logger
+search_string = "search index=figaro"
+splunk_connector = SplunkConnector.new
+channel_list = splunk_connector.search_splunk search_string, "ipvs/api/smarttv/channels/v1", 300, "-500s"
+
+if channel_list.length > 0
+  puts channel_list[0].inspect
+  lineup.process_json_lineup channel_list[0]
+end
+# l = Lineup.new @logger
+# input = l.get_file_as_string "../../../test_cases/roku/unit_tests/data/sample_lineup.dat"
+# puts "input = #{input}"
+# l.process_lineup input
+# l.peek
+

data/lib/lib/data_services/program.rb

@@ -0,0 +1,48 @@
+class Program
+
+  attr_accessor( :tms_guide_id, :tms_program_id, :call_sign, :vod_tms_guide_id, :title, :icons, :short_desc, :tms_series_id, :season, :episode, :episode_title, :type, :start_time_sec, :duration_min, :end_time)
+  def initialize(logger)
+    @logger = logger
+    @title = nil
+    @episode_title = nil
+    @tms_guide_id = nil
+    @tms_program_id = nil
+    @short_desc = nil
+    @start_time_sec = nil
+    @end_time  = nil
+  end
+
+  def initialize(logger)
+    @logger = logger
+  end
+
+  def populate program_hash
+    @tms_guide_id = program_hash["tmsGuideId"]
+    @tms_program_id = program_hash["tmsProgramId"]
+    @call_sign = program_hash["callSign"]
+    @vod_tms_guide_id = program_hash["vodTmsSeriesId"]
+    @title = program_hash["title"]
+    @short_desc = program_hash["shortDesc"]
+    @icons = program_hash["icons"]
+
+    meta_data = program_hash["metadata"]
+    unless (meta_data.nil?)
+      @tms_series_id = meta_data["tmsSeriesId"]
+      @season = meta_data["season"]
+      @episode = meta_data["episode"]
+      @episode_title = meta_data["title"]
+      @type = meta_data["type"]
+    end
+
+    @start_time_sec = program_hash["startTimeSec"]
+    @duration_min  = program_hash["durationMinutes"]
+    if (! @start_time_sec.nil?  &&  ! @duration_min.nil?)
+      sec = @duration_min.to_i * 60
+      @end_time = @start_time_sec + sec
+    end
+
+    @genres = program_hash["genres"]
+    @rating = program_hash["rating"]
+    @ratings_blocked = program_hash["ratingsBlocked"]
+  end
+end

data/lib/lib/data_services/schedule.rb

@@ -0,0 +1,18 @@
+class Schedule
+
+=begin
+  public int hourBegin = 0;
+  public int hourEnd;
+  public String tmsGuideId = "";
+  public ArrayList<IpvsGrid> programArray;
+=end
+
+
+  attr_accessor(:hour_begin, :hour_end)
+  def initialize(logger)
+    @logger = logger
+    @hour_begin = 0;
+    @hour_end = 0;
+    @tms_guide_id = "";
+  end
+end

data/lib/lib/data_services/splunk_connector.rb

@@ -0,0 +1,135 @@
+require 'splunk-sdk-ruby'
+require 'json'
+require 'nokogiri'
+
+
+# Joe Davison
+# 1/6/2017
+# SplunkConnector is some experimental code to validate that results written to splunk can
+# be retrieved into the TMC environment.  Currently this code checks splunk in a loop to count iterations
+# and sleeps for 1 second until fresh data is retrieved.  Using this code, it was observed that there
+# is a 1 minute latency between data posted to splunk and its visibility in either the splunk web interface
+# or this api.
+
+# This code needs to be smarter to allow it to continue to search for the correct record(s) when
+# more than one device is logging.
+
+class SplunkConnector
+
+  # list_apps can be used to validate the connection to splunk is healthy
+  def list_apps service
+    puts '     List of apps     '
+    puts '======================'
+    service.apps.each do |app|
+      puts app.name
+    end
+
+  end
+
+  # provides a mechanism to execute a given splunk search ex: "search index=figaro"
+  # keeps executing the search for a given number of attempts, or until the desired path
+  # (where the record represented has a json element within a figaro response - at the location "request.params.path" )
+  # AND the returned record(s) are contained by "response.payload"
+  def search_splunk( search_string, desired_path, num_tries = 100, look_back_secs = 5)
+    service = Splunk::Service.new(:host => "chrcnc-hnav-splunksearchhead-01.os.vap.rr.com",
+                                  :port => 8089,
+                                  :username => "figaro",
+                                  :password => "figaro").login()
+
+    results = []
+    if (desired_path.nil?  ||  desired_path.length() < 1)
+      puts "ERROR: search_splunk: desired_path must be specified "
+    end
+    puts "executing search_splunk #{search_string} for #{desired_path}"
+    num_results = 0
+
+    while num_tries > 0
+      job = Splunk::Jobs.new(service)
+      stream = job.create_oneshot(
+          search_string,
+          :earliest_time => look_back_secs,
+          :latest_time => "now")
+      sep_results = Splunk::ResultsReader.new(stream)
+      num_results = sep_results.count()
+      puts Time.new.inspect + "  " + num_results.to_s + " matches looking for results: #{search_string}"
+
+      if (num_results > 0)
+        results = parse_splunk_record stream, desired_path
+        puts "There are " + results.count().to_s + " records in results"
+        if (results.count() > 0)
+          puts "\n\n"
+          break
+        end
+      end
+
+      num_tries = num_tries - 1
+      sleep 1
+    end
+    return results
+  end
+
+  # parse_splunk_record encapsulates the processing of records retrieved from splunk
+  # (where the record represented has a json element within a figaro response - at the location "request.params.path" )
+  # AND the returned record(s) are contained by "response.payload"
+  def parse_splunk_record splunk_stream, desired_path
+    results = []
+
+    reader = Splunk::ResultsReader.new(splunk_stream)
+    reader.each do |result|
+
+      raw_result = result["_raw"]
+      puts raw_result.to_s
+      r = JSON.parse raw_result
+      path = r["request"]["params"]["path"]
+      payload = r["response"]["payload"]
+      puts "path = #{path}"
+      puts "payload = #{payload}"
+      if (path == desired_path)
+        results.push payload
+      end
+
+    end
+    return results
+  end
+
+  # Use this method to test the connection is being made properly
+  def validate_splunk_connection
+    service = Splunk::Service.new(:host => "chrcnc-hnav-splunksearchhead-01.os.vap.rr.com",
+                                  :port => 8089,
+                                  :username => "figaro",
+                                  :password => "figaro").login()
+
+    # list_apps can be used to validate the connection to splunk is healthy
+    s_connector = SplunkConnector.new
+    s_connector.list_apps service
+  end
+
+  # Execute this unit test to validate retrieval of the channel list delivered from the figaro interface
+  # This test waits approximately 5 minutes for data to be delivered to splunk from figaro
+  # You must trigger an event to request the channel list independently of this test execution
+  # You may use OVP login with figaro_local to cause this to occur * see configuration note below
+  # during testing a latency of approximately 1 minute was observed between the figaro console logging of the data
+  # until it was available from splunk
+  def channel_list_unit_test
+    search_string = "search index=figaro"
+    channel_list = SplunkConnector.new.search_splunk search_string, "ipvs/api/smarttv/channels/v1", 300, "-10s"
+
+    if channel_list.length > 0
+      puts channel_list[0].to_s
+    end
+  end
+
+  # s_connector = SplunkConnector.new
+  # s_connector.channel_list_unit_test
+
+end
+
+# contents of figaro modules/sam-spayed/config/index.js file for channel_list_unit_test:
+#     paths: [
+#     '/ipvs/api/smarttv/lineup/v1',
+#     '/ipvs/api/smarttv/location/v1',
+#     '/ipvs/api/smarttv/channels/v1'
+# ],
+#     logging: {
+#     url: 'https://figaro.ovp.timewarnercable.com/device/figaro/logger?apikey=4567figaro123', //where to send the logs
+# }