Kapitel 6. Anwendung / Funktionalität

public class MyJobListener implements JobListener {
  public void stateChanged(Job job, State oldState, State newState) {
    dump("stateChanged", job, oldState, newState, null, null);
  }

  public void executionFailed(Job job, Node node, String messageId, String reason, Throwable cause) {
    dump("executionFailed", job, node, messageId, reason, cause);
  }

  public void errorOccurred(Job job, Node node, String messageId, String message, Throwable cause) {
    dump("errorOccurred", job, node, messageId, message, cause);
  }

  public void warningOccurred(Job job, Node node, String messageId, String message, Throwable cause) {
    dump("warningOccurred", job, node, messageId, message, cause);
  }

  public void subPipelineCreated(Job job, Node parent, Set<? extends Node> createdNodes) {
    dump("subPipelineCreated", job, parent);
  }

  private void dump(String ctx, Job job, Object... args) {
    System.err.println("Context:   " + ctx);
    System.err.println("Job:       " + job.toString());
    if (args == null)
      return;
    for (Object arg : args)
      System.err.println("           " + arg.toString());
  }
}

TimeLimit tl = new TimeLimit(60, TimeUnit.SECONDS);
tl.setExceedAction(WhenExceedAction.ABORT); // default

NodeCountLimit ncl = new NodeCountLimit(20);
ncl.setExceedAction(WhenExceedAction.WARN);

Job job = createServerJob();
job.setType("run stream analysis");

// Nodes erstellen:
// 1. Dateneingabe-Node
StreamInputNode siNode = new StreamInputNode();
// 2. Analyseknoten
StreamAnalysisNode saNode = new StreamAnalysisNode();
// 3. Ausgabe-Node
StreamOutputNode soNode = new StreamOutputNode();

// Workflow erstellen
job.attach(siNode.appendSuccessor(saNode).appendSuccessor(soNode));

// Job ausführen und Dokumentdatenstrom senden
job.submit();
siNode.addStream(…);
siNode.complete();

// Auf Antwort vom Server warten //@Callout Die Methode getStreamBundle() blockiert, bis der Server die Abarbeitung beendet hat. Eine asynchrone Verarbeitung ist durch die Verwendung einer JobListener-Implementierung zu realisieren
for (Stream stream : soNode.getStreamBundle()) {
  // Lesen der beschreibenden Daten
  final StreamDescriptor descr = stream.getDescriptor();
  final String mimeType = descr.getMimeType();
}

// Server-Job erstellen
Job job = createServerJob();
job.setType("retrieve document info");

// InfoNode erstellen
JadiceDocumentInfoNode infoNode = new JadiceDocumentInfoNode();

// Listener erstellen und an NotificatioNode anhängen
DocumentInfoListener documentInfoListener = new DocumentInfoListener();
NotificationNode notifyNode = new NotificationNode();
notifyNode.addNotificationResultListener(documentInfoListener);

// Workflow zusammenstellen
StreamInputNode siNode = new StreamInputNode();
siNode.appendSuccessor(infoNode);
infoNode.appendSuccessor(notifyNode);
// Datenstrom am Ende der Analyse verwerfen
notifyNode.appendSuccessor(new NullNode());

// 1. Node dem Job übergeben...
job.attach(siNode);
// ...und Job starten
job.submit();

// Nach dem Start des Jobs den Datenstrom dem Inputnode übergeben
siNode.addStream(…);
// Dateneingabe beenden
siNode.complete();
// Auf Abarbeitung durch Server warten (siehe oben)
documentInfoListener.waitForDocumentInfo();
// DokumentInfo holen und Daten ausgeben
IDocumentInfo documentInfo = documentInfoListener.getDocumentInfo();
System.out.println("Anzahl Seiten  : " + documentInfo.getPageCount());
// Beispielhaft: Daten der ersten Seite
System.out.println("Format         : " + documentInfo.getFormat(0));
System.out.println("Größe (Pixel) : " + documentInfo.getSize(0).getWidth() + "x"
    + documentInfo.getSize(0).getHeight());
System.out.println("Auflösung (dpi): " + documentInfo.getVerticalResolution(0) + "x"
    + documentInfo.getHorizontalResolution(0));

public class DocumentInfoListener implements NotificationListener {
  /**
   * Dokumentinfo, wird vom JadiceDocumentInfoNode erzeugt und an den StreamDescriptor gehängt
   */
  private IDocumentInfo documentInfo;

  /**
   * Latch um Thread zu blockieren, bis {@link #documentInfo} verfügbar ist. Hinweis:
   * Fehlerbehandlung, wenn Job abbricht / keine Ergebnis geliefert wird, im Beispiel nicht
   * umgesetzt
   */
  private CountDownLatch latch = new CountDownLatch(1);

  @Override
  public void notificationRecieved(StreamDescriptor streamDescriptor) {
    final Serializable prop = streamDescriptor.getProperties().get(JadiceDocumentInfoNode.PROPERTY_NAME);
    if (prop != null && prop instanceof IDocumentInfo) {
      documentInfo = (IDocumentInfo) prop;
      latch.countDown();
    }
  }

  public void waitForDocumentInfo() throws InterruptedException {
    // Blockieren bis IDocumentInfo erhalten wurde
    latch.await();
  }

  public IDocumentInfo getDocumentInfo() {
    return documentInfo;
  }
}

Job job = createServerJob();
job.setType("merge pdfs");

// Nodes erstellen:
// 1. Dateneingabe-Node
StreamInputNode siNode = new StreamInputNode();
// 2. Zusammenfassen von Eingabedaten (1...n zu 1)
PDFMergeNode pmNode = new PDFMergeNode();
// 3. Ausgabe-Node
StreamOutputNode soNode = new StreamOutputNode();

// Workflow erstellen
job.attach(siNode.appendSuccessor(pmNode).appendSuccessor(soNode));
// Job ausführen
job.submit();

// PDF-Dokument-Datenstrom senden
siNode.addStream(…);
siNode.addStream(…);
// ... evtl. weitere Datenströme

// Dateneingabe beenden
siNode.complete();

// Auf Antwort vom Server warten
for (Stream stream : soNode.getStreamBundle()) {
  // Lesen der Daten
  InputStream is = stream.getInputStream();
}

Job job = createServerJob();
job.setType("unpack zip");

// Nodes erstellen:
// 1. Dateneingabe-Node
StreamInputNode siNode = new StreamInputNode();
// 2. Entpacken von ZIP-Archiven
UnZIPNode unzipNode = new UnZIPNode();
// 3. Ausgabe-Node
StreamOutputNode soNode = new StreamOutputNode();

// Workflow erstellen
job.attach(siNode.appendSuccessor(unzipNode).appendSuccessor(soNode));

// Job ausführen
job.submit();
// Dokument-Datenstrom senden
siNode.addStream(…);
// Dateneingabe beenden
siNode.complete();

// Auf Antwort vom Server warten
for (Stream stream : soNode.getStreamBundle()) {
  // Lesen der Daten (1 Stream je Datei im Archiv)
  System.out.println("filename: " + stream.getDescriptor().getFileName());
  InputStream is = stream.getInputStream();
}

Job job = createServerJob();
job.setType("external my converter");

// Nodes erstellen:
// 1. Dateneingabe-Node
StreamInputNode siNode = new StreamInputNode();
// 2. Externer Prozess
ExternalProcessCallNode epcNode = new ExternalProcessCallNode();
// Konfiguration:
// Programmname (Backslashes müssen escaped werden!)
epcNode.setProgramName("C:\\Programme\\MyConverter\\MyConverter.exe");
// Kommandozeilen-Parameter
// ${infile} und ${outfile:pdf} ersetzt jadice server
epcNode.setArguments("-s -a ${infile} /convert=${outfile:pdf}");
// 3. Ausgabe-Node
StreamOutputNode soNode = new StreamOutputNode();

// Workflow erstellen
job.attach(siNode.appendSuccessor(epcNode).appendSuccessor(soNode));

// Job abschicken und Eingabedatenstrom übergeben
job.submit();
StreamDescriptor sd = new StreamDescriptor();
// jadice server speichert die Datei bei Uebergabe an das externe Programm
// unter diesem Namen ab.
sd.setFileName("myfile.dat");
siNode.addStream(new BundledStream(…, sd));
siNode.complete();

// Auf Antwort vom Server warten
for (Stream stream : soNode.getStreamBundle()) {
  // Lesen der Daten
  InputStream is = stream.getInputStream();
}