unimatrix-cli 2.2.0

data/lib/unimatrix_cli/iris/stream_input/create_command.rb

@@ -0,0 +1,43 @@
+module UnimatrixCLI
+  module Iris
+    module StreamInput
+      class CreateCommand < Command
+
+        option :realm,  "The realm uuid",                         type: :string, required: true
+        option :stream, "The stream the stream_input belongs to", type: :string, required: true
+        option :region, "The region of the stream",               type: :string, default: "us-east-1"
+
+        synopsis "Create a new stream_input"
+
+        def execute
+          stream_input = create_stream_input
+
+          if validate( stream_input, 'Iris::StreamInput' )
+            write( message: "StreamInput uuid: #{ stream_input.uuid }" )
+          else
+            write( 
+              message: "Error creating stream_input: #{ stream_input.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def create_stream_input
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_inputs"
+
+          stream_input = Unimatrix::Iris::StreamInput.new(
+            region: @options[ :region ],
+            state: 'disconnected'
+          )
+
+          operation( 
+            endpoint, 
+            realm_uuid: @options[ :realm ] 
+          ).write( 'stream_inputs', stream_input ).first rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_input/describe_command.rb

@@ -0,0 +1,37 @@
+module UnimatrixCLI
+  module Iris
+    module StreamInput
+      class DescribeCommand < Command
+
+        option :stream_input, "The stream_input uuid", type: :string, required: true, short: :i
+        option :stream, "The uuid of its stream",      type: :string, required: true
+
+        synopsis "Describe a stream_input"
+
+        def execute
+          stream_input = find_stream_input
+
+          if validate( stream_input, 'Iris::StreamInput' )
+            parse_object( stream_input ).each do | response | 
+              write( message: response )
+            end
+          else
+            write( 
+              message: "StreamInput could not be found: #{ stream_input.inspect }",
+              error: true
+            )            
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_stream_input
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_inputs/" +
+            "#{ @options[ :stream_input ] }"
+
+          operation( endpoint ).read.first
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_output/create_command.rb

@@ -0,0 +1,55 @@
+module UnimatrixCLI
+  module Iris
+    module StreamOutput
+      class CreateCommand < Command
+
+        option :realm,    "The realm uuid",               type: :string, required: true
+        option :stream,   "The stream_output's stream",   type: :string, required: true
+        option :key,      "The key of the stream_output", type: :string, required: true
+        option :region,   "The region of the stream",     type: :string, default:  "us-east-1"
+        option :url,      "The url of the stream_output", type: :string
+        option :username, "Authentication username",      type: :string
+        option :password, "Authentication password",      type: :string
+
+        synopsis "Create a new stream_output"
+
+        def execute
+          stream_output = create_stream_output
+
+          if validate( stream_output, 'Iris::StreamOutput' )
+            write( message: "StreamOutput uuid: #{ stream_output.uuid }" )
+          else
+            write( 
+              message: "Error creating stream_output: #{ stream_output.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def create_stream_output
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_outputs"
+
+          stream_output = Unimatrix::Iris::StreamOutput.new(
+            key: @options[ :key ],
+            state: 'disconnected'
+          )
+
+          if @options[ :username ] && @options[ :password ]
+            output.authentication_username = @options[ :username ]
+            output.authentication_password = @options[ :password ]
+          end
+
+          stream_output.url = @options[ :url ] if @options[ :url ]
+
+          operation( 
+            endpoint,
+            realm_uuid: @options[ :realm ],
+            region: @options[ :region ]
+          ).write( 'stream_outputs', stream_output ).first rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_output/describe_command.rb

@@ -0,0 +1,37 @@
+module UnimatrixCLI
+  module Iris
+    module StreamOutput
+      class DescribeCommand < Command
+
+        option :stream_output, "The stream_output uuid", type: :string, required: true, short: :o
+        option :stream, "The uuid of its stream",        type: :string, required: true
+
+        synopsis "Describe a stream_output"
+
+        def execute
+          stream_output = find_stream_output
+
+          if validate( stream_output, 'Iris::StreamOutput' )
+            parse_object( stream_output ).each do | response | 
+              write( message: response )
+            end
+          else
+            write( 
+              message: "StreamOutput could not be found: #{ stream_output.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_stream_output
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_outputs/" +
+            "#{ @options[ :stream_output ] }"
+
+          operation( endpoint ).read.first
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_recorder/create_command.rb

@@ -0,0 +1,49 @@
+module UnimatrixCLI
+  module Iris
+    module StreamRecorder
+      class CreateCommand < Command
+
+        option :realm,          "The realm uuid",               type: :string, required: true
+        option :stream,         "The stream_recorder's stream", type: :string, required: true
+        option :duration_limit, "Duration limit",               type: :integer
+
+        synopsis "Create a new stream_recorder"
+
+        def execute
+          stream_recorder = create_stream_recorder
+
+          if validate( stream_recorder, 'Iris::StreamRecorder' )
+            write( 
+              message: "StreamRecorder uuid: #{ stream_recorder.uuid }" 
+            )
+          else
+            write( 
+              message: "Error creating stream_recorder: #{ stream_recorder.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def create_stream_recorder
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_recorders"
+
+          stream_recorder = Unimatrix::Iris::StreamRecorder.new(
+            state: 'default',
+            recording_state: 'off'
+          )
+
+          if @options[ :duration_limit ]
+            stream_recorder.duration_limit = @options[ :duration_limit ]
+          end
+
+          operation( 
+            endpoint, 
+            realm_uuid: @options[ :realm ] 
+          ).write( 'stream_recorders', stream_recorder ).first rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_recorder/describe_command.rb

@@ -0,0 +1,37 @@
+module UnimatrixCLI
+  module Iris
+    module StreamRecorder
+      class DescribeCommand < Command
+
+        option :stream_recorder, "The stream_recorder uuid", type: :string, required: true, short: :r
+        option :stream,   "The uuid of its stream",          type: :string, required: true
+
+        synopsis "Describe a stream_recorder"
+
+        def execute
+          stream_recorder = find_stream_recorder
+
+          if validate( stream_recorder, 'Iris::StreamRecorder' )
+            parse_object( stream_recorder ).each do | response | 
+              write( message: response )
+            end
+          else
+            write( 
+              message: "StreamRecorder could not be found: #{ stream_recorder.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_stream_recorder
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_recorders/" +
+            "#{ @options[ :stream_recorder ] }"
+
+          operation( endpoint ).read.first
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_transcriber/create_command.rb

@@ -0,0 +1,54 @@
+module UnimatrixCLI
+  module Iris
+    module StreamTranscriber
+      class CreateCommand < Command
+
+        option :realm,        "The realm uuid",                  type: :string,  required: true
+        option :stream,       "The stream_transcriber's stream", type: :string,  required: true
+        option :min_duration, "The minimum segment duration",    type: :integer, short:    :n
+        option :max_duration, "The maximum segment duration",    type: :integer, short:    :x
+
+        synopsis "Create a new stream_transcriber"
+
+        def execute
+          stream_transcriber = create_stream_transcriber
+
+          if validate( stream_transcriber, 'Iris::StreamTranscriber' )
+            write( 
+              message: "StreamTranscriber uuid: #{ stream_transcriber.uuid }"
+            )
+          else
+            write( 
+              message: "Error creating stream_transcriber: " +
+                "#{ stream_transcriber.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def create_stream_transcriber
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_transcribers"
+
+          stream_transcriber = Unimatrix::Iris::StreamTranscriber.new(
+            state: 'default'
+          )
+
+          if @options[ :min_duration ]
+            stream_transcriber.minimum_segment_duration = @options[ :min_duration ] 
+          end
+
+          if @options[ :max_duration ]
+            stream_transcriber.maximum_segment_duration = @options[ :max_duration ] 
+          end
+
+          operation( 
+            endpoint,
+            realm_uuid: @options[ :realm ]
+          ).write( 'stream_transcribers', stream_transcriber ).first rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_transcriber/describe_command.rb

@@ -0,0 +1,37 @@
+module UnimatrixCLI
+  module Iris
+    module StreamTranscriber
+      class DescribeCommand < Command
+
+        option :stream_transcriber, "The stream_transcriber uuid", type: :string, required: true, short: :t
+        option :stream,             "The uuid of its stream",      type: :string, required: true
+
+        synopsis "Describe a stream_transcriber"
+
+        def execute
+          stream_transcriber = find_stream_transcriber
+
+          if validate( stream_transcriber, 'Iris::StreamTranscriber' )
+            parse_object( stream_transcriber ).each do | response | 
+              write( message: response )
+            end
+          else
+            write( 
+              message: "StreamTranscriber could not be found: #{ stream_transcriber.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_stream_transcriber
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_transcribers/" +
+            "#{ @options[ :stream_transcriber ] }"
+
+          operation( endpoint ).read.first
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_transmutator/create_command.rb

@@ -0,0 +1,65 @@
+module UnimatrixCLI
+  module Iris
+    module StreamTransmutator
+      class CreateCommand < Command
+
+        option :realm,             "The realm uuid",                   type: :string, required: true
+        option :stream,            "The stream_transmutator's stream", type: :string, required: true
+        option :url,               "The destination url",              type: :string, required: true
+        option :height,            "Video height in pixels",           type: :integer
+        option :width,             "Video width in pixels",            type: :integer
+        option :video_bitrate,     "Video data rate in bps",           type: :integer
+        option :audio_bitrate,     "Audio data rate in bps",           type: :integer
+        option :audio_sample_rate, "Audio sample rate in Hz",          type: :integer
+
+        synopsis "Create a new stream_transmutator"
+
+        def execute
+          stream_transmutator = create_stream_transmutator
+
+          if validate( stream_transmutator, 'Iris::StreamTransmutator' )
+            write( 
+              message: "StreamTransmutator uuid: #{ stream_transmutator.uuid }"
+            )
+          else
+            write( 
+              message: "Error creating stream_transmutator: #{ stream_transmutator.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def create_stream_transmutator
+          endpoint = "/streams/#{ @options[ :stream ] }/stream_transmutators"
+
+          stream_transmutator = Unimatrix::Iris::StreamTransmutator.new(
+            url: @options[ :url ],
+            state: 'default'
+          )
+
+          stream_transmutator.height = @options[ :height ] if @options[ :height ]
+          stream_transmutator.width =  @options[ :width ]  if @options[ :width ]
+
+          if @options[ :video_bitrate ]
+            stream_transmutator.video_bitrate = @options[ :video_bitrate ]
+          end
+
+          if @options[ :audio_bitrate ]
+            stream_transmutator.audio_bitrate = @options[ :audio_bitrate ]
+          end
+
+          if @options[ :audio_sample_rate ]
+            stream_transmutator.audio_sample_rate = @options[ :audio_sample_rate ]
+          end
+
+          operation( 
+            endpoint,
+            realm_uuid: @options[ :realm ]
+          ).write( 'stream_transmutators', stream_transmutator ).first rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/iris/stream_transmutator/describe_command.rb

@@ -0,0 +1,38 @@
+module UnimatrixCLI
+  module Iris
+    module StreamTransmutator
+      class DescribeCommand < Command
+
+        option :stream_transmutator, "The stream_transmutator uuid", type: :string, required: true, short: :t
+        option :stream,              "The uuid of its stream", type: :string, required: true
+
+        synopsis "Describe a stream_transmutator"
+
+        def execute
+          stream_transmutator = find_stream_transmutator
+
+          if validate( stream_transmutator, 'Iris::StreamTransmutator' )
+            parse_object( stream_transmutator ).each do | response | 
+              write( message: response )
+            end
+          else
+            write( 
+              message: "StreamTransmutator could not be found: " +
+                "#{ stream_transmutator.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_stream_transmutator
+          endpoint = "/streams/#{ @options[ :stream ] }/" +
+            "stream_transmutators/#{ @options[ :stream_transmutator ] }"
+
+          operation( endpoint ).read.first
+        end
+      end
+    end
+  end
+end