cantemo-portal-agent 1.0.9 → 1.1.0

data/lib/envoi/aspera/watch_service/client.rb

@@ -0,0 +1,397 @@
+require 'json'
+require 'logger'
+require 'open3'
+require 'shellwords'
+
+module Envoi
+  module Aspera
+    module WatchService
+
+      class Client
+
+        attr_accessor :logger, :initial_args, :config
+
+        attr_accessor :aswatchadmin_executable_path, :default_username
+
+        DEFAULT_ASWATCHADMIN_EXECUTABLE_PATH = '/Library/Aspera/bin/aswatchadmin'
+
+        DAEMON_NAME_FIELD_NAME          = 'name'
+        DAEMON_CONFIGURATION_FIELD_NAME = 'configuration'
+
+        DAEMONS_QUERY_LINE_PART_TO_SUB = 'configuration: '
+        DAEMONS_QUERY_LINE_START       = "#{DAEMONS_QUERY_LINE_PART_TO_SUB} {"
+
+        class Expressions
+          SNAPSHOT_CREATE_VERSION_PARSE          = /(?<version>\d*)\.$/
+          SNAPSHOT_PRINT_PARSE                   = /^\s{2}(?<path>.*), (?<stat_as_json>\{"ino":\d+,.*})$/
+          SUBSCRIPTION_CREATE_PARSE              = /(?<json>\{.*\})\s*$/
+          SUBSCRIPTION_RESUBSCRIBE_SUCCESS_PARSE = /^\[aswatchadmin resubscribe\] Successfully resubscribed subscription '[^']*'\.$/
+          SNAPSHOT_DIFFERENTIAL_PARSE            = /^event\=(?<event>[^\,]*),path\=(?<path>.*),stat\=\[type\=(?<stat_type>[A-Z_]*),(?<change>[^\]]*)\]$/
+        end
+
+        class SnapshotEntry < Hash
+
+          def initialize(data)
+            # @attributes = data.is_a?(MatchData) ? { path: data[:path], stat_as_json: data[:stat_as_json] } : data
+            merge! data
+          end
+
+          def path; self[:path] end
+
+          def stat
+            self[:stat] ||= begin
+              json = self[:stat_as_json]
+              JSON.parse(json) if json
+            end
+          end
+
+          def stat_as_json; self[:stat_as_json] end
+
+          if MatchData.method_defined?(:named_captures)
+            def self.new_from_match_data(match_data)
+              new(match_data.named_captures)
+            end
+          else
+            def self.new_from_match_data(match_data)
+              new(Hash[match_data.names.map(&:to_sym).zip(match_data.captures)])
+            end
+          end
+        end
+
+        def self.current_os_type
+          case RUBY_PLATFORM
+          when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+            return :windows
+          when /darwin|mac os/
+            return :mac
+          else  # unix family
+            return :unix
+          end
+        end
+
+        def self.detect_executable
+          executable_name = 'aswatchadmin'
+          paths = case current_os_type
+          when :windows
+            executable_name += '.exe'
+            [
+              File.join(ENV['LOCALAPPDATA'], 'Aspera', 'bin', executable_name)
+            ]
+          when :mac
+            [
+              "/Library/Aspera/bin/#{executable_name}",
+            ]
+          else
+            [
+              File.join("/opt/aspera/bin/#{executable_name}")
+            ]
+          end
+          paths.find { |p| File.executable?(p) }
+        end
+
+        def initialize(args = {})
+          @initial_args = args.clone
+          initialize_logger(args)
+
+          @config = args[:config]
+
+          @aswatchadmin_executable_path = args[:aswatchadmin_executable_path] ||
+                                          self.class.detect_executable ||
+                                          DEFAULT_ASWATCHADMIN_EXECUTABLE_PATH
+          @default_daemon_name          = args[:default_daemon_name] || args[:daemon_name] || default_daemon_name_get
+          @dry_run                      = args.fetch(:dry_run, false)
+        end
+
+        def initialize_logger(args = {})
+          @logger = args[:logger] || Logger.new(STDOUT)
+        end
+
+        def dry_run?;
+          @dry_run
+        end
+
+        def shell_execute(command, dry_run = @dry_run)
+          command = command.shelljoin if command.is_a?(Array)
+          if dry_run
+            logger.debug { "Skipping Execution of Command: '#{command}' " }
+            return
+          end
+          logger.debug { "Executing Command: '#{command}'" }
+
+          response = ''
+          Open3.popen3(command) do |stdin, stdout, stderr, thread|
+            # stdin.sync = true
+            # stdout.sync = true
+            # stderr.sync = true
+            output = ''
+            loop do
+              output << stdout.read #rescue nil
+              output << stderr.read # rescue nil
+              unless output.empty?
+                # print output
+                response << output.dup
+                output.clear
+              end
+              break if thread.stop?
+            end
+          end
+
+          logger.debug { "RESPONSE: #{response.empty? ? '' : "\n#{response}"}" }
+          response
+        end
+
+        # @return [Hash]
+        def default_daemon_get
+          daemons = daemons_query
+          return nil unless daemons.length == 1
+          default_daemon = daemons.first
+        end
+
+        # @return [String|nil]
+        def default_daemon_name_get
+          _default_daemon = default_daemon_get
+          return nil unless _default_daemon
+          _default_daemon[DAEMON_NAME_FIELD_NAME]
+        end
+
+        # @return [Array]
+        def daemons_query(args = {})
+          command  = [aswatchadmin_executable_path, 'query-daemons']
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, true)
+
+          daemons_query_response_parse(response)
+        end
+
+        # @return [Array[Hash]]
+        def daemons_query_response_parse(response)
+          response_ary = response.split("\n")
+          first_line   = response_ary.shift
+          daemon       = nil
+          daemons      = response_ary.each_with_object([]) do |line, _daemons|
+            _line = line.strip
+
+            if _line.start_with?(DAEMONS_QUERY_LINE_START)
+              configuration_json                      = _line.sub(DAEMONS_QUERY_LINE_PART_TO_SUB, '')
+              configuration                           = JSON.parse(configuration_json)
+              daemon[DAEMON_CONFIGURATION_FIELD_NAME] = configuration
+            else
+              _daemons << daemon if daemon
+              daemon_name = _line
+              daemon      = { DAEMON_NAME_FIELD_NAME => daemon_name }
+            end
+          end
+          daemons << daemon if daemon
+        end
+
+        def subscription_create(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          watch_folder_path = args[:watch_folder_path]
+          raise ArgumentError, 'Missing argument for required parameter watch_folder_path' unless watch_folder_path
+
+          scan_period = args[:scan_period]
+          expire_in   = args[:expire_in]
+
+          command = [aswatchadmin_executable_path, 'subscribe', daemon_name, watch_folder_path]
+          command << '--scan-period' << scan_period if scan_period
+          command << '--expire_in' << expire_in if expire_in
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, true)
+
+          subscription_create_response_parse(response)
+        end
+
+        # @param [Object]  response
+        # @return [Object]
+        def subscription_create_response_parse(response)
+          subscription_json_match = Expressions::SUBSCRIPTION_CREATE_PARSE.match(response)
+          raise "Failed to parse new subscription information from response. '#{response}'" unless subscription_json_match
+          subscription_json = subscription_json_match.to_s
+          subscription      = JSON.parse(subscription_json)
+        end
+
+        def subscription_resubscribe(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          subscription_id = args[:subscription_id]
+          raise ArgumentError, 'Missing argument for required parameter subscription_id' unless subscription_id
+
+          command  = [aswatchadmin_executable_path, 'resubscribe', daemon_name, subscription_id]
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, true)
+
+          subscription_resubscribe_parse_response(response)
+        end
+
+        def subscription_resubscribe_parse_response(response)
+          raise response unless Expressions::SUBSCRIPTION_RESUBSCRIBE_SUCCESS_PARSE.match(response)
+          true
+        end
+
+        # Create a snapshot using the subscription
+        #
+        # ```
+        # $ /Library/Aspera/bin/aswatchadmin create-snapshot jw f090e8b5-d9e2-474b-acb1-68c4f76c8c53
+        # [aswatchadmin create-snapshot] Successfully created snapshot 0.
+        # ```
+        def subscription_snapshot_create(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          subscription_id = args[:subscription_id]
+          raise ArgumentError, 'Missing argument for required parameter subscription_id' unless subscription_id
+
+          command  = [aswatchadmin_executable_path, 'create-snapshot', daemon_name, subscription_id]
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, true)
+
+          subscription_snapshot_create_response_parse(response)
+        end
+
+        def subscription_snapshot_create_response_parse(response)
+          snapshot_version = Expressions::SNAPSHOT_CREATE_VERSION_PARSE.match(response)
+          raise "Failed to parse snapshot version from response. '#{response}'" unless snapshot_version
+          snapshot_version
+        end
+
+        def subscription_snapshot_differential(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          subscription_id = args[:subscription_id]
+          raise ArgumentError, 'Missing argument for required parameter subscription_id' unless subscription_id
+
+          from = args[:from]
+
+          to = args[:to]
+
+          path = args[:path]
+          identifier = args[:identifier]
+          format = args[:format]
+          escape = args[:escape]
+          exclude_create = args[:exclude_create]
+          exclude_modify = args[:exclude_modify]
+          exclude_remove = args[:exclude_remove]
+          leafs_only = args[:leafs_only]
+
+          command  = [aswatchadmin_executable_path, 'snapshot-differential', daemon_name, subscription_id]
+          command << from if from
+          command << to if to
+          command << '--path' << path if path && !path.empty?
+          command << '--identifier' << identifier if identifier && !identifier.empty?
+          command << '--format' << format if format && !format.empty?
+          command << '--escape' << escape if escape && !escape.empty?
+          command << '--exclude_create' if exclude_create
+          command << '--exclude_modify' if exclude_modify
+          command << '--exclude-remove' if exclude_remove
+          command << '--leafs-only' if leafs_only
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, true)
+
+          subscription_snapshot_differential_response_parse(response)
+        end
+
+        def subscription_snapshot_differential_response_parse(response)
+          response.split.map do |v|
+            m = v.match(Expressions::SNAPSHOT_DIFFERENTIAL_PARSE)
+            m ? Hash[m.names.zip(m.captures)] : v
+          end.join('\n')
+        end
+
+        def subscription_snapshot_print(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          subscription_id = args[:subscription_id]
+          raise ArgumentError, 'Missing argument for required parameter subscription_id' unless subscription_id
+
+          snapshot_version = args[:snapshot_version]
+          command          = [aswatchadmin_executable_path, 'print-snapshot', daemon_name, subscription_id]
+          command << '--snapshot' << snapshot_version if snapshot_version
+
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, false)
+
+          subscription_snapshot_print_response_parse(response)
+        end
+
+        def subscription_snapshot_print_response_parse(response)
+          response
+              .to_enum(:scan, Expressions::SNAPSHOT_PRINT_PARSE)
+              .map { SnapshotEntry.new_from_match_data(Regexp.last_match) }
+        end
+
+        def subscription_snapshot_entries_get(args = { })
+          response = subscription_snapshot_print(args)
+          subscription_snapshot_print_response_parse(response)
+        end
+
+
+        # List subscriptions for a specific daemon
+        # @see https://download.asperasoft.com/download/docs/entsrv/3.8.1/cs_admin_osx/webhelp/index.html#dita-watchfolder/watchd_subscriptions.html
+        def subscriptions_get(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          command  = [aswatchadmin_executable_path, 'query-subscriptions', daemon_name]
+          response = shell_execute(command)
+
+          return response unless args.fetch(:parse_response, true)
+
+          subscriptions_get_response_parse(response)
+        end
+
+        def subscriptions_get_response_parse(response)
+          response_json = "[#{response.split.join(",\n")}]"
+          subscriptions = JSON.parse(response_json)
+        end
+
+        # Unsubscribe from a watch
+        #
+        # $ /Library/Aspera/bin/aswatchadmin unsubscribe daemonname 3b758f2d-97f9-4054-80d5-ed67dcaa8daa
+        # [aswatchadmin unsubscribe] Successfully unsubscribed subscription '3b758f2d-97f9-4054-80d5-ed67dcaa8daa' from daemon 'daemonname'.
+        #
+        # @see https://download.asperasoft.com/download/docs/entsrv/3.8.1/cs_admin_osx/webhelp/index.html#dita-watchfolder/watchd_subscriptions.html
+        def subscription_unsubscribe(args = {})
+          daemon_name = args[:daemon_name] || args[:daemon] || @default_daemon_name
+          raise ArgumentError, 'Missing argument for required parameter daemon_name' unless daemon_name
+
+          subscription_id = args[:subscription_id]
+          raise ArgumentError, 'Missing argument for required parameter subscription_id' unless subscription_id
+
+          command  = [aswatchadmin_executable_path, 'unsubscribe', daemon_name, subscription_id]
+          response = shell_execute(command)
+        end
+
+        def subscriptions_unsubscribe_all(args = {})
+          subscriptions = subscriptions_get(args)
+          args_out      = args.dup
+          path          = args[:path]
+          subscriptions.each do |subscription|
+            next unless subscription['path'] == path if path
+            subscription_id            = subscription['identifier']
+            args_out[:subscription_id] = subscription_id
+            subscription_unsubscribe(args_out)
+          end
+        end
+
+        def subscription_find_for_path(args = {})
+          path          = args[:path]
+          subscriptions = args[:subscriptions] || subscriptions_get(args)
+          subscriptions.keep_if { |s| s['path'] =~ /(?:\w|-)*:\/{2,3}#{Regexp.escape(path)}/ }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/envoi/aspera/watch_service/snapshot.rb

@@ -0,0 +1,11 @@
+module Envoi
+  module Aspera
+    module WatchService
+
+      class Snapshot
+        
+      end
+
+    end
+  end
+end