Beispiele für Nachverarbeitungsscripts

     properties.put("Status", "Success");

     //
     // Evaluate the built-in exitCode property, which indicates the exit code
     // of the script called by the plug-in step. Typically, if the value of
     // the exitCode property is non-zero, the plug-in step failed.
     //
     if (properties.get("exitCode") != 0) {
          properties.put("Status", "Failure");
     }
     else {

          //
          // Register a scanner to search for the text "error at line" in the log.
          // The first argument is a regular expression.
          //
          // The second argument, an inline function, is invoked once for
          // every line in the log output that matches the pattern. The "lineNumber"
          // variable contains the line number where the match occurred, and the
          // "line" variable is the full text of the line.
          //
          scanner.register("(?i)ERROR at line",  function(lineNumber, line) {

              //
              // In this case, we build up an "Error" property which
              // contains the text of all errors that are found. We find every
              // line starting with "error at line" and add it to this list.
              //
              var errors = properties.get("Error");
              if (errors == null) {
                  errors = new java.util.ArrayList();
                  properties.put("Error", errors);
              }
              errors.add(line);


              //
              // If a line starting with "error at line" is found, the step has
              // failed, so we set the special "Status" property to "Failure",
              // indicating to the UrbanCode Deploy server that the step should
              // be marked as a failure.
              //
              properties.put("Status", "Failure");
          });
         
          //
          // Multiple searches can be registered with the scanner. We add a
          // second search to look for some interesting text to set as an output
          // property.
          //
          // For example, if there is a line "The value is BLUE", then we end up
          // with an output property, "Value", with a value of "BLUE".
          //
          scanner.register("The value is", function(lineNumber, line) {
              var value = line.replace("The value is ", "");
              properties.put("Value", value);
          });
         
          scanner.scan();


          //
          // Convert the collected list of error strings into a single string and
          // set that as an output property.
          //
          var errors = properties.get("Error");
          if (errors == null) {
              errors = new java.util.ArrayList();
              properties.put("Error", errors);
          }
          properties.put("Error", errors.toString());
     }

Für die folgenden Scripts werden zwei Schritte in demselben Prozess angenommen. Das Nachverarbeitungsscript für den ersten Schritt erstellt zwei Ausgabeeigenschaften mit der Bezeichnung Status and Step1Prop:

if (properties.get("exitCode")==0)
  { properties.put("Status","Success"); }
else
  { properties.put("Status","Failure"); }

properties.put("Step1Prop","value1");

Danach kann ein zweiter Schritt auf diese Eigenschaften zugreifen. Wenn der erste Schritt beispielsweise Step1 genannt wurde und die Ausgabeeigenschaften Status und Step1Prop angibt, könnten Sie einen Shell-Schritt mit dem folgenden Code erstellen, um auf diese Eigenschaften zuzugreifen:

echo Properties of previous step:
echo "${p:Step1/Status}"
echo "${p:Step1/Step1Prop}"

Der zweite Schritt kann auch diese Eigenschaften in seinem Nachverarbeitungsscript nutzen. Beispiel: Das folgende Nachverarbeitungsscript enthält die Eigenschaft Status des vorherigen Schritts in einer Eigenschaft für den zweiten Schritt:

{ 
properties.put("Step2Prop","New property");
properties.put("Status","OK");
properties.put("StatusOfPreviousStep","${p:Step1/Status}");
}

Das Weiterreichen eines Werts von einem Schritt zum nächsten umfasst mehrere allgemeine Schritte:

1. Speichern Sie den Wert im ersten Schritt an einer Stelle, wo das Nachverarbeitungsscript darauf zugreifen kann. Sie können den Wert speichern, indem Sie ihn in die Protokolldatei für den Schritt schreiben. Beispiel: Wenn Sie einen Shell-Schritt ausführen, können Sie den Wert und einen eindeutigen Schlüssel mit dem Befehl echo in ein Protokoll schreiben:

   echo "myvalue=1234"

   Folglich zeigt das Protokoll für den Schritt den Schlüssel und den Wert an:

   myvalue=12345

2. Verwenden Sie im Nachverarbeitungsscript für den Schritt das Objekt scanner, um das Protokoll nach dem Schlüssel zu durchsuchen. Weisen Sie dann den Wert einem Ausgabeparameter zu. Das folgende Beispielscript durchsucht das Ausgabeprotokoll nach dem Schlüssel myvalue= und speichert dann den Wert in der Ausgabeeigenschaft myOutputValue:

   var exit = properties.get('exitCode');
   
   scanner.register("myvalue=", function(lineNumber, line) {
        var value=line.replace("myvalue=","");
        properties.put("myOutputValue",value);
   });
   
   if (exit == 0) {
       properties.put('Status', 'Success');
   }
   else {
        properties.put('Status', 'Failure');
   }
   
   scanner.scan();

3. Beziehen Sie sich in nachfolgenden Schritten auf die Ausgabeparameter des ersten Schritts. Beispiel: Wenn der erste Schritt den Namen SetMyValue hat, können Sie in nachfolgenden Schritten mit dem folgenden Code auf die Eigenschaft verweisen:

   ${p:SetMyValue/myOutputValue}