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

*/

*

* Design Notes:

*

* serving a tablet consists in having exclusive (among tablet servers) access

* to a range of rows, and the files that store their information

*

* one Tablet server serves several tablets at once

*

* implements a ScanCache containing recently read values for

* exploitation of temporal locality

*

* we may get exploitation of spatial locality through the mechanism

* of reading in 64Kb (?) blocks from MapFiles - check on this

* if not, we need to implement a BlockCache

*

*

* Jobs

*

* Load information from tablets into memory (indices ...)

* Listen for requests from clients

* Upon receiving a new request, spawn a worker thread (limit?)

* manage worker threads

*

* Worker thread

*

* handle row requests from clients, parse out columns

* manage scanner state

* access row information from HDFS

* send data to the client

* receive interrupts from server, close files and die

*

*

*/

  private static final Logger log = Logger.getLogger(TabletServer.class);

 

  private static HashMap<String,Long> prevGcTime = new HashMap<String,Long>();

  private static long lastMemorySize = 0;

  private static AtomicLong scanCount = new AtomicLong();

  private static final Class<? extends LoggerStrategy> DEFAULT_LOGGER_STRATEGY = RoundRobinLoggerStrategy.class;

 

  private static final long MAX_TIME_TO_WAIT_FOR_SCAN_RESULT_MILLIS = 1000;

 

  private TabletServerLogger logger;

  private LoggerStrategy loggerStrategy;

 

  protected TabletServerMinCMetrics mincMetrics = new TabletServerMinCMetrics();

 

  public TabletServer() {

    super();

    SimpleTimer.getInstance().schedule(new TimerTask() {

      @Override

      public void run() {

        synchronized (onlineTablets) {

          long now = System.currentTimeMillis();

          for (Tablet tablet : onlineTablets.values())

            try {

              tablet.updateRates(now);

            } catch (Exception ex) {

              log.error(ex, ex);

            }

        }

      }

    }, 5000, 5000);

  }

 

  private synchronized static void logGCInfo() {

    List<GarbageCollectorMXBean> gcmBeans = ManagementFactory.getGarbageCollectorMXBeans();

    Runtime rt = Runtime.getRuntime();

   

    StringBuilder sb = new StringBuilder("gc");

   

    boolean sawChange = false;

   

    long maxIncreaseInCollectionTime = 0;

   

    for (GarbageCollectorMXBean gcBean : gcmBeans) {

      Long prevTime = prevGcTime.get(gcBean.getName());

      long pt = 0;

      if (prevTime != null) {

        pt = prevTime;

      }

     

      long time = gcBean.getCollectionTime();

     

      if (time - pt != 0) {

        sawChange = true;

      }

     

      long increaseInCollectionTime = time - pt;

      sb.append(String.format(" %s=%,.2f(+%,.2f) secs", gcBean.getName(), time / 1000.0, increaseInCollectionTime / 1000.0));

      maxIncreaseInCollectionTime = Math.max(increaseInCollectionTime, maxIncreaseInCollectionTime);

      prevGcTime.put(gcBean.getName(), time);

    }

   

    long mem = rt.freeMemory();

   

    if (mem > lastMemorySize) {

      sawChange = true;

    }

   

    String sign = "+";

    if (mem - lastMemorySize <= 0) {

      sign = "";

    }

   

    sb.append(String.format(" freemem=%,d(%s%,d) totalmem=%,d", mem, sign, (mem - lastMemorySize), rt.totalMemory()));

   

    if (sawChange) {

      log.debug(sb.toString());

    }

   

    final long keepAliveTimeout = AccumuloConfiguration.getSystemConfiguration().getTimeInMillis(Property.INSTANCE_ZK_TIMEOUT);

    if (maxIncreaseInCollectionTime > keepAliveTimeout) {

      Halt.halt("Garbage collection may be interfering with lock keep-alive.  Halting.", -1);

    }

   

    lastMemorySize = mem;

  }

 

  private TabletStatsKeeper statsKeeper;

 

  private static class Session {

    long lastAccessTime;

    long startTime;

    String user;

    String client = TServerUtils.clientAddress.get();

    public boolean reserved;

   

    public void cleanup() {}

  }

 

   

    SecureRandom random;

    Map<Long,Session> sessions;

   

    SessionManager() {

      random = new SecureRandom();

      sessions = new HashMap<Long,Session>();

     

      final long maxIdle = AccumuloConfiguration.getSystemConfiguration().getTimeInMillis(Property.TSERV_SESSION_MAXIDLE);

     

      TimerTask r = new TimerTask() {

        public void run() {

          sweep(maxIdle);

        }

      };

     

      SimpleTimer.getInstance().schedule(r, 0, Math.max(maxIdle / 2, 1000));

    }

   

    synchronized long createSession(Session session, boolean reserve) {

      long sid = random.nextLong();

     

      while (sessions.containsKey(sid)) {

        sid = random.nextLong();

      }

     

      sessions.put(sid, session);

     

      session.reserved = reserve;

     

      session.startTime = session.lastAccessTime = System.currentTimeMillis();

     

      return sid;

    }

   

    /**

     * while a session is reserved, it cannot be canceled or removed

     *

     * @param sessionId

     */

   

    synchronized Session reserveSession(long sessionId) {

      Session session = sessions.get(sessionId);

      if (session != null) {

        if (session.reserved)

          throw new IllegalStateException();

        session.reserved = true;

      }

     

      return session;

     

    }

   

    synchronized void unreserveSession(Session session) {

      if (!session.reserved)

        throw new IllegalStateException();

      session.reserved = false;

      session.lastAccessTime = System.currentTimeMillis();

    }

   

    synchronized void unreserveSession(long sessionId) {

      Session session = getSession(sessionId);

      if (session != null)

        unreserveSession(session);

    }

   

    synchronized Session getSession(long sessionId) {

      Session session = sessions.get(sessionId);

      if (session != null)

        session.lastAccessTime = System.currentTimeMillis();

      return session;

    }

   

    Session removeSession(long sessionId) {

      Session session = null;

      synchronized (this) {

        session = sessions.remove(sessionId);

      }

     

      // do clean up out side of lock..

      if (session != null)

        session.cleanup();

     

      return session;

    }

   

    private void sweep(long maxIdle) {

      ArrayList<Session> sessionsToCleanup = new ArrayList<Session>();

      synchronized (this) {

        Iterator<Session> iter = sessions.values().iterator();

        while (iter.hasNext()) {

          Session session = iter.next();

          long idleTime = System.currentTimeMillis() - session.lastAccessTime;

          if (idleTime > maxIdle && !session.reserved) {

            iter.remove();

            sessionsToCleanup.add(session);

          }

        }

      }

     

      // do clean up outside of lock

      for (Session session : sessionsToCleanup) {

        session.cleanup();

      }

    }

   

    synchronized void removeIfNotAccessed(final long sessionId, long delay) {

      Session session = sessions.get(sessionId);

      if (session != null) {

        final long removeTime = session.lastAccessTime;

        TimerTask r = new TimerTask() {

          public void run() {

            Session sessionToCleanup = null;

            synchronized (SessionManager.this) {

              Session session2 = sessions.get(sessionId);

              if (session2 != null && session2.lastAccessTime == removeTime && !session2.reserved) {

                sessions.remove(sessionId);

                sessionToCleanup = session2;

              }

            }

           

            // call clean up outside of lock

            if (sessionToCleanup != null)

              sessionToCleanup.cleanup();

          }

        };

       

        SimpleTimer.getInstance().schedule(r, delay);

      }

    }

   

    public synchronized List<ActiveScan> getActiveScans() {

     

      ArrayList<ActiveScan> activeScans = new ArrayList<ActiveScan>();

     

      long ct = System.currentTimeMillis();

     

      for (Entry<Long,Session> entry : sessions.entrySet()) {

        Session session = entry.getValue();

        if (session instanceof ScanSession) {

          ScanSession ss = (ScanSession) session;

         

          ScanState state = ScanState.RUNNING;

         

          RunnableFuture<ScanBatch> nbt = ss.nextBatchTask;

          if (nbt == null || nbt.isDone() || nbt.isCancelled()) {

            state = ScanState.IDLE;

          }

         

          activeScans.add(new ActiveScan(ss.client, ss.user, ss.extent.getTableId().toString(), ct - ss.startTime, ct - ss.lastAccessTime, ScanType.SINGLE,

              state, ss.extent.toThrift(), Translator.translate(ss.columnSet, Translator.CT), ss.ssiList, ss.ssio));

         

        } else if (session instanceof MultiScanSession) {

          MultiScanSession mss = (MultiScanSession) session;

         

          ScanState state = ScanState.RUNNING;

         

          RunnableFuture<MultiScanResult> nbt = mss.lookupTask;

          if (nbt == null || nbt.isDone() || nbt.isCancelled()) {

            state = ScanState.IDLE;

          }

         

          activeScans.add(new ActiveScan(mss.client, mss.user, mss.threadPoolExtent.getTableId().toString(), ct - mss.startTime, ct - mss.lastAccessTime,

              ScanType.BATCH, state, mss.threadPoolExtent.toThrift(), Translator.translate(mss.columnSet, Translator.CT), mss.ssiList, mss.ssio));

        }

      }

     

      return activeScans;

    }

  }

 

  private static class UpdateSession extends Session {

    public Tablet currentTablet;

    public MapCounter<Tablet> successfulCommits = new MapCounter<Tablet>();

    Map<KeyExtent,Long> failures = new HashMap<KeyExtent,Long>();

    List<KeyExtent> authFailures = new ArrayList<KeyExtent>();

    public Violations violations;

    public AuthInfo credentials;

    public long totalUpdates = 0;

    public long flushTime = 0;

    Stat prepareTimes = new Stat();

    Stat walogTimes = new Stat();

    Stat commitTimes = new Stat();

    Stat authTimes = new Stat();

    public Map<Tablet,List<Mutation>> queuedMutations = new HashMap<Tablet,List<Mutation>>();

    public long queuedMutationSize = 0;

  }

 

  private static class ScanSession extends Session {

    public KeyExtent extent;

    public HashSet<Column> columnSet;

    public List<IterInfo> ssiList;

    public Map<String,Map<String,String>> ssio;

    public long entriesReturned = 0;

    public Stat nbTimes = new Stat();

    public long batchCount = 0;

    public RunnableFuture<ScanBatch> nextBatchTask;

    public AtomicBoolean interruptFlag;

    public Scanner scanner;

   

    @Override

    public void cleanup() {

      try {

        if (nextBatchTask != null)

          nextBatchTask.cancel(true);

      } finally {

        if (scanner != null)

          scanner.close();

      }

    }

   

  }

 

  private static class MultiScanSession extends Session {

    HashSet<Column> columnSet;

    Map<KeyExtent,List<Range>> queries;

    public List<IterInfo> ssiList;

    public Map<String,Map<String,String>> ssio;

    public Authorizations auths;

   

    // stats

    int numRanges;

    int numTablets;

    int numEntries;

    long totalLookupTime;

   

    public RunnableFuture<MultiScanResult> lookupTask;

    public KeyExtent threadPoolExtent;

   

    @Override

    public void cleanup() {

      if (lookupTask != null)

        lookupTask.cancel(true);

    }

  }

 

  /**

   * This little class keeps track of writes in progress and allows readers to wait for writes that started before the read. It assumes that the operation ids

   * are monotonically increasing.

   *

   */

  static class WriteTracker {

    private static AtomicLong operationCounter = new AtomicLong(1);

    private Map<TabletType,TreeSet<Long>> inProgressWrites = new EnumMap<TabletType,TreeSet<Long>>(TabletType.class);

   

    WriteTracker() {

      for (TabletType ttype : TabletType.values()) {

        inProgressWrites.put(ttype, new TreeSet<Long>());

      }

    }

   

    synchronized long startWrite(TabletType ttype) {