ass_launcher 0.1.1.alpha

data/lib/ass_launcher/enterprise/ole.rb

@@ -0,0 +1,188 @@
+# encoding: utf-8
+
+require 'ass_launcher/enterprise/ole/ole_binaries'
+
+module AssLauncher
+  module Enterprise
+    # 1C:Enterprise ole objects layer
+    module Ole
+      # 1C Infobase External Connection
+      class IbConnection
+        attr_reader :__ole__
+        protected :__ole__
+
+        # (see OleBinaries::AbstractAssOleBinary#initialize)
+        def initialize(requirement)
+          @requirement = requirement.to_s
+        end
+
+        # Open connection in to infobase described in conn_str
+        # @param conn_str [Support::ConnectionString::Server,
+        #  Support::ConnectionString::File, String]
+        def __open__(conn_str)
+          return true if __opened__?
+          __init_ole__(__ole_binary__.ole.connect(__cs__(conn_str)))
+          true
+        end
+
+        def __init_ole__(ole)
+          @__ole__ = ole
+        end
+        private :__init_ole__
+
+        # Try close connection.
+        # @note *It* *not* *guaranteed* *real* *closing* *connection!*
+        #  Connection keep alive while have any alive WIN32OLE refs
+        #  generated this connection. {WIN32OLE#\_\_ass_ole_free\_\_} try kill
+        #  refs but it work not always
+        # @see WIN32OLE
+        def __close__
+          return true if __closed__?
+          __ole__.send :__ass_ole_free__
+          @__ole__ = nil
+          true
+        end
+
+        # True if connection closed
+        def __closed__?
+          __ole__.nil?
+        end
+
+        # True if connection opened
+        def __opened__?
+          !__closed__?
+        end
+
+        # Set 1C Ole server properties
+        def __configure_com_connector__(**opts)
+          opts.each do |k, v|
+            __ole_binary__.ole.setproperty(k, v)
+          end
+        end
+
+        def __cs__(conn_str)
+          return conn_str.to_ole_string if conn_str.respond_to? :to_ole_string
+          conn_str.to_s
+        end
+        protected :__cs__
+
+        def __ole_binary__
+          @__ole_binary__ ||= OleBinaries::COMConnector.new(@requirement)
+        end
+        protected :__ole_binary__
+
+        # Try call ole method
+        # @raise [RuntimeError] if object closed
+        def method_missing(method, *args)
+          fail "Attempt call method for closed object #{self.class.name}"\
+            if __closed__?
+          __ole__.send(method, *args)
+        end
+        protected :method_missing
+      end
+
+      # IWorkingProcessConnection
+      class WpConnection < IbConnection
+        # Connection with 1C Server working process described in uri
+        # @param uri [URI, String]
+        def __open__(uri)
+          return true if __opened__?
+          __init_ole__(__ole_binary__.ole.connectworkingprocess(uri.to_s))
+          true
+        end
+      end
+
+      # Wrapper for IServerAgentConnection
+      class AgentConnection < IbConnection
+        # Connection with 1C Server agent described in uri
+        # @param (see WpConnection#__open__)
+        def __open__(uri)
+          return true if __opened__?
+          __init_ole__(__ole_binary__.ole.connectagent(uri.to_s))
+          true
+        end
+      end
+
+      class ApplicationConnectError < StandardError; end
+
+      # Wrapper for V8xc.Application ole object
+      class ThinApplication < IbConnection
+        # Array of objects with opened connection for close all
+        def self.objects
+          @objects ||= []
+        end
+
+        # Close all opened connectons
+        def self.close_all
+          objects.each(&:__close__)
+        end
+
+        def initialize(requirement)
+          super
+          @opened = false
+        end
+
+        # (see IbConnection#__open__)
+        # @raise [ApplicationConnectError]
+        def __open__(conn_str)
+          return true if __opened__?
+          __try_open__(conn_str)
+          self.class.objects << self
+          __opened__?
+        end
+
+        def __try_open__(conn_str)
+          @opened = __ole_binary__.ole.connect(__cs__(conn_str))
+          fail ApplicationConnectError unless __opened__?
+        rescue StandardError => e
+          @opened = false
+          @__ole_binary__ = nil
+          raise e
+        end
+        protected :__try_open__
+
+        def __ole__
+          __ole_binary__.ole
+        end
+        protected :__ole__
+
+        def __opened__?
+          @opened
+        end
+
+        def __closed__?
+          !__opened__?
+        end
+
+        def __close__
+          return true if __closed__?
+          # rubocop:disable HandleExceptions
+          begin
+            __ole__.terminate
+          rescue
+            # NOP
+          ensure
+            @__ole_binary__ = nil
+            @opened = false
+            ThinApplication.objects.delete(self)
+          end
+          # rubocop:enable HandleExceptions
+          true
+        end
+
+        def __ole_binary__
+          @__ole_binary__ ||= OleBinaries::ThinApplication.new(@requirement)
+        end
+        protected :__ole_binary__
+      end
+
+      # Wrapper for V8x.Application ole object
+      class ThickApplication < ThinApplication
+        def __ole_binary__
+          @__ole_binary__ ||= OleBinaries::ThickApplication.new(@requirement)
+        end
+        protected :__ole_binary__
+      end
+    end
+  end
+end

data/lib/ass_launcher/enterprise/web_clients.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module AssLauncher
+  module Enterprise
+    module WebClients
+      module DefinedArguments
+        def self.extented(base)
+          raise "FIXME #{base}"
+        end
+      end
+
+      # Return object for run 1C webclent in required internet browser
+      # @param name [Symbol] - name of required internet browser for
+      #  run 1C webclent
+      # @return [WebClients::IE, WebClients::Firefox, WebClients::Chrome,
+      #  WebClients::Safary]
+      def self.client(name)
+        fail ArgumentError, "Invalid client name `#{name}'"\
+          unless BROWSERS.include? name
+        BROWSERS[name]
+      end
+
+      # @abstract
+      class Client
+        def accepted_connstr
+          [:http]
+        end
+
+        def initialize(connection_string)
+          @connection_string = connection_string
+          validate_connection_string
+          extend DefinedArguments
+        end
+
+        def validate_connection_string
+          raise 'FIXME'
+          #fail ArgumentError, "Invalid connection_string \
+          #`#{@connection_string}'"\
+          #unless accepted_connstr.include?(@connection_string.is)
+        end
+
+        # @todo TODO: можно запускать как драйвер силениум
+        def run(args)
+          raise 'FIXME'
+        end
+      end # Client
+      class Firefox < Client; end
+      class IE < Client; end
+      class Chrome < Client; end
+      class Safary < Client; end
+
+      BROWSERS = { firefox: Firefox,
+                   iexplore: IE,
+                   chrome: Chrome,
+                   safary: Safary
+      }.freeze
+    end
+  end
+end

data/lib/ass_launcher/enterprise.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+module AssLauncher
+  #
+  class Configuration
+    # Path for search 1C binaries
+    attr_accessor :search_path
+  end
+  # 1C:Entrprise platform abstraction layer
+  module Enterprise
+    require 'ass_launcher/enterprise/binary_wrapper'
+    require 'ass_launcher/enterprise/web_clients'
+    require 'ass_launcher/enterprise/ole'
+
+    extend AssLauncher::Support::Platforms
+
+    WIN_BINARIES = { BinaryWrapper::ThinClient => '1cv8c.exe',
+                     BinaryWrapper::ThickClient => '1cv8.exe'
+    }.freeze
+    LINUX_BINARIES = { BinaryWrapper::ThinClient => '1cv8c',
+                       BinaryWrapper::ThickClient => '1cv8'
+    }.freeze
+    def self.windows_or_cygwin?
+      platform.cygwin? || platform.windows?
+    end
+    private_class_method :windows_or_cygwin?
+
+    def self.linux?
+      platform.linux?
+    end
+    private_class_method :linux?
+
+    # Return paths for searching instaled 1C platform
+    # @note
+    #  - For Windows return value of 'Program Files' env.
+    #  - For Linux return '/opt/1C'
+    #  - In both cases you can set {AssLauncher::Configuration#search_path} and
+    #    it will be added into array
+    # @return [Array<String>
+    def self.search_paths
+      sp = []
+      sp << AssLauncher.config.search_path
+      if windows_or_cygwin?
+        sp += platform.env[/\Aprogram\s*files.*/i].uniq.map { |pf| "#{pf}/1c*" }
+      elsif linux?
+        sp += %w(/opt/1C /opt/1c)
+      end
+      sp.compact.uniq
+    end
+
+    # @api private
+    def self.binaries(klass)
+      if windows_or_cygwin?
+        WIN_BINARIES[klass]
+      elsif linux?
+        LINUX_BINARIES[klass]
+      end
+    end
+
+    def self.find_clients(klass)
+      find_binaries(binaries(klass)).map do |binpath|
+        klass.new(binpath)
+      end
+    end
+    private_class_method :find_clients
+
+    def self.requiremet?(client, requiremet)
+      return true if requiremet.empty?
+      Gem::Requirement.new(requiremet).satisfied_by? client.version
+    end
+    private_class_method :requiremet?
+
+    # Return array of wrappers for 1C thin client executables
+    # found in {.search_paths}
+    # @param requiremet [String] - suitable for [Gem::Requirement] string.
+    #  Define requiremet version of 1C:Platform.
+    # @return [Array<BinaryWrapper::ThinClient>]
+    def self.thin_clients(requiremet = '')
+      find_clients(BinaryWrapper::ThinClient).map do |c|
+        c if requiremet?(c, requiremet)
+      end.compact
+    end
+
+    # Return array of wrappers for 1C platform(thick client) executables
+    # found in {.search_paths}
+    # @param (see thin_clients)
+    # @return [Array<BinaryWrapper::ThickClient>]
+    def self.thick_clients(requiremet = '')
+      find_clients(BinaryWrapper::ThickClient).map do |c|
+        c if requiremet?(c, requiremet)
+      end.compact
+    end
+
+    # (see WebClients.client)
+    def self.web_client(name)
+      WebClients.client(name)
+    end
+
+    # Find and return all 1C:Entrprise binaries
+    # @return [Array<BinaryWrapper>]
+    def self.find_binaries(basename)
+      return [] if basename.to_s.empty?
+      r = []
+      search_paths.flatten.each do |sp|
+        r += platform.glob("#{sp}/**/#{basename}")
+      end
+      r
+    end
+    private_class_method :find_binaries
+  end
+end