ass_maintainer-info_base 0.1.2 → 1.0.0

data/lib/ass_maintainer/info_base/cfg.rb

@@ -1,16 +1,18 @@
 module AssMaintainer
   class InfoBase
-    # @abstract
-    class AbstractCfg
-      attr_reader :infobase
-      # @param infobase [InfoBase]
-      def initialize(infobase)
-        @infobase = infobase
+    module Abstract
+      # @abstract
+      class Cfg
+        attr_reader :infobase
+        # @param infobase [InfoBase]
+        def initialize(infobase)
+          @infobase = infobase
+        end
       end
     end
 
     # Object for manipuate whith infobase configuration
-    class Cfg < AbstractCfg
+    class Cfg < Abstract::Cfg
       # Dump configuration to +XML+ files
       # @param path [String]
       # @return [String] path
@@ -55,14 +57,16 @@ module AssMaintainer
     end
 
     # Object for manipuate whith database configuration
-    class DbCfg < AbstractCfg
+    class DbCfg < Abstract::Cfg
       # Update database configuration from infobase
       # configuration
-      def update
+      # @param was_err [true false] control +warningsAsErrors+ 1C:Enterprise
+      #  CLI parameter
+      def update(was_err = false)
         fail MethodDenied, :update if infobase.read_only?
         infobase.designer do
           updateDBCfg do
-            warningsAsErrors
+            warningsAsErrors if was_err
           end
         end.run.wait.result.verify!
       end

data/lib/ass_maintainer/info_base/file_ib.rb

@@ -10,11 +10,6 @@ module AssMaintainer
         end
       end
 
-      # True if infobase exists
-      def exists?
-        File.file?("#{connection_string.path}/1Cv8.1CD")
-      end
-
       def maker
         options[:maker] || InfoBase::DefaultMaker.new
       end
@@ -25,51 +20,39 @@ module AssMaintainer
       end
       private :destroyer
 
-      # Connection string fore createinfobase
-      def make_connection_string
-        connection_string
+      # (see Interfaces::InfoBase#sessions)
+      def sessions
+        []
       end
 
-      # Dummy infobase wrupper
-      # @return [InfoBaseWrapper]
-      def infobase_wrapper
-        @infobase_wrapper = InfoBaseWrapper.new(self)
+      # (see Interfaces::InfoBase#lock)
+      def lock(*_)
       end
 
-      # (see Interfaces::InfoBaseWrapper)
-      class InfoBaseWrapper
-        include Interfaces::InfoBaseWrapper
-        attr_accessor :infobase
-        def initialize(infobase)
-          self.infobase = infobase
-        end
-
-        # (see Interfaces::InfoBaseWrapper#sessions)
-        def sessions
-          []
-        end
+      # (see Interfaces::InfoBase#unlock)
+      def unlock
+      end
 
-        # (see Interfaces::InfoBaseWrapper#lock)
-        def lock
-        end
+      # (see Interfaces::InfoBase#unlock!)
+      def unlock!
+      end
 
-        # (see Interfaces::InfoBaseWrapper#unlock)
-        def unlock
-        end
+      # (see Interfaces::InfoBase#locked?)
+      def locked?
+        false
+      end
 
-        # (see Interfaces::InfoBaseWrapper#unlock!)
-        def unlock!
-        end
+      # (see Interfaces::InfoBase#exists?)
+      def exists?
+        File.file?("#{connection_string.path}/1Cv8.1CD")
+      end
 
-        # (see Interfaces::InfoBaseWrapper#locked?)
-        def locked?
-          false
-        end
+      # (see Interfaces::InfoBase#lock_schjobs)
+      def lock_schjobs
+      end
 
-        # (see Interfaces::InfoBaseWrapper#locked_we?)
-        def locked_we?
-          false
-        end
+      # (see Interfaces::InfoBase#unlock_schjobs)
+      def unlock_schjobs
       end
     end
   end

data/lib/ass_maintainer/info_base/interfaces.rb

@@ -1,5 +1,12 @@
 module AssMaintainer
   class InfoBase
+    # Riseses when infobase already locked and +InfoBase#unlock_code+
+    # does not macth +PermissionCode+ on server
+    class UnlockError < StandardError; end
+
+    # Raises when +InfoBase#unlock_code+ not setted
+    class LockError < StandardError; end
+
     # Define absract Interfaces
     # for worker classes
     module Interfaces
@@ -31,45 +38,67 @@ module AssMaintainer
         end
       end
 
-      # Interface for {FileIb::InfoBaseWrapper} and
-      # {ServerIb::InfoBaseWrapper} classes
-      module InfoBaseWrapper
-        # Returns array of infobase sessions
-        # For file infobase returns empty array
-        # @return [Array <Session>]
+      # Common interface for different infobase types
+      # Interface must be implemented in {InfoBase::FileIb} and
+      # {InfoBase::ServerIb} modules
+      module InfoBase
+        require 'date'
+
+        # @note For {InfoBase::FileIb} must returns empty array
+        # Returns array of infobase sessions exclude
+        # {InfoBase::Session::EXCLUDE_APP_IDS} application types
+        # @return [Array <InfoBase::Session>]
         def sessions
           fail NotImplementedError
         end
 
-        # Lock infobase. It work for server infobase only.
-        # For file infobase it do nothing
-        def lock
+        # @note It must work for {InfoBase::ServerIb} only.
+        #  For {InfoBase::FileIb} it must do nothing
+        # Locking infobase if it possible. Be careful it terminate all
+        # sessions! Before do it should set +InfoBase#unlock_code+!
+        # Schedule jobs will be locked to!
+        # @raise [LockError] unless +InfoBase#unlock_code+ setted
+        # @raise [UnlockError] unless soft {#unlock} possible. If catched
+        #   it, shold do force unlock {unlock!} and try againe
+        def lock(from: Time.now, to: Time.now + 3600, message: '')
           fail NotImplementedError
         end
 
-        # Unlock infobase which {#locked_we?}.
-        # It work for server infobase only.
-        # For file infobase it do nothing
+        # @note (see #lock)
+        # Soft unlocking infobase if it possible.
+        # For force unlocking exec #{unlock!}
+        # @raise [UnlockError] unless unlocking possible
         def unlock
           fail NotImplementedError
         end
 
-        # Unlock infobase.
-        # It work for server infobase only.
-        # For file infobase it do nothing
+        # @note (see #lock)
+        # Force unlock infobase.
         def unlock!
           fail NotImplementedError
         end
 
-        # Lock infobase. It work for server infobase only.
-        # For file infobase it return +false+
+        # @note (see #lock)
+        # Lock schedule jobs
+        def lock_schjobs
+          fail NotImplementedError
+        end
+
+        # @note (see #lock)
+        # Unlock schedule jobs
+        def unlock_schjobs
+          fail NotImplementedError
+        end
+
+        # @note For {InfoBase::FileIb} it must always return +false+
+        #  It work for {InfoBase::ServerIb} only.
+        # Return +true+ if on server flag +SessionsDenied == true+
         def locked?
           fail NotImplementedError
         end
 
-        # True if infobase locked this
-        # For file infobase it return +false+
-        def locked_we?
+        # True if infobase exists
+        def exists?
           fail NotImplementedError
         end
       end

data/lib/ass_maintainer/info_base/server_ib.rb

@@ -1,97 +1,299 @@
 module AssMaintainer
   class InfoBase
+    class Session
+      # AppID excluded from {Interfaces::InfoBase#sessions} array
+      # - SrvrConsole - cluster console
+      # - COMConsole - ole cluster console
+      # - OpenIDProvider - OpenID provider
+      # - RAS - administration server
+      EXCLUDE_APP_IDS = %w{SrvrConsole COMConsole OpenIDProvider RAS}
+
+      # see {#initialize} +app_id+
+      attr_reader :app_id
+
+      # see {#initialize} +host+
+      attr_reader :host
+
+      # see {#initialize} +id+
+      attr_reader :id
+
+      # see {#initialize} +user+
+      attr_reader :user
+
+      # see {#initialize} +infobase+
+      attr_reader :infobase
+
+      # @api private
+      # @param id [Fixnum] sessions id
+      # @param app_id [String] client application id
+      # @param host [String] client host name
+      # @param user [Strin] infobase user
+      # @param infobase [InfoBase] infobase instance
+      def initialize(id, app_id, host, user, infobase)
+        @id = id
+        @app_id = app_id
+        @host = host
+        @user = user
+        @infobase = infobase
+      end
+
+      # Terminate session
+      def terminate
+        infobase.send(:infobase_wrapper).terminate(self) unless terminated?
+      end
+
+      # True if session is terminated
+      def terminated?
+        infobase.send(:infobase_wrapper).session_get(id).empty?
+      end
+    end
+
     # Mixins for infobase deployed on 1C:Eneterprise server
     module ServerIb
-      require 'ass_maintainer/info_base/server_ib/helpers'
-      # Defauld destroyer for serever infobase
+      require 'ass_maintainer/info_base/server_ib/enterprise_servers'
+
+      # @api private
+      # Defauld destroyer for server infobase
       class ServerBaseDestroyer
+
+        # On default database will be destroyed!
+        DROP_MODE = :destroy_db
+
         include Interfaces::IbDestroyer
+
+        # {InfoBase::Interfaces::IbDestroyer#entry_point} overload
         def entry_point
-          fail NotImplementedError
+          infobase.send(:infobase_wrapper).drop_infobase!(DROP_MODE)
         end
       end
 
-      def maker
-        options[:maker] || InfoBase::DefaultMaker.new
+      # @api private
+      # server infobase maker
+      class ServerBaseMaker < InfoBase::DefaultMaker
+
+        # Fields of {#connection_string} required for 1C command
+        # +createinfobase+
+        REQUIRE_FIELDS = [:dbsrvr, :dbuid, :dbms]
+
+        # {InfoBase::Interfaces::IbMaker#entry_point} overload
+        def entry_point
+          prepare_making
+          super
+        end
+
+        # Prepare {#connection_string} before execute making command
+        def prepare_making
+          fail "Fields #{REQUIRE_FIELDS} must be filled" unless require_filled?
+          cs = connection_string
+          set_if_empty :db, cs.ref
+          set_if_empty :crsqldb, 'Y'
+          set_if_empty :susr, infobase.cluster_usr
+          set_if_empty :spwd, infobase.cluster_pwd
+        end
+
+        # True if all fields from {REQUIRE_FIELDS} setted
+        # in {#connection_string}
+        def require_filled?
+          REQUIRE_FIELDS.each do |f|
+            return false if infobase.connection_string.send(f).nil?
+          end
+          true
+        end
+
+        # set {#connection_string} field +prop+ to +value+ if filed
+        # +prop+ empty?
+        # @param prop [String Symbol] field name
+        # @param value
+        def set_if_empty(prop, value)
+          connection_string.send("#{prop}=", value) if\
+            connection_string.send(prop).to_s.empty?
+        end
+
+        # Return {InfoBase#connection_string} instance
+        def connection_string
+          infobase.connection_string
+        end
       end
-      private :maker
 
-      # True if infobase exists
-      def exists?
-        infobase_wrapper.exists?
+      def maker
+        options[:maker] || ServerBaseMaker.new
       end
+      private :maker
 
       def destroyer
         options[:destroyer] || ServerBaseDestroyer.new
       end
       private :destroyer
 
-      # @return (see #def_server_agent)
-      def server_agent
-        @server_agent ||= def_server_agent
+      # @return {InfoBaseWrapper}
+      def infobase_wrapper
+        @infobase_wrapper ||= InfoBaseWrapper.new(self)
       end
+      private :infobase_wrapper
 
-      # @return [EnterpriseServers::ServerAgent]
-      def def_server_agent
-        host = sagent_host || connection_string.servers[0].host
-        port = sagent_port || InfoBase::DEFAULT_SAGENT_PORT
-        EnterpriseServers::ServerAgent.new("#{host}:#{port}",
-                                           sagent_usr,
-                                           sagent_pwd)
+      def wp_connection
+        infobase_wrapper.wp_connection
       end
-      private :def_server_agent
+      private :wp_connection
 
-      # @param a [EnterpriseServers::ServerAgent]
-      def server_agent=(a)
-        fail ArgumentError unless a.instance_of? ServerAgent
-        @server_agent = a
+      # (see Interfaces::InfoBase#sessions)
+      def sessions
+        infobase_wrapper.sessions.map do |s|
+          s.to_session(self) unless Session::EXCLUDE_APP_IDS.include? s.AppId
+        end.compact
       end
 
-      # Set claster user name
-      # @param user_name [String]
-      def cluster_usr=(user_name)
-        connection_string.susr = user_name
+      # (see Interfaces::InfoBase#lock)
+      def lock(from: Time.now, to: Time.now + 3600, message: '')
+        fail LockError, '#unlock_code is required' if unlock_code.to_s.empty?
+        unlock
+        wp_connection.lock_sessions!(from, to, unlock_code, message)
+        lock_schjobs
+        sessions.each do |sess|
+          sess.terminate
+        end
+        nil
       end
 
-      # Claster user name
-      def claster_usr
-        connection_string.susr || (self.claster_usr = options[:claster_usr])
+      # (see Interfaces::InfoBase#unlock)
+      def unlock
+        wp_connection.raise_unless_unlock_possable UnlockError, unlock_code
+        unlock!
+        nil
       end
 
-      # Set claster user password
-      # @param password [String]
-      def cluster_pwd=(password)
-        connection_string.spwd = password
+      # (see Interfaces::InfoBase#unlock!)
+      def unlock!
+        wp_connection.unlock_schjobs!
+        wp_connection.unlock_sessions!
+        nil
       end
 
-      # Claster user password
-      def claster_pwd
-        connection_string.spwd || (self.claster_pwd = options[:claster_pwd])
+      # (see Interfaces::InfoBase#lock_schjobs)
+      def lock_schjobs
+        wp_connection.lock_schjobs!
+        nil
       end
 
-      # @return [EnrepriseServers::Claster]
-      def claster
-        EnterpriseServers::Claster.from_cs(connection_string)
+      # (see Interfaces::InfoBase#unlock_schjobs)
+      def unlock_schjobs
+        wp_connection.unlock_schjobs!
+        nil
       end
 
-      def filled?(fields)
-        fields.each do |f|
-          return false if connection_string[f].nil?
-        end
-        true
+      # (see Interfaces::InfoBase#locked?)
+      def locked?
+        wp_connection.locked?
       end
-      private :filled?
 
-      # Connection string fore createinfobase
-      def make_connection_string
-        fields = [:dbsrvr, :db, :dbms]
-        fail "Required fields #{fields} must be filled" unless filled?(fields)
-        AssLauncher::Support::ConnectionString.new(connection_string.to_s)
+      # (see Interfaces::InfoBase#exists?)
+      def exists?
+        infobase_wrapper.exists?
       end
 
-      # @return {InfoBaseWrapper}
-      def infobase_wrapper
-        @infobase_wrapper = InfoBaseWrapper.new(self, server_agent, claster)
+      # @api private
+      # Wrapper for manipulate
+      # with real information base deployed in 1C:Enterprise server
+      # ower the 1C Ole classes
+      class InfoBaseWrapper
+        attr_accessor :infobase
+        alias_method :ib, :infobase
+        def initialize(infobase)
+          self.infobase = infobase
+        end
+
+        # @return [EnterpriseServers::ServerAgent]
+        def sagent_get
+          EnterpriseServers::ServerAgent
+            .new "#{ib.sagent_host || cs_servers[0].host}:#{ib.sagent_port}",
+                 ib.sagent_usr,
+                 ib.sagent_pwd
+        end
+        private :sagent_get
+
+        def exists?
+          clusters.size > 0
+        end
+
+        # @return [AssLauncher::Enterprise::Ole::AgentConnection]
+        def sagent
+          @sagent ||= sagent_get.connect(infobase.platform_require)
+        end
+
+        def cs_servers
+          ib.connection_string.servers.uniq {|s| [s.host.upcase, s.port.upcase]}
+        end
+        private :cs_servers
+
+        def cs_clusters
+          cs_servers.map do |s|
+            EnterpriseServers::Cluster
+              .new("#{s.host}:#{s.port}", ib.cluster_usr, ib.cluster_pwd)
+          end
+        end
+        private :cs_clusters
+
+        def fail_multiple_servers_not_support
+          fail NotImplementedError,
+              'Multiple clusters deployment not supported' if\
+              cs_servers.size > 1
+        end
+        private :fail_multiple_servers_not_support
+
+        # @return [Array<EnterpriseServers::Cluster>] clusters defined in
+        # +#infobase.clusters+ attached into {#sagent}
+        # @raise [RuntimeError] unsupport multiple servers infobase deployments
+        def clusters
+          fail_multiple_servers_not_support
+          cs_clusters.select do |cl|
+            cl.attach(sagent).infobase_include? ib_ref
+          end
+        end
+
+        def wp_connection
+          fail 'Infobase not exists' unless exists?
+          clusters[0].wp_connection(self)
+        end
+
+        # Helper
+        def ib_ref
+          ib.connection_string.ref
+        end
+
+        # @param session [InfoBase::Session]
+        def terminate(session)
+          session_get(session.id).each do |s|
+            s.terminate
+          end
+        end
+
+        # Helper select session per +ID+. In normal returns arry with single
+        # element or empty array
+        # @return [Array<EnterpriseServers::Wrappers::Session>]
+        def session_get(id)
+          sessions.select {|s| s.SessionId().to_s == id.to_s}
+        end
+
+        # @return [Array<EnterpriseServers::Wrappers::Session>] infobase
+        # sessions
+        def sessions
+          return [] unless exists?
+          clusters.map do |cl|
+            cl.infobase_sessions(ib_ref)
+          end.flatten
+        end
+
+        # Dlete infobase.
+        # @note For first item calls {EnterpriseServers::Cluster#drop_infobase!}
+        #   with real +mode+ and uses mode == :alive_db for all other.
+        #   Otherwise when mode == :destroy_db raises error
+        #   "Не найдена база данных * в SQL-сервере *"
+        # @param mode (see Cluster#drop_infobase!)
+        def drop_infobase!(mode)
+          clusters.each_with_index do |cl, index|
+            cl.drop_infobase!(self, (index == 0 ? mode : :alive_db))
+          end
+        end
       end
     end
   end