private Versions readVersions(VFSLeaf leaf, VFSLeaf fVersions) {
    if (fVersions == null) {
      return new NotVersioned();
    }

    try {
      VFSContainer fVersionContainer = fVersions.getParentContainer();
      VersionsFileImpl versions = (VersionsFileImpl) XStreamHelper.readObject(mystream, fVersions);
      versions.setVersionFile(fVersions);
      versions.setCurrentVersion((Versionable) leaf);
      if (versions.getRevisionNr() == null || versions.getRevisionNr().length() == 0) {
        versions.setRevisionNr(getNextRevisionNr(versions));
      }

      for (VFSRevision revision : versions.getRevisions()) {
        RevisionFileImpl revisionImpl = (RevisionFileImpl) revision;
        revisionImpl.setContainer(fVersionContainer);
      }
      return versions;
    } catch (Exception e) {
      log.warn("This file is not a versions XML file: " + fVersions, e);
      fVersions.delete();
      VersionsFileImpl versions = new VersionsFileImpl();
      versions.setCurrentVersion((Versionable) leaf);
      versions.setVersioned(isVersioned(leaf));
      versions.setRevisionNr(getNextRevisionNr(versions));
      log.warn("Deleted corrupt version XML file and created new version XML file: " + versions);
      // the old revisions can not be restored automatically. They are still on disk, you could
      // recover them
      // manually. This is not a perfect solution, but at least the user does not get an RS
      return versions;
    }
  }
  @Override
  public void extract(VFSLeaf document, File bufferFile)
      throws IOException, DocumentAccessException {
    if (!(document instanceof LocalFileImpl)) {
      log.warn("Can only index local file");
      return;
    }

    List<String> cmds = new ArrayList<String>();
    cmds.add(searchModule.getPdfExternalIndexerCmd());
    cmds.add(((LocalFileImpl) document).getBasefile().getAbsolutePath());
    cmds.add(bufferFile.getAbsolutePath());

    CountDownLatch doneSignal = new CountDownLatch(1);

    ProcessWorker worker = new ProcessWorker(cmds, doneSignal);
    worker.start();

    try {
      doneSignal.await(3000, TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
      log.error("", e);
    }

    worker.destroyProcess();
  }
  private void loadSelectionKeysFromConfig() {
    Map<String, String> handlerConfig = cfgFactory.loadConfigForHandler(this);

    // now "calculate" available year-values for dropdown, according to
    // handler config
    if (handlerConfig.containsKey(PROP_FROM) && handlerConfig.containsKey(PROP_TO)) {
      // we have a valid config
      int nowYear = Calendar.getInstance().get(Calendar.YEAR);

      String from = handlerConfig.get(PROP_FROM);
      String to = handlerConfig.get(PROP_TO);
      int i_from = 1900;
      int i_to = 1900;

      if (from.startsWith("+")) i_from = nowYear + Integer.parseInt(from.substring(1));
      else if (from.startsWith("-")) i_from = nowYear - Integer.parseInt(from.substring(1));
      else i_from = Integer.parseInt(from);

      if (to.startsWith("+")) i_to = nowYear + Integer.parseInt(to.substring(1));
      else if (to.startsWith("-")) i_to = nowYear - Integer.parseInt(to.substring(1));
      else i_to = Integer.parseInt(to);

      if (i_to < i_from) {
        logger.warn("wrong config in YearPropertyHandler : to is smaller than from...");
        // leave selectionKeys to default
        selectionKeys = getDefaultYears();
      } else {
        // now fill the array
        int span = i_to - i_from;
        if (span > 1000) span = 1000; // just prevent toooooo long dropdown-list ^
        selectionKeys = new String[span + 1];
        for (int j = 0; j <= span; j++) selectionKeys[j] = String.valueOf(i_from + j);
      }
    }
  }
  private void refreshUIState() {
    boolean enabled = false;
    String cronExpression = "";
    if (CoreSpringFactory.containsBean("schedulerFactoryBean")) {
      log_.info("refreshUIState: schedulerFactoryBean found");
      Object schedulerFactoryBean = CoreSpringFactory.getBean("schedulerFactoryBean");
      if (schedulerFactoryBean != null && schedulerFactoryBean instanceof Scheduler) {
        Scheduler schedulerBean = (Scheduler) schedulerFactoryBean;
        int triggerState;
        try {
          triggerState =
              schedulerBean.getTriggerState("updateStatisticsTrigger", null /*trigger group*/);
          enabled = (triggerState != Trigger.STATE_NONE) && (triggerState != Trigger.STATE_ERROR);
          log_.info(
              "refreshUIState: updateStatisticsTrigger state was "
                  + triggerState
                  + ", enabled now: "
                  + enabled);
        } catch (SchedulerException e) {
          log_.warn(
              "refreshUIState: Got a SchedulerException while asking for the updateStatisticsTrigger's state",
              e);
        }
      }
      CronTriggerBean triggerBean =
          (CronTriggerBean) CoreSpringFactory.getBean("updateStatisticsTrigger");
      JobDetail jobDetail = triggerBean.getJobDetail();
      enabled &= jobDetail.getName().equals("org.olat.statistics.job.enabled");
      log_.info("refreshUIState: org.olat.statistics.job.enabled check, enabled now: " + enabled);
      cronExpression = triggerBean.getCronExpression();
      StatisticUpdateManager statisticUpdateManager = getStatisticUpdateManager();
      if (statisticUpdateManager == null) {
        log_.info("refreshUIState: statisticUpdateManager not configured");
        enabled = false;
      } else {
        enabled &= statisticUpdateManager.isEnabled();
        log_.info("refreshUIState: statisticUpdateManager configured, enabled now: " + enabled);
      }
    } else {
      log_.info("refreshUIState: schedulerFactoryBean not found");
    }
    if (enabled) {
      content.contextPut(
          "status",
          getTranslator().translate("statistics.status.enabled", new String[] {cronExpression}));
    } else {
      content.contextPut("status", getTranslator().translate("statistics.status.disabled"));
    }
    content.contextPut("statisticEnabled", enabled);

    recalcLastUpdated();

    updateStatisticUpdateOngoingFlag();
  }
Exemple #5
0
  @Override
  public SearchResults call() throws ParseException {
    IndexSearcher searcher = null;
    try {
      boolean debug = log.isDebug();

      if (!searchService.existIndex()) {
        log.warn("Index does not exist, can't search for queryString: " + queryString);
        throw new ServiceNotAvailableException("Index does not exist");
      }

      if (debug) log.debug("queryString=" + queryString);
      searcher = searchService.getIndexSearcher();
      BooleanQuery query = searchService.createQuery(queryString, condQueries);
      if (debug) log.debug("query=" + query);

      long startTime = System.currentTimeMillis();
      int n = SearchServiceFactory.getService().getSearchModuleConfig().getMaxHits();

      TopDocs docs = searcher.search(query, n);
      long queryTime = System.currentTimeMillis() - startTime;
      if (debug) log.debug("hits.length()=" + docs.totalHits);
      SearchResultsImpl searchResult =
          new SearchResultsImpl(
              searchService.getMainIndexer(),
              searcher,
              docs,
              query,
              searchService.getAnalyzer(),
              identity,
              roles,
              firstResult,
              maxResults,
              doHighlighting,
              false);
      searchResult.setQueryTime(queryTime);
      searchResult.setNumberOfIndexDocuments(docs.totalHits);
      if (debug) log.debug("found=" + docs.totalHits);

      return searchResult;
    } catch (ParseException pex) {
      throw pex;
    } catch (Exception naex) {
      log.error("", naex);
      return null;
    } finally {
      searchService.releaseIndexSearcher(searcher);
      DBFactory.getInstance().commitAndCloseSession();
    }
  }
 /**
  * [used by Spring]
  *
  * @param cronExpression
  */
 public void setCronExpression(String cronExpression) {
   if (CronExpression.isValidExpression(cronExpression)) {
     this.cronExpression = cronExpression;
   } else {
     if (StringHelper.containsNonWhitespace(cronExpression)) {
       // was not empty, so someone tried to set someting here, let user know that it was garbage
       log.warn(
           "Configured cron expression is not valid::"
               + cronExpression
               + " check your search.indexing.cronjob.expression property",
           null);
     }
     this.cronExpression = null;
   }
 }
Exemple #7
0
  private static ContainerAndFile findWritableRootFolderForRecursion(
      VFSContainer rootDir, String relFilePath, int recursionLevel) {
    recursionLevel++;
    if (recursionLevel > 20) {
      // Emergency exit condition: a directory hierarchy that has more than 20
      // levels? Probably not..
      log.warn(
          "Reached recursion level while finding writable root Folder - most likely a bug. rootDir::"
              + rootDir
              + " relFilePath::"
              + relFilePath);
      return null;
    }

    if (rootDir instanceof NamedContainerImpl) {
      rootDir = ((NamedContainerImpl) rootDir).getDelegate();
    }
    if (rootDir instanceof MergeSource) {
      MergeSource mergedDir = (MergeSource) rootDir;
      // first check if the next level is not a second MergeSource
      int stop = relFilePath.indexOf("/", 1);
      if (stop > 0) {
        String nextLevel = extractChild(relFilePath);
        VFSItem item = mergedDir.resolve(nextLevel);
        if (item instanceof NamedContainerImpl) {
          item = ((NamedContainerImpl) item).getDelegate();
        }
        if (item instanceof MergeSource) {
          rootDir = (MergeSource) item;
          relFilePath = relFilePath.substring(stop);
          return findWritableRootFolderForRecursion(rootDir, relFilePath, recursionLevel);
        }
      }

      VFSContainer rootWriteContainer = mergedDir.getRootWriteContainer();
      if (rootWriteContainer == null) {
        // we have a merge source without a write container, try it one higher,
        // go through all children of this one and search the correct child in
        // the path
        List<VFSItem> children = rootDir.getItems();
        if (children.isEmpty()) {
          // ups, a merge source without children, no good, return null
          return null;
        }

        String nextChildName = relFilePath.substring(1, relFilePath.indexOf("/", 1));
        for (VFSItem child : children) {
          // look up for the next child in the path
          if (child.getName().equals(nextChildName)) {
            // use this child as new root and remove the child name from the rel
            // path
            if (child instanceof VFSContainer) {
              rootDir = (VFSContainer) child;
              relFilePath = relFilePath.substring(relFilePath.indexOf("/", 1));
              break;
            } else {
              // ups, a merge source with a child that is not a VFSContainer -
              // no good, return null
              return null;
            }
          }
        }
      } else {
        // ok, we found a merge source with a write container
        rootDir = rootWriteContainer;
      }
    }
    if (rootDir != null && rootDir instanceof LocalFolderImpl) {
      // finished, we found a local folder we can use to write
      return new ContainerAndFile(rootDir, relFilePath);
    } else {
      // do recursion
      return findWritableRootFolderForRecursion(rootDir, relFilePath, recursionLevel);
    }
  }