• Home
• io.snappydata
• gemfire-core
• 1.6.2.1
• source code
• BucketRegion.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.gemstone.gemfire.internal.cache.BucketRegion Maven / Gradle / Ivy

/*
 * Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License. You
 * may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License. See accompanying
 * LICENSE file.
 */
/*
 * Changes for SnappyData distributed computational and data platform.
 *
 * Portions Copyright (c) 2018 SnappyData, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License. You
 * may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License. See accompanying
 * LICENSE file.
 */

package com.gemstone.gemfire.internal.cache;

import java.io.DataOutput;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import com.gemstone.gemfire.*;
import com.gemstone.gemfire.cache.*;
import com.gemstone.gemfire.cache.hdfs.HDFSIOException;
import com.gemstone.gemfire.cache.hdfs.internal.AbstractBucketRegionQueue;
import com.gemstone.gemfire.cache.hdfs.internal.hoplog.HoplogOrganizer;
import com.gemstone.gemfire.cache.partition.PartitionListener;
import com.gemstone.gemfire.cache.query.internal.IndexUpdater;
import com.gemstone.gemfire.distributed.DistributedMember;
import com.gemstone.gemfire.distributed.DistributedSystem;
import com.gemstone.gemfire.distributed.internal.AtomicLongWithTerminalState;
import com.gemstone.gemfire.distributed.internal.DirectReplyProcessor;
import com.gemstone.gemfire.distributed.internal.DistributionAdvisor.Profile;
import com.gemstone.gemfire.distributed.internal.DistributionManager;
import com.gemstone.gemfire.distributed.internal.DistributionStats;
import com.gemstone.gemfire.distributed.internal.MembershipListener;
import com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember;
import com.gemstone.gemfire.i18n.LogWriterI18n;
import com.gemstone.gemfire.internal.Assert;
import com.gemstone.gemfire.internal.HeapDataOutputStream;
import com.gemstone.gemfire.internal.cache.BucketAdvisor.BucketProfile;
import com.gemstone.gemfire.internal.cache.FilterRoutingInfo.FilterInfo;
import com.gemstone.gemfire.internal.cache.control.MemoryEvent;
import com.gemstone.gemfire.internal.cache.delta.Delta;
import com.gemstone.gemfire.internal.cache.locks.ExclusiveSharedLockObject;
import com.gemstone.gemfire.internal.cache.locks.LockMode;
import com.gemstone.gemfire.internal.cache.locks.LockingPolicy.ReadEntryUnderLock;
import com.gemstone.gemfire.internal.cache.locks.ReentrantReadWriteWriteShareLock;
import com.gemstone.gemfire.internal.cache.partitioned.*;
import com.gemstone.gemfire.internal.cache.tier.sockets.CacheClientNotifier;
import com.gemstone.gemfire.internal.cache.tier.sockets.ClientTombstoneMessage;
import com.gemstone.gemfire.internal.cache.tier.sockets.ClientUpdateMessage;
import com.gemstone.gemfire.internal.cache.versions.VersionSource;
import com.gemstone.gemfire.internal.cache.versions.VersionStamp;
import com.gemstone.gemfire.internal.cache.versions.VersionTag;
import com.gemstone.gemfire.internal.cache.wan.GatewaySenderEventImpl;
import com.gemstone.gemfire.internal.cache.wan.parallel.ConcurrentParallelGatewaySenderQueue;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.offheap.StoredObject;
import com.gemstone.gemfire.internal.offheap.annotations.Unretained;
import com.gemstone.gemfire.internal.shared.Version;
import com.gemstone.gemfire.internal.snappy.CallbackFactoryProvider;
import com.gemstone.gemfire.internal.snappy.StoreCallbacks;

/**
 * The storage used for a Partitioned Region.
 * This class asserts distributed scope as well as a replicate data policy
 * It does not support transactions
 * 
 * Primary election for a BucketRegion can be found in the 
 * {@link com.gemstone.gemfire.internal.cache.BucketAdvisor} class
 * 
 * @author Mitch Thomas
 * @since 5.1
 *
 */
public class BucketRegion extends DistributedRegion implements Bucket {

  /**
   * A special value for the bucket size indicating that this bucket
   * has been destroyed.
   */
  private static final long BUCKET_DESTROYED = Long.MIN_VALUE;
  private final AtomicLong counter = new AtomicLong();
  private AtomicLong limit;
  private final AtomicLong numOverflowOnDisk = new AtomicLong();
  private final AtomicLong numOverflowBytesOnDisk = new AtomicLong();
  private final AtomicLong numEntriesInVM = new AtomicLong();
  private final AtomicLong evictions = new AtomicLong();
  private static final ThreadLocal bucketRegionIndexCleaner = 
      new ThreadLocal() ;

  /**
   * Contains size in bytes of the values stored
   * in theRealMap. Sizes are tallied during put and remove operations.
   */
  private final AtomicLongWithTerminalState bytesInMemory =
    new AtomicLongWithTerminalState();

  private final AtomicLong inProgressSize = new AtomicLong();

  public static final ReadEntryUnderLock READ_SER_VALUE = new ReadEntryUnderLock() {
    public final Object readEntry(final ExclusiveSharedLockObject lockObj,
        final Object context, final int iContext, boolean allowTombstones) {
      final RegionEntry re = (RegionEntry)lockObj;
      final BucketRegion br = (BucketRegion)context;
      return br.getSerialized(re, (iContext & DO_NOT_LOCK_ENTRY) != 0);
    }
  };

  public static class RawValue {

    public static final RawValue NULLVALUE = GemFireCacheImpl.FactoryStatics
        .rawValueFactory.newInstance(null);
    public static final RawValue REQUIRES_ENTRY_LOCK = GemFireCacheImpl
        .FactoryStatics.rawValueFactory.newInstance(null);

    protected Object rawValue;

    protected transient boolean fromCacheLoader;

    protected RawValue(Object rawVal) {
      this.rawValue = rawVal;
    }

    public static RawValue newInstance(final Object rawVal,
        final GemFireCacheImpl cache) {
      return cache.getRawValueFactory().newInstance(rawVal);
    }

    public final boolean isValueByteArray() {
      return this.rawValue instanceof byte[];
    }

    public final Object getRawValue() {
      return this.rawValue;
    }

    public final void writeAsByteArray(DataOutput out) throws IOException {
      if (isValueByteArray()) {
        DataSerializer.writeByteArray((byte[]) this.rawValue, out);
      } else if (this.rawValue instanceof CachedDeserializable) {
        ((CachedDeserializable)this.rawValue).writeValueAsByteArray(out);
      } else if (Token.isInvalid(this.rawValue)) {
        DataSerializer.writeByteArray(null, out);
      } else if (this.rawValue == Token.TOMBSTONE) { 
        DataSerializer.writeByteArray(null, out);
      } else {
        DataSerializer.writeObjectAsByteArray(this.rawValue, out);
      }
    }

    /**
     * Return the de-serialized value without changing the stored form
     * in the heap.  This causes local access to create a de-serialized copy (extra work)
     * in favor of keeping values in serialized form which is important because
     * it makes remote access more efficient.  This assumption is that remote
     * access is much more frequent.
     * TODO Unused, but keeping for potential performance boost when local Bucket 
     * access de-serializes the entry (which could hurt perf.)
     * 
     * @return the de-serialized value
     */
    public final Object getDeserialized(boolean copyOnRead) {
      if (isValueByteArray()) {
        if (copyOnRead) {
          // TODO move this code to CopyHelper.copy?
          byte[] src = (byte[])this.rawValue;
          byte[] dest = new byte[src.length];
          System.arraycopy(this.rawValue, 0, dest, 0, dest.length);
          return dest;
        } else {
          return this.rawValue;
        }
      } else if (this.rawValue instanceof CachedDeserializable) {
        if (copyOnRead) {
          return ((CachedDeserializable)this.rawValue).getDeserializedWritableCopy(null, null);
        } else {
          return ((CachedDeserializable)this.rawValue).getDeserializedForReading();
        }
      } else if (Token.isInvalid(this.rawValue)) {
        return null;
      } else {
        if (copyOnRead) {
          return CopyHelper.copy(this.rawValue);
        } else {
          return this.rawValue;
        }
      }
    }

    public final RawValue setFromCacheLoader() {
      this.fromCacheLoader = true;
      return this;
    }

    public final boolean isFromCacheLoader() {
      return this.fromCacheLoader;
    }

    @Override
    public String toString() {
      return "RawValue(value=" + this.rawValue + ",isByteArray="
          + isValueByteArray() + ')';
    }
  }

  /**
   * Factory for {@link RawValue} instances. Overridden by GemFireXD to provide
   * own RawValues that will also apply projection during serialization.
   * 
   * @author swale
   * @since 7.0
   */
  public static class RawValueFactory {

    private static final RawValueFactory _instance = new RawValueFactory();

    protected RawValue newInstance(final Object rawVal) {
      return new RawValue(rawVal);
    }

    public static RawValueFactory getFactory() {
      return _instance;
    }
  }

  private final int redundancy;
  
  /** the partitioned region to which this bucket belongs */
  protected final PartitionedRegion partitionedRegion;
  private final Map pendingSecondaryExpires = new HashMap(); 
 
  /* one map per bucket region */
  private final HashMap allKeysMap =
    new HashMap();

  static final boolean FORCE_LOCAL_LISTENERS_INVOCATION = 
    Boolean.getBoolean("gemfire.BucketRegion.alwaysFireLocalListeners");
  // gemfire.BucktRegion.alwaysFireLocalListeners=true

  private volatile AtomicLong eventSeqNum = null;

  public static final long INVALID_UUID = VMIdAdvisor.INVALID_ID;

  public final ReentrantReadWriteLock columnBatchFlushLock =
      new ReentrantReadWriteLock();


  /**
   * A read/write lock to prevent writing to the bucket when GII from this bucket is in progress
   */
  private final ReentrantReadWriteWriteShareLock snapshotGIILock
      = new ReentrantReadWriteWriteShareLock();

  private final Object giiReadLockForSIOwner = new Object();
  private final Object giiWriteLockForSIOwner = new Object();

  private final boolean lockGIIForSnapshot =
      Boolean.getBoolean("snappydata.snapshot.isolation.gii.lock");

  public final AtomicLong getEventSeqNum() {
    return eventSeqNum;
  }

  protected final AtomicReference hoplog = new AtomicReference();
  
  public BucketRegion(String regionName, RegionAttributes attrs,
      LocalRegion parentRegion, GemFireCacheImpl cache,
      InternalRegionArguments internalRegionArgs) {
    super(regionName, attrs, parentRegion, cache, internalRegionArgs);
    if(PartitionedRegion.DISABLE_SECONDARY_BUCKET_ACK) {
      Assert.assertTrue(attrs.getScope().isDistributedNoAck());
    } 
    else {
      Assert.assertTrue(attrs.getScope().isDistributedAck());
    }
    Assert.assertTrue(attrs.getDataPolicy().withReplication());
    Assert.assertTrue( ! attrs.getEarlyAck());
    Assert.assertTrue( ! attrs.getEnableGateway());
    Assert.assertTrue(isUsedForPartitionedRegionBucket());
    Assert.assertTrue( ! isUsedForPartitionedRegionAdmin());
    Assert.assertTrue(internalRegionArgs.getBucketAdvisor() != null);
    Assert.assertTrue(internalRegionArgs.getPartitionedRegion() != null);
    this.redundancy = internalRegionArgs.getPartitionedRegionBucketRedundancy();
    this.partitionedRegion = internalRegionArgs.getPartitionedRegion();
  }
  
  // Attempt to direct the GII process to the primary first
  @Override
  protected void initialize(InputStream snapshotInputStream,
      InternalDistributedMember imageTarget,
      InternalRegionArguments internalRegionArgs) 
    throws TimeoutException, IOException, ClassNotFoundException
  {
    // Set this region in the ProxyBucketRegion early so that profile exchange will
    // perform the correct fillInProfile method
    getBucketAdvisor().getProxyBucketRegion().setBucketRegion(this);
    boolean success = false;
    try {
      if (this.partitionedRegion.isShadowPR()
          && this.partitionedRegion.getColocatedWith() != null) {
        PartitionedRegion parentPR = ColocationHelper
            .getLeaderRegion(this.partitionedRegion);
        BucketRegion parentBucket = parentPR.getDataStore().getLocalBucketById(
            getId());
        // needs to be set only once.
        if (parentBucket.eventSeqNum == null) {
          parentBucket.eventSeqNum = new AtomicLong(getId());
        }
      }
      if (this.partitionedRegion.getColocatedWith() == null) {
        this.eventSeqNum = new AtomicLong(getId());
      } else {
        PartitionedRegion parentPR = ColocationHelper
            .getLeaderRegion(this.partitionedRegion);
        BucketRegion parentBucket = parentPR.getDataStore().getLocalBucketById(
            getId());
        if (parentBucket == null) {
          if (getCache().getLoggerI18n().fineEnabled()) {
            getCache().getLoggerI18n().fine(
                "The parentBucket of region"
                    + this.partitionedRegion.getFullPath() + " bucketId "
                    + getId() + " is NULL");
          }
        }
        Assert.assertTrue(parentBucket != null);
        this.eventSeqNum = parentBucket.eventSeqNum;
      }
      
      final InternalDistributedMember primaryHolder = 
        getBucketAdvisor().basicGetPrimaryMember();
      if (primaryHolder != null && ! primaryHolder.equals(getMyId())) {
        // Ignore the provided image target, use an existing primary (if any)
        super.initialize(snapshotInputStream, primaryHolder, internalRegionArgs);
      } else {
        super.initialize(snapshotInputStream, imageTarget, internalRegionArgs);
      }

      success = true;
    } finally {
      if(!success) {
        removeFromPeersAdvisors(false);
        getBucketAdvisor().getProxyBucketRegion().clearBucketRegion(this);
      }
    }
  }
  
  

  @Override
  public void initialized() {
    //announce that the bucket is ready
    //setHosting performs a profile exchange, so there
    //is no need to call super.initialized() here.
  }
  
  @Override
  protected DiskStoreImpl findDiskStore(RegionAttributes ra, InternalRegionArguments internalRegionArgs) {
    return internalRegionArgs.getPartitionedRegion().getDiskStore();
  }

  @Override
  public void createEventTracker() {
    this.eventTracker = new EventTracker(this);
    this.eventTracker.start();
  }
  
  @Override
  protected CacheDistributionAdvisor createDistributionAdvisor(
      InternalRegionArguments internalRegionArgs){
    return internalRegionArgs.getBucketAdvisor();
  }
  
  public final BucketAdvisor getBucketAdvisor() {
    return (BucketAdvisor)this.distAdvisor;
  }

  public final boolean isHosting() {
    return getBucketAdvisor().isHosting();
  }

  /**
   * Use it only when threads are doing incremental updates. If updates are random
   * then this method may not be optimal.
   */
  protected static boolean setIfGreater(AtomicLong l, long update) {
    while (true) {
      long cur = l.get();

      if (update > cur) {
        if (l.compareAndSet(cur, update))
          return true;
      } else
        return false;
    }
  }

  @Override
  protected EventID distributeTombstoneGC(Set