Exemplo n.º 1
0
    private boolean next() {
      if (myRes != null) return true;

      long started = startTiming();
      try {
        Loader loader;
        if (myLoaders != null) {
          while (myIndex < myLoaders.size()) {
            loader = myLoaders.get(myIndex++);
            if (!myCache.loaderHasName(myName, loader)) {
              myRes = null;
              continue;
            }
            myRes = loader.getResource(myName, myCheck);
            if (myRes != null) return true;
          }
        } else {
          while ((loader = getLoader(myIndex++)) != null) {
            if (!myCache.loaderHasName(myName, loader)) continue;
            myRes = loader.getResource(myName, myCheck);
            if (myRes != null) return true;
          }
        }
      } finally {
        logTiming(ClassPath.this, started, myName);
      }

      return false;
    }
    private boolean next() {
      if (myRes != null) return true;
      long started = myDebugTime ? System.nanoTime() : 0;
      Loader loader;
      try {
        if (myLoaders != null) {
          while (myIndex < myLoaders.size()) {
            loader = myLoaders.get(myIndex++);
            if (!myCache.loaderHasName(myName, loader)) {
              myRes = null;
              continue;
            }
            myRes = loader.getResource(myName, myCheck);
            if (myRes != null) return true;
          }
        } else {
          while ((loader = getLoader(myIndex++)) != null) {
            if (!myCache.loaderHasName(myName, loader)) continue;
            myRes = loader.getResource(myName, myCheck);
            if (myRes != null) return true;
          }
        }
      } finally {
        if (myDebugTime) reportTime(started, myName);
      }

      return false;
    }
Exemplo n.º 3
0
  @Nullable
  public Resource getResource(String s, boolean flag) {
    final long started = startTiming();
    try {
      int i;
      if (myCanUseCache) {
        Resource prevResource =
            myCache.iterateLoaders(s, flag ? ourCheckedIterator : ourUncheckedIterator, s, this);
        if (prevResource != null) return prevResource;

        synchronized (myUrls) {
          if (myUrls.isEmpty()) return null;
        }

        i = myLoaders.size();
      } else {
        i = 0;
      }

      Loader loader;
      while ((loader = getLoader(i++)) != null) {
        if (myCanUseCache) {
          if (!myCache.loaderHasName(s, loader)) continue;
        }
        Resource resource = loader.getResource(s, flag);
        if (resource != null) {
          return resource;
        }
      }
    } finally {
      logTiming(this, started, s);
    }

    return null;
  }
Exemplo n.º 4
0
  String getContent(String identifier) throws Exception {
    logger.trace("Searching for '{}' in cache.", identifier);
    ResourceWrapper wrapper = resources.get(identifier);

    // If not in cache yet, load it
    if (wrapper == null) {
      long start = System.currentTimeMillis();
      logger.debug("'{}' not in cache. Loading and processing...", identifier);
      String extension = FilenameUtils.getExtension(identifier);

      Type type = TypeFactory.getType(extension);
      if (type == null) {
        logger.warn("No type available for the specified resource: {}", extension);
        throw new UnknownTypeException(
            "No type available for the specified resource: " + extension);
      }

      String content = processContent(loader.loadResource(identifier), type);
      wrapper = new ResourceWrapper(identifier, type, content);
      resources.put(identifier, wrapper);
      logger.debug("Resource loaded and processed in {} ms.", System.currentTimeMillis() - start);
    } else {
      // If in cache, check last modified
      if (wrapper.getLastLoaded() < loader.lastModified(identifier)) {
        // If last loaded was before last modified, load it again
        wrapper.setContent(loader.loadResource(identifier));
      }
    }

    return wrapper.getContent();
  }
    @Override
    public Void doInBackground() {

      setProgress(0);

      MetaData metaData;
      final Loader loader = new Loader();
      final File file = loader.load();

      final Collection<File> files =
          FileUtils.listFiles(
              file, new RegexFileFilter("^(.*.mp3)"), DirectoryFileFilter.DIRECTORY);
      final List<Song> songList = new ArrayList<Song>();
      int onePercent = files.size() / 100;
      if (onePercent == 0) {
        onePercent = 1;
      }
      int progressSoFar = 0;
      for (final File singleFile : files) {
        metaData = new MetaData(singleFile);
        songList.add(new Song(metaData, singleFile));

        progress++;
        if (progress % onePercent == 0) {
          setProgress(Math.min(++progressSoFar, 99));
        }
      }

      songLibrary = new SongLibrary(songList);
      setProgress(100);
      pcs.firePropertyChange("libraryLoaded", 0, songLibrary);
      return null;
    }
Exemplo n.º 6
0
  /**
   * Create an <code>ObjectName</code> for this <code>Loader</code> object.
   *
   * @param domain Domain in which this name is to be created
   * @param loader The Loader to be named
   * @exception MalformedObjectNameException if a name cannot be created
   */
  static ObjectName createObjectName(String domain, Loader loader)
      throws MalformedObjectNameException {

    ObjectName name = null;
    Container container = loader.getContainer();

    if (container instanceof Engine) {
      name = new ObjectName(domain + ":type=Loader");
    } else if (container instanceof Host) {
      name = new ObjectName(domain + ":type=Loader,host=" + container.getName());
    } else if (container instanceof Context) {
      String path = ((Context) container).getPath();
      if (path.length() < 1) {
        path = "/";
      }
      Host host = (Host) container.getParent();
      name = new ObjectName(domain + ":type=Loader,path=" + path + ",host=" + host.getName());
    } else if (container == null) {
      // What is that ???
      DefaultContext defaultContext = loader.getDefaultContext();
      if (defaultContext != null) {
        Container parent = defaultContext.getParent();
        if (parent instanceof Engine) {
          name = new ObjectName(domain + ":type=DefaultLoader");
        } else if (parent instanceof Host) {
          name = new ObjectName(domain + ":type=DefaultLoader,host=" + parent.getName());
        }
      }
    }

    return (name);
  }
Exemplo n.º 7
0
  @Subscribe
  public void buildModList(FMLLoadEvent event) {
    this.modList = loader.getIndexedModList();
    Builder<String, EventBus> eventBus = ImmutableMap.builder();

    for (ModContainer mod : loader.getModList()) {
      EventBus bus = new EventBus(mod.getModId());
      boolean isActive = mod.registerBus(bus, this);
      if (isActive) {
        Level level = Logger.getLogger(mod.getModId()).getLevel();
        FMLLog.log(
            mod.getModId(),
            Level.FINE,
            "Mod Logging channel %s configured at %s level.",
            level == null ? "default" : level);
        FMLLog.log(mod.getModId(), Level.INFO, "Activating mod %s", mod.getModId());
        activeModList.add(mod);
        modStates.put(mod.getModId(), ModState.UNLOADED);
        eventBus.put(mod.getModId(), bus);
      } else {
        FMLLog.log(
            mod.getModId(),
            Level.WARNING,
            "Mod %s has been disabled through configuration",
            mod.getModId());
        modStates.put(mod.getModId(), ModState.UNLOADED);
        modStates.put(mod.getModId(), ModState.DISABLED);
      }
    }

    eventChannels = eventBus.build();
  }
Exemplo n.º 8
0
  /**
   * the Main way to add plugin to the PluginLoader
   *
   * @author RoboRave
   * @param plugin the class of the plugin
   * @throws IllegalAccessException
   * @throws InstantiationException
   */
  @SuppressWarnings("static-access")
  public static void addPlugin(Class<? extends Plugin> plugin)
      throws InstantiationException, IllegalAccessException {

    // if(plugin.getClass().getAnnotation(PreInit.class) != null)
    // {
    plugin.newInstance().preInit();
    if (MainCore.instance.dev == true && CommonUtils.isObfuscatedEnv() == false)
      CoreLogger.info("Loaded Preinit for " + plugin.newInstance().meta().name);
    // }

    //   if(plugin.getAnnotation(Info.Init.class))
    // {
    plugin.newInstance().init();
    if (MainCore.instance.dev == true && CommonUtils.isObfuscatedEnv() == false)
      CoreLogger.info("Loaded Init for " + plugin.newInstance().meta().name);
    // }

    // if(plugin.getClass().isAnnotationPresent(PostInit.class))
    // {
    plugin.newInstance().postInit();
    if (MainCore.instance.dev == true && CommonUtils.isObfuscatedEnv() == false)
      CoreLogger.info("Loaded Postinit for " + plugin.newInstance().meta().name);
    // }

    Loader.instance().mods.add(plugin);

    Loader.instance().plugins.add(plugin.newInstance().meta().name);
  }
Exemplo n.º 9
0
 public void testLoader() {
   Logger.getLogger("uk.ac.starlink.util").setLevel(Level.SEVERE);
   assertNull(Loader.getClassInstance("no.class.here.mate", TestCase.class));
   assertNull(Loader.getClassInstance(getClass().getName(), Comparable.class));
   assertEquals(
       LoaderTest.class, Loader.getClassInstance(getClass().getName(), TestCase.class).getClass());
 }
Exemplo n.º 10
0
 private void parseSimpleFieldAnnotation(
     SetMultimap<String, ASMData> annotations,
     String annotationClassName,
     Function<ModContainer, Object> retreiver)
     throws IllegalAccessException {
   String[] annName = annotationClassName.split("\\.");
   String annotationName = annName[annName.length - 1];
   for (ASMData targets : annotations.get(annotationClassName)) {
     String targetMod = (String) targets.getAnnotationInfo().get("value");
     Field f = null;
     Object injectedMod = null;
     ModContainer mc = this;
     boolean isStatic = false;
     Class<?> clz = modInstance.getClass();
     if (!Strings.isNullOrEmpty(targetMod)) {
       if (Loader.isModLoaded(targetMod)) {
         mc = Loader.instance().getIndexedModList().get(targetMod);
       } else {
         mc = null;
       }
     }
     if (mc != null) {
       try {
         clz = Class.forName(targets.getClassName(), true, Loader.instance().getModClassLoader());
         f = clz.getDeclaredField(targets.getObjectName());
         f.setAccessible(true);
         isStatic = Modifier.isStatic(f.getModifiers());
         injectedMod = retreiver.apply(mc);
       } catch (Exception e) {
         Throwables.propagateIfPossible(e);
         FMLLog.log(
             getModId(),
             Level.WARNING,
             e,
             "Attempting to load @%s in class %s for %s and failing",
             annotationName,
             targets.getClassName(),
             mc.getModId());
       }
     }
     if (f != null) {
       Object target = null;
       if (!isStatic) {
         target = modInstance;
         if (!modInstance.getClass().equals(clz)) {
           FMLLog.log(
               getModId(),
               Level.WARNING,
               "Unable to inject @%s in non-static field %s.%s for %s as it is NOT the primary mod instance",
               annotationName,
               targets.getClassName(),
               targets.getObjectName(),
               mc.getModId());
           continue;
         }
       }
       f.set(target, injectedMod);
     }
   }
 }
Exemplo n.º 11
0
  @Override
  public List load(EntityInfo... entityInfos) {
    // no need to timeouManage here, the underlying loader is the real time consumer
    List results = new ArrayList(entityInfos.length);
    if (entityInfos.length == 0) {
      return results;
    }

    if (projectionEnabledOnThis(entityInfos[0])) {
      Loader objectLoader = getObjectLoader();
      objectLoader.load(entityInfos); // load by batch
      for (EntityInfo entityInfo : entityInfos) {
        final Object entityInstance = objectLoader.loadWithoutTiming(entityInfo);
        entityInfo.populateWithEntityInstance(entityInstance);
      }
    }
    for (EntityInfo entityInfo : entityInfos) {
      if (transformer != null) {
        results.add(transformer.transformTuple(entityInfo.getProjection(), aliases));
      } else {
        results.add(entityInfo.getProjection());
      }
    }

    return results;
  }
Exemplo n.º 12
0
 /**
  * Loads the cache result, computing it if needed by executing the query phase and otherwise
  * deserializing the cached value into the {@link SearchContext#queryResult() context's query
  * result}. The combination of load + compute allows to have a single load operation that will
  * cause other requests with the same key to wait till its loaded an reuse the same cache.
  */
 public void loadIntoContext(
     final ShardSearchRequest request, final SearchContext context, final QueryPhase queryPhase)
     throws Exception {
   assert canCache(request, context);
   Key key = buildKey(request, context);
   Loader loader = new Loader(queryPhase, context, key);
   Value value = cache.get(key, loader);
   if (loader.isLoaded()) {
     key.shard.requestCache().onMiss();
     // see if its the first time we see this reader, and make sure to register a cleanup key
     CleanupKey cleanupKey =
         new CleanupKey(
             context.indexShard(),
             ((DirectoryReader) context.searcher().getIndexReader()).getVersion());
     if (!registeredClosedListeners.containsKey(cleanupKey)) {
       Boolean previous = registeredClosedListeners.putIfAbsent(cleanupKey, Boolean.TRUE);
       if (previous == null) {
         context.searcher().getIndexReader().addReaderClosedListener(cleanupKey);
       }
     }
   } else {
     key.shard.requestCache().onHit();
     // restore the cached query result into the context
     final QuerySearchResult result = context.queryResult();
     result.readFromWithId(context.id(), value.reference.streamInput());
     result.shardTarget(context.shardTarget());
   }
 }
Exemplo n.º 13
0
 public void computeBranding() {
   if (brandings == null) {
     Builder brd = ImmutableList.<String>builder();
     brd.add(Loader.instance().getMCVersionString());
     brd.add(Loader.instance().getMCPVersionString());
     brd.add("FML v" + Loader.instance().getFMLVersionString());
     String forgeBranding = (String) callForgeMethod("getBrandingVersion");
     if (!Strings.isNullOrEmpty(forgeBranding)) {
       brd.add(forgeBranding);
     }
     if (sidedDelegate != null) {
       brd.addAll(sidedDelegate.getAdditionalBrandingInformation());
     }
     try {
       Properties props = new Properties();
       props.load(getClass().getClassLoader().getResourceAsStream("fmlbranding.properties"));
       brd.add(props.getProperty("fmlbranding"));
     } catch (Exception ex) {
       // Ignore - no branding file found
     }
     int tModCount = Loader.instance().getModList().size();
     int aModCount = Loader.instance().getActiveModList().size();
     brd.add(
         String.format(
             "%d mod%s loaded, %d mod%s active",
             tModCount, tModCount != 1 ? "s" : "", aModCount, aModCount != 1 ? "s" : ""));
     brandings = brd.build();
   }
 }
Exemplo n.º 14
0
  public BranchGroup createSceneGraph(URL url) {

    try {
      Loader loader = new com.sun.j3d.loaders.objectfile.ObjectFile();
      Scene scene = loader.load(url);
      BranchGroup bg = scene.getSceneGroup();
      System.out.println(bg);
      TransformGroup[] views = scene.getViewGroups();
      if (views != null) {
        for (int i = 0; i < views.length; i++) {
          System.out.print(views[i]);
        }
        if (views.length > 0) viewStart = views[0];
      }
      return bg;
    } catch (Exception ex) {
      // in case there was a problem, print the stack out
      ex.printStackTrace();
      // System.out.println(ex);
      add("South", new Label(ex.toString()));
      System.out.println("URL: " + url);
      BranchGroup bg = new BranchGroup();
      bg.addChild(new ColorCube());
      System.out.println(bg);
      return bg;
    }
  }
  @Nullable
  public Resource getResource(String s, boolean flag) {
    final long started = myDebugTime ? System.nanoTime() : 0;

    try {
      int i;
      if (myCanUseCache) {
        Resource prevResource =
            myCache.iterateLoaders(s, flag ? checkedIterator : uncheckedIterator, s, this);
        if (prevResource != null) return prevResource;

        synchronized (myUrls) {
          if (myUrls.isEmpty()) return null;
        }

        i = myLoaders.size();
      } else {
        i = 0;
      }

      for (Loader loader; (loader = getLoader(i)) != null; i++) {
        if (myCanUseCache) {
          if (!myCache.loaderHasName(s, loader)) continue;
        }
        Resource resource = loader.getResource(s, flag);
        if (resource != null) {
          return resource;
        }
      }

      return null;
    } finally {
      if (myDebugTime) reportTime(started, s);
    }
  }
Exemplo n.º 16
0
  @Override
  public void bindMetadata(MetadataCollection mc) {
    modMetadata = mc.getMetadataForId(getModId(), descriptor);

    if (descriptor.containsKey("useMetadata")) {
      overridesMetadata = !((Boolean) descriptor.get("useMetadata")).booleanValue();
    }

    if (overridesMetadata || !modMetadata.useDependencyInformation) {
      Set<ArtifactVersion> requirements = Sets.newHashSet();
      List<ArtifactVersion> dependencies = Lists.newArrayList();
      List<ArtifactVersion> dependants = Lists.newArrayList();
      annotationDependencies = (String) descriptor.get("dependencies");
      Loader.instance()
          .computeDependencies(annotationDependencies, requirements, dependencies, dependants);
      modMetadata.requiredMods = requirements;
      modMetadata.dependencies = dependencies;
      modMetadata.dependants = dependants;
      FMLLog.finest("Parsed dependency info : %s %s %s", requirements, dependencies, dependants);
    } else {
      FMLLog.finest(
          "Using mcmod dependency info : %s %s %s",
          modMetadata.requiredMods, modMetadata.dependencies, modMetadata.dependants);
    }
    if (Strings.isNullOrEmpty(modMetadata.name)) {
      FMLLog.info(
          "Mod %s is missing the required element 'name'. Substituting %s", getModId(), getModId());
      modMetadata.name = getModId();
    }
    internalVersion = (String) descriptor.get("version");
    if (Strings.isNullOrEmpty(internalVersion)) {
      Properties versionProps = searchForVersionProperties();
      if (versionProps != null) {
        internalVersion = versionProps.getProperty(getModId() + ".version");
        FMLLog.fine(
            "Found version %s for mod %s in version.properties, using",
            internalVersion, getModId());
      }
    }
    if (Strings.isNullOrEmpty(internalVersion) && !Strings.isNullOrEmpty(modMetadata.version)) {
      FMLLog.warning(
          "Mod %s is missing the required element 'version' and a version.properties file could not be found. Falling back to metadata version %s",
          getModId(), modMetadata.version);
      internalVersion = modMetadata.version;
    }
    if (Strings.isNullOrEmpty(internalVersion)) {
      FMLLog.warning(
          "Mod %s is missing the required element 'version' and no fallback can be found. Substituting '1.0'.",
          getModId());
      modMetadata.version = internalVersion = "1.0";
    }

    String mcVersionString = (String) descriptor.get("acceptedMinecraftVersions");
    if (!Strings.isNullOrEmpty(mcVersionString)) {
      minecraftAccepted = VersionParser.parseRange(mcVersionString);
    } else {
      minecraftAccepted = Loader.instance().getMinecraftModContainer().getStaticVersionRange();
    }
  }
Exemplo n.º 17
0
 private void ensureHeavy() {
   if (!created) {
     loader.ensureHeavy(record);
     if (before != null) {
       loader.ensureHeavy(before);
     }
   }
 }
 private Loader obtainInstance(String documentId) throws FileNotFoundException {
   Loader loader;
   synchronized (mArchives) {
     loader = getInstanceUncheckedLocked(documentId);
     loader.getReadLock().lock();
   }
   return loader;
 }
Exemplo n.º 19
0
 public void AddJob() // method  to add a process and execute
     {
   load.loader();
   // load.quickSort(load.arlist,0,load.arlist.size()-1);
   System.out.println(load.getJobs());
   for (int i = 0; i < load.getJobs(); i++) {
     queue.add(load.arlist.get(i));
   }
 }
 /**
  * Returns a MIME type of a document within an archive.
  *
  * @see DocumentsProvider.getDocumentType(String)
  */
 public String getDocumentType(String documentId) throws FileNotFoundException {
   Loader loader = null;
   try {
     loader = obtainInstance(documentId);
     return loader.get().getDocumentType(documentId);
   } finally {
     releaseInstance(loader);
   }
 }
 /**
  * Finds the resource with the specified name on the URL search path or null if not found or
  * security check fails.
  *
  * @param name the name of the resource
  * @param check whether to perform a security check
  * @return a <code>URL</code> for the resource, or <code>null</code> if the resource could not be
  *     found.
  */
 public URL findResource(String name, boolean check) {
   Loader loader;
   for (int i = 0; (loader = getLoader(i)) != null; i++) {
     URL url = loader.findResource(name, check);
     if (url != null) {
       return url;
     }
   }
   return null;
 }
 /**
  * Returns metadata of a document within an archive.
  *
  * @see DocumentsProvider.queryDocument(String, String[])
  */
 public Cursor queryDocument(String documentId, @Nullable String[] projection)
     throws FileNotFoundException {
   Loader loader = null;
   try {
     loader = obtainInstance(documentId);
     return loader.get().queryDocument(documentId, projection);
   } finally {
     releaseInstance(loader);
   }
 }
 /**
  * Finds the first Resource on the URL search path which has the specified name. Returns null if
  * no Resource could be found.
  *
  * @param name the name of the Resource
  * @param check whether to perform a security check
  * @return the Resource, or null if not found
  */
 public Resource getResource(String name, boolean check) {
   Loader loader;
   for (int i = 0; (loader = getLoader(i)) != null; i++) {
     Resource res = loader.getResource(name, check);
     if (res != null) {
       return res;
     }
   }
   return null;
 }
Exemplo n.º 24
0
 /*     */ public void startElement(UnmarshallingContext.State state, TagName ea)
     throws SAXException {
   /*  59 */ JaxBeanInfo beanInfo = parseXsiType(state, ea, this.defaultBeanInfo);
   /*  60 */ if (beanInfo == null) {
     /*  61 */ beanInfo = this.defaultBeanInfo;
     /*     */ }
   /*  63 */ Loader loader = beanInfo.getLoader(null, false);
   /*  64 */ state.setLoader(loader);
   /*  65 */ loader.startElement(state, ea);
   /*     */ }
Exemplo n.º 25
0
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    listView = (ListView) findViewById(R.id.list);
    prefs = getSharedPreferences("com.uclastudentmedia.test_bank", 0);

    Loader loader = new Loader();
    loader.execute();
  }
 /**
  * Opens a file within an archive.
  *
  * @see DocumentsProvider.openDocument(String, String, CancellationSignal))
  */
 public ParcelFileDescriptor openDocument(
     String documentId, String mode, final CancellationSignal signal)
     throws FileNotFoundException {
   Loader loader = null;
   try {
     loader = obtainInstance(documentId);
     return loader.get().openDocument(documentId, mode, signal);
   } finally {
     releaseInstance(loader);
   }
 }
 /**
  * Opens a thumbnail of a file within an archive.
  *
  * @see DocumentsProvider.openDocumentThumbnail(String, Point, CancellationSignal))
  */
 public AssetFileDescriptor openDocumentThumbnail(
     String documentId, Point sizeHint, final CancellationSignal signal)
     throws FileNotFoundException {
   Loader loader = null;
   try {
     loader = obtainInstance(documentId);
     return loader.get().openDocumentThumbnail(documentId, sizeHint, signal);
   } finally {
     releaseInstance(loader);
   }
 }
 @Override
 public void entryRemoved(boolean evicted, String key, Loader oldValue, Loader newValue) {
   oldValue.getWriteLock().lock();
   try {
     oldValue.get().close();
   } catch (FileNotFoundException e) {
     Log.e(TAG, "Failed to close an archive as it no longer exists.");
   } finally {
     oldValue.getWriteLock().unlock();
   }
 }
 /**
  * Returns true if a document within an archive is a child or any descendant of the archive
  * document or another document within the archive.
  *
  * @see DocumentsProvider.isChildDocument(String, String)
  */
 public boolean isChildDocument(String parentDocumentId, String documentId) {
   Loader loader = null;
   try {
     loader = obtainInstance(documentId);
     return loader.get().isChildDocument(parentDocumentId, documentId);
   } catch (FileNotFoundException e) {
     throw new IllegalStateException(e);
   } finally {
     releaseInstance(loader);
   }
 }
Exemplo n.º 30
0
  public void loadEvents() throws Exception {
    ReplicatorRuntime runtime = null;
    Pipeline pipeline = null;
    Class<?> headExtractorClass = null;
    Class<?> storeClass = null;

    try {
      runtime =
          new ReplicatorRuntime(
              this.buildLoaderConfig(),
              new MockOpenReplicatorContext(),
              ReplicatorMonitor.getInstance());
      runtime.configure();
      pipeline = runtime.getPipeline();

      ExtractorWrapper ew = (ExtractorWrapper) pipeline.getHeadExtractor();
      headExtractorClass = ew.getExtractor().getClass();
      if (Loader.class.isAssignableFrom(headExtractorClass) != true) {
        throw new Exception(
            "Unable to start the loader because "
                + headExtractorClass
                + " does not extend "
                + Loader.class);
      }

      Loader extractor = (Loader) ew.getExtractor();
      if (extractor.getLockTables() == true) {
        for (String storeName : pipeline.getStoreNames()) {
          Store store = pipeline.getStore(storeName);
          storeClass = store.getClass();
          if (THL.class.isAssignableFrom(storeClass) == true) {
            THL thlStore = (THL) store;
            thlStore.setUrl(null);
          }
        }
      }

      runtime.prepare();
      pipeline.start(new MockEventDispatcher());
      pipeline.shutdownAfterHeartbeat("LOAD_COMPLETE");
      while (pipeline.isShutdown() != true) {
        // Wait for the pipeline to complete
        Thread.sleep(100);
      }

      logger.info("Tables imported");
    } finally {
      runtime.release();
    }
  }