cantemo-portal-agent 1.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54171a0f3c7ff03ad9ea8411d2f0df91ce7b352a
+  data.tar.gz: 7ca1ab0d8df364f79e19c29c31f315245b797217
+SHA512:
+  metadata.gz: 953df856aa882c921ec522d1bea9664fb72f8545af8f488c62b10a9f0d47b11a0dab564c6b1b61399243887263c39cf28777599860f1d4449a625e5c2d7d0450
+  data.tar.gz: ae7adea3924f9f89d70d00c5a8c07be688eb0a04498557ad078c761d5e68a4b0d82d3f9c97c19fa00bbaaa70c049a83bc1134022976f0e00afb471ec3a2176ce

data/exe/cantemo-portal-agent

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+ARGV.unshift 'vidispine'
+should_retry = true
+
+begin
+  require 'envoi/mam/agent/cli'
+
+  Envoi::Mam::Agent::Cli::CONFIG_FILE_PATHS.clear
+  Envoi::Mam::Agent::Cli::CONFIG_FILE_PATHS.concat [
+      "./cantemo-portal-agent-config.json",
+      "~/cantemo-portal-agent-config.json",
+  ]
+  require 'envoi/mam/agent/cli/commands/vidispine'
+rescue LoadError => e
+  lib_path = __FILE__ == '(irb)' ? File.join(Dir.cwd, 'lib') : File.expand_path('../../lib', __FILE__)
+  $:.unshift(lib_path) unless $:.include?(lib_path) or !File.exist?(lib_path)
+  if should_retry
+    should_retry = false
+    retry
+  end
+  abort(e.message)
+end
+
+
+

data/lib/cantemo/portal/agent.rb

@@ -0,0 +1,9 @@
+require 'cantemo/portal/agent/version'
+
+module Cantemo
+  module Portal
+    class Agent
+
+    end
+  end
+end

data/lib/cantemo/portal/agent/version.rb

@@ -0,0 +1,7 @@
+module Cantemo
+  module Portal
+    class Agent
+      VERSION = '1.0.9'.freeze
+    end
+  end
+end

data/lib/envoi/mam/agent.rb

@@ -0,0 +1,119 @@
+require 'logger'
+require 'open3'
+
+require 'envoi/mam/agent/version'
+require 'envoi/mam/agent/config_service_client'
+
+module Envoi
+  module Mam
+    class Agent
+
+      attr_accessor :logger, :initial_args, :config, :api_client
+
+      def initialize(args = { })
+        @initial_args = args.clone
+        @config = args[:config]
+        @notifiers = args[:notifiers] || [ ]
+
+        @dry_run = args.fetch(:dry_run, false)
+
+        initialize_logger(args)
+        initialize_api_client(args) # if self.respond_to?(:initialize_api_client)
+        after_initialize
+      end
+
+      def after_initialize
+
+      end
+
+      def initialize_logger(args = { })
+        @logger = args[:logger] || Logger.new(STDOUT)
+      end
+
+      def dry_run?; @dry_run end
+
+      def notify(message, args = { })
+        return if @notifiers.empty?
+        args[:level] ||= :info
+        args[:message] ||= message
+        @notifiers.each { |notifier| notifier.notify(args) }
+      end
+
+      # @param [Hash] args {}
+      # @option args [Object] :api_client
+      # Will usually be overridden by child class
+      def initialize_api_client(args = { })
+        @api_client = args[:api_client] || begin
+
+        end
+      end
+
+      def shell_execute(command, dry_run = @dry_run)
+        if dry_run
+          logger.debug { "Skipping Execution of Command: '#{command}' " }
+          return
+        end
+        logger.debug { "Executing Command: '#{command}'" }
+
+        Open3.popen3(command) do |stdin, stdout, stderr, thread|
+          # stdin.sync = true
+          # stdout.sync = true
+          # stderr.sync = true
+
+          output = ''
+          until thread.stop?
+            output << stdout.read #rescue nil
+            output << stderr.read # rescue nil
+            unless output.empty?
+              print output
+              output.clear
+            end
+          end
+        end
+      end
+
+      def self.load_from_config_file(args)
+        config_file_path = args[:config_file_path]
+        config_file_path = config_file_path.find { |v| File.exists?(v) } if config_file_path.is_a?(Array)
+        abort("Missing Config File. '#{config_file_path}'") unless config_file_path && !config_file_path.empty? && File.exists?(config_file_path)
+
+        begin
+          config = JSON.parse(File.read(config_file_path))
+        rescue => e
+          abort("Config File Failed to Load. '#{$!}'")
+        end
+        args[:config] = config
+
+        self.new(args.merge({ :config => config }))
+      end
+
+      def self.load_from_config_service(args)
+        args_out = { }
+        args_out[:app_id] = args[:config_service_app_id]
+        args_out[:token] = args[:config_service_app_token]
+        args_out[:api_url] = args[:config_service_app_url]
+        config = Envoi::Mam::Agent::ConfigServiceClient.config_get(args_out)
+        args[:config] = config
+
+        self.new(args.merge({ :config => config }))
+      end
+
+      def self.load_config_and_init(args)
+        if args[:config_service_app_id] && args[:config_service_app_token]
+          load_from_config_service(args)
+        else args[:config_file_path]
+          load_from_config_file(args)
+        end
+      end
+
+
+      def run_operation
+        case initial_args[:operation]
+        when :upload; upload(initial_args) if self.respond_to?(:upload)
+        when :download; download(initial_args) if self.respond_to?(:download)
+        end
+      end
+
+    end
+  end
+end

data/lib/envoi/mam/agent/base_daemon.rb

@@ -0,0 +1,32 @@
+module Envoi
+  module Mam
+    class Agent
+
+      class BaseDaemon
+
+        attr_accessor :logger, :initial_args
+
+        def initialize(*args)
+          @initial_args = args
+        end
+
+        # Processes a hash and creates instance variables for each key set to it's corresponding value
+        # If args is an array then it processes the first hash it comes to in that array (Good for passing *args from a previous method)
+        #
+        # @param args (Hash|Array|nil) The hash or array to process
+        def set_instance_variables(args = nil)
+          _args = args
+          _args = _args.find { |v| v.is_a? Hash } if _args.is_a? Array
+          _args.each { |key, val| instance_variable_set("@#{key}", val) } if _args.is_a? Hash
+        end
+
+      end
+
+      # Agent
+    end
+
+    # Mam
+  end
+
+  # Envoi
+end

data/lib/envoi/mam/agent/cli.rb

@@ -0,0 +1,37 @@
+require 'optparse'
+
+require 'envoi/mam/agent'
+
+module Envoi
+  module Mam
+    class Agent
+
+      class Cli
+
+        CONFIG_FILE_PATHS = [
+          "./envoi-mam-agent-config.json",
+          "~/envoi-mam-agent-config.json",
+        ]
+        CONFIG_FILE_PATHS.map! { |v| File.expand_path(v) }
+
+        attr_accessor :logger, :initial_args
+
+        def initialize(*args)
+          @initial_args = args
+        end
+
+        def parse_arguments
+
+        end
+
+
+      end
+
+      # Agent
+    end
+
+    # Mam
+  end
+
+  # Envoi
+end

data/lib/envoi/mam/agent/cli/commands.rb

@@ -0,0 +1,89 @@
+#Command Loader
+#
+
+# module Envoi
+#   module Mam
+#     class Agent
+#       class CLI
+#         class Commands
+#
+#
+#           # Commands
+#         end
+#
+#         # CLI
+#       end
+#
+#       # Agent
+#     end
+#
+#     # Mam
+#   end
+#
+#   # Envoi
+# end
+
+def usage
+  command_list_str = ''
+  Dir.glob(File.join(@commands_dir, "*#{@command_ext}")).each do |fn|
+    command_list_str += "\n\t - #{File.basename(fn, @command_ext)}"
+  end
+
+  <<-EOT
+Usage: #{File.basename($0)} COMMAND [ARGS]
+  
+  Available Commands:
+    #{command_list_str}
+    
+All commands can be run with -h (or --help) for more information.
+  EOT
+end
+
+@commands_dir = File.join(File.dirname(__FILE__), 'commands')
+@command_ext = '.rb'
+
+command_aliases = {
+}
+
+if ARGV.empty?
+  should_show_usage = true
+else
+  command_name = ARGV[0].clone
+  command_name = command_aliases[command_name] || command_name
+  should_show_usage = %w(-h --help).include?(command_name.downcase)
+end
+if should_show_usage
+  puts usage
+  exit(true)
+end
+
+command_file_path = File.join(@commands_dir, command_name)
+abort(usage) unless File.exist?("#{command_file_path}#{@command_ext}")
+
+require 'envoi/mam/agent/cli'
+
+begin
+  require "#{command_file_path}#{@command_ext}"
+rescue LoadError => e
+  abort(e.message)
+end
+
+
+# Execute the command if it is in object form, otherwise it's just a script and executed when we required it
+if Envoi::Mam::Agent::Cli.const_defined?('Commands')
+  command_class_name = command_name.to_s.capitalize
+  if Envoi::Mam::Agent::Cli::Commands.const_defined?(command_class_name)
+    command_object = Envoi::Mam::Agent::Cli::Commands.const_get( command_class_name.capitalize ) rescue nil
+  end
+  command_object ||= begin
+    command_class_name = command_class_name.upcase
+    Envoi::Mam::Agent::Cli::Commands.const_defined?(command_class_name) ? Envoi::Mam::Agent::Cli::Commands.const_get( command_class_name ) : false
+  end
+  if command_object
+    command_instance = command_object.new if command_object.respond_to?(:new)
+    command_instance.execute if command_instance.respond_to?(:execute)
+  end
+end
+
+
+

data/lib/envoi/mam/agent/cli/commands/iconik.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+lib_path = __FILE__ == '(irb)' ? File.join(Dir.cwd, 'lib') : File.expand_path('../../../lib', __FILE__)
+$:.unshift(lib_path) unless $:.include?(lib_path) or !File.exists?(lib_path)
+require 'rubygems'
+require 'optparse'
+
+require 'envoi/mam/agent/cli'
+require 'envoi/mam/iconik/agent'
+
+current_command = ARGV.shift
+ARGV << '--help' if ARGV.empty?
+
+default_config_file_paths = Envoi::Mam::Agent::Cli::CONFIG_FILE_PATHS
+
+aspera_ascp_paths = Envoi::Mam::Agent::TransferClient::Aspera::ASCP_PATHS
+default_aspera_ascp_path = aspera_ascp_paths.find { |v| File.exist? v } || aspera_ascp_paths.first
+
+# test_args = %w(--download --send-to-envoi --destination-path /tmp)
+# ARGV.concat test_args
+args = {
+    :config_file_path                        => default_config_file_paths,
+    :default_ascp_path                       => default_aspera_ascp_path,
+    :dry_run                                 => false,
+    :preserve_path                           => true,
+    :destination_path                        => File.expand_path('.'),
+    :should_download_presentation            => false,
+    :should_add_presentation_assets_to_envoi => false
+}
+
+args[:config_service_app_id] = ENV['ENVOI_MAM_AGENT_APP_ID']
+args[:config_service_app_token] = ENV['ENVOI_MAM_AGENT_APP_TOKEN']
+args[:config_service_app_url] = ENV['ENVOI_MAM_AGENT_APP_URL']
+
+op = OptionParser.new
+op.on('-c', '--config-file-path FILEPATH', 'The path to the configuration file.') { |v| args[:config_file_path] = v }
+op.on('--agent-app-id ID', '') { |v| args[:config_service_app_id] = v }
+op.on('--agent-token TOKEN', '') { |v| args[:config_service_app_token] = v }
+op.on('--agent-service-api URL', '') { |v| args[:config_service_api_url] = v }
+
+op.on('--asset-id ASSETID', 'The Iconik item ID.') { |v| args[:asset_id] = v }
+op.on('-f', '--format-name FORMATNAME', 'The Iconik format name used to find the file to download.') { |v| args[:format_name] = v }
+op.on('--storage-id STORAGEID', 'The Iconik storage id to use for the transfer.') { |v| args[:storage_id] = v}
+#
+
+op.on('--file-path PATH', '') { |v| args[:file_path] = v }
+op.on('-d', '--destination-path DIRPATH', 'The destination path to download or upload to.', "default: '#{args[:destination_path]}'") { |v| args[:destination_path] = v }
+op.on('-p','--[no-]preserve-path', "default: #{args[:preserve_path]}") { |v| args[:preserve_path] = v }
+
+op.on('-o', '--operation OP', [ :download, :upload ], 'Transfer Direction.', "default: #{args[:operation]}" ) { |v| args[:operation] = v }
+op.on('--transfer-type TYPE', [ :aspera, :s3 ],'Force the type of transfer to use. Ex: aspera || s3') { |v| args[:transfer_type] = v }
+
+# op.on('--dry-run', 'Run without executing the transfer.') { |v| args[:dry_run] = v }
+op.on('--help', 'Show this message.') { puts op; exit }
+op.load
+op.parse!
+
+args[:file_path] ||= ARGV.shift
+args[:destination_path] ||= ARGV.shift unless ARGV.empty?
+
+agent = Envoi::Mam::Iconik::Agent.load_config_and_init(args)
+agent.run_operation

data/lib/envoi/mam/agent/cli/commands/mediasilo.rb

@@ -0,0 +1,296 @@
+#!/usr/bin/env ruby
+# lib_path = __FILE__ == '(irb)' ? File.join(Dir.cwd, 'lib') : File.expand_path('../../../lib', __FILE__)
+# $:.unshift(lib_path) unless $:.include?(lib_path) or !File.exists?(lib_path)
+# require 'rubygems'
+require 'optparse'
+require 'pp'
+
+require 'envoi/mam/agent/cli'
+require 'envoi/mam/mediasilo/agent'
+
+current_command = ARGV.shift
+ARGV << '--help' if ARGV.empty?
+
+default_config_file_paths = Envoi::Mam::Agent::Cli::CONFIG_FILE_PATHS
+
+aspera_ascp_paths = Envoi::Mam::Agent::TransferClient::Aspera::ASCP_PATHS
+default_aspera_ascp_path = aspera_ascp_paths.find { |v| File.exist? v } || aspera_ascp_paths.first
+
+args = {
+    :config_file_path => default_config_file_paths,
+    :default_aspera_ascp_path => default_aspera_ascp_path,
+    :dry_run => false,
+    :operation => :download,
+    :preserve_path => true,
+    :transfer_type => '',
+
+    :asset_derivative_type => 'source',
+}
+
+args[:config_service_app_id] = ENV['ENVOI_MAM_AGENT_APP_ID']
+args[:config_service_app_token] = ENV['ENVOI_MAM_AGENT_APP_TOKEN']
+args[:config_service_app_url] = ENV['ENVOI_MAM_AGENT_APP_URL']
+
+op = OptionParser.new
+op.on('--mediasilo-path PATH', 'The path on MediaSilo to download from or upload to.', "PROJECTNAME/[FOLDERNAME]/.../[ASSETTITLE]") { |v| args[:mediasilo_path] = v }
+op.on('--mediasilo-project-name PROJECTNAME') { |v| args[:mediasilo_project_name] = v }
+op.on('--mediasilo-asset-derivative-type DERIVATIVE', 'The derivative to use when downloading and asset.', "default: #{args[:asset_derivative_type]}") { |v| args[:asset_derivative_type] = v }
+op.on('--mediasilo-asset-id ASSETID', '') { |v| args[:asset_id] = v }
+
+op.on('-c', '--config-file-path FILEPATH', 'The path to the configuration file.') { |v| args[:config_file_path] = v }
+op.on('--agent-app-id ID', '') { |v| args[:config_service_app_id] = v }
+op.on('--agent-token TOKEN', '') { |v| args[:config_service_app_token] = v }
+op.on('--agent-service-api URL', '') { |v| args[:config_service_api_url] = v }
+
+op.on('--file-path PATH', '') { |v| args[:file_path] = v }
+op.on('-d', '--destination-path DIRPATH', 'The destination path to download or upload to.', "default: '.'") { |v| args[:destination_path] = v }
+op.on('-p','--[no-]preserve-path', "default: true") { |v| args[:preserve_path] = v }
+op.on('-o', '--operation OP', [ :download, :upload ], 'Transfer Direction.', "default: #{args[:operation]}" ) { |v| args[:operation] = v }
+op.on('--transfer-type TYPE', [ :aspera, :s3 ],'Force the type of transfer to use. Ex: aspera || s3') { |v| args[:transfer_type] = v }
+op.on('--transfer-token TOKEN', '') { |v| args[:transfer_token] = v }
+op.on('--dry-run', 'Run without executing the transfer.') { |v| args[:dry_run] = v }
+op.on('--help', 'Show this message.') { puts op; exit }
+op.load
+op.parse!
+
+args[:file_path] ||= ARGV.shift
+args[:destination_path] ||= ARGV.shift unless ARGV.empty?
+
+# module Envoi
+#
+#   module Mam
+#
+#     class MediaSilo
+#
+#       attr_accessor :logger, :config, :api_client
+#
+#       class Agent < Envoi::Mam::Agent
+#
+#         DEFAULT_DOWNLOAD_DESTINATION_PATH = '.'
+#
+#         class CaseSensitiveHeaderKey < String
+#           # def downcase; self end
+#           def capitalize; self end
+#         end
+#
+#         class FileToSend < File
+#           def bytesize; size end
+#         end
+#
+#         def initialize_api_client(args = { })
+#           @api_client = args[:api_client] || begin
+#             ms_config = config['mediasilo']
+#             mediasilo_hostname = ms_config['hostname']
+#             mediasilo_username = ms_config['username']
+#             mediasilo_password = ms_config['password']
+#             mediasilo_api_key = ms_config['api_key']
+#
+#             client_args = { }
+#             client_args[:hostname] = mediasilo_hostname if mediasilo_hostname
+#             client_args[:username] = mediasilo_username if mediasilo_username
+#             client_args[:password] =  mediasilo_password if mediasilo_password
+#             client_args[:api_key] = mediasilo_api_key if mediasilo_api_key
+#             Ubiquity::MediaSilo::API::V3::Utilities.new(client_args)
+#           end
+#
+#         end
+#
+#         def download(args = { })
+#           transfer_type = args[:transfer_type]
+#
+#           file_path = args[:file_path]
+#           project_id = args[:project_id]
+#           folder_id = args[:folder_id]
+#           asset_id = args[:asset_id]
+#
+#           mediasilo_path = args[:mediasilo_path]
+#           project_name = args[:project_name]
+#           folder_name = args[:folder_name]
+#
+#           if mediasilo_path || project_name || folder_name
+#             check_path_result = api_client.check_path(mediasilo_path)
+#             found = check_path_result[:existing]
+#
+#             project = found[:project] || { }
+#             project_id = project['id']
+#
+#             folders = found[:folders]
+#             folder_id = (folders.last || { })['id']
+#
+#             asset = found[:asset] || { }
+#             asset_id = asset['id']
+#           end
+#
+#           asset ||= asset_id
+#
+#           destination_file_path = args[:destination_path] || DEFAULT_DOWNLOAD_DESTINATION_PATH
+#
+#           case transfer_type
+#           when :aspera; download_using_aspera(asset_id, destination_file_path, args)
+#           else
+#             do_upload_response = download_using_http(asset, destination_file_path, args)
+#             asset_url = do_upload_response[:asset_url]
+#           end
+#
+#         end
+#
+#         def download_using_aspera(asset_id, destination_file_path, args = { })
+#           derivative_type = args[:asset_derivative_type]
+#           derivative_type = derivative_type.downcase == 'source' ? 'source' : 'proxy'
+#           ticket = api.aspera_file_download_ticket_create(:asset_id => asset_id, :target => derivative_type)
+#
+#           host = ticket['server']
+#           username = ticket['username']
+#           password = ticket['password']
+#           token = ticket['token']
+#
+#           original_file_name = ticket['fileName']
+#
+#           file_path = ticket['path']
+#           target_path = destination_file_path
+#
+#           FileUtils.mkdir_p(target_path) if target_path.end_with?('/') && !File.directory?(target_path)
+#           if target_path.end_with?('/') || File.directory?(target_path)
+#             target_path = File.join(target_path, original_file_name)
+#           end
+#
+#           aspera_config = { }
+#           aspera_config['host'] = host
+#           aspera_config['username'] = username
+#           aspera_config['password'] = password
+#           aspera_config['token'] = token
+#
+#           client = Envoi::Mam::Agent::TransferClient::Aspera.new(agent: self)
+#           client.download(aspera_config, file_path, target_path)
+#         end
+#
+#         def download_using_http(asset, destination_file_path, args)
+#           overwrite = args.fetch(:overwrite, false)
+#           derivative_type = args[:asset_derivative_type]
+#           api_client.asset_download_derivative(derivative_type, asset, destination_file_path, overwrite)
+#         end
+#
+#         def upload(args = { })
+#           transfer_type = args[:transfer_type]
+#
+#           file_path = args[:file_path]
+#           project_id = args[:project_id]
+#           folder_id = args[:folder_id]
+#           asset_id = args[:asset_id]
+#
+#           mediasilo_path = args[:mediasilo_path]
+#           project_name = args[:project_name]
+#           folder_name = args[:folder_name]
+#
+#           if mediasilo_path || project_name || folder_name
+#             check_path_result = api_client.check_path(mediasilo_path, true)
+#             found = check_path_result[:existing]
+#
+#             project = found[:project] || { }
+#             project_id = project['id']
+#
+#             folders = found[:folders]
+#             folder_id = (folders.last || { })['id']
+#           end
+#
+#           # # preserve_path = args.fetch(:preserve_path, vidispine_storage_true)
+#           # preserve_path = args.fetch(:preserve_path, true)
+#           #
+#           # destination_path = args[:destination_path] || DEFAULT_DESTINATION_PATH
+#           # relative_path = preserve_path ? File.dirname(file_path) : nil
+#           # relative_path = nil if relative_path == '.'
+#           #
+#           # target_path = relative_path ? File.join(destination_path, relative_path) : destination_path
+#           # target_path = target_path[0..-1] if target_path.start_with?('/') && !destination_path.start_with?('/')
+#
+#           # upload file
+#           case transfer_type
+#           when :aspera; upload_using_aspera(file_path, args)
+#           else
+#             do_upload_response = upload_using_http(file_path)
+#             asset_url = do_upload_response[:asset_url]
+#           end
+#
+#           asset_create_args = {
+#               'projectId' => project_id,
+#               'folderId' => folder_id,
+#               :source_url => asset_url
+#           }
+#           response = api_client.asset_create(asset_create_args)
+#         end
+#
+#         def upload_using_aspera(file_path, args = { })
+#           raise 'Upload using Aspera not yet Implemented.'
+#
+#           file_name = File.basename(file_path)
+#
+#           ticket =  api.aspera_file_upload_ticket_create(:file_name => file_name)
+#
+#           host = ticket['server']
+#           username = ticket['username']
+#           password = ticket['password']
+#           token = ticket['token']
+#           destination = ticket['destination']
+#
+#           target_path = destination
+#
+#           aspera_config = { }
+#           aspera_config['host'] = host
+#           aspera_config['username'] = username
+#           aspera_config['password'] = password
+#           aspera_config['token'] = token
+#
+#           client = Envoi::Mam::Agent::TransferClient::Aspera.new(agent: self)
+#           client.upload(aspera_config, file_path, target_path)
+#         end
+#
+#         def upload_using_http(file_path)
+#           file_name = File.basename(file_path)
+#
+#           res = api_client.asset_upload_ticket_create(:file_name => file_name)
+#           uri_str = res['assetUrl']
+#
+#           uri = URI.parse(uri_str)
+#
+#           amz_date = res['amzDate']
+#           amz_acl = res['amzAcl']
+#           content_type = res['contentType']
+#           authorization = res['authorization']
+#
+#           file = File.open(file_path)
+#           # file = FileToSend.open(file_path)
+#
+#           req = Net::HTTP::Put.new(uri.request_uri)
+#           req['x-amz-date'] = amz_date
+#           req['x-amz-acl'] = amz_acl
+#           req[CaseSensitiveHeaderKey.new('Content-Type')] = content_type
+#           res[CaseSensitiveHeaderKey.new('Authorization')] = authorization
+#           req[CaseSensitiveHeaderKey.new('Transfer-Encoding')] = 'chunked'
+#           req[CaseSensitiveHeaderKey.new('Content-Length')] = file.size
+#
+#           req.body_stream = file
+#
+#           # req.body = FileToSend.open(file_path)
+#
+#           request = req
+#           http = Net::HTTP.new(uri.host, uri.port)
+#           http.use_ssl = true
+#           logger.debug { %(REQUEST: #{request.method} https://#{http.address}:#{http.port}#{request.path} HEADERS: #{request.to_hash.inspect} #{api_client.http_client.log_request_body and request.request_body_permitted? ? "BODY: #{api_client.http_client.format_body_for_log_output(request)}" : ''}) }
+#
+#           res = http.request(req)
+#           { :asset_url => uri_str }
+#         end
+#
+#
+#       end
+#
+#     end
+#
+#   end
+#
+# end
+
+agent = Envoi::Mam::MediaSilo::Agent.load_config_and_init(args)
+agent.run_operation
+
+