scopeable_6650_patch_20220906a.patch

Constantin Asofiei, 09/06/2022 02:23 PM

     **     CA  20220405          Added authentication and authorization for web requests.  When this is enabled,
     **                           the target API call will be executed under the authenticated FWD context, and not
     **                           the agent's context.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     **     CA  20220906          Moved the interactive client cleaner to LogicalTerminal.registerCleaner().
     */
     /*
-...
        /**
         * Register default services:
         * <ol>
         * <li> {@link SharedVariableManager} </li>
         * <li> {@link UnnamedStreams} </li>
         * <li> {@link LogicalTerminal} </li>
         * <li> {@link Persistence} </li>
         * <li> {@link AccumulatorManager} </li>
         * <li> {@link WebServer} </li>
         * <li> custom account extension plugin </li>
         * </ol>
-...
              @Override
              public void initialize()
+             {
                 SharedVariableManager.initialize();
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 UnnamedStreams.initialize();
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 LogicalTerminal.initialize();
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 ServerKeyStore.initialize();
+             }
           });
-...
+                }
+             }
           });
           serverHooks.add(new AbstractInitTermListener()
+          {
              @Override
              public void initialize()
+             {
                 AccumulatorManager.initialize();
+             }
           });
           // register controller for method execution tracing
           serverHooks.add(new AbstractInitTermListener()
+          {
-...
                                        false,
                                        false);
           // make sure that the global block gets a special notification - but only for non-appserver sessions.
           LogicalTerminal.registerCleaner();
           Object result = null;
           try
+          {

     **                           DmoMeta to avoid duplicating their collection and storage.
     **     OM  20220726          Added recordAlreadyFound flag for block next/prev iterations on unique
     **                           find-by-rowid queries.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     */
     /*
-...
+       {
           closed = false;
           int scope = TransactionManager.findNearestExternal();
           int scope = BufferManager.get().findNearestExternal();
           RecordBuffer[] buffers = getRecordBuffers();
           for (RecordBuffer buffer : buffers)

     **                           were added to the collection during iterating it, resulting in a
     **                           ConcurrentModificationException (refs #6356).
     **     CA  20220707          Cache the converted Java names for the dynamic buffers.
     **     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the
     **                           registration is now specific to each type of scopeable.  For each case, the block
     **                           will be registered for scope support (for that particular scopeable) only when
     **                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This
     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     **     CA  20220906          Removed state which is no longer used (PersistentProcScope.loadedBuffers and
     **                           undoData) and removed methods which are not being invoked.
     **                           Moved the parameter assigner scopeable support to AbstractParameter (as all
     **                           parameters require scope support, not just fields).
     **                           Extracted all BufferManager state which requires notification for
     **                           'isImportantBlock' to an external TxWrapper class (including the private class
     **                           here), to allow the scopeable BufferManager state related only to buffers (and
     **                           not transaction related) to be registered for scope notifications in a lazy
     **                           manner, when buffers are accessed/used/opened.
     */
     /*
-...
     import com.goldencode.p2j.oo.lang.*;
     import com.goldencode.p2j.persist.dirty.*;
     import com.goldencode.p2j.persist.id.*;
     import com.goldencode.p2j.persist.lock.*;
     import com.goldencode.p2j.persist.orm.*;
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.LogHelper;
     import com.goldencode.p2j.util.ErrorManager;
     import com.goldencode.util.*;
     import com.goldencode.util.Stack;
     /**
      * Manages all record buffers within the current user context.  This includes
-...
      */
     public final class BufferManager
     implements Scopeable,
                Commitable,
                BatchListener,
                StopConditionVetoHandler,
                Resettable
                StopConditionVetoHandler
+    {
        /** Logger */
        private static final Logger LOG = LogHelper.getLogger(BufferManager.class.getName());
-...
           @Override protected BufferManager initialValue() { return (new BufferManager()); }
        };
        /** Flag indicating whether class was initialized, i.e. {@link #initialize} was called */
        private static boolean initialized = false;
        /** A cache of buffer-related fields defined in a specific legacy-converted class. */
        private static final Map<Class<?>, Set<Field>> classBufferFields = new ConcurrentHashMap<>();
-...
        // intentionally package private for direct use from RecordBuffer
        final Map<BufferType, MutableInteger> changeScopes = new HashMap<>();
        /** Transaction finalizable to manage transaction state locally (avoid context-local calls) */
        private final Finalizable xactFin = new Finalizable()
+       {
           @Override public void finished() { transactionDepth = -1; }
           @Override public void deleted()  { }
           @Override public void iterate()  { }
           @Override public void retry()    { }
        };
        /** Finalizable which clears batch mode at the appropriate times */
        private final Finalizable batchCleaner = new Finalizable()
+       {
-...
           @Override public void iterate()  { RecordBuffer.cleanupBatchMode(BufferManager.this); }
           @Override public void retry()    { RecordBuffer.cleanupBatchMode(BufferManager.this); }
        };
        /** Field assigner for function/procedure parameter assign-backs */
        private final Scopeable fieldScopes = FieldAssigner.getScopeable();
        /** The buffers which will be registered on the next scope entry. */
        private final Set<RecordBuffer> pendingBuffers = Collections.newSetFromMap(new IdentityHashMap<>());
-...
         */
        private final ScopedDictionary<Object, Map<String, RecordBuffer>> byLegacyName = new ScopedDictionary<>();
        /**
         * Scoped dictionary which key set contains all buffers into which a new record was loaded (or
         * the old record was reloaded) into corresponding scopes. Value set doesn't contain any useful
         * information and is used as a temporary data storage during copying from one scope level to
         * another.
         */
        private final ScopedDictionary<RecordBuffer, Boolean> loadedBuffers = new ScopedDictionary<>();
        /** Buffers whose scopes have been opened, but are not yet initialized */
        private final Map<RecordBuffer, Boolean> uninitializedOpenBuffers = new WeakHashMap<>();
-...
        private final ScopedList<RecordBuffer> openBuffers = new ScopedList<>();
        /**
         * The buffers touched via a Create, Update or Delete operation, in each scope. If the full transaction
         * block is not {@link #commit committed} or {@link #rollback rolled back}, then the buffers will be merged
         * in the previous scope.
         */
        private final TailScopedDictionary<RecordBuffer, Boolean> dirtyBuffers = new TailScopedDictionary<>();
        /**
         * Scoped dictionary which contains currently active static temp tables (i.e. table scope was
         * opened and not yet closed). Keyed by a {@code TempTableKey} compound from the legacy table
         * name and the procedure where the temp table was defined.
-...
        private final ScopedDictionary<OutputTableHandleCopier, Integer> thOutputParameters =
           new ScopedDictionary<>();
        /** Database to transaction wrapper instance map */
        private final Map<Database, TxWrapper> txWrapperMap = new HashMap<>();
        /** Transaction wrappers not yet activated */
        private final Map<Database, TxWrapper> inactiveTxWrappers = new HashMap<>();
        /** Track the external scopes pushed on {@link BufferManager}. */
        private final Stack<Boolean> externalScope = new Stack<>();
        /** Active persistence contexts (those which have an open database session) */
        private final Set<Persistence.Context> activePersistenceContexts = Collections.newSetFromMap(new IdentityHashMap<>());
        /** All undoable actions scoped by block and keyed by buffer type */
        private final ScopedDictionary<BufferType, UndoData> undoData = new ScopedDictionary<>();
        /** Stack of batch mode data */
        private final ArrayDeque<BatchModeData> batchModeStack = new ArrayDeque<>();
-...
        /** Helper to use the ProcedureManager without any context local lookups. */
        private final ProcedureManager.ProcedureHelper pm = ProcedureManager.getProcedureHelper();
        /** Counter of in-use buffers for each database. */
        private final Map<Database, MutableInteger> activeDatabases = new HashMap<>();
        /** Transaction helper */
        private final TransactionManager.TransactionHelper txHelper;
        /** Block depth at which full application transaction began, or -1 if not in a transaction */
        private int transactionDepth = -1;
        /** Tx wrapper helper. */
        private TxWrapper.TxWrapperHelper txWrapperHelper;
        /** Change broker instance. */
        private final ChangeBroker changeBroker;
        /** Connection manager */
        private ConnectionManager connMgr = null;
        /** Context-local access to unique constraint tracker */
        private UniqueTracker.Context uniqueTrackerCtx = UniqueTracker.getContext();
        /** Number of nested queries being processed */
        private int queryDepth = 0;
        /** Counter of the number of scope transitions (push or pop) */
        private long scopeTransitions = 0L;
        /** Counter of the number of application-level transactions */
        private long transactionCount = 0L;
        /** Map of bound buffers to there destination, for each procedure. */
        private Map<TemporaryBuffer, Map<Object, Set<TemporaryBuffer>>> bindingBuffers = new IdentityHashMap<>();
-...
        private BufferManager()
+       {
           byLegacyName.setIdentityKeys(true);
           loadedBuffers.setIdentityKeys(true);
           dirtyBuffers.setIdentityKeys(true);
           thOutputParameters.setIdentityKeys(true);
           txHelper = TransactionManager.getTransactionHelper();
           txHelper.registerBatchListener(this);
           txHelper.registerStopVetoHandler(this);
           txHelper.registerResettable(this);
           changeBroker = ChangeBroker.get();
           if (LOG.isLoggable(Level.FINE))
+          {
-...
+       }
        /**
         * Retrieve the context-local instance of this class, instantiating it
         * first if necessary.
         * Retrieve the context-local instance of this class, instantiating it first if necessary.
+        *
         * @return  Context-local instance of this class.
         * @throws  IllegalStateException
         *            when {@link BufferManager} is not activated, i.e. {@link
         *            #initialize()} is not called.
         */
        public static BufferManager get()
+       {
           if (!BufferManager.initialized)
+          {
              throw new IllegalStateException(
                 "An attempt to use uninitialized BufferManager. Is persistence activated?");
+          }
           BufferManager bm = context.get();
           if (bm.connMgr == null)
+          {
-...
                 throw new RuntimeException("Multiple ConnectionManager in same context.");
+             }
+          }
           if (bm.txWrapperHelper == null)
+          {
              bm.txWrapperHelper = TxWrapper.getHelper(bm);
+          }
           return bm;
+       }
        /**
         * Register the {@link BufferManager} instance as for scope notifications at the current block.
+        *
         * @param    bufferManager
         *           The {@link BufferManager} instance.
         */
        public static void registerScopeable(BufferManager bufferManager)
+       {
           if (bufferManager == null)
+          {
              bufferManager = get();
+          }
           // both ChangeBroker and BufferManager need to be added
           bufferManager.txHelper.registerBlockScopeable(bufferManager);
           bufferManager.txHelper.registerBlockScopeable(bufferManager.changeBroker);
+       }
        /**
         * Register the {@link BufferManager} instance as pending scopeable, to be added to the next block.
+        *
         * @param    bufferManager
         *           The {@link BufferManager} instance.
         */
        public static void registerPendingScopeable(BufferManager bufferManager)
+       {
           if (bufferManager == null)
+          {
              bufferManager = get();
+          }
           // both ChangeBroker and BufferManager need to be added
           bufferManager.txHelper.registerPendingScopeable(bufferManager);
           bufferManager.txHelper.registerPendingScopeable(bufferManager.changeBroker);
+       }
        /**
         * Register the {@link TxWrapper} scopeable as pending for the next opened block.
+        *
         * @param    bufferManager
         *           The {@link BufferManager} instance.
         */
        public static void registerTxScopeable(BufferManager bufferManager)
+       {
           if (bufferManager == null)
+          {
              bufferManager = get();
+          }
           bufferManager.txWrapperHelper.registerPendingScopeable();
+       }
        /**
         * Cleanup of pending resources. This is called when the external procedure constructor failed
         * to build a new object because of an exception thrown in a member initialization (shared
         * frame/table).
-...
           bm.pendingBufferClasses.clear();
           bm.pendingStaticTempTables.clear();
+       }
        /**
         * Register with the {@link com.goldencode.p2j.util.TransactionManager
         * TransactionManager} a factory object which creates instances of this
         * class, so that they can be registered to receive notifications of
         * runtime scope start and finish events.
         * <p>
         * This method should be invoked once during the server bootstrap phase.
         */
        static void initialize()
+       {
           TransactionManager.registerScopeableFactory(BufferManager::get);
           BufferManager.initialized = true;
+       }
        /**
         * Register this buffer as 'dirty' in the current scope.
         * <p>
-...
         */
        public void registerDirtyBuffer(RecordBuffer recordBuffer)
+       {
           dirtyBuffers.addEntry(false, recordBuffer, false);
           // although no state in BufferManager is touched when registering a dirty buffer, we need to register
           // it with the current block, as there is logic dependent on the 'depth' of the application stack which
           // uses buffers
           registerScopeable(this);
           txWrapperHelper.registerDirtyBuffer(recordBuffer);
+       }
        /**
-...
+       }
        /**
         * A full transaction or sub-transaction is committing. Notify all dirty buffers in the current scope.
+        *
         * @param   transaction
         *          {@code true} if full transaction; {@code false} if sub-transaction.
         */
        @Override
        public void commit(boolean transaction)
+       {
           Map<RecordBuffer, Boolean> buffers = dirtyBuffers.getDictionaryAtScope(0, false);
           if (buffers != null && !buffers.isEmpty())
+          {
              for (RecordBuffer buf : buffers.keySet())
+             {
                 buf.commit(transaction);
+             }
              if (transaction)
+             {
                 buffers.clear();
+             }
+          }
+       }
        /**
         * A full transaction or sub-transaction is rolling back. Notify all dirty buffers in the current scope.
+        *
         * @param   transaction
         *          {@code true} if full transaction; {@code false} if sub-transaction.
         */
        @Override
        public void rollback(boolean transaction)
+       {
           Map<RecordBuffer, Boolean> buffers = dirtyBuffers.getDictionaryAtScope(0, false);
           if (buffers != null && !buffers.isEmpty())
+          {
              for (RecordBuffer buf : buffers.keySet())
+             {
                 buf.rollback(transaction);
+             }
              if (transaction)
+             {
                 buffers.clear();
+             }
+          }
+       }
        /**
         * A block is exiting or iterating normally within a transaction. Notify all dirty buffers in the current
         * scope.
+        *
         * @param   transaction
         *          {@code true} if full transaction; {@code false} if sub-transaction.
         * @param   aggressiveFlush
         *          {@code true} if transaction manager is in aggressive subtransaction
         *          flush mode, indicating that any transient buffers should be validated and
         *          flushed, regardless of other state.
         */
        @Override
        public void validate(boolean transaction, boolean aggressiveFlush)
+       {
           TailMap<RecordBuffer, Boolean> buffers = dirtyBuffers.getDictionaryAtScope(0, false);
           if (buffers != null && !buffers.isEmpty())
+          {
              ArrayList<Map<RecordBuffer, Boolean>> validatedAddedDirtyBuffers = null;
              try (AutoCloseable itersafe = buffers.flagIterating())
+             {
                 for (RecordBuffer buf : buffers.keySet())
+                {
                    buf.validate(transaction, aggressiveFlush);
                    // The next block is rarely entered, only in edge cases.
                    // Details:
                    // The invocation of buf.validate can (for example) result in
                    // an ABL publish + subscribe (from an OEDB write trigger),
                    // resulting in more buffers that need to be validated.
                    // Since we are iterating, the extra buffers are added to
                    // a standalone 'tail' collection. We validate them immediately,
                    // and add them to dirtyBuffers after iterating has completed.
                    Map<RecordBuffer, Boolean> addedDirtyBuffers = buffers.pop();
                    while (addedDirtyBuffers != null)
+                   {
                       // Validate all additions
                       addedDirtyBuffers.keySet().forEach((v) -> v.validate(transaction, aggressiveFlush));
                       // Store the validated additions to add them afterwards
                       // A list is used for clarity and to facilitate possible
                       // removal logic in the future (which can't happen at the moment).
                       if (validatedAddedDirtyBuffers == null)
+                      {
                          validatedAddedDirtyBuffers = new ArrayList<>();
+                      }
                       validatedAddedDirtyBuffers.add(addedDirtyBuffers);
                       // Fetch possible new additions of the added validate invocations.
                       // We take control of this collection, at the TailMap it
                       // is forgotten.
                       addedDirtyBuffers = buffers.pop();
+                   }
+                }
+             }
              catch (Exception e)
+             {
                 throw new IllegalStateException("Exception at dirtyBuffers.flagIterating block", e);
+             }
              // The next block is rarely entered, only in edge cases, see above.
              if (validatedAddedDirtyBuffers != null)
+             {
                 for (Map<RecordBuffer, Boolean> bufmap : validatedAddedDirtyBuffers)
+                {
                    // Note: addEntry(false, ...) because:
                    //       We do not need the global scope.
                    //       At the top of this method, scope 0 is used, not scope -1 (global).
                    bufmap.forEach((k,v) -> dirtyBuffers.addEntry(false, k, v));
+                }
+             }
              // do not clear the buffers here, only commit/rollback can clear it
+          }
+       }
        /**
         * Query the scope level which currently is open. This is the number of &quot;important&quot; scopes;
         * NO_TRANSACTION blocks inside an application transaction are ignored. So, this number may be lower
         * than the actual number of nested block scopes open, as tracked by the {@code TransactionManager}.
-...
+       }
        /**
         * Find the nearest external block (from the bottom of the stack).
+        *
         * @return   See above.
         */
        public int findNearestExternal()
+       {
           int idx = externalScope.size() - 1;
           while (idx > 0)
+          {
              if (externalScope.get(idx))
+             {
                 return idx + 1;
+             }
              idx = idx - 1;
+          }
           return -1;
+       }
        /**
         * Check the specified exception and determine whether we want to allow it
         * to be honored by the {@link TransactionManager}, or whether we want to
         * veto the STOP at this scope.
-...
         */
        public void beginTx(boolean inTx, boolean fullTx, int blockDepth)
+       {
           if (inTx)
+          {
              if (fullTx)
+             {
                 // create a database xaction wrapper for each connected database, but do not
                 // activate it yet
                 txWrapperMap.clear();         // should be empty already
                 inactiveTxWrappers.clear();   // should be empty already
                 List<Database> databases = connMgr.getActiveDatabases();
                 for (Database database : databases)
+                {
                    createTxWrapper(database);
+                }
                 transactionDepth = blockDepth - 1;  // match TM transaction level
                 transactionCount++;
                 // register for master transaction finish/iterate to clear transaction depth
                 txHelper.registerTransactionFinish(xactFin, true);
+             }
              // register various services for callbacks if current block has transaction properties
              if (txHelper.currentTransactionLevel() != TransactionManager.NO_TRANSACTION)
+             {
                 // register savepoint manager for callbacks at full and sub-transaction blocks
                 for (TxWrapper txw : txWrapperMap.values())
+                {
                    txw.registerSavepointHooks(fullTx);
+                }
                 // register to get Commitable notifications for open buffers
                 txHelper.registerCommitAt(blockDepth - 1, this);
                 // register unique tracker context to get Commitable/Finalizable notifications
                 uniqueTrackerCtx.register(txHelper, blockDepth - 1);
+             }
+          }
           scopeTransitions++;
           if (fullTx)
+          {
              // activate a pending TxWrapper for any database with a buffer that already is open
              Iterator<Database> iter = activeDatabases.keySet().iterator();
              while (iter.hasNext())
+             {
                 Database database = iter.next();
                 maybeActivateTxWrapper(database);
+             }
+          }
           txWrapperHelper.beginTx(inTx, fullTx, blockDepth);
+       }
        /**
-...
         */
        public void endTx(boolean inTx, boolean fullTx)
+       {
           scopeTransitions++;
           txWrapperHelper.endTx(inTx, fullTx);
+       }
        /**
-...
        public void endTxPost()
+       {
           // if any DBs were used in this tx block and remained connected, disconnect now
           connMgr.transactionEnded();
           txWrapperHelper.endTxPost();
+       }
        /**
-...
        @Override
        public void scopeStart()
+       {
           if (!isImportantBlockTransition())
+          {
              // nothing to do
              return;
+          }
           BlockType bt = txHelper.getBlockType();
           if (bt.equals(BlockType.INTERNAL_PROC) ||
               bt.equals(BlockType.FUNCTION)      ||
-...
           allBuffers.addScope(null);
           byLegacyName.addScope(null);
           loadedBuffers.addScope(null);
           dirtyBuffers.addScope(null);
           openBuffers.pushScope();
           openStaticTempTables.addScope(null);
           thOutputParameters.addScope(null);
           undoData.addScope(null);
           fieldScopes.scopeStart();
           externalScope.push(txHelper.isExternalBlock());
           BatchModeData crtBatchScope = batchModeStack.peek();
           if (crtBatchScope != null && crtBatchScope.batchDepth == BatchModeData.INTERNAL)
-...
              LOG.log(Level.FINER,
                      Utils.describeContext() + ":  block scope " + blockDepth + " started");
+          }
           boolean inTx = txHelper.isTransaction();
           boolean fullTx = inTx && txHelper.isFullTransaction();
           beginTx(inTx, fullTx, blockDepth);
+       }
        /**
-...
        @Override
        public void scopeFinished()
+       {
           if (!isImportantBlockTransition())
+          {
              // nothing to do
              return;
+          }
           PersistentProcScope ppScope = null;
           if (!txHelper.isGlobalBlock())
-...
+             }
+          }
           // here we will be out of sync with the TM on a transaction boundary, because our
           // transaction depth is cleared with a transaction finalizable, which is called before this
           // scope finished notification, so we rely on the TM.isTransaction() instead of our own
           boolean inTx = txHelper.isTransaction();
           boolean fullTx = txHelper.isFullTransaction();
           endTx(inTx, fullTx);
           Map<RecordBuffer, Boolean> dirtyBufs = dirtyBuffers.getDictionaryAtScope(0, false);
           dirtyBuffers.deleteScope();
           if (dirtyBufs != null && !dirtyBufs.isEmpty() && dirtyBuffers.size() > 1)
+          {
              // do not merge into the global block, as all changes should have been already committed or rolled
              // back.  this is required as temporary buffers can be changed without an active transaction present
              // on the stack: in this case, they will be pushed to the previous scope until the global block is
              // reached, when they will be discarded.
              for (RecordBuffer buffer : dirtyBufs.keySet())
+             {
                 // merge into previous scope, but only buffers with records which were changed, as the record
                 // associated (at initial dirty registration of the buffer) may have been flushed to the database,
                 // and the current record may not be 'dirty'
                 if (buffer.getCurrentRecord() != null)
+                {
                    Record record = buffer.getCurrentRecord();
                    if (buffer.isTouched() ||
                        record.checkState(DmoState.NEW)      ||
                        record.checkState(DmoState.STALE)    ||
                        record.checkState(DmoState.DELETING) ||
                        record.checkState(DmoState.DELETED)  ||
                        record.checkState(DmoState.INVALID)  ||
                        record.checkState(DmoState.CHANGED)  ||
                        record.checkState(DmoState.TRACKED))
+                   {
                       dirtyBuffers.addEntry(false, buffer, false);
+                   }
+                }
+             }
+          }
           undoData.deleteScope();
           // Copy the set of buffers contained in the current scope of the
           // loadedBuffers (which is about to be removed) to the enclosing scope.
           // Only buffers which are open at the enclosing or a higher scope
           // should be copied.
           if (loadedBuffers.size() > 1)
+          {
              Set<RecordBuffer> currentLoadedBuffers = loadedBuffers.getDictionaryAtScope(0, false).keySet();
              Collection<RecordBuffer> currentOpenBuffers = openBuffers.sublistAtScope(0);
              for (RecordBuffer buffer : currentLoadedBuffers)
+             {
                 if (buffer.getOpenScopeCount() > 1 || !currentOpenBuffers.contains(buffer))
+                {
                    // if this buffer is missing at the current scope of open
                    // buffers or it presents there but has open scope count > 1,
                    // that means that it presents at a higher level and it should
                    // be copied to the enclosing scope
                    loadedBuffers.setValueAtScope(buffer, 1, false);
                    buffer.addLoadedBuffersScope(loadedBuffers.size() - 1);
+                }
+             }
+          }
           if (ppScope != null)
+          {
              // save the data for this external procedure, as these will need to be removed from the
              // global scope, when the procedure gets deleted.
              Map<RecordBuffer, Boolean> thisLoadedBuffers = loadedBuffers.getDictionaryAtScope(0, false);
              ppScope.loadedBuffers.putAll(thisLoadedBuffers);
              List<RecordBuffer> thisOpenBuffers = openBuffers.sublistAtScope(0);
              ppScope.openBuffers.addAll(thisOpenBuffers);
-...
              ppScope.openStaticTempTables.putAll(thisOpenStaticTempTables);
              // add all these to the global scope, too
              if (!thisLoadedBuffers.isEmpty())
+             {
                 loadedBuffers.getDictionaryAtScope(loadedBuffers.size() - 1, true)
                              .putAll(thisLoadedBuffers);
+             }
              if (!thisOpenBuffers.isEmpty())
+             {
                 openBuffers.addAll(true, thisOpenBuffers);
-...
+             }
+          }
           loadedBuffers.deleteScope();
           openBuffers.popScope();
           allBuffers.deleteScope();
           byLegacyName.deleteScope();
           fieldScopes.scopeFinished();
           openStaticTempTables.deleteScope();
           thOutputParameters.deleteScope();
           externalScope.pop();
           BatchModeData bmd = batchModeStack.pop();
           if (bmd.batchDepth == BatchModeData.INTERNAL)
+          {
-...
                      Utils.describeContext() + ":  block scope " + txHelper.getNestingLevel() + " finished");
+          }
           if (fullTx)
+          {
              endTxPost();
+          }
           maybeCloseSessions();
+       }
-...
         * Provides notification that the external procedure scope has been deleted.
         * <p>
         * If we are deleting a persistent procedure, clean all its data from the global scope for the
         * following dictionaries: {@link #loadedBuffers}, {@link #openBuffers}, {@link #allBuffers},
         * {@link #openStaticTempTables}.
         * following dictionaries: {@link #openBuffers}, {@link #allBuffers}, {@link #openStaticTempTables}.
         */
        @Override
        public void scopeDeleted()
-...
+          {
              // remove all these from the global scope
              if (!scope.loadedBuffers.isEmpty())
+             {
                 loadedBuffers.getDictionaryAtScope(loadedBuffers.size() - 1, true)
                              .keySet()
                              .removeAll(scope.loadedBuffers.keySet());
+             }
              if (!scope.openBuffers.isEmpty())
+             {
                 openBuffers.removeAllFrom(true, scope.openBuffers);
-...
+       }
        /**
         * Get the {@link ScopeId} for the instance.
+        *
         * @return   {@link ScopeId#BUFFER_MANAGER}.
         */
        @Override
        public ScopeId getScopeId()
+       {
           return ScopeId.BUFFER_MANAGER;
+       }
        /**
         * Provides a notification that a batch is starting or ending.  Enters or
         * exits batch assignment mode for all record buffers in this context,
         * depending on the value of <code>start</code>.
-...
+       }
        /**
         * Releases the buffers into which a new record was loaded (or the old
         * record was reloaded) into the current or deeper scopes, or only clears
         * the list of buffers pending to be released.
+        *
         * @param clearOnly
         *        If <code>true</code> then clear the list of buffers pending to be
         *        released, otherwise perform release of these buffers and clear
         *        the list after that.
         */
        public void resetState(boolean clearOnly)
+       {
           Map<RecordBuffer, Boolean> buffers = loadedBuffers.getDictionaryAtScope(0, false);
           if (buffers == null || buffers.isEmpty())
+          {
              return;
+          }
           if (!clearOnly)
+          {
              for (RecordBuffer buffer : buffers.keySet())
+             {
                 if (!buffer.isPendingRollbackProcessed())
+                {
                    buffer.release(false, false);
+                }
                 else
+                {
                    buffer.resetPendingRollbackProcessed();
+                }
+             }
+          }
           buffers.clear();
+       }
        /**
         * Marks the table for postponed delete, if it is possible. Postponed delete can take place if
         * the table is used as [INPUT-]OUTPUT TABLE-HANDLE parameter.
+        *
-...
         */
        public boolean isTransaction()
+       {
           return transactionDepth >= 0;
+       }
        /**
         * Check whether the block at the specified block depth is within an application-level
         * transaction.
+        *
         * @param   level
         *          Zero-based block depth (counting from the outermost scope).
+        *
         * @return  {@code true} if we are in a transaction, else {@code false}.
         */
        public boolean isTransactionAt(int level)
+       {
           return transactionDepth >= 0 && transactionDepth <= level;
+       }
        /**
         * Check whether the current block marks (and is within) the boundary of an application-level
         * full transaction.
+        *
         * @return  {@code true} if we are at (and within) a full transaction boundary, else {@code
         *          false}.
         */
        public boolean isFullTransaction()
+       {
           return transactionDepth >= 0 && getOpenBufferScopes() - 1 == transactionDepth;
+       }
        /**
         * Get the zero-based block depth (counting from the outermost scope) at which the current,
         * full, application-level transaction (if any) began.
+        *
         * @return  Zero-based block depth of current, full transaction, or -1 if we are not currently
         *          within a transaction.
         */
        public int getFullTransactionBlock()
+       {
           return transactionDepth;
           return txWrapperHelper.isTransaction();
+       }
        /**
-...
         */
        public long getScopeTransitions()
+       {
           return scopeTransitions;
           return txWrapperHelper.getScopeTransitions();
+       }
        /**
         * Get the open buffers from the current scope.
+        *
         * @return   See above.
         */
        Collection<RecordBuffer> getOpenBuffers()
+       {
           return openBuffers.scopes() == 0 ? Collections.EMPTY_LIST : openBuffers.sublistAtScope(0);
+       }
        /**
-...
         */
        long getTransactionCount()
+       {
           return transactionCount;
           return txWrapperHelper.getTransactionCount();
+       }
        /**
-...
              throw new UnsupportedOperationException(
                "A buffer can't be bound to more than one table in the same program!");
+          }
           dstBuffers.add(dstBuf);
           bindBuffer(dstBuf, srcBuf);
-...
+       }
        /**
         * Register an undoable which is responsible for setting the buffer's
         * proper current record after all reversibles are processed.
+        *
         * @param   buffer
         *          Record buffer for which a change is being tracked for undo
         *          purposes.  It is assumed the buffer has been initialized.
         * @param   undoTarget
         *          The undoable responsible with setting the buffer back to its
         *          proper record.
         */
        void registerBufferUndoable(RecordBuffer buffer, Undoable undoTarget)
+       {
           Map<BufferType, UndoData> dict = undoData.getDictionaryAtScope(0, true);
           RecordBuffer master = buffer.getMasterBuffer();
           BufferType key = master.getBufferType();
           if (dict != null)
+          {
              UndoData ud = dict.get(key);
              if (ud == null)
+             {
                 ud = new UndoData();
                 dict.put(key, ud);
+             }
              ud.bufferUndoable = undoTarget.deepCopy();
+          }
+       }
        /**
         * Register a newly defined record buffer in the current scope.  Buffers are deregistered
         * implicitly when the scope in which they were registered ends.
+        *
-...
         */
        void registerPending(Class<?> def, RecordBuffer buffer)
+       {
           registerPendingScopeable(this);
           pendingBuffers.add(buffer);
           registerPendingBufferClass(buffer, def);
-...
           int[] allBufferScopes = buffer.getAllBuferScopes();
           int[] byLegacyNameScopes = buffer.getByLegacyNameScopes();
           int[] loadedBuffersScopes = buffer.getLoadedBuffersScope();
           int[] openBuffersScopes = buffer.getOpenBuffersScope();
           int scopeSize = allBuffers.size();
-...
           // remove from global scope always
           // openBuffers.removeFrom(openScopes - 1, buffer);
           int loadedScopes = loadedBuffers.size();
           for (int scope : loadedBuffersScopes)
+          {
              int depth = loadedScopes - scope;
              Map<RecordBuffer, Boolean> loaded = loadedBuffers.getDictionaryAtScope(depth, false);
              if (loaded != null)
+             {
                 loaded.remove(buffer);
+             }
+          }
           // remove from global scope always
           Map<RecordBuffer, Boolean> loaded = loadedBuffers.getDictionaryAtScope(-1, false);
           if (loaded != null)
+          {
              loaded.remove(buffer);
+          }
           txWrapperHelper.deregisterDynamicBuffer(buffer);
           if (referent != null)
+          {
-...
+             {
                 procScope.allBuffers.remove(key);
                 byLegacy.accept(procScope.byLegacyName);
                 procScope.loadedBuffers.remove(buffer);
                 procScope.openBuffers.remove(buffer);
+             }
+          }
-...
         */
        void startBatchAssignMode(boolean internal)
+       {
           registerScopeable(this);
           int currentScope = getOpenBufferScopes();
           BatchModeData bmd = batchModeStack.peek();
-...
+       }
        /**
         * Remove all <code>Reversible</code> objects associated with the given buffer from their
         * respective scoped dictionaries.
+        *
         * @param   buffer
         *          Buffer associated with the <code>Reversible</code>s to be removed.
         */
        void removeAllReversibles(TemporaryBuffer buffer)
+       {
           // delete entries from current and parent scopes
           BufferType bufType = buffer.getMasterBuffer().getBufferType();
           undoData.removeEntryThroughScope(bufType, 1);
+       }
        /**
         * Called by {@link RecordBuffer} when a new buffer scope is opened. It registers the open scope with the
         * buffer manager, so that the buffer can receive block scope start and stop notifications, and be
         * registered for commit/rollback/validate processing when a full transaction is begun.
-...
         */
        void registerPendingStaticTempTable(StaticTempTable table, boolean global)
+       {
           registerPendingScopeable(this);
           pendingStaticTempTables.put(table, global);
+       }
-...
         */
        void openScopeAt(int openScopeDepth, RecordBuffer buffer)
+       {
           // TODO: this seems to be called only for 'openScopeDepth == 0'.
           if (buffer.isActive())
+          {
              if (openScopeDepth == 0)
-...
         */
        void maybeActivateTxWrapper(Database database)
+       {
           TxWrapper txw = inactiveTxWrappers.remove(database);
           if (txw != null)
+          {
              txw.activate();
+          }
           txWrapperHelper.maybeActivateTxWrapper(database);
+       }
        /**
-...
         */
        void notifyRecordWasLoaded(RecordBuffer recordBuffer)
+       {
           if (recordBuffer.getCurrentRecord() != null && !recordBuffer.isDynamic())
+          {
              pm.notifyStaticRecordWasLoaded(recordBuffer);
+          }
           if (recordBuffer.getCurrentRecord() == null || recordBuffer.isTemporary())
+          {
              return;
+          }
           loadedBuffers.addEntry(false, recordBuffer, false);
           recordBuffer.addLoadedBuffersScope(loadedBuffers.size());
           txWrapperHelper.notifyRecordWasLoaded(recordBuffer);
+       }
        /**
-...
+       }
        /**
         * Create an inactive transaction wrapper for the given database. It will be activated the
         * first time an open buffer scope is detected or when a new buffer scope is opened, at which
         * time a database-level transaction will be opened.
+        *
         * @param   database
         *          Database for which this transaction wrapper is created.
+        *
         * @return  Transaction wrapper object.
         */
        private TxWrapper createTxWrapper(Database database)
+       {
           TxWrapper txw = new TxWrapper(database);
           txWrapperMap.put(database, txw);
           inactiveTxWrappers.put(database, txw);
           return txw;
+       }
        /**
         * Compose a message suitable for logging.  Reports open buffer scopes and
         * context information in addition to a custom message.
+        *
         * @param   persistence
         *          Persistence object which will provide context info.
         * @param   text
         *          Custom message text.
+        *
         * @return  Composed message text.
         */
        private String message(Persistence persistence, String text)
+       {
           return persistence.message("scope " + getOpenBufferScopes() + ": " + text);
+       }
        /**
         * Add the source buffers to the destination map.
+        *
         * @param    dst
-...
         */
        private void trackDatabase(RecordBuffer buffer, boolean add)
+       {
           if (add)
+          {
              Database database = buffer.getDatabase();
              MutableInteger count = activeDatabases.get(database);
              if (count == null)
+             {
                 activeDatabases.put(database, count = new MutableInteger(0));
+             }
              count.set(count.get() + 1);
+          }
           else if (buffer.isActive() && buffer.getOpenScopeCount() > 0)
+          {
              Database database = buffer.getDatabase();
              MutableInteger count = activeDatabases.get(database);
              if (count == null)
+             {
                 throw new IllegalStateException("Tracking for " + database + " is unbalanced!");
+             }
              if (count.get() == 1)
+             {
                 activeDatabases.remove(database);
+             }
              else
+             {
                 count.set(count.get() - 1);
+             }
+          }
           txWrapperHelper.trackDatabase(buffer, add);
+       }
        /**
-...
         * @return  {@code true} if the block is considered &quot;important&quot; by the above criteria, else
         *          {@code false}.
         */
        private boolean isImportantBlockTransition()
+       {
           return !txHelper.isTransaction() ||
                  txHelper.currentTransactionLevel() != TransactionManager.NO_TRANSACTION;
+       }
        /**
         * Storage mechanism for maps of reversible/undoable actions, keyed by
         * primary key.  One instance of this class holds all such objects for a
         * single buffer in a single scope.
         */
        private static class UndoData
+       {
           /** Undoable which will set a no-undo buffer to its proper record after a rollback. */
           Undoable bufferUndoable;
+       }
        /**
         * An object which manages the "master" {@code Commitable} and {@code Finalizable} events of an
         * application transaction. It creates a database transaction to correspond with the application
         * transaction, and as it receives events from the {@code TransactionManager}, it delegates related
         * responsibilities to various components of the persistence framework.
         */
        private class TxWrapper
        implements Finalizable,
                   Commitable
+       {
           /** Backing database */
           private final Database database;
           /** Dirty share context */
           private final DirtyShareContext dirtyContext;
           /** Savepoint manager (can be {@code null} */
           private final SavepointManager savepointManager;
           /** Persistence context, for access to database session and transaction */
           private Persistence.Context persistenceCtx;
           /** Roll back the transaction when block finishes, if not previously acted upon */
           private boolean autoRollback = false;
           /** {@code true} for an initial transaction only until the first commit or rollback */
           private boolean initialTx = false;
           /**
            * The sole constructor.
+           *
            * @param   database
            *          The {@code Database} where the transaction takes place.
            */
           TxWrapper(Database database)
+          {
              this.database = database;
              // Because the BufferManager manages all record buffers within the current user context, we cannot
              // separate the DIRTY-READ from the normal tables at this moment. Since this instance is only used
              // for final cleanup, we acquire the context for the DIRTY-READ database so that context will be
              // cleaned up correctly. The non-DIRTY-READ information will be ignored.
              this.dirtyContext = DirtyShareFactory.getContextInstance(database);
              this.savepointManager =
                 (DatabaseManager.TEMP_TABLE_DB.equals((database)) && DatabaseManager.FORCE_NO_UNDO_TEMP_TABLES)
                 ? null
                 : new SavepointManager();
              // register for master transaction commit/rollback
              txHelper.registerTransactionCommit(this, true);
              // register for master transaction finish/iterate
              txHelper.registerTransactionFinish(this, true);
+          }
           /**
            * Implementation of {@code Finalizable} interface: provides a notification that the block whose scope
            * in which the object is registered is about to iterate and attempt another pass.  This provides an
            * opportunity to preserve state from the previous pass and make preparations for the coming pass.
            */
           @Override
           public void iterate()
+          {
              if (!isActive())
+             {
                 return;
+             }
              if (LOG.isLoggable(Level.FINE))
+             {
                 LOG.log(Level.FINE, message(persistenceCtx.getPersistence(), "master transaction iterate"));
+             }
              end();
              begin();
+          }
           /**
            * Implementation of {@code Finalizable} interface: provides a notification that the block whose scope
            * in which the object is registered is about to retry the same iteration (all loop control data is
            * unchanged). This provides an opportunity to clear or reset state from the previous pass.
            */
           @Override
           public void retry()
+          {
              if (!isActive())
+             {
                 return;
+             }
              if (LOG.isLoggable(Level.FINE))
+             {
                 LOG.log(Level.FINE,
                         message(persistenceCtx.getPersistence(), "master transaction retry"));
+             }
              end();
              begin();
+          }
           /**
            * Implementation of {@code Finalizable} interface: Provides a notification that the scope in which the
            * object is registered is ending and the object's reference may or may not be lost after this method
            * is called. This provides a natural and standard mechanism to clean-up any resources that may need
            * to be closed explicitly such as operating system files or sockets.
            */
           @Override
           public void finished()
+          {
              try
+             {
                 if (autoRollback)
+                {
                    if (isActive() && LOG.isLoggable(Level.FINE))
+                   {
                       LOG.log(Level.FINE,
                               message(persistenceCtx.getPersistence(), "triggering auto-rollback"));
+                   }
                    rollback(true);
+                }
+             }
              finally
+             {
                 if (isActive() && LOG.isLoggable(Level.FINE))
+                {
                    LOG.log(Level.FINE,
                            message(persistenceCtx.getPersistence(), "master transaction finished"));
+                }
                 txWrapperMap.remove(database);
                 if (!isActive())
+                {
                    inactiveTxWrappers.remove(database);
                    return;
+                }
                 end();
+             }
+          }
           /**
            * Implementation of {@code Finalizable} interface: provides a notification that the external program
            * in which the object is registered is being deleted and the object's reference may be lost after this
            * method is called.
            */
           @Override
           public void deleted()
+          {
              // no-op
+          }
           /**
            * Implementation of {@code Commitable} interface: saves any temporary state to the persistent form or
            * storage that is associated with this class.
+           *
            * @param    transaction
            *           {@code true} if this is a full transaction and {@code false} if this is only a
            *           sub-transaction (a nested scope with transaction support).
            */
           @Override
           public void commit(boolean transaction)
+          {
              if (!isActive())
+             {
                 return;
+             }
              if (LOG.isLoggable(Level.FINE))
+             {
                 LOG.log(Level.FINE,
                         message(persistenceCtx.getPersistence(), "master transaction commit"));
+             }
              try
+             {
                 initialTx = false;
                 autoRollback = false;
                 persistenceCtx.commit();
+             }
              catch (PersistenceException exc)
+             {
                 if (LOG.isLoggable(Level.SEVERE))
+                {
                    LOG.log(Level.SEVERE,
                            message(persistenceCtx.getPersistence(), "commit error"), exc);
+                }
                 // No good way to recover from this.  Let it abend.
                 throw new RuntimeException(exc);
+             }
              finally
+             {
                 // Reclaim any primary keys which had been waiting to be recycled,
                 // pending a commit.
                 if (DatabaseManager.TEMP_TABLE_DB.equals(database))
+                {
                    Commitable ctx = TemporaryBuffer.getContextCommitable();
                    ctx.commit(transaction);
+                }
+             }
+          }
           /**
            * Implementation of {@code Commitable} interface: notifies that a rollback has just occurred (all state
            * maintained through the {@link Undoable} interface has been already rolled back). This notification
            * can be used to implement cleanup of any custom state that needs to be maintained in this case. It can
            * also be used to implement a rollback that is completely independent of the {@code Undoable}
            * (externally driven) interface.
+           *
            * @param    transaction
            *           {@code true} if this is a full transaction and {@code false} if this is only a
            *           sub-transaction (a nested scope with transaction support).
            */
           @Override
           public void rollback(boolean transaction)
+          {
              if (!isActive())
+             {

... This diff was truncated because it exceeds the maximum size that can be displayed.

Project

General

Profile

FWD » Core Development » Base Language

scopeable_6650_patch_20220906a.patch