FWD » Core Development » Database

** Copyright (c) 2020-2022, Golden Code Development Corporation.

**     IAS 20220327 Added 'registerMBean' method.

    * Register MBean

    * 

    * @param mbean

    *        MBean to be registered 

    * @param name

    *        MBean name 

    */

   public void registerMBean(Object mbean, String name)

   {

      try

      {

         MBeanServer server = ManagementFactory.getPlatformMBeanServer();

         server.registerMBean(mbean, new ObjectName("com.goldencode.p2j:name=" + name));

      } 

      catch (Exception e)

      {

         LOG.log(Level.SEVERE, "MBean registratiion faild", e);

      }

   }

   /**

    * Register MBean

    * 

    * @param mbean

    *        MBean to be registered 

    * @param name

    *        MBean name 

    */

   public static void register(Object mbean, String name)

   {

      Holder.INSTANCE.registerMBean(mbean, name);

   }

   /**

       * @param    ts

       *           The measurement time stamp

       * @param    comment

       *           The comment

       * 

       * @return   The string representation of the counter

       * 

       * @throws   IOException

       *           If IO exception occurs

       *        The measurement time stamp

       *         If IO exception occurs

       * 

       * @param    ts

       *           The measurement time stamp

       * @param    comment

       *           The comment

       * 

       * @return   The string representation of the counter

       * 

       * @throws   IOException

       *           If IO exception occurs

    *         If IO exception occurs

/*

** Module   : LockTableUpdaterStat.java

** Abstract : LockTableUpdater JMX instrumentation. 

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

** -#- -I- --Date-- ---------------------------------Description----------------------------------

** 001 IAS 20230327 Created initial version.

*/ 

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.jmx;

/** LockTableUpdater JMX instrumentation */

public class LockTableUpdaterStat

implements LockTableUpdaterStatMBean

{

   /** LockTableUpdater worker */

   private final LockTableUpdaterStatMBean worker;

   /**

    * Constructor.

    * @param worker

    *        LockTableUpdater worker

    */

   public LockTableUpdaterStat(LockTableUpdaterStatMBean worker)

   {

      super();

      this.worker = worker;

   }

   /**

    * Get number of processed lock events.

    * @return number of processed lock events.

    */

   @Override

   public long getLockEvents()

   {

      return worker.getLockEvents();

   }

   /**

    * Get number of active locks

    * @return number of active locks.

    */

   @Override

   public long getActiveLocks()

   {

      return worker.getActiveLocks();

   }

   /**

    * Get number of locks in VST.

    * @return number of locks in VST.

    */

   @Override

   public long getPersistedLocks()

   {

      return worker.getPersistedLocks();

   }

   /**

    * Get number of VST records deleted not in batch.

    * @return number of VST records deleted not in batch.

    */

   @Override

   public long getDeletesFromVST()

   {

      return worker.getDeletesFromVST();

   }

   /**

    * Get number of 'persist' calls.

    * @return number of 'persist' calls.

    */

   @Override

   public long getPersistCalls()

   {

      return worker.getPersistCalls();

   }

   /**

    * Force 'persist' call

    */

   @Override

   public void flush()

   {

      worker.flush();

   }

}

/*

** Module   : LockTableUpdaterStatMBean.java

** Abstract : LockTableUpdater JMX instrumentation interface. 

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

** -#- -I- --Date-- ---------------------------------Description----------------------------------

** 001 IAS 20230327 Created initial version.

*/ 

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.jmx;

/** LockTableUpdater JMX instrumentation interface. */

public interface LockTableUpdaterStatMBean

{

   /**

    * Get number of processed lock events.

    * @return number of processed lock events.

    */

   public long getLockEvents();

   /**

    * Get number of active locks

    * @return number of active locks.

    */

   public long getActiveLocks();

   /**

    * Get number of locks in VST.

    * @return number of locks in VST.

    */

   public long getPersistedLocks();

   /**

    * Get number of VST records deleted not in batch.

    * @return number of VST records deleted not in batch.

    */

   public long getDeletesFromVST();

   /**

    * Get number of 'persist' calls.

    * @return number of 'persist' calls.

    */

   public long getPersistCalls();

   /**

    * Force 'persist' call

    */

   public void flush();

}

** Copyright (c) 2004-2022, Golden Code Development Corporation.

**     IAS 20220324          Re-worked LockTableUpdater.

            LockTableUpdater ltu = new LockTableUpdater(primaryDB, metaDB);

   public static LockTableUpdater getLockTableUpdater(Database database)

**     IAS 20220324          Re-worked LockTableUpdater.

**     IAS 20220324          Re-worked LockTableUpdater.

      if (legacyName.equalsIgnoreCase("_Trans"))

** Copyright (c) 2013-2022, Golden Code Development Corporation.

**     IAS 20220324 Performance optimization in the UserTableStatUpdater style.

import java.util.concurrent.*;

import java.util.concurrent.atomic.*;

import java.util.concurrent.locks.*;

import javax.management.loading.*;

import org.apache.jasper.tagplugins.jstl.core.*;

import com.goldencode.p2j.jmx.*;

    * @param   primary 

    *          Primary database

   public LockTableUpdater(Database primary, Database metaDatabase)

   {

      this.worker = new UpdateWorker(

                        PersistenceFactory.getInstance(metaDatabase),

                        primary);

   }

   /**

    * Persist locks in the meta database

    */

   public void persist()

   {

      worker.persist();

   }

   implements LockTableUpdaterStatMBean

      /** SQL query to find a lock record by PK */

               "select m." + Session.PK + " from " + LOCK_TABLE + " m " +

               "where m." + Session.PK + " = ?1";

      /** Number of processed lock events. */

      private static final AtomicLong lockEvents = new AtomicLong(0);

      /** Number of records in VST. */

      private static final AtomicLong persistedLocks = new AtomicLong(0);

      /** Number of VST records deleted not in batch. */

      private static final AtomicLong deletesFromVST = new AtomicLong(0);

      /** Number of 'persist' calls */

      private static final AtomicLong persistCalls = new AtomicLong(0);

      /** Executor for operations with VST */

      private final Executor executor = Executors.newSingleThreadExecutor(

               new ThreadFactory()

               {

                  @Override

                  public Thread newThread(Runnable r)

                  {

                     Thread workThread = new AssociatedThread(r);

                     workThread.setDaemon(true);

                     workThread.setName("Lock metadata update thread");

                     return workThread;

                  }

               }

      );

      /** Locks' map */

      private final ConcurrentMap<LockRecId, MinimalLockImpl> locks = new ConcurrentSkipListMap<>();

      /** Map version */

      private final AtomicLong mapVersion = new AtomicLong();

      /** Meta table vesrion */

      private final AtomicLong databaseVersion = new AtomicLong(0);

      /** Locks' map guard */

      private final ReentrantReadWriteLock guard = new ReentrantReadWriteLock();

      /** database name */

      private final Database primary;

      private AtomicLong nextPrimaryKey = new AtomicLong(1L);

      UpdateWorker(Persistence persistence, Database primary)

         this.primary = primary;

         FwdJMX.register(new LockTableUpdaterStat(this), primary.getName() + ".locks");

         executor.execute(() -> {}); // start executor

      }

      /**

       * Submit persisting locks task to the meta database and wait for end

       */

      public void persist()

      {

         CountDownLatch latch = new CountDownLatch(1);

         executor.execute(() -> {

            try 

            {

               doPersist();

               latch.countDown();

            }

            catch(Throwable t)

            {

               log.log(Level.WARNING, "Failed to persist lock table data", t);

            }

         });

         try

         {

            latch.await();

         }

         catch (InterruptedException ignore)

         {

         }

      }

      /**

       * Persist locks to the meta database

       */

      public void doPersist()

      {

         persistCalls.incrementAndGet();

         guard.writeLock().lock();

         try

         {

            if (databaseVersion.get() >= mapVersion.get())

            {

               return;

            }

            for(Iterator<Map.Entry<LockRecId, MinimalLockImpl>> it = locks.entrySet().iterator();

                it.hasNext(); )

            {

               Map.Entry<LockRecId, MinimalLockImpl> e = it.next();

               e.getValue().persist();

               if (e.getValue().deleted)

               {

                  it.remove();

               }

            }

            databaseVersion.set(mapVersion.get());

         }

         finally

         {

            guard.writeLock().unlock();

         }

      }

         lockEvents.incrementAndGet();

         guard.readLock().lock();

            mapVersion.incrementAndGet();

            LockRecId lrId = new LockRecId(event);

            if (event.getNewType() == LockType.NONE )

            {

               MinimalLockImpl ml = locks.remove(lrId);

               if (ml != null && ml.persisted.get() >= 0) 

               {

                  // lock was already persisted, VST cleanup is required

                  ml.guardedUpdate(event);

                  executor.execute(() -> {

                     try

                     {

                        if (ml.persist())

                        {

                           deletesFromVST.incrementAndGet();

                        }

                     }

                     catch(Throwable t)

                     {

                       log.log(Level.WARNING, "Cannot delete lock data for " + ml.eventString, t); 

                     }

                  });

               }

               return;

            }

            MinimalLockImpl ml = locks.computeIfAbsent(lrId, k -> new MinimalLockImpl(event));

            if (!ml.version.compareAndSet(-1, 0)) // not a new lock, should be updated

            {

               ml.guardedUpdate(event);

            guard.readLock().unlock();

      public long getLockRecordID(RecordLockEvent event) 

         Integer fileNum;

         if (MetadataManager.inUse(MetadataManager._FILE))

            // converted table name is stored in MetaFile.userMisc

            fileNum = MetadataManager.getFileNum(primary, table);

            if (fileNum == null)

            {

               String msg = "Table '" + table + "' not found in metadata [" + event.toString() + "]";

               throw new IllegalStateException(msg);

            }

         }

         else

         {

            // the _File metadata is not available

            fileNum = 0;

         }

      /** In-memory holder for the _Lock VST data*/ 

      private class MinimalLockImpl

      {

         /** Lock guard */

         public final ReentrantReadWriteLock guard = new ReentrantReadWriteLock();

         /** Lock version */

         public final AtomicLong version = new AtomicLong(-1);

         /** Lock version last persisted */

         public final AtomicLong persisted = new AtomicLong(-1);

         /** Flag indicating that the corresponding record was already deleted in VST */

         public volatile boolean deleted = false;

         /** Primary key */

         public final long key;

         /** Lock Id */

         public final int64 lockId;

         /** User */

         public final integer lockUsr;

         /** Lock name */

         public final character lockName;

         /** Table fileNum */ 

         public final integer lockTable;

         /** Record Id */

         public final int64 lockRecid;

         /** Chain */

         public final integer lockChain;

         /** Old lock type */

         private LockType oldType;

         /** New lock type */

         private LockType newType;

         /** Lock type string */

         private character lockType;

         /** Lock flags */

         private character lockFlags;

         /** Event string representation (for logging) */

         private String eventString;

         /**

          * Constructor

          * 

          * @param event

          *        Lock event

          */

         public MinimalLockImpl(RecordLockEvent event)

         {

            key = nextPrimaryKey.incrementAndGet();

            // set user name and user id

            String subject = event.getOsUserName();

            if (subject == null)

            {

               subject = event.getLocker().getSubject();

            }

            character userName = new character(subject);

            lockName = userName;

            lockUsr = event.getUserid();

            // get file number for table

            Integer fileNum = getFileNum(event);

            // assign other properties that will not change with new events

            lockId = new int64(key);    // re-use primary key

            lockTable = new integer(fileNum);

            lockRecid = new int64(getLockRecordID(event));

            // In ProgressOE, the locking table is divided into chains anchored in a hash table.

            // These chains are provided for fast lookup of record locks by Rec-id.

            // FWD OTOH, relies on underlying database for recid/rowid lookup so the chain is at

            // least irrelevant. In order to have a substitute and keep things simple, we will

            // assume that each table has a single chain and its value is computed as an fixed

            // offset from the table ID.

            lockChain = new integer(fileNum + CHAIN_OFFSET);

            update(event);

         }

         /** 

          * Guarded update holder with event data

          * @param event 

          *        lock event

          *  

          */ 

         public void guardedUpdate(RecordLockEvent event)

         {

            guard.writeLock().lock();

            try

            {

               update(event);

               version.incrementAndGet();

            }

            finally

            {

               guard.writeLock().unlock();

            }

         }

         /** 

          * Update holder with event data

          * @param event 

          *        lock event

          *  

          */ 

         public void update(RecordLockEvent event)

         {

            this.oldType = event.getOldType();

            this.newType = event.getNewType();

            String code = newType.isExclusive() ? "X" : "S"; // TODO:  get this right

            if (oldType.isShare())

            {

               code += " U"; // an upgrade

            }

            // From ABL online manual: values of flags field specify:

            //    S: a share lock,

            //    X: an exclusive lock,

            //    U: a lock upgraded from share to exclusive,

            //    L: a lock in limbo,

            //    Q: a queued lock,

            //    K: a lock kept across transaction end boundary,

            //    J: a lock is part of a JTA transaction,

            //    C: a lock is in create mode for JTA,

            //    E: a lock wait timeout has expired on this queued lock.

            this.lockFlags = new character(code);

            boolean isTable = (event.getIdentifier() instanceof TableIdentifier);

            this.lockType = new character(isTable ? "TAB" : "REC");

            this.eventString = String.format("%s: %d[%d, %d]", event.toString(), 

                     key, lockRecid.longValue(), lockUsr.intValue());

         }

         /** Create record in the _Lock VST */

         private Record createRecord() throws PersistenceException

         {

            Record dmo = null;

            try

            {

               // create new DMO instance and back the proxy with it

               dmo = dmoClass.newInstance();

               dmo.initialize(null, true);

               handler.setDelegate(dmo);

               // assign primary key

               dmo.primaryKey(key);

               // lock meta record for writing

               RecordIdentifier<String> metaIdent = new RecordIdentifier<>(dmoClass.getName(),

                        dmo.primaryKey());

               persistence.lock(LockType.EXCLUSIVE, metaIdent, true);

               proxy.setLockName(lockName);

               proxy.setLockUsr(lockUsr);

               proxy.setLockId(lockId); // re-use primary key

               proxy.setLockTable(lockTable);

               proxy.setLockRecid(lockRecid);

               proxy.setLockChain(lockChain);

            }

            catch (InstantiationException | IllegalAccessException exc)

            {

               String msg = String.format("Error creating meta lock record for event %s",

                        eventString);

               throw new PersistenceException(msg, exc);

            }

            return dmo;

         }

         /** Find record in the _Lock VST */

         private Record findRecord() throws PersistenceException

         {

            Long id = persistence.getSingleSQLResult(SQL_LOCK, new Object[] { key });

            Record dmo = null;

            if (id != null)

            {

               RecordIdentifier<String> metaIdent = new RecordIdentifier<>(dmoClass.getName(),

                        id);

               persistence.lock(LockType.EXCLUSIVE, metaIdent, true);

               dmo = persistence.quickLoad(metaIdent);

            }

            if (dmo == null)

            {

               throw new PersistenceException(

                        "No lock record found for lock event:  " + eventString);

            }

            handler.setDelegate(dmo);

            return dmo;

         }

         /** 

          * Guarded persist lock data in the _Lock VST. 

          * @return <code>true</code> if success

          */

         public boolean persist()

         {

            guard.writeLock().lock();

            try

            {

               return doPersist();

            }

            finally