com.caucho.v5.kelp.PageServiceImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of baratine Show documentation
A reactive Java web server.
There is a newer version: 1.0.1
/*
 * Copyright (c) 1998-2015 Caucho Technology -- all rights reserved
 *
 * This file is part of Baratine(TM)
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Baratine is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Baratine 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Baratine; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.v5.kelp;

import io.baratine.service.AfterBatch;
import io.baratine.service.Result;
import io.baratine.service.Service;
import io.baratine.service.ServiceRef;

import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.function.Predicate;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.caucho.v5.amp.Direct;
import com.caucho.v5.baratine.InService;
import com.caucho.v5.db.journal.JournalStore;
import com.caucho.v5.db.journal.JournalStream;
import com.caucho.v5.io.StreamSource;
import com.caucho.v5.io.TempBuffer;
import com.caucho.v5.kelp.PageLeafImpl.Split;
import com.caucho.v5.kelp.PageServiceSync.GcContext;
import com.caucho.v5.kelp.PageServiceSync.PutType;
import com.caucho.v5.kelp.PageTree.SplitTree;
import com.caucho.v5.kelp.RangeIteratorKelp.PredicateTrue;
import com.caucho.v5.kelp.TableListener.TypePut;
import com.caucho.v5.kelp.query.EnvKelp;
import com.caucho.v5.kelp.segment.SegmentKelp;
import com.caucho.v5.kelp.segment.SegmentStream;
import com.caucho.v5.lifecycle.Lifecycle;
import com.caucho.v5.util.ConcurrentArrayList;
import com.caucho.v5.util.CurrentTime;
import com.caucho.v5.util.Hex;
import com.caucho.v5.util.L10N;
import com.caucho.v5.util.LruCache;

/**
 * Actor responsible for managing the page tables.
 */
//@NonBlocking
@Service
public class PageServiceImpl implements PageService
{
  private static final L10N L = new L10N(PageServiceImpl.class);
  private static final Logger log = Logger.getLogger(PageServiceImpl.class.getName());
  
  private static final int ROOT_TREE = 1;
  private static final int ROOT_LEAF = 2;
  
  private final TableKelp _table;
  private final JournalKelpImpl _journal;
  
  private final PageMap _pages = new PageMap<>();
  // private final PageMap _blobPages = new PageMap<>();
  
  private AtomicInteger _tailPid = new AtomicInteger();
  // private AtomicInteger _blobCounter = new AtomicInteger();
  
  private ConcurrentArrayList _listeners
    = new ConcurrentArrayList<>(TableListener.class);
  
  private final Deque _freeBlobs
    = new ArrayDeque<>();
    
  private final AtomicBoolean _isCollecting = new AtomicBoolean();
  
  private int _rootPid = 1;

  private final RowCursor _workCursor;

  private JournalStore _jbs;
  private JournalStream _journalStream;
  
  private long _lastTime;
  private long _lastVersion;
  
  private Lifecycle _lifecycle = new Lifecycle();
  
  private LruCache _updateLru = new LruCache<>(1024);
  
  PageServiceImpl(TableKelp table,
                   JournalStore jbs)
  {
    Objects.requireNonNull(table);
    
    _table = table;
    
    _jbs = jbs;
    // XXX: should be table unique name
    _journalStream = _jbs.openJournalStream(table.getName());
    _journal = new JournalKelpImpl(_table, _journalStream);
    
    _workCursor = _table.cursor();
  }
  
  @Override
  public void start(Result result)
  {
    loadImpl(result.of((t,r)->afterStart(r)));
  }
  
  private void loadImpl(Result result)
  {
    if (! _lifecycle.toActive()) {
      result.ok(null);
      return;
    }
    
    _table.getReadWriteActor().init(_table, this);
    
    validateAndRepair();
    _journal.replayJournal(this);
    
    collectFreeBlobs();
    
    result.ok(null);
  }
  
  private void afterStart(Result result)
  {
    DatabaseServiceKelp database = _table.getDatabase().getDatabaseService();
    
    database.addTableImpl(_table.getName(), _table, 
                          result.of((t,r)->afterAddTable(t,r)));
  }
  
  private void afterAddTable(TableKelp table, Result result)
  {
    if (_table != table) {
      result.ok(table);
      return;
    }

    checkpoint(result.of(v->_table));
  }
  
  public TableKelp getTable()
  {
    return _table;
  }
  
  @Direct
  public long getMemorySize()
  {
    int tail = _tailPid.get();
    
    long size = 0;
    
    for (int i = 0; i <= tail; i++) {
      Page page = _pages.get(i);
      
      if (page != null) {
        size += page.getSize();
      }
    }
    
    return size;
  }
  
  //
  // Service methods
  //
  
  @Direct
  @Override
  public void getDirect(RowCursor cursor, Result result)
  {
    boolean isValid = getImpl(cursor);
    
    result.ok(isValid);
  }
  
  /**
   * Non-peek get.
   */
  @Override
  public void getSafe(RowCursor cursor, Result result)
  {
    result.ok(getImpl(cursor));
  }
  
  private boolean getImpl(RowCursor cursor)
  {
    PageLeafImpl leaf = getLeafByCursor(cursor);
    
    if (leaf == null) {
      return false;
    }
    
    return leaf.get(cursor);
  }
  
  /**
   * For cluster calls, returns a stream to the new value if the value
   * has changed. 
   */
  @Direct
  @Override
  public void getStream(RowCursor cursor, 
                        Result result)
  {
    long version = cursor.getVersion();
    
    PageLeafImpl leaf = getLeafByCursor(cursor);
    
    if (leaf == null) {
      result.ok(new GetStreamResult(false, null));
      return;
    }
    
    if (! leaf.get(cursor)) {
      result.ok(new GetStreamResult(false, null));
      return;
    }

    if (version == cursor.getVersion()) {
      result.ok(new GetStreamResult(true, null));
      return;
    }
    
    StreamSource ss = leaf.getStream(cursor, this);
    
    boolean isFound = ss != null;

    result.ok(new GetStreamResult(isFound, ss));
  }

  @Direct
  public PageLeafImpl getLeafByCursor(RowCursor cursor)
  {
    int pid = getTree(cursor, _rootPid);
    
    while (pid > 0) {
      PageLeafImpl leaf = loadLeaf(pid);
    
      if (cursor.compareKey(leaf.getMaxKey(), 0) <= 0) {
        return leaf;
      }
      
      pid = leaf.getNextId();
    }
    
    return null;
  }

  @Override
  public void put(RowCursor cursor,
                  PutType putType,
                  Result result)
  {
    updateVersion(cursor);
    
    _journal.put(cursor);
      
    putImpl(cursor, null, putType, result);
    
    // result.complete(true);
    
    if (_journal.isCheckpointRequired()) {
      checkpoint(Result.ignore());
    }
    
    collectImpl();
  }

  @Override
  public void putWithBackup(RowCursor cursor, 
                            PutType putType,
                            BackupKelp backupCb,
                            Result result)
  {
    updateVersion(cursor);
    
    _journal.put(cursor);
      
    putImpl(cursor, backupCb, putType, (Result) result);

    // result.complete(Boolean.TRUE);
    
    if (_journal.isCheckpointRequired()) {
      checkpoint(Result.ignore());
    }
    
    collectImpl();
    
    /*
    if (backupCb != null) {
      putBackup(cursor, backupCb);
    }
    */
  }
  
  @Override
  public void update(RowCursor min, 
                     RowCursor max, 
                     EnvKelp envKelp,
                     UpdateKelp update, 
                     @Service BackupKelp backup, 
                     Result result)
  {
    int count = 0;

    RangeIteratorKelp iter = new RangeIteratorKelp(_table, min, max, envKelp);
    
    while (iter.hasNext()) {
      RowCursor cursor = iter.next();
      
      if (update.onRow(cursor, envKelp)) {
        count++;
        putWithBackup(cursor, PutType.PUT, backup, Result.ignore());
      }
    }

    result.ok(count);
  }
  
  @Override
  public void replace(RowCursor cursor,
                      EnvKelp envKelp,
                      UpdateKelp update, 
                      @Service BackupKelp backup, 
                      Result result)
  {
    updateVersion(cursor);
    
    replaceImpl(cursor, envKelp, update, backup, result.of(x->1));
    
    // result.complete(1);
    
    if (_journal.isCheckpointRequired()) {
      checkpoint(Result.ignore());
    }
    
    collectImpl();
  }
  
  private void replaceImpl(RowCursor cursor,
                           EnvKelp envKelp,
                           UpdateKelp update, 
                           @Service BackupKelp backup,
                           Result result)
  {
    PutType putType = PutType.PUT;
    
    RowCursor workCursor = _table.cursor();

    // update version in case of foreign clock skew
    _lastVersion = Math.max(_lastVersion, cursor.getVersion());
    
    // int leafPid;
    
    int leafPid = getTree(cursor, _rootPid);
    
    if (leafPid <= 0) {
      throw new IllegalStateException("Missing leaf for " + String.valueOf(cursor) + " " + _rootPid);
    }

    PageLeafImpl leaf = loadLeafForUpdate(leafPid);

    if (leaf.compareTo(cursor) != 0) {
      // repair parent tree
      // If an updated split leaf is saved but the updated parent tree is not,
      // the loaded database needs to repair the parent tree.
      // System.out.println("REPAIR PARENT TREE: " + cursor);
      
      leaf = getLeafByCursor(cursor);
      
      if (leaf == null) {
        throw new IllegalStateException("Cursor " + cursor + " is not in leaf " + leaf
                                        + " parent " + getTreeParent(cursor.getKey(), 
                                                                     _rootPid,
                                                                     leafPid));
      }
    }
    
    PageLeafImpl newLeaf;
    
    workCursor.copyFrom(cursor);
    
    if (leaf.get(workCursor) && update.onRow(workCursor, envKelp)) {
      _journal.put(workCursor);
      
      RowCursor workCursor2 = _table.cursor();
      
      newLeaf = leaf.put(_table, this, workCursor, workCursor2,
                         backup, putType,
                         result);
    }
    else {
      _journal.put(cursor);
      
      newLeaf = leaf.put(_table, this, cursor, workCursor,
                         backup, putType,
                         result);
    }
    
    if (newLeaf == null) {
      // cursor.removeBlobs();
      return;
    }
    
    if (leaf != newLeaf) {
      if (! compareAndSetLeaf(leaf, newLeaf)) {
        throw new IllegalStateException("Leaf unable to compact " + leaf + " " + newLeaf);
      }
      
      PageLeafStub stub = (PageLeafStub) leaf.getStub();
      
      if (stub != null) {
        stub.copyToCompact(newLeaf);
      }
    }
    
    if (_table.getMaxNodeLength() < newLeaf.getSize()) {
      int parentPid = getTreeParent(cursor.getKey(), _rootPid, newLeaf.getId());
      
      splitPage(parentPid, newLeaf.getId());
    }
    
    //notifyOnPut(cursor, putType);
    
    //cursor.removeBlobs();
  }
  
  @Override
  public int writeBlob(int nextPid, 
                       StreamSource ss,
                       int offset,
                       int length)
  {
    try {
      int pid = allocateBlobPageId();

      PageBlob oldPage = getBlobPage(pid);

      long seq;
      if (oldPage != null) {
        seq = oldPage.getSequence();
      }
      else {
        seq = 0;
      }

      // int offset = len - blobPageSizeMax;

      PageBlobTemp page = new PageBlobTemp(pid, nextPid, seq, 
                                           ss.openChild(), 
                                           offset, length);

      page.setDirty();

      nextPid = pid;

      compareAndSetBlobPage(oldPage, page);

      page.clearDirty();

      int writeSequence = page.nextWriteSequence();
      _table.getReadWrite().writeBlobPage(page,
                                          writeSequence,
                                          Result.onOk(x->page.afterDataFlush(this, writeSequence)));

      return pid;
    } finally {
      // ss is opened by caller
      ss.close();
    }
  }

  @Override
  public void remove(RowCursor cursor, 
                     BackupKelp backup,
                     Result result)
  {
    updateVersion(cursor);
      
    _journal.remove(cursor);
      
    removeImpl(cursor, backup, result);
    
    if (_journal.isCheckpointRequired()) {
      checkpoint(Result.ignore());
    }
  }

  @Override
  public void removeRange(RowCursor min,
                          RowCursor max,
                          Predicate predicate,
                          BackupKelp backup,
                          Result result)
  {
    if (predicate == null) {
      predicate = PredicateTrue.TRUE;
    }
    
    long version = nextVersion();
    
    try {
      Iterator iter = new RangeIteratorKelp(_table, min, max, predicate);
      
      while (iter.hasNext()) {
        RowCursor cursor = iter.next();

        cursor.setVersion(version);
        
        _journal.remove(cursor);
      
        removeImpl(cursor, backup, Result.ignore());
      }
    } finally {
      result.ok(true);
    }
    
    if (_journal.isCheckpointRequired()) {
      checkpoint(Result.ignore());
    }
  }
  
  private void updateVersion(RowCursor cursor)
  {
    long version = cursor.getVersion();

    if (version == 0) {
      version = nextVersion();
      cursor.setVersion(version);
    }
  }

  public int getTailPid()
  {
    return _tailPid.get();
  }
  
  public boolean waitForComplete()
  {
    return true;
  }
  
  @Override
  public void flush(Result