org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/statesystem/StateSystemManager.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012 Ericsson
   3  * Copyright (c) 2010, 2011 École Polytechnique de Montréal
   4  * Copyright (c) 2010, 2011 Alexandre Montplaisir <alexandre.montplaisir@gmail.com>
   5  *
   6  * All rights reserved. This program and the accompanying materials are
   7  * made available under the terms of the Eclipse Public License v1.0 which
   8  * accompanies this distribution, and is available at
   9  * http://www.eclipse.org/legal/epl-v10.html
  10  *
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.core.statesystem;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17
  18 import org.eclipse.linuxtools.internal.tmf.core.statesystem.HistoryBuilder;
  19 import org.eclipse.linuxtools.internal.tmf.core.statesystem.IStateHistoryBackend;
  20 import org.eclipse.linuxtools.internal.tmf.core.statesystem.historytree.HistoryTreeBackend;
  21 import org.eclipse.linuxtools.internal.tmf.core.statesystem.historytree.ThreadedHistoryTreeBackend;
  22 import org.eclipse.linuxtools.tmf.core.component.TmfComponent;
  23 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  24
  25 /**
  26  * This abstract manager class handles loading or creating state history files
  27  * for use in TMF's generic state system.
  28  *
  29  * @version 1.0
  30  * @author Alexandre Montplaisir
  31  */
  32 public abstract class StateSystemManager extends TmfComponent {
  33
  34     /** Size of the blocking queue to use when building a state history */
  35     private final static int QUEUE_SIZE = 10000;
  36
  37     /**
  38      * Load the history file matching the target trace. If the file already
  39      * exists, it will be opened directly. If not, it will be created from
  40      * scratch. In the case the history has to be built, it's possible to block
  41      * the calling thread until construction is complete.
  42      *
  43      * @param htFile
  44      *            The target name of the history file we want to use. If it
  45      *            exists it will be opened. If it doesn't, a new file will be
  46      *            created with this name/path.
  47      * @param htInput
  48      *            The IStateChangeInput to use for building the history file. It
  49      *            may be required even if we are opening an already-existing
  50      *            history (ie, for partial histories).
  51      * @param buildManually
  52      *            If false, the construction will wait for a signal before
  53      *            starting. If true, it will build everything right now and
  54      *            block the caller. It has no effect if the file already exists.
  55      * @return A IStateSystemQuerier handler to the state system, with which you
  56      *         can then run queries on the history.
  57      * @throws TmfTraceException
  58      *             If there was a problem reading or writing one of the files.
  59      *             See the contents of this exception for more info.
  60      */
  61     public static IStateSystemQuerier loadStateHistory(File htFile,
  62             IStateChangeInput htInput, boolean buildManually)
  63             throws TmfTraceException {
  64         IStateSystemQuerier ss;
  65         IStateHistoryBackend htBackend;
  66
  67         /* If the target file already exists, do not rebuild it uselessly */
  68         // TODO for now we assume it's complete. Might be a good idea to check
  69         // at least if its range matches the trace's range.
  70         if (htFile.exists()) {
  71             /* Load an existing history */
  72             try {
  73                 htBackend = new HistoryTreeBackend(htFile);
  74                 ss = HistoryBuilder.openExistingHistory(htBackend);
  75                 return ss;
  76             } catch (IOException e) {
  77                 /*
  78                  * There was an error opening the existing file. Perhaps it was
  79                  * corrupted, perhaps it's an old version? We'll just
  80                  * fall-through and try to build a new one from scratch instead.
  81                  */
  82             }
  83         }
  84
  85         /* Create a new state history from scratch */
  86         HistoryBuilder builder;
  87
  88         if (htInput == null) {
  89             return null;
  90         }
  91         try {
  92             htBackend = new ThreadedHistoryTreeBackend(htFile,
  93                     htInput.getStartTime(), QUEUE_SIZE);
  94             builder = new HistoryBuilder(htInput, htBackend, buildManually);
  95         } catch (IOException e) {
  96             /*
  97              * If it fails here however, it means there was a problem writing to
  98              * the disk, so throw a real exception this time.
  99              */
 100             throw new TmfTraceException(e.toString(), e);
 101         }
 102         return builder.getStateSystemQuerier();
 103     }
 104 }