Esempio n. 1
1
  /**
   * Move the files
   *
   * @param fileLocation
   * @param filename
   * @param filebeforepprocess
   * @return
   */
  private boolean moveFile(
      String fileLocation,
      String filename,
      String filebeforepprocess,
      String fileafterprocess,
      String newFileLocation)
      throws FileSystemException {

    boolean resultStatus = false;

    FileSystemOptions opts = FTPSiteUtils.createDefaultOptions();
    FileSystemManager manager = VFS.getManager();
    // Create remote object
    FileObject remoteFile = manager.resolveFile(fileLocation + filename, opts);
    FileObject newFile = manager.resolveFile(newFileLocation + filename, opts);
    if (!filebeforepprocess.equals("")) {
      FileObject fBeforeProcess = manager.resolveFile(filebeforepprocess + filename, opts);
      fBeforeProcess.copyFrom(remoteFile, Selectors.SELECT_SELF);
    }

    if (remoteFile.exists()) {
      remoteFile.moveTo(newFile);
      resultStatus = true;
      if (log.isDebugEnabled()) {
        log.info("Move remote file success");
      }
    }

    if (!fileafterprocess.equals("")) {
      FileObject fAfterProcess = manager.resolveFile(fileafterprocess + filename, opts);
      fAfterProcess.copyFrom(newFile, Selectors.SELECT_SELF);
    }

    return resultStatus;
  }
Esempio n. 2
0
 public static FileObject resolveFile(String fileUri, UserAuthenticator userAuthenticator)
     throws FileSystemException {
   FileSystemOptions opts = null;
   if (VFS.getManager().getBaseFile() != null) {
     opts = VFS.getManager().getBaseFile().getFileSystem().getFileSystemOptions();
   }
   if (opts == null) {
     opts = new FileSystemOptions();
   }
   DefaultFileSystemConfigBuilder.getInstance().setUserAuthenticator(opts, userAuthenticator);
   FileObject file = resolveFile(fileUri, opts);
   return file;
 }
 private void startFileMonitor(long scanInterval) throws FileSystemException {
   FileSystemManager fsManager = VFS.getManager();
   FileObject listenFile = fsManager.resolveFile(propertyFile.getAbsolutePath());
   DefaultFileMonitor defaultFileMonitor = new DefaultFileMonitor(new ServiceIdFileMonitor(this));
   defaultFileMonitor.setDelay(scanInterval);
   defaultFileMonitor.addFile(listenFile);
   defaultFileMonitor.start();
   LOGGER.info("Started file monitor on " + propertyFile.getAbsolutePath());
 }
Esempio n. 4
0
  /** @param aLauncher Launcher being used in background */
  public NuxeoLauncherGUI(NuxeoLauncher aLauncher) {
    launcher = aLauncher;
    // Set OS-specific decorations
    if (PlatformUtils.isMac()) {
      System.setProperty("apple.laf.useScreenMenuBar", "true");
      System.setProperty("com.apple.mrj.application.growbox.intrudes", "false");
      System.setProperty("com.apple.mrj.application.live-resize", "true");
      System.setProperty("com.apple.macos.smallTabs", "true");
    }
    initFrame();
    dumpedConfigMonitor =
        new DefaultFileMonitor(
            new FileListener() {
              @Override
              public void fileDeleted(FileChangeEvent event) {
                // Ignore
              }

              @Override
              public void fileCreated(FileChangeEvent event) {
                updateNuxeoFrame();
              }

              @Override
              public void fileChanged(FileChangeEvent event) {
                updateNuxeoFrame();
              }

              private synchronized void updateNuxeoFrame() {
                waitForFrameLoaded();
                log.debug("Configuration changed. Reloading frame...");
                launcher.init();
                updateServerStatus();
                try {
                  Properties props = new Properties();
                  props.load(new FileReader(getConfigurationGenerator().getDumpedConfig()));
                  nuxeoFrame.updateLogsTab(props.getProperty("log.id"));
                } catch (IOException e) {
                  log.error(e);
                }
              }
            });
    try {
      dumpedConfigMonitor.setRecursive(false);
      FileObject dumpedConfig =
          VFS.getManager().resolveFile(getConfigurationGenerator().getDumpedConfig().getPath());
      dumpedConfigMonitor.addFile(dumpedConfig);
      dumpedConfigMonitor.start();
    } catch (FileSystemException e) {
      throw new RuntimeException("Couldn't find " + getConfigurationGenerator().getNuxeoConf(), e);
    }
  }
  /** Constructor for testing purposes. Takes a repository as a parameter. */
  public OlapServiceImpl(IUnifiedRepository repo, final MondrianServer server) {
    this.repository = repo;
    this.filters = new CopyOnWriteArrayList<IOlapConnectionFilter>();
    this.server = server;

    try {
      DefaultFileSystemManager dfsm = (DefaultFileSystemManager) VFS.getManager();
      if (dfsm.hasProvider("mondrian") == false) {
        dfsm.addProvider("mondrian", new MondrianVfs());
      }
    } catch (FileSystemException e) {
      throw new RuntimeException(e);
    }
  }
  public static void deployWebappFiles(ServletContext servletContext) throws IOException {
    Assert.Arg.notNull(servletContext, "servletContext");

    FileSystemManager fsManager = VFS.getManager();
    FileObject webappDir = fsManager.resolveFile(servletContext.getRealPath("/"));
    logger.info("Webapp dir: " + webappDir.getName());

    for (Enumeration<URL> dirUrls = getResources(WEBAPP_DIR); dirUrls.hasMoreElements(); ) {
      FileObject extWebappDir = fsManager.resolveFile(dirUrls.nextElement().toExternalForm());
      logger.info("Extension webapp dir: " + extWebappDir.getName());
      if (extWebappDir.getType().hasChildren()) {
        logger.info("  Deploying webapp files ... ");
        webappDir.copyFrom(extWebappDir, new AllFileSelector());
      }
    }
  }
Esempio n. 7
0
  public ConfigurationWatcher(ConfigChangeListener<C> configListener, Class<C> confClass) {
    this.configListener = configListener;
    this.confClass = confClass;
    this.confFilePath = ConfigurationManager.getConfFilePath(confClass);

    try {
      FileSystemManager fsManager = VFS.getManager();
      FileObject file = fsManager.resolveFile(this.confFilePath);
      fileMonitor = new DefaultFileMonitor(this);
      fileMonitor.setRecursive(false);
      fileMonitor.addFile(file);
      fileMonitor.start();

      this.notifyListener();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Esempio n. 8
0
 public FileObject connectAndChangeToWorkDir() throws FileSystemException {
   StaticUserAuthenticator auth =
       new StaticUserAuthenticator(null, ftpConfig.getUsername(), ftpConfig.getPassword());
   FileSystemOptions opts = new FileSystemOptions();
   switch (ftpConfig.getType()) {
     case FTP:
       FtpFileSystemConfigBuilder.getInstance().setSoTimeout(opts, SOCKET_TIMEOUT);
       FtpFileSystemConfigBuilder.getInstance().setDataTimeout(opts, DATA_TIMEOUT);
       FtpFileSystemConfigBuilder.getInstance().setConnectTimeout(opts, CONNET_TIMEOUT);
       break;
     case FTPS:
       FtpsFileSystemConfigBuilder.getInstance().setSoTimeout(opts, SOCKET_TIMEOUT);
       FtpsFileSystemConfigBuilder.getInstance().setDataTimeout(opts, DATA_TIMEOUT);
       FtpsFileSystemConfigBuilder.getInstance().setConnectTimeout(opts, CONNET_TIMEOUT);
       break;
     case SFTP:
       SftpFileSystemConfigBuilder.getInstance().setTimeout(opts, SOCKET_TIMEOUT);
       break;
   }
   DefaultFileSystemConfigBuilder.getInstance().setUserAuthenticator(opts, auth);
   FileObject fo = VFS.getManager().resolveFile(connectionString, opts);
   LOG.info("connected at {} #{}", connectionString, ftpConfig.getId());
   return fo;
 }
  private void killLogstashAgent(int logAgentNumber, String logstashLogPath) {

    FileObject listendir;
    CustomFileListener listener = new CustomFileListener();
    long TIMEOUT_BETWEEN_FILE_QUERYING = 1000;
    long LOOP_TIMEOUT_IN_MILLIS = 10 * 1000;

    try {
      FileSystemManager fileSystemManager = VFS.getManager();
      listendir = fileSystemManager.resolveFile(logstashLogPath);
    } catch (FileSystemException e) {
      e.printStackTrace();
      return;
    }

    DefaultFileMonitor fm = new DefaultFileMonitor(listener);
    fm.setRecursive(true);
    fm.addFile(listendir);
    fm.setDelay(TIMEOUT_BETWEEN_FILE_QUERYING);
    fm.start();

    LogUtils.log("waiting to destroy logger");
    long startTimeMillis = System.currentTimeMillis();

    while (true) {

      if (!listener.isProcessUp()) {
        break;
      }

      listener.setProcessUp(false);

      try {
        TimeUnit.MILLISECONDS.sleep(LOOP_TIMEOUT_IN_MILLIS);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    long endTimeMillis = System.currentTimeMillis();
    LogUtils.log("destroying logstash agent " + logAgentNumber);
    LogUtils.log("waited " + (endTimeMillis - startTimeMillis) / 1000 + " seconds");
    fm.stop();

    //        File logstashOutputFile = new File(logstashLogPath);

    if (logAgentNumber == 1) {

      process.destroy();
      process = null;
    } else {

      process2.destroy();
      process2 = null;
    }

    //        try {
    //            TimeUnit.SECONDS.sleep(5);
    //
    //            LogUtils.log("returning logstash config file to initial state");
    //            if(logAgentNumber == 1){
    //                IOUtils.replaceFileWithMove(new File(confFilePath), new File(backupFilePath));
    //                FileUtils.deleteQuietly(new File(backupFilePath));
    //            }
    //            else{
    //                IOUtils.replaceFileWithMove(new File(confFilePath2), new
    // File(backupFilePath2));
    //                FileUtils.deleteQuietly(new File(backupFilePath2));
    //
    //            }
    //        } catch (IOException e) {
    //            e.printStackTrace();
    //        } catch (InterruptedException e) {
    //            e.printStackTrace();
    //        }

    //        if(logstashOutputFile.exists()){
    //            FileUtils.deleteQuietly(logstashOutputFile);
    //        }
  }
Esempio n. 10
0
 public static FileObject resolveFile(String fileUri, FileSystemOptions opts)
     throws FileSystemException {
   FileObject file = VFS.getManager().resolveFile(fileUri, opts);
   return file;
 }
  public void process() throws Exception {
    StreamProcessingLogDataCollector logDataCollector =
        new StreamProcessingLogDataCollector(logDataParsedListener, batchProcessingContext);
    FileSystemManager manager = null;
    try {
      manager = VFS.getManager();
    } catch (FileSystemException e1) {
      return;
    }
    int i = 0;
    ArrayList<FileObject> fileObjects = new ArrayList<>();
    for (String file : files) {
      i++;
      FileObject resolveFile = null;
      try {
        batchProcessingContext.printIfVerbose(
            "Resolving file %s [%d of %d]", file, i, files.size());
        try {
          resolveFile = manager.resolveFile(file);
        } catch (Exception e) {
          file = new File(file).getAbsolutePath();
          resolveFile = manager.resolveFile(file);
        }
        if (resolveFile != null) {
          fileObjects.add(resolveFile);
        }
      } catch (Exception e) {
        System.err.printf("Error resolving %s: %s", file, e.getMessage());
      }
    }
    batchProcessingContext.setAllFiles(fileObjects);

    if (logDataParsedListener instanceof BatchProcessingListener) {
      ((BatchProcessingListener) logDataParsedListener).processingStarted(batchProcessingContext);
    }

    AutoDetectingImporterProvider importerProvider =
        new AutoDetectingImporterProvider(
            AllPluginables.getInstance().getLogImportersContainer().getElements());
    i = 0;
    for (FileObject resolveFile : fileObjects) {
      i++;

      String fileName = resolveFile.getName().getBaseName();
      try {
        batchProcessingContext.printIfVerbose(
            "Opening file %s [%d of %d]", fileName, i, fileObjects.size());
        batchProcessingContext.setCurrentFile(resolveFile);
        if (logDataParsedListener instanceof SingleFileBatchProcessingListener) {
          ((SingleFileBatchProcessingListener) logDataParsedListener)
              .processingFileStarted(batchProcessingContext);
        }
        LoadingInfo openFileObject = Utils.openFileObject(resolveFile);
        LogImporter logImporter = importerProvider.getLogImporter(openFileObject);
        if (logImporter == null) {
          System.err.println("Can't find suitable log importer for " + fileName);
          continue;
        }
        batchProcessingContext.printIfVerbose(
            "Will user log importer: %s [%s]",
            logImporter.getName(), logImporter.getPluginableId());

        // TODO for HTTP, Attempted read on closed stream. issue related to checking if file is
        // gziped
        // Utils.closeQuietly(resolveFile);
        // String fileUrl = resolveFile.getURL().toString();
        // resolveFile = manager.resolveFile(fileUrl);
        // openFileObject = Utils.openFileObject(resolveFile);

        batchProcessingContext.setCurrentFile(resolveFile);
        ParsingContext context = new ParsingContext();
        context.setLogSource(resolveFile.getName().getFriendlyURI());
        logImporter.initParsingContext(context);
        logImporter.importLogs(openFileObject.getContentInputStream(), logDataCollector, context);

        if (logDataParsedListener instanceof SingleFileBatchProcessingListener) {
          ((SingleFileBatchProcessingListener) logDataParsedListener)
              .processingFileFinished(batchProcessingContext);
        }
        batchProcessingContext.printIfVerbose(
            "File %s processed  [%d of %d]", fileName, i, files.size());
      } catch (Exception e) {
        batchProcessingContext.printIfVerbose(
            "Error processing file %s: %s", fileName, e.getMessage());
        System.err.println("Can't resolve file " + fileName + ": " + e.getMessage());
        continue;
      }
    }
    if (logDataParsedListener instanceof BatchProcessingListener) {
      ((BatchProcessingListener) logDataParsedListener).processingFinished(batchProcessingContext);
    }
  }