awslive-inputlooper 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d419767541f1dad5b2d78c48e6bfbcaa2ddd5696927db79776182257457b8fa
+  data.tar.gz: 3756e17fd1a8e81ff61fbeab5864bff7ec7417778a6d1e96d0f82215f3f95ea5
+SHA512:
+  metadata.gz: 5ebee223608ff8c27b0ce0498f180cf13cb44fd5bb0a909f067b2a0c56c95c3a91e1ee95f7e1effb3f686e51b49a73f7a4dd1e196e9cae97002a0461879e3b55
+  data.tar.gz: 6711775e948903d5b0d21463598c152e0fe9339c5defbf84917e0f8b7c76568b612f76a86d88f2c1b45fa9e10665c2f625391434228448a6b5284930449426a9

data/bin/awslive-inputlooper

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "awslive-inputlooper"
+require 'optimist'
+
+
+global_opts = Optimist::options do
+  banner "AWS Live Inputlooper, helps in switching and looping the live inputs associated with Medialive channel"
+  opt :access_key_id, "AWS Key", :type => :string, :short => "k"
+  opt :secret_access_key, "AWS Secret", :type => :string, :short => "s"
+  opt :channel_id, "Channel Id", :type => :string, :short => "c", :required => true
+  opt :playlist, "Enter the list of files in comma separated fashion", :type => :string, :short => "p"
+  opt :loop_delay, " Enter the Delay to be induced for looping the inputs", :type => :int, :short => "d"
+  opt :verbose, "Enter true for verbose", :type => :string, :short => "v"
+end
+puts "AWS Live Inputlooper, helps in switching and looping the live inputs associated with Medialive channel"
+
+def print_opts
+  puts ""
+  puts "Following options can be provided.."
+  puts "1. switch_and_loop_inputs"
+  puts "2. playlist_loop_alive"
+  puts "3. stop_playlist_loop"
+  puts "4. update_playlist"
+  puts "5. switch_playlist"
+  puts "6. pause_channel"
+  puts "7. Quit"
+end
+
+print_opts
+
+@input_looper = Awslive::InputLooper.new(global_opts[:channel_id])
+if !global_opts[:verbose].nil? && global_opts[:verbose] == "true"
+  @input_looper.set_log_flag(true)
+else
+  @input_looper.set_log_flag(false)
+end
+while true
+  #cmd = ARGV.shift # get the subcommand
+  cmd = gets.chomp
+  cmd_opts = case cmd
+               when "switch_and_loop_inputs" # Switch and Loop Inputs
+                 if global_opts[:playlist].nil?
+                   puts "Please provide playlist details"
+                   global_opts[:playlist] = gets.chomp
+                 end
+                 playlist = global_opts[:playlist].split(",")
+                 puts "Switch and looping  the channel #{global_opts[:channel_id]} with playlist #{playlist}"
+                 delay = global_opts[:loop_delay].nil? ? 5 : global_opts[:loop_delay]
+                 @input_looper.switch_and_loop_playlist(playlist, delay)
+                 sleep 10
+                 puts "Playlist Alive #{@input_looper.playlist_loop_alive}"
+               when "playlist_loop_alive"
+                 puts @input_looper.playlist_loop_alive
+               when "stop_playlist_loop"
+                 puts @input_looper.stop_playlist_loop
+               when "update_playlist"
+                 puts "Enter New Playlist "
+                 new_playist_str = gets.chomp
+                 new_playlist = new_playist_str.split(",")
+                 if @input_looper.playlist_loop_alive
+                   @input_looper.update_playlist(new_playlist)
+                   puts "Playlist updated!"
+                 else
+                   puts "Switch and Loop not active"
+                 end
+               when "switch_playlist"
+                 puts "Enter New Playlist "
+                 new_playist_str = gets.chomp
+                 new_playlist = new_playist_str.split(",")
+                 delay = global_opts[:loop_delay].nil? ? 5 : global_opts[:loop_delay]
+                 @input_looper.switch_playlist(new_playlist, delay )
+               when "pause_channel"
+                 @input_looper.pause_channel
+               when "quit"
+                 break
+               else
+                 puts "Invalid command!!, try valid command"
+             end
+end
+
+

data/lib/awslive-common/action_type.rb

@@ -0,0 +1,4 @@
+module ActionType
+  INPUT_SWITCH  = "Input Switch"
+  PAUSE         = "pause"
+end

data/lib/awslive-common/all_exceptions.rb

@@ -0,0 +1,9 @@
+module AwsliveExceptions
+
+    class InternalException < StandardError; end
+
+    class InvalidInputException < StandardError; end
+
+    class InvalidChannelStateException  < StandardError; end
+
+end

data/lib/awslive-common/logging.rb

@@ -0,0 +1,9 @@
+module AwsliveLogging
+  @log_enabled = true
+  def set_log_flag(flag)
+    @log_enabled = flag
+  end
+  def log(text)
+    puts text if @log_enabled
+  end
+end

data/lib/awslive-common/start_type.rb

@@ -0,0 +1,5 @@
+module StartType
+  FIXED     = "fixed"
+  FOLLOW    = "follow"
+  IMMEDIATE = "immediate"
+end

data/lib/awslive-inputlooper.rb

@@ -0,0 +1 @@
+require 'awslive-inputlooper/input_looper'

data/lib/awslive-inputlooper/input_looper.rb

@@ -0,0 +1,216 @@
+# Internal Libraries
+require_relative '../awslive-common/start_type'
+require_relative '../awslive-common/action_type'
+require_relative '../awslive-scheduler/schedule_action'
+require_relative '../awslive-common/all_exceptions'
+require_relative '../awslive-common/logging'
+
+# Thrid Party Library.
+require 'aws-sdk-medialive'
+
+
+module Awslive
+  class InputLooper
+    include StartType
+    include ActionType
+    include AwsliveExceptions
+    include AwsliveLogging
+
+    INITAL_INPUT_ACTION_NAME = "Initial Channel Input"
+
+    def initialize(channel_id, playlist = nil)
+      credentials = Aws::SharedCredentials.new
+      if credentials.set?
+        @medialiveclient = Aws::MediaLive::Client.new(:credentials => credentials)
+      else
+        @medialiveclient = Aws::MediaLive::Client.new
+      end
+      @scheduler = Awslive::ScheduleAction.new(@medialiveclient)
+      @channel_id = channel_id
+      @playlist = playlist
+      @loop_thread = nil
+    end
+
+    def switch_and_loop_playlist(playlist, sleep_time = nil)
+      @loop_thread = Thread.new {
+        @playlist = playlist
+        log ("Switch input Monitoring started!!")
+        switch_input(true)
+        # AWS recommends to have 5 sec delay beteen the switches.
+        sleep 5
+        sleep_time = 5 if sleep_time.nil? || sleep_time < 5
+        loop do
+          success = switch_input
+          break if !success
+          sleep sleep_time
+        end
+        log( "Switch input Monitoring Stopped!!")
+      }
+    end
+
+    def playlist_loop_alive
+      isalive = @loop_thread.nil? ? false : @loop_thread.alive?
+      isalive
+    end
+
+    def stop_playlist_loop
+      Thread.kill(@loop_thread) if playlist_loop_alive
+      true
+    end
+
+    def update_playlist(playlist)
+      @playlist = playlist
+      return true
+    end
+
+    def switch_playlist(playlist, sleep_time = nil)
+      if stop_playlist_loop
+        switch_and_loop_playlist(playlist, sleep_time)
+      end
+      return playlist_loop_alive
+    end
+
+    def switch_input(force_immed = nil)
+      # Fetching the channel information every time to know the state of the channel and input in pipeline.
+      channel_info = get_channel_info
+      channel_state = channel_info[:state]
+      # the switching loop will be active only when the channel is in "RUNNING" state.
+      if channel_state == "RUNNING"
+        # Identifying one static and one dyanmic input to enable the switch and loop inputs.
+        static_input, dynamic_input = get_valid_inputs(channel_info[:input_attachments])
+
+        if static_input.nil? || dynamic_input.nil?
+          log( "No Valid inputs for Switch and loop; please provision one static and one dynamic input in the Channel #{@channel_id}")
+          raise InvalidInputException.new("No Valid inputs; should be provisioned with one static and one dynamic Input")
+        end
+
+        current_input_name = get_current_input(channel_info)
+        current_input_action_name = get_current_action(channel_info)
+        sc_action =  @scheduler.get_scheudle_action(@channel_id, current_input_action_name)
+        log( "Current input #{current_input_name}  #{current_input_action_name}")
+        if force_immed || sc_action.nil? || is_schedule_empty?
+          log( "Schedule is empty or schedule does not exist; Hence creating one immediate action with static input")
+          data = {}
+          #data[:input_ref_name] = static_input[:input_attachment_name]
+          data[:input_ref_name] = dynamic_input[:input_attachment_name]
+          data[:url_path] = @playlist[0]
+          @scheduler.create(@channel_id, IMMEDIATE, INPUT_SWITCH, data)
+          return true
+        end
+
+        follow_schedule = @scheduler.get_follow_schedule(@channel_id, current_input_action_name)
+        current_url = @scheduler.get_action_url(@channel_id, current_input_action_name)
+        log( "current URL #{current_url} next URL #{follow_schedule}")
+        unless follow_schedule.nil?
+          follow_url = @scheduler.get_follow_action_url(@channel_id, current_input_action_name)
+          log("Follow URL #{follow_url}")
+          next_file = identify_next_input(current_url)
+          log( "Next URL #{next_file}")
+          if !follow_url[0].nil? && next_file != follow_url[0]
+            log( "Playlist seems to be changed, hence aligning.")
+            @scheduler.delete( @channel_id,[ "#{follow_schedule[:action_name]}"])
+            next_input_name = dynamic_input[:input_attachment_name]
+            log ("next input name #{next_input_name}")
+            data = {}
+            data[:follow_input] = current_input_action_name
+            data[:trigger_input] = next_input_name
+            data[:url_path] = next_file
+            @scheduler.create(@channel_id, FOLLOW, INPUT_SWITCH, data)
+          else
+            log( "No change in follow schedule!. not change in playlist")
+            return true
+          end
+        else
+          log("No follow Schedule!")
+          next_file = identify_next_input(current_url)
+          unless next_file.nil?
+            next_input_name = dynamic_input[:input_attachment_name]
+            log( "Next input Name #{next_input_name} #{next_file}")
+            data = {}
+            data[:follow_input] = current_input_action_name
+            data[:trigger_input] = next_input_name
+            data[:url_path] = next_file
+            @scheduler.create(@channel_id, FOLLOW, INPUT_SWITCH, data)
+          end
+        end
+      else
+        log("invalid channel state #{channel_state}")
+        raise InvalidChannelStateException.new("Channel state Should be RUNNING, instead of #{channel_state}")
+      end
+    end
+
+    def identify_next_input(file_url)
+      next_file = @playlist[0]
+      #puts " File Url #{file_url}"
+      if !file_url.nil? && !file_url[0].nil?
+        @playlist.each_with_index do | playlist_file, index |
+          #puts "next file identification #{playlist_file}   #{file_url[0]}  #{index}"
+          if playlist_file == file_url[0]
+            if index == (@playlist.length - 1)
+              next_file = @playlist[0]
+            else
+              next_file = @playlist[index + 1]
+            end
+          end
+        end
+      end
+      next_file
+    end
+
+    def is_schedule_empty?
+      schedule_info = @medialiveclient.describe_schedule({ :channel_id => "#{@channel_id}"})
+      schedule_actions = schedule_info[:schedule_actions]
+      schedule_actions.empty?
+    end
+
+    def get_valid_inputs(inputs)
+      static_input = nil
+      dynamic_input = nil
+
+      inputs.each do | input |
+        next if input[:input_settings][:source_end_behavior] != "CONTINUE"
+        input_info = @medialiveclient.describe_input({ :input_id => "#{input[:input_id]}" })
+        if input_info[:input_source_type] == "STATIC"
+          static_input = input
+        elsif input_info[:input_source_type] == "DYNAMIC"
+          dynamic_input = input
+        end
+        if !static_input.nil? && !dynamic_input.nil?
+          break
+        end
+      end
+      puts static_input
+      puts dynamic_input
+      return static_input, dynamic_input
+    end
+
+
+    def get_channel_info
+      @medialiveclient.describe_channel({ :channel_id => "#{@channel_id}" })
+    end
+
+    def get_current_input(channel_info = nil )
+      channel_info = get_channel_info if channel_info.nil?
+      current_input_name = channel_info[:pipeline_details][0][:active_input_attachment_name]
+      current_input_name
+    end
+
+    def get_current_action(channel_info = nil )
+      channel_info = get_channel_info if channel_info.nil?
+      current_action_name = channel_info[:pipeline_details][0][:active_input_switch_action_name]
+      current_action_name
+    end
+
+
+    def get_channel_class(channel_info = nil)
+      channel_info = get_channel_info if channel_info.nil?
+      channel_info[:channel_class]
+    end
+
+    def pause_channel
+      @scheduler.create(@channel_id, IMMEDIATE, PAUSE, get_channel_class)
+    end
+
+  end
+
+end

data/lib/awslive-scheduler/input_switch_schedule_action.rb

@@ -0,0 +1,56 @@
+module Awslive
+  class InputSwitchScheduleAction
+
+    FOLLOW_HASH = {
+            action_name: "f1",
+            schedule_action_start_settings: {
+                follow_mode_schedule_action_start_settings: {
+                    reference_action_name: "imm",
+                    follow_point: "END"
+                }
+            },
+            schedule_action_settings: {
+                input_switch_settings: {
+                    input_attachment_name_reference: "input1",
+                    url_path: []
+                }
+            }
+        }
+
+    IMMEDIATE_HASH = {
+            :action_name => "action_name",
+            :schedule_action_start_settings => {
+                :immediate_mode_schedule_action_start_settings => {}
+            },
+            :schedule_action_settings => {
+                :input_switch_settings => {
+                    :input_attachment_name_reference => "input_name",
+                    :url_path => []
+                }
+            }
+        }
+
+    def get_immediate_schedule_action( input_ref_name, urlpath = nil)
+      action_hash = IMMEDIATE_HASH.clone
+      action_hash[:action_name] = "#{get_action_id}"
+      action_hash[:schedule_action_settings][:input_switch_settings][:input_attachment_name_reference] = "#{input_ref_name}"
+      action_hash[:schedule_action_settings][:input_switch_settings][:url_path] = [ urlpath ] unless urlpath.nil?
+      action_hash
+    end
+
+    def get_follow_schedule_action(follow_input, trigger_input, urlpath = nil)
+      action_hash = FOLLOW_HASH.clone
+      action_hash[:action_name] = "#{get_action_id}"
+      puts "action hash #{action_hash}"
+      action_hash[:schedule_action_start_settings][:follow_mode_schedule_action_start_settings][:reference_action_name] = "#{follow_input}"
+      action_hash[:schedule_action_settings][:input_switch_settings][:input_attachment_name_reference] = "#{trigger_input}"
+      action_hash[:schedule_action_settings][:input_switch_settings][:url_path] = [ urlpath ] unless urlpath.nil?
+      action_hash
+    end
+
+    def get_action_id
+      Time.now.to_i
+    end
+
+  end
+end

data/lib/awslive-scheduler/pause_schedule_action.rb

@@ -0,0 +1,40 @@
+module Awslive
+  class PauseScheduleAction
+
+    PAUSE_HASH = {
+        :action_name => "pause",
+        :schedule_action_start_settings => {
+            :fixed_mode_schedule_action_start_settings => {
+                :time => "2019-12-22T14:36:01.302Z"
+            }
+        },
+        :schedule_action_settings => {
+            :pause_state_settings => {
+                :pipelines => []
+            }
+        }
+    }
+
+    def get_pause_schedule_action(type)
+      action_hash = PAUSE_HASH.clone
+      action_hash["actionName"] = "#{get_action_id}"
+      exec_time = ( Time.now + 10 ).iso8601
+      action_hash["scheduleActionStartSettings"]["fixedModeScheduleActionStartSettings"]["time"] = "#{exec_time}"
+      pipelines = []
+      pipelines << {
+          pipeline_id: "PIPELINE_0"
+      }
+      if type == "STANDARD"
+        pipelines << {
+            pipeline_id: "PIPELINE_1"
+        }
+      end
+      action_hash["scheduleActionSettings"]["pauseStateSettings"]["pipelines"] = pipelines
+      action_hash
+    end
+
+    def get_action_id
+      Time.now.to_i
+    end
+  end
+end

data/lib/awslive-scheduler/schedule_action.rb

@@ -0,0 +1,123 @@
+require_relative '../awslive-common/action_type'
+require_relative '../awslive-common/start_type'
+require_relative 'input_switch_schedule_action'
+require_relative 'pause_schedule_action'
+
+require 'aws-sdk-medialive'
+
+module Awslive
+  class ScheduleAction
+    include ActionType
+    include StartType
+
+    def initialize(mediaclient = nil)
+      if !mediaclient.nil?
+        @mediaclient = mediaclient
+      else
+        credentials = Aws::SharedCredentials.new
+        @mediaclient = Aws::MediaLive::Client.new(:credentials => credentials)
+      end
+      @input_switch_schedule_action = Awslive::InputSwitchScheduleAction.new
+      @pause_schedule_action = Awslive::PauseScheduleAction.new
+    end
+
+    def create_schedule(channel_id, scheduled_actions )
+      payload = {
+          channel_id: "#{channel_id}",
+          creates: {
+              schedule_actions: scheduled_actions
+          }
+      }
+      @mediaclient.batch_update_schedule( payload )
+    end
+
+    def delete(channel_id, action_names)
+      @mediaclient.batch_update_schedule( {
+                                              channel_id: "#{channel_id}",
+                                              deletes: {
+                                                  action_names: action_names
+                                              }
+                                          } )
+
+    end
+
+    def get_follow_schedule(channel_id, action_name)
+      follow_schedule = nil
+      response = @mediaclient.describe_schedule({channel_id: "#{channel_id}", max_results: 100 } )
+      loop do
+        response[:schedule_actions].each do | schedule_action |
+          unless schedule_action[:schedule_action_start_settings][:follow_mode_schedule_action_start_settings].nil?
+            # This is follow action
+            if schedule_action[:schedule_action_start_settings][:follow_mode_schedule_action_start_settings][:reference_action_name] == action_name
+              follow_schedule = schedule_action
+              break
+            end
+          end
+        end
+        break if !follow_schedule.nil? || response[:next_token].nil?
+        response = @mediaclient.describe_schedule({channel_id: "#{channel_id}", max_results: 100, next_token: response[:next_token] } )
+      end
+      follow_schedule
+    end
+
+    def create(channel_id, start_type, action_type, data)
+      scheduled_action = []
+      if action_type == INPUT_SWITCH
+        if start_type == IMMEDIATE
+          scheduled_action << @input_switch_schedule_action.get_immediate_schedule_action(data[:input_ref_name], data[:url_path])
+        elsif start_type == FOLLOW
+          scheduled_action << @input_switch_schedule_action.get_follow_schedule_action(data[:follow_input], data[:trigger_input], data[:url_path])
+        end
+      elsif action_type == PAUSE
+        if start_type == FIXED
+          scheduled_action << @pause_scheduler.get_pause_schedule_action(data[:channel_class])
+        end
+      end
+      unless scheduled_action.empty?
+        create_response = create_schedule(channel_id, scheduled_action)
+      end
+      create_response
+    end
+
+    def get_scheudle_action(channel_id, action_name)
+      sc_action = nil
+      response = @mediaclient.describe_schedule({
+                                                    channel_id: "#{channel_id}", max_results: 100
+                                                })
+      loop do
+        response[:schedule_actions].each do | schedule_action |
+          if schedule_action[:action_name] == action_name
+            sc_action = schedule_action
+            break
+          end
+        end
+        break if !sc_action.nil? || response[:next_token].nil?
+        response = @mediaclient.describe_schedule({channel_id: "#{channel_id}", max_results: 100, next_token: response[:next_token] } )
+      end
+      sc_action
+    end
+
+    def get_follow_action_url(channel_id, action_name)
+      url = nil
+      follow_schedule = get_follow_schedule(channel_id, action_name)
+      url = follow_schedule[:schedule_action_settings][:input_switch_settings][:url_path] unless follow_schedule.nil?
+      url
+    end
+
+    def get_action_url(channel_id, action_name)
+      url = nil
+      follow_schedule = get_scheudle_action(channel_id, action_name)
+      puts "Follow Schedule #{follow_schedule}"
+      url = follow_schedule[:schedule_action_settings][:input_switch_settings][:url_path] unless follow_schedule.nil?
+      url
+    end
+
+    def get_action_id
+      Time.now.to_i
+    end
+
+    def delete_all(channel_id)
+      @mediaclient.delete_schedule({ channel_id: channel_id })
+    end
+  end
+end

data/lib/test/awslive_input_looper_test.rb

@@ -0,0 +1,8 @@
+require 'awslive-inputlooper'
+
+class AwsliveInputLooperTest
+end
+
+playlist = ["s3transition-lambda-poc/frozen_test1.mp4", "s3transition-lambda-poc/oceans.mp4", "s3transition-lambda-poc/big-bunny1.mp4", "s3transition-lambda-poc/sample1.mp4"]
+looper = Awslive::InputLooper.new("2179374", playlist)
+looper.switch_and_loop_playlist

data/lib/test/schedule_action_test.rb

@@ -0,0 +1,11 @@
+require_relative './input-switch/put-switch/input_switch_schedule_action'
+
+=begin
+class ScheduleActionTest
+
+end
+=end
+credentials = Aws::SharedCredentials.new
+medialiveclient = Aws::MediaLive::Client.new(:credentials => credentials)
+input_switch_action = InputSwitchScheduleAction.new(medialiveclient)
+puts input_switch_action.get_immediate_schedule_action("test")

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: awslive-inputlooper
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Maheshwaran G
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-medialive
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.40'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.40'
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: AWS live Input Looper gem helps in switching & looping live inputs in
+  AWS Medialive channel, enabling VOD playlist as live in a sequence / circular loop
+  fashion
+email:
+- pgmaheshwaran@gmail.com
+executables:
+- awslive-inputlooper
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/awslive-inputlooper
+- lib/awslive-common/action_type.rb
+- lib/awslive-common/all_exceptions.rb
+- lib/awslive-common/logging.rb
+- lib/awslive-common/start_type.rb
+- lib/awslive-inputlooper.rb
+- lib/awslive-inputlooper/input_looper.rb
+- lib/awslive-scheduler/input_switch_schedule_action.rb
+- lib/awslive-scheduler/pause_schedule_action.rb
+- lib/awslive-scheduler/schedule_action.rb
+- lib/test/awslive_input_looper_test.rb
+- lib/test/schedule_action_test.rb
+homepage: https://github.com/ooyala/awslive-input-looper
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ooyala/awslive-input-looper
+  source_code_uri: https://github.com/ooyala/awslive-input-looper
+  changelog_uri: https://github.com/ooyala/awslive-input-looper
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: AWS live Input Looper gem helps in switching & looping live inputs in AWS
+  Medialive channel, enabling VOD playlist as live in a sequence / circular loop fashion
+test_files: []