unimatrix-cli 2.2.0

data/lib/unimatrix_cli/login_command.rb

@@ -0,0 +1,91 @@
+module UnimatrixCLI
+  class LoginCommand < Command
+
+    option :username,    "Your username",                 type: :string, required: true
+    option :password,    "Your password",                 type: :string, required: true
+    option :environment, "The environment to log into",   type: :string, required: true
+    option :region,      "The region to log into",        type: :string
+    option :client,      "Client id (optional)",          type: :string
+    option :secret,      "Client secret (optional)",      type: :string
+
+    synopsis "Log in with your username, password, and environment. " +
+      "Specify region as 'us-east-1' or 'us-west-1'." +
+      "Specify a client_id, or make sure to provide it as an ENV variable. " +
+      "Specify a client_secret, if necessary, or provide as an ENV variable."
+
+    ENVIRONMENTS = %w( development acceptance staging production )
+    REGIONS = %w( us-east-1 us-west-2 )
+
+    def execute
+      if save_environment
+        save_region
+
+        response = log_in_request
+        if response[ 'access_token' ].nil?
+          write( message: "Error logging in: #{ response.inspect }", error: true )
+        else
+          save_access_token( response[ 'access_token' ] )
+          write( message: 'Successfully logged in; saving access_token and environment' )
+        end
+      else
+        write( message: 'Invalid environment', error: true )
+      end
+    end
+
+    #----------------------------------------------------------------------------
+
+    private; def log_in_request
+      endpoint = "#{ Configuration.default_config[ 'keymaker_url' ] }/token"
+
+      client_id     = @options[ :client ] || ENV[ 'CLIENT_ID' ]
+      client_secret = @options[ :secret ] || ENV[ 'CLIENT_SECRET' ]
+
+      body = {
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: 'password',
+        username: @options[ :username ],
+        password: @options[ :password ]
+      }
+
+      # Unimatrix SDK does not support Keymaker token response
+      make_request( endpoint, 'Post', body )
+    end
+
+    private; def save_environment
+      if ENVIRONMENTS.include?( @options[ :environment ] )
+        create_unimatrix_directory
+        File.write( 
+          Configuration.environment_file_path, 
+          "#{ @options[ :environment ] }" 
+        )
+      else
+        false
+      end
+    end
+
+    private; def save_region
+      if @options[ :region ] && REGIONS.include?( @options[ :region ] )
+        create_unimatrix_directory
+        File.write(
+          Configuration.region_file_path,
+          "#{ @options[ :region ] }"
+        )
+      end
+    end
+
+    private; def save_access_token( access_token )
+      create_unimatrix_directory
+      File.write( 
+        Configuration.access_token_file_path, 
+        "#{ access_token }" 
+      )
+    end
+
+    private; def create_unimatrix_directory
+      unless Dir.exist?( Configuration.unimatrix_directory_path )
+        Dir.mkdir( Configuration.unimatrix_directory_path )
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/logout_command.rb

@@ -0,0 +1,21 @@
+module UnimatrixCLI
+  class LogoutCommand < Command
+
+    synopsis "Log out"
+
+    def execute
+      write( message: "Logging you out." )
+      delete_saved_data( Configuration.access_token_file_path )
+      delete_saved_data( Configuration.environment_file_path )
+      delete_saved_data( Configuration.region_file_path )
+    end
+
+    #----------------------------------------------------------------------------
+
+    private; def delete_saved_data( file_path )
+      if File.file?( file_path )
+        File.write( file_path, "" )
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/version.rb

@@ -0,0 +1,3 @@
+module UnimatrixCLI
+  VERSION = '2.2.0'
+end

data/lib/unimatrix_cli/zephyrus/input/create_command.rb

@@ -0,0 +1,40 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Input
+      class CreateCommand < Command
+        
+        option :key, "The input key", type: :string, required: true
+        option :uid, "The input uid", type: :string
+
+        synopsis "Create a new input"
+
+        def execute
+          input = create_input
+
+          if validate( input, 'Zephyrus::Input' )
+            write( message: "Input uuid: #{ input.uuid }" )
+          else
+            write( 
+              message: "Error creating input: #{ input.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def create_input
+          input = Unimatrix::Zephyrus::Input.new( 
+            key: @options[ :key ], 
+            state: 'disconnected' 
+          ) 
+          input.uid = @options[ :uid ] if @options[ :uid ]
+
+          operation( 
+            '/inputs'
+          ).write( 'inputs', input ).first rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/input/describe_command.rb

@@ -0,0 +1,35 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Input
+      class DescribeCommand < Command
+        
+        option :input, "The input uuid", type: :string, required: true
+
+        synopsis "Describe an input"
+
+        def execute
+          input = find_input
+
+          if validate( input, 'Zephyrus::Input' )
+            parse_object( input ).each do | response | 
+              write( message: response )
+            end
+          else
+            write( 
+              message: "Input could not be found: #{ input.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_input
+          operation(
+            "/inputs/#{ @options[ :input ] }"
+          ).read.first
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/input/list_command.rb

@@ -0,0 +1,38 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Input
+      class ListCommand < Command
+
+        option :key, "The key of the inputs", type: :string
+        option :uid, "The uid of the inputs", type: :string
+
+        synopsis "List inputs with a specific key and/or uid"
+
+        def execute
+          inputs = find_inputs
+          
+          if validate_collection( inputs, 'Zephyrus::Input' )
+            inputs.each do | input | 
+              write( message: input.uuid )
+            end
+          else
+            write( 
+              message: "Inputs could not be found: #{ inputs.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_inputs
+          endpoint = "/inputs?"
+          endpoint += "key=#{ @options[ :key ] }&" if @options[ :key ]
+          endpoint += "uid=#{ @options[ :uid ] }" if @options[ :uid ]
+
+          operation( endpoint ).read
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/output/list_command.rb

@@ -0,0 +1,44 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Output
+      class ListCommand < Command
+
+        option :input,     "The input uuid",         type: :string, required: true
+        option :type_name, "The type of outputs",    type: :string, required: true
+        option :key,       "The key of the outputs", type: :string
+        option :url,       "The url of the outputs", type: :string
+        option :uid,       "The uid of the outputs", type: :string
+
+        synopsis "List outputs for a specific input"
+
+        def execute
+          outputs = find_outputs
+          
+          if validate_collection( outputs, 'Zephyrus::Output' )
+            outputs.each do | output |
+              write( message: output.uuid )
+            end
+          else
+            write( 
+              message: "Outputs could not be found: #{ outputs.inspect }",
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_outputs
+          endpoint = "/inputs/#{ @options[ :input ] }/outputs?" +
+            "type_name=#{ @options[ :type_name ] }"
+
+          endpoint += "&key=#{ @options[ :key ] }" if @options[ :key ]
+          endpoint += "&url=#{ @options[ :url ] }" if @options[ :url ]
+          endpoint += "&uid=#{ @options[ :uid ] }" if @options[ :uid ]
+
+          operation( endpoint ).read
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/recording/configuration_command.rb

@@ -0,0 +1,43 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Recording
+      class ConfigurationCommand < Command
+
+        option :key, "The key for an input", type: :string, required: true
+
+        synopsis "Display recording configuration for an input"
+
+        def execute
+          response = recording_configuration_request
+          if response[ 'outputs' ].nil?
+            write( 
+              message: "Configuration could not be found: #{ response.inspect }",
+              error: true
+            )
+          else
+            response[ 'outputs' ].each do | output | 
+              write( message: parse_configuration_output( output ) )
+            end
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def recording_configuration_request
+          endpoint = "#{ Configuration.default_config[ 'zephyrus_url' ] }/" +
+            "recording/configuration?key=#{ @options[ :key ] }"
+
+          # Unimatrix SDK cannot handle Zephyrus configuration responses
+          make_request( endpoint, 'Get' )
+        end
+
+        private; def parse_configuration_output( output )
+          output = output.map do | key, value |
+            "#{ key }: #{ value }\n"
+          end
+          output << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/rendition/list_command.rb

@@ -0,0 +1,40 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Rendition
+      class ListCommand < Command
+
+        option :input,  "The input uuid",            type: :string, required: true
+        option :output, "The output uuid",           type: :string, required: true
+        option :uid,    "The uid of the renditions", type: :string, required: true
+
+        synopsis "List renditions for a specific output and uid"
+
+        def execute
+          renditions = find_renditions
+          
+          if validate_collection( renditions, 'Zephyrus::Rendition' )
+            renditions.each do | rendition | 
+              write( message: rendition.uuid )
+            end
+          else
+            write( 
+              message: "Renditions could not be found: #{ renditions.inspect }",
+              error: true
+            )
+          
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def find_renditions
+          endpoint = "/inputs/#{ @options[ :input ] }/" +
+            "outputs/#{ @options[ :output ] }" +
+            "/renditions?uid=#{ @options[ :uid ] }"
+
+          operation( endpoint ).read
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/routing/configuration_command.rb

@@ -0,0 +1,43 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Routing
+      class ConfigurationCommand < Command
+
+        option :key, "The key for an input", type: :string, required: true
+
+        synopsis "Display routing configuration for an input"
+
+        def execute
+          response = routing_configuration_request
+          if response[ 'outputs' ].nil?
+            write( 
+              message: "Configuration could not be found: #{ response.inspect }",
+              error: true
+            )
+          else
+            response[ 'outputs' ].each do | output | 
+              write( message: parse_configuration_output( output ) )
+            end
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def routing_configuration_request
+          endpoint = "#{ Configuration.default_config[ 'zephyrus_url' ] }/" +
+            "routing/configuration?key=#{ @options[ :key ] }"
+
+          # Unimatrix SDK cannot handle Zephyrus configuration responses
+          make_request( endpoint, 'Get' )
+        end
+
+        private; def parse_configuration_output( output )
+          output = output.map do | key, value |
+            "#{ key }: #{ value }\n"
+          end
+          output << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/transcoding/configuration_command.rb

@@ -0,0 +1,55 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Transcoding
+      class ConfigurationCommand < Command
+
+        option :key, "The key for an input", type: :string, required: true
+
+        synopsis "Display transcoding configuration for an input"
+
+        def execute
+          response = transcoding_configuration_request
+          if response[ 'outputs' ].nil?
+            write( 
+              message: "Configuration could not be found: #{ response.inspect }",
+              error: true
+            )
+          else
+            response[ 'outputs' ].each do | output | 
+              write( message: parse_configuration_output( output ) )
+            end
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def transcoding_configuration_request
+          endpoint = "#{ Configuration.default_config[ 'zephyrus_url' ] }/" +
+            "transcoding/configuration?key=#{ @options[ :key ] }"
+
+          # Unimatrix SDK cannot handle Zephyrus configuration responses
+          make_request( endpoint, 'Get' )
+        end
+
+        private; def parse_configuration_output( output )
+          output = output.map do | key, value |
+            if key == "renditions"
+              renditions = value.map { | rendition | parse_rendition( rendition ) }.join
+              "renditions:\n*\n#{ renditions }"
+            else
+              "#{ key }: #{ value }\n"
+            end
+          end
+          output << "\n"
+        end
+
+        private; def parse_rendition( rendition )
+          rendition = rendition.map do | key, value |
+            "#{ key }: #{ value }\n"
+          end
+          rendition << "*\n"
+        end
+      end
+    end
+  end
+end