org.apache.geode.internal.cache.TXStateInterface Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of geode-core Show documentation
Apache Geode provides a database-like consistency model, reliable transaction processing and a shared-nothing architecture to maintain very low latency performance with high concurrency processing
There is a newer version: 1.15.1
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You 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.
 */
/**
 * File comment
 */
package org.apache.geode.internal.cache;

import java.util.Collection;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

import javax.transaction.Synchronization;

import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CommitConflictException;
import org.apache.geode.cache.TransactionId;
import org.apache.geode.cache.UnsupportedOperationInTransactionException;
import org.apache.geode.cache.Region.Entry;
import org.apache.geode.cache.client.internal.ServerRegionDataAccess;
import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
import org.apache.geode.internal.cache.tx.TransactionalOperation.ServerRegionOperation;

/**
 * An entity that tracks transactions must implement this interface.
 * 
 */
public interface TXStateInterface extends Synchronization, InternalDataView {

  public TransactionId getTransactionId();

  /**
   * Used by transaction operations that are doing a read operation on the specified region.
   * 
   * @return the TXRegionState for the given LocalRegion or null if no state exists
   */
  public TXRegionState readRegion(LocalRegion r);

  /**
   * Used by transaction operations that are doing a write operation on the specified region.
   * 
   * @return the TXRegionState for the given LocalRegion
   */
  public TXRegionState writeRegion(LocalRegion r);

  /**
   * Returns a nanotimer timestamp that marks when begin was called on this transaction.
   */
  public long getBeginTime();

  /**
   * Returns the number of changes this transaction would have made if it successfully committed.
   */
  public int getChanges();

  /**
   * Determines if a transaction is in progress. Transactions are in progress until they commit or
   * rollback.
   * 
   * @return true if this transaction has completed.
   */
  public boolean isInProgress();

  /**
   * Returns the next modification serial number. Note this method is not thread safe but does not
   * need to be since a single thread owns a transaction.
   */
  public int nextModSerialNum();

  /**
   * Return true if mod counts for this transaction can not be represented by a byte
   * 
   * @since GemFire 5.0
   */
  public boolean needsLargeModCount();

  /*
   * Only applicable for Distributed transaction.
   */
  public void precommit()
      throws CommitConflictException, UnsupportedOperationInTransactionException;

  public void commit() throws CommitConflictException;

  public void rollback();

  public List getEvents();



  /** Implement TransactionEvent's getCache */
  public Cache getCache();

  public Collection getRegions();

  public void invalidateExistingEntry(final EntryEventImpl event, boolean invokeCallbacks,
      boolean forceNewEntry);

  /**
   * @param region
   * @param keyInfo
   * @param allowTombstones
   * @return a Region.Entry if it exists either in committed state or in transactional state,
   *         otherwise returns null
   */
  public Entry getEntry(final KeyInfo keyInfo, final LocalRegion region, boolean allowTombstones);

  /**
   * @param keyInfo
   * @param localRegion
   * @param updateStats TODO
   */
  public Object getDeserializedValue(KeyInfo keyInfo, LocalRegion localRegion, boolean updateStats,
      boolean disableCopyOnRead, boolean preferCD, EntryEventImpl clientEvent,
      boolean returnTombstones, boolean retainResult);

  public TXEvent getEvent();

  public TXRegionState txWriteRegion(final LocalRegion localRegion, final KeyInfo entryKey);

  public TXRegionState txReadRegion(LocalRegion localRegion);

  public boolean txPutEntry(final EntryEventImpl event, boolean ifNew, boolean requireOldValue,
      boolean checkResources, Object expectedOldValue);

  /**
   * @param entryKey TODO
   * @param localRegion TODO
   * @param rememberRead true if the value read from committed state needs to be remembered in tx
   *        state for repeatable read.
   * @param createTxEntryIfAbsent should a transactional entry be created if not present.
   * @return a txEntryState or null if the entry doesn't exist in the transaction and/or committed
   *         state.
   */
  public TXEntryState txReadEntry(KeyInfo entryKey, LocalRegion localRegion, boolean rememberRead,
      boolean createTxEntryIfAbsent);

  public void rmRegion(LocalRegion r);

  /**
   * 
   * @param state
   * @return true if transaction is in progress and the given state has the same identity as this
   *         instance
   */
  public boolean isInProgressAndSameAs(TXStateInterface state);

  /**
   * 
   * @return true if callbacks should be fired for this TXState
   */
  public boolean isFireCallbacks();

  /**
   * On the remote node, the tx can potentially be accessed by multiple threads, specially with
   * function execution. This lock should be used to synchronize access to the tx state.
   * 
   * @return the lock to be used
   */
  public ReentrantLock getLock();

  public boolean isRealDealLocal();

  public boolean isMemberIdForwardingRequired();

  public InternalDistributedMember getOriginatingMember();

  public TXCommitMessage getCommitMessage();

  /**
   * perform additional tasks to suspend a transaction
   */
  public void suspend();

  /**
   * perform additional tasks to resume a suspended transaction
   */
  public void resume();

  /**
   * record a transactional operation for possible later replay
   */
  public void recordTXOperation(ServerRegionDataAccess region, ServerRegionOperation op, Object key,
      Object arguments[]);

  public void close();

  /*
   * Determine if its TxState or not
   */
  public boolean isTxState();

  /*
   * Determine if is TxStateStub or not
   */
  public boolean isTxStateStub();

  /*
   * Determine if is TxStateProxy or not
   */
  public boolean isTxStateProxy();

  /*
   * Is class related to Distributed Transaction, and not colocated transaction
   */
  public boolean isDistTx();

  /*
   * Is class meant for Coordinator for Distributed Transaction
   * 
   * Will be true for DistTXCoordinatorInterface
   */
  public boolean isCreatedOnDistTxCoordinator();
}