Exemple #1
0
  /**
   * @param bean
   * @param progressListener
   * @return
   * @throws NotEnoughDiskSpaceException
   * @throws FileBrokerException
   * @throws JMSException
   * @throws IOException
   * @throws Exception
   */
  public boolean uploadToCacheIfNeeded(DataBean bean, CopyProgressListener progressListener)
      throws NotEnoughDiskSpaceException, FileBrokerException, JMSException, IOException,
          Exception {

    try {
      bean.getLock().readLock().lock();

      // upload only if not already available in cache or storage
      if (Session.getSession()
              .getServiceAccessor()
              .getFileBrokerClient()
              .isAvailable(bean.getId(), bean.getSize(), bean.getChecksum(), FileBrokerArea.CACHE)
          || Session.getSession()
              .getServiceAccessor()
              .getFileBrokerClient()
              .isAvailable(
                  bean.getId(), bean.getSize(), bean.getChecksum(), FileBrokerArea.STORAGE)) {
        return false;
      }

      // need to upload
      return upload(bean, FileBrokerArea.CACHE, progressListener);

    } finally {
      bean.getLock().readLock().unlock();
    }
  }
  private void doImportSequence() {
    try {
      new SequenceImportDialog(Session.getSession().getApplication());

    } catch (Exception me) {
      Session.getSession().getApplication().reportException(me);
    }
  }
  private void doCreateFromText() {
    try {
      new CreateFromTextDialog(Session.getSession().getApplication());

    } catch (Exception me) {
      Session.getSession().getApplication().reportException(me);
    }
  }
Exemple #4
0
  private boolean upload(
      DataBean dataBean, FileBrokerArea area, CopyProgressListener progressListener)
      throws Exception {
    // check if content is still available
    if (dataBean.getContentLocations().size() == 0) {
      return false;
    }

    // try to upload
    try {
      String checksum =
          Session.getSession()
              .getServiceAccessor()
              .getFileBrokerClient()
              .addFile(
                  dataBean.getId(),
                  area,
                  getContentStream(dataBean, DataNotAvailableHandling.EXCEPTION_ON_NA),
                  getContentLength(dataBean),
                  progressListener);

      setOrVerifyChecksum(dataBean, checksum);

    } catch (Exception e) {
      logger.warn("could not upload data: " + dataBean.getName(), e);
      throw e;
    }
    return true;
  }
Exemple #5
0
 public void addContentLocationForDataBean(DataBean bean, StorageMethod method, URL url)
     throws ContentLengthException, IOException {
   ContentLocation location = new ContentLocation(method, getHandlerFor(method), url);
   try {
     setOrVerifyContentLength(bean, getContentLength(location));
   } catch (IOException e) {
     throw new IOException("content length not available: " + e);
   } catch (ContentLengthException e) {
     try {
       DataManager manager = Session.getSession().getDataManager();
       String msg;
       msg =
           "Wrong content length for dataset "
               + bean.getName()
               + ". "
               + " In ContentLocation "
               + location.getUrl()
               + ", length is "
               + getContentLength(location)
               + " bytes. ";
       msg += "Content locations: ";
       for (ContentLocation loc : manager.getContentLocationsForDataBeanSaving(bean)) {
         msg += loc.getUrl() + " " + manager.getContentLength(loc) + " bytes, ";
       }
       throw new ContentLengthException(msg);
     } catch (IOException e1) {
       logger.error("another exception while handling " + Exceptions.getStackTrace(e), e);
     }
   }
   bean.addContentLocation(location);
 }
Exemple #6
0
  public void connectChildren(final List<? extends DataItem> children, final DataFolder parent) {

    final ArrayList<AddTypeTagsCallable> callables = new ArrayList<>();
    final ArrayList<DataItemCreatedEvent> events = new ArrayList<>();

    // edit databeans in EDT
    ThreadUtils.runInEDT(
        new Runnable() {
          @Override
          public void run() {
            for (DataItem child : children) {
              // was it already connected?
              boolean wasConnected = child.getParent() != null;
              if (!wasConnected) {
                // prepare event, but don't send it yet
                events.add(new DataItemCreatedEvent(child));
              }

              // connect to this
              child.setParent(parent);

              // add
              parent.children.add(child);

              // prepare type tagging callables
              if (child instanceof DataBean) {
                callables.add(new AddTypeTagsCallable((DataBean) child));
              }
            }
          }
        });

    // run type tagging in parallel in background threads
    try {
      // run callables and wait until all have finished
      List<Future<Object>> futures = executor.invokeAll(callables);

      for (Future<Object> future : futures) {
        // check callable for exception, and throw if found
        future.get();
      }

      // dispatch events in EDT
      ThreadUtils.runInEDT(
          new Runnable() {
            @Override
            public void run() {
              for (DataItemCreatedEvent event : events) {
                dispatchEvent(event);
              }
            }
          });

    } catch (InterruptedException | ExecutionException e) {
      Session.getSession().getApplication().reportExceptionThreadSafely(e);
    }
  }
Exemple #7
0
  public boolean uploadToStorageIfNeeded(DataBean bean) throws Exception {

    // check if already in storage
    if (Session.getSession()
        .getServiceAccessor()
        .getFileBrokerClient()
        .isAvailable(bean.getId(), bean.getSize(), bean.getChecksum(), FileBrokerArea.STORAGE)) {
      return true;
    }

    // move from cache if possible
    if (Session.getSession()
        .getServiceAccessor()
        .getFileBrokerClient()
        .moveFromCacheToStorage(bean.getId())) {
      return true;
    }

    // upload
    return upload(bean, FileBrokerArea.STORAGE, null);
  }
Exemple #8
0
  /**
   * Reset import screen. This can be used while creating totally new instance of import screen or
   * just resetting the default.
   *
   * @param setVisibleAfterReset set import screen frame visible after it has been reseted
   */
  public void resetImportScreen(boolean setVisibleAfterReset) {

    application = Session.getSession().getApplication();

    // If frame exists, set visibility to false while resetting
    if (frame != null) {
      frame.setVisible(false);
    }

    // Create new instances of conversion model, column type manager and trimmers
    conversionModel = new ConversionModel(this);
    columnTypeManager = new ColumnTypeManager(0);
    dataTrimmer = new DataTrimmer();

    // Ignore first
    dataTrimmer.addIgnoreColumnNumber(0);

    flagTrimmer = new DataTrimmer();
    flagTrimmer.addIgnoreColumnNumber(0);

    // Table has to be first to get references right
    tableFrame = new TableInternalFrame(this);
    toolsFrame = new ToolsInternalFrame(this);

    conversionModel.addConversionChangeListener(tableFrame);
    columnTypeManager.addColumnTypeChangeListener(tableFrame);
    columnTypeManager.addColumnTypeChangeListener(toolsFrame);

    frame = new JFrame("Import tool");
    mainSplit = new JSplitPane();

    frame.setLayout(new BorderLayout());
    frame.setSize(IMPORT_SCREEN_SIZE);

    mainSplit.setOrientation(JSplitPane.HORIZONTAL_SPLIT);
    mainSplit.setDividerLocation(TOOLS_FRAME_WIDTH);
    mainSplit.setLeftComponent(toolsFrame);
    mainSplit.setRightComponent(tableFrame);
    mainSplit.getLeftComponent().setMinimumSize(new Dimension(150, 0));
    mainSplit.setResizeWeight(0);

    frame.add(mainSplit, BorderLayout.CENTER);

    // Reset buttons
    changeStepPanel = null;
    frame.add(getChangeStepButtonsPanel(), BorderLayout.SOUTH);

    if (setVisibleAfterReset) {
      frame.setVisible(true);
    }
  }
  /**
   * Creates a new instance of AutomatedMovement
   *
   * @param projection
   * @param worker
   */
  public AutomatedMovement(Projection projection, Worker worker) {
    this.projection = projection;
    this.worker = worker;
    this.taskQueue = new LinkedList<Task>();
    // this.obj = new Object();

    Session.getSession()
        .getApplication()
        .addClientEventListener(
            new PropertyChangeListener() {
              public void propertyChange(PropertyChangeEvent evt) {
                if (evt instanceof VisualisationMethodChangedEvent) {
                  AutomatedMovement.this.kill();
                }
              }
            });
  }
Exemple #10
0
  private InputStream getBaseContentStream(DataBean bean, DataNotAvailableHandling naHandling)
      throws IOException {

    // try local content locations first
    ContentLocation location = getClosestContentLocation(bean);

    if (location != null) {

      // local available TODO maybe check if it really is available
      return location.getHandler().getInputStream(location);
    }

    // try from filebroker
    Exception remoteException;
    try {
      return Session.getSession()
          .getServiceAccessor()
          .getFileBrokerClient()
          .getInputStream(bean.getId());
    } catch (Exception e) {
      remoteException = e;
    }

    // not available
    switch (naHandling) {
      case EMPTY_ON_NA:
        return new ByteArrayInputStream(new byte[] {});

      case INFOTEXT_ON_NA:
        return new ByteArrayInputStream(DATA_NA_INFOTEXT.getBytes());

      case NULL_ON_NA:
        return null;

      default:
        String message = "data contents not available";
        if (remoteException != null) {
          message += ": " + remoteException.getMessage();
        }
        throw new RuntimeException(message, remoteException);
    }
  }
Exemple #11
0
 /**
  * Returns content size in bytes. Returns -1 if data is not available.
  *
  * <p>Size reported by content location is stored in DataBean in read from there when possible.
  */
 public Long getContentLength(DataBean bean) {
   if (bean.getSize() == null) {
     try {
       ContentLocation location = getClosestContentLocation(bean);
       if (location != null) {
         bean.setSize(getContentLength(location));
       } else {
         Long size =
             Session.getSession()
                 .getServiceAccessor()
                 .getFileBrokerClient()
                 .getContentLength(bean.getId());
         if (size != null) {
           bean.setSize(size);
         } else {
           return -1l;
         }
       }
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
   }
   return bean.getSize();
 }
  private void createOperations() {
    for (OperationType operationType : sessionType.getOperation()) {
      String operationSessionId = operationType.getId();

      // check for unique id
      if (operationRecords.containsKey(operationSessionId)) {
        logger.warn("duplicate operation id: " + operationSessionId);
        continue;
      }

      OperationRecord operationRecord = new OperationRecord();

      // name id
      operationRecord.setNameID(createNameID(operationType.getName()));

      // category
      operationRecord.setCategoryName(operationType.getCategory());
      String colorString = operationType.getCategoryColor();
      if (colorString != null) {
        operationRecord.setCategoryColor(Color.decode(colorString));
      }

      // module
      operationRecord.setModule(operationType.getModule());

      // parameters
      for (ParameterType parameterType : operationType.getParameter()) {
        operationRecord.addParameter(
            parameterType.getName().getId(),
            parameterType.getName().getDisplayName(),
            parameterType.getName().getDescription(),
            parameterType.getValue());
      }

      // source code
      String sourceCodeFileName = operationType.getSourceCodeFile();
      if (sourceCodeFileName != null && !sourceCodeFileName.isEmpty()) {
        String sourceCode = null;
        try {
          sourceCode = getSourceCode(sourceCodeFileName);
        } catch (Exception e) {
          logger.warn("could not load source code from " + sourceCodeFileName);
        }

        // might be null, is ok
        operationRecord.setSourceCode(sourceCode);
      }

      // update names, category from the current version of the tool
      OperationDefinition currentTool;
      currentTool =
          Session.getSession()
              .getApplication()
              .getOperationDefinitionBestMatch(
                  operationRecord.getNameID().getID(),
                  operationRecord.getModule(),
                  operationRecord.getCategoryName());
      if (currentTool != null) {
        operationRecord.getNameID().setDisplayName(currentTool.getDisplayName());
        operationRecord.getNameID().setDescription(currentTool.getDescription());
        if (currentTool.getCategory().getModule() != null) {
          operationRecord.setModule(currentTool.getCategory().getModule().getModuleName());
        }
        operationRecord.setCategoryName(currentTool.getCategoryName());
        operationRecord.setCategoryColor(currentTool.getCategory().getColor());

        for (ParameterRecord parameterRecord : operationRecord.getParameters()) {
          Parameter currentParameter =
              currentTool.getParameter(parameterRecord.getNameID().getID());
          if (currentParameter != null) {
            parameterRecord.getNameID().setDisplayName(currentParameter.getDisplayName());
            parameterRecord.getNameID().setDescription(currentParameter.getDescription());
          }
        }
      }

      // store the operation record
      operationRecords.put(operationSessionId, operationRecord);
      operationTypes.put(operationRecord, operationType);
    }
  }
Exemple #13
0
    @Override
    public void taskToDo() {
      List<ImportItem> dataItems = new ArrayList<ImportItem>();

      boolean hasNext = files.hasNext();
      File currentFile = null;
      try {
        do {

          // Write file to disk
          conversionModel.writeToFile(informator); // Throws exceptions

          // Import files to application and create the DataBeans
          if (application != null) {

            for (File outputFile : conversionModel.getOutputFiles()) {
              ImportItem item = new ImportItem(outputFile);
              item.setType(Session.getSession().getDataManager().getContentType("text/tab"));
              item.setFilename(outputFile.getName());

              dataItems.add(item);
            }
          }

          // Get next file
          hasNext = files.hasNext();
          if (hasNext) {
            currentFile = files.next();
            conversionModel.setInputFile(currentFile);
          }

          if (hasNext) {
            informator.setMessage("Writing data to disk from file " + currentFile.getName());
          }

        } while (hasNext && importSession.getUseSameDescriptions());

        application.importGroup(dataItems, importSession.getDestinationFolder());
      }

      // Catch exceptions
      catch (ClosedByInterruptException cbie) {
        // Do nothing
      } catch (Exception ex) {
        if (application != null) {
          application.reportException(ex);
        } else {
          ex.printStackTrace();
        }
      } finally {

        // All files wrote with the same description
        if (!hasNext) {
          // Reset the import screen and do not show it after resetting
          resetImportScreen(false);
          resetImportSession();

          // Initialize the first step, but do no show it
          gotoFirstStep();
        } else {
          // Reset the import screen and show it again after resetting
          resetImportScreen(true);

          conversionModel.setInputFile(currentFile);

          // Update table and chop the data from input file
          updateTable(false);

          // Initialize the first step and show it
          gotoFirstStep();
        }
      }
    }