* 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.

*/

* We need to be able to have the master tell a tabletServer to

* close this file, and the tablet server to handle all pending client reads

* before closing

*

*/

*

* this class just provides an interface to read from a MapFile mostly takes care of reporting start and end keys

*

* need this because a single row extent can have multiple columns this manages all the columns (each handled by a store) for a single row-extent

*

*

*/

 

  public class CommitSession {

   

    private int seq;

    private InMemoryMap memTable;

    private int commitsInProgress;

    private long maxCommittedTime = Long.MIN_VALUE;

   

    private CommitSession(int seq, InMemoryMap imm) {

      this.seq = seq;

      this.memTable = imm;

      commitsInProgress = 0;

    }

   

    public int getWALogSeq() {

      return seq;

    }

   

    private void decrementCommitsInProgress() {

      if (commitsInProgress < 1)

        throw new IllegalStateException("commitsInProgress = " + commitsInProgress);

     

      commitsInProgress--;

      if (commitsInProgress == 0)

        Tablet.this.notifyAll();

    }

   

    private void incrementCommitsInProgress() {

      if (commitsInProgress < 0)

        throw new IllegalStateException("commitsInProgress = " + commitsInProgress);

     

      commitsInProgress++;

    }

   

    private void waitForCommitsToFinish() {

      while (commitsInProgress > 0) {

        try {

          Tablet.this.wait(50);

        } catch (InterruptedException e) {

          log.warn(e, e);

        }

      }

    }

   

    public void abortCommit(List<Mutation> value) {

      Tablet.this.abortCommit(this, value);

    }

   

    public void commit(List<Mutation> mutations) {

      Tablet.this.commit(this, mutations);

    }

   

    public Tablet getTablet() {

      return Tablet.this;

    }

   

    public boolean beginUpdatingLogsUsed(ArrayList<RemoteLogger> copy, boolean mincFinish) {

      return Tablet.this.beginUpdatingLogsUsed(memTable, copy, mincFinish);

    }

   

    public void finishUpdatingLogsUsed() {

      Tablet.this.finishUpdatingLogsUsed();

    }

   

    public int getLogId() {

      return logId;

    }

   

    public KeyExtent getExtent() {

      return extent;

    }

   

    private void updateMaxCommittedTime(long time) {

      maxCommittedTime = Math.max(time, maxCommittedTime);

    }

   

    private long getMaxCommittedTime() {

      if (maxCommittedTime == Long.MIN_VALUE)

        throw new IllegalStateException("Tried to read max committed time when it was never set");

      return maxCommittedTime;

    }

   

  }

 

  private class TabletMemory {

    private InMemoryMap memTable;

    private InMemoryMap otherMemTable;

    private InMemoryMap deletingMemTable;

    private int nextSeq = 1;

    private CommitSession commitSession;

   

    TabletMemory() {

      memTable = new InMemoryMap();

      commitSession = new CommitSession(nextSeq, memTable);

      nextSeq += 2;

    }

   

    InMemoryMap getMemTable() {

      return memTable;

    }

   

    InMemoryMap getMinCMemTable() {

      return otherMemTable;

    }

   

    CommitSession prepareForMinC() {

      if (otherMemTable != null) {

        throw new IllegalStateException();

      }

     

      if (deletingMemTable != null) {

        throw new IllegalStateException();

      }

     

      otherMemTable = memTable;

      memTable = new InMemoryMap();

     

      CommitSession oldCommitSession = commitSession;

      commitSession = new CommitSession(nextSeq, memTable);

      nextSeq += 2;

     

      tabletResources.updateMemoryUsageStats(memTable.estimatedSizeInBytes(), otherMemTable.estimatedSizeInBytes());

     

      return oldCommitSession;

    }

   

    void finishedMinC() {

     

      if (otherMemTable == null) {

        throw new IllegalStateException();

      }