Richtlinien zum Erstellen benutzerdefinierter Aktivitäten im Service Manager Authoring Tool
Wichtig
Diese Version von Service Manager das Ende des Supports erreicht hat, wird empfohlen, ein Upgrade auf Service Manager 2019durchzuführen.
Service Manager automatisiert eine Vielzahl von IT-Prozessen (Informationstechnologie). Für den Incident Management-Prozess umfasst Service Manager beispielsweise verschiedene automatisierte Schritte, z. B. automatisierte Benachrichtigungen an Benutzer, wenn Incidents erstellt oder aufgelöst werden, und automatische Weiterleitung von Vorfällen an verschiedene Warteschlangen basierend auf der Kategorisierung. Diese Automatisierung wird mithilfe von für die verschiedenen Lösungen definierten Workflows implementiert. Hierfür werden WF-Funktionen (Windows Workflow Foundation) zum Beschreiben, Ausführen und Nachverfolgen der automatisierten Vorgänge verwendet.
Kunden und Partner können die integrierte Automatisierung erweitern, indem sie neue Workflows definieren und diese einem Prozess hinzufügen. Workflows können so festgelegt werden, dass sie nach einem festen Zeitplan ausgeführt werden, oder wenn eine bestimmte Bedingung in der Datenbank auftritt, z. B. wenn ein Incident erstellt wird oder der Status etwa in Aktiv oder Aufgelöstgeändert wird.
Die Service Manager Authoring Tool bietet eine benutzerfreundliche Methode zum Erstellen neuer Workflows. Das Tool enthält eine Bibliothek mit verschiedenen Workflowaktivitäten, wie Erstellen oder Aktualisieren eines Incidents, sowie einen grafischen Drag & Drop-Designer, mit dessen Hilfe Sie diese Workflowaktivitäten in einer Workflowsequenz anordnen können. Das Authoring Tool kompiliert dann den neuen Workflow in eine Reihe von Definitionen, Code und Management Pack-Inhalten. Wenn diese Informationen in Service Manager importiert werden, wird der neue Workflow in die angegebene Lösung integriert.
Wenn Sie wissen, was im Hintergrund des Authoring Tools vor sich geht, können fortgeschrittene Benutzer von Vorteil sein. Zunächst können Kunden und Partner diese Informationen verwenden, um die Workflowaktivitätsbibliothek in Service Manager um Workflowaktivitäten zu erweitern, die für ihre spezifischen Prozesse gelten. Zweitens können Entwickler diese Informationen verwenden, um benutzerdefinierte oder erweiterte Workflows zu erstellen, die mit Service Manager kompatibel sind, indem sie ihr gewünschtes Entwicklungstool verwenden, z. B. das Microsoft Visual Studio Entwicklungssystem.
Workflowaktivitäten und die WorkflowActivityBase-Klasse
Service Manager Workflows verwenden WF-Aktivitäten. Um problemlos mit dem Authoring Tool zu arbeiten, leiten sich diese Aktivitäten von der Basisklasse WorkflowActivityBaseab, die zum Namespace Microsoft.EnterpriseManagement.Workflow.Common gehört. Mit der Basisklasse WorkflowActivityBase werden Eigenschaften und Methoden eingeführt, die in der allgemeinen Basisklasse Activity für WF-Aktivitäten nicht verfügbar sind. Weitere Informationen zum Definieren von WF-Aktivitäten mithilfe der generischen Activity-Basisklasse finden Sie unter Aktivitätsklasse.
Vorteile der Verwendung der WorkflowActivityBase-Klasse
Benutzer können WF-Aktivitäten aus der Visual Studio Aktivitätsbibliothek importieren und mit diesen Aktivitäten imErstellungsbereich des Erstellungstools arbeiten. Diese Aktivitäten verhalten sich wie in der Visual Studio-Entwurfsumgebung. Sie verfügen nicht über die Anpassungen, die in die Service Manager-Aktivitätsbibliothek integriert sind.
Hinweis
Nicht alle Visual Studio WF-Aktivitäten wurden auf Kompatibilität mit dem Authoring Tool getestet, und einige Visual Studio WF-Aktivitäten werden möglicherweise nicht ordnungsgemäß im Authoring Tool ausgeführt.
In der folgenden Tabelle sind die Unterschiede im Verhalten zwischen WF-Aktivitäten, die auf der Basisklasse WorkflowActivityBase basieren, und WF-Aktivitäten, die auf der allgemeinen Basisklasse Activity basieren, aufgeführt.
| Szenario | WF-Aktivität des Erstellungstools (WorkflowActivityBase-Basisklasse) | Visual Studio WF-Aktivität (BasisklasseActivity ) |
|---|---|---|
| Der Benutzer bindet Aktivitätseigenschaften (an Service Manager Objekteigenschaften oder an Eigenschaften anderer Aktivitäten). | Ruft das Dialogfeld Bind -Eigenschaft an auf, das für Service Manager Benutzer angepasst ist. | Das für Entwickler bestimmte Dialogfeld Eigenschaft binden wird aufgerufen. |
| Benutzer fügt die Aktivität einer ForEach-Schleife -Aktivität hinzu. | Die Eigenschaften Propertytobind (Schleifenindex) und CurrentItemwerden hinzugefügt, die für die Teilnahme an schleifenspezifischen Vorgängen erforderlich sind (CurrentItem ist eine interne Eigenschaft). | Verhält sich bei jeder Iteration der Schleife gleich und interagiert nicht mit der Eigenschaft, mit der die Schleife indiziert wird. |
Wichtig
Aufgrund der Anpassungen, die für den Workflow-Designer des Erstellungstools erforderlich sind, funktionieren Aktivitäten, die auf der WorkFlowActivityBase-Klasse basieren, in der Visual Studio Workflowentwurfsumgebung nicht wie erwartet.
Benutzer können benutzerdefinierte WF-Aktivitäten in Visual Studio für die Verwendung im Authoring Tool erstellen. Um jedoch das benutzerdefinierte Entwurfszeitverhalten des Authoring Tools nutzen zu können, müssen benutzerdefinierte Aktivitäten auf der WorkflowActivityBase-Klasse und nicht auf der Activity-Klasse basieren.
Workflowaktivitäten und Service Manager automatisierte Aktivitäten
WF-Aktivitäten können mit einem anderen Aktivitätstyp interagieren, dem Service Manager Aktivitäten, die von Service Manager Arbeitselementen verwendet werden. Arbeitselemente sind einer der Haupttypen von Objekten, die Service Manager verwendet. Mit Arbeitselementen werden Arbeitseinheiten wie Incidents, Service Requests, Change Requestsund andere Arbeitseinheiten nachverfolgt. Die meisten Arbeitselemente umfassen mindestens eine Service Manager Aktivitäten. Ein Change Request enthält beispielsweise mindestens zwei Aktivitäten: eine Überprüfen -Aktivität und eine Änderungsausführung -Aktivität. Mit dem Arbeitselement werden diese Aktivitäten in der Regel der Reihe nach ausgeführt.
Wenn ein Arbeitselement erstellt wird, wird die erste Service Manager Aktivität aktiv und bleibt aktiv, während Service Manager (oder der Benutzer) die von der Aktivität dargestellte Arbeit ausführt. Nach Abschluss dieser Arbeit markiert Service Manager die erste Aktivität als Abgeschlossen und aktiviert die nächste Aktivität in der Sequenz. Wenn die letzte Aktivität in der Sequenz als Abgeschlossenmarkiert ist, markiert Service Manager das gesamte Arbeitselement als Abgeschlossen.
Einige Service Manager Aktivitäten können manuell ausgeführt werden, z. B. die Überprüfungsaktivität einer Änderungsanforderung. Andere Service Manager Aktivitäten können automatisiert werden, z. B. eine Aktivität, die eine E-Mail an einen Benutzer sendet. Die Aktivität Änderungsausführung eines Change Requests kann automatisiert werden. Service Manager verwendet WF-Workflows, um Service Manager Aktivitäten zu automatisieren.
Beispiel: Aktivitätsstatus auf Abgeschlossen festlegen
In diesem Beispiel einer WF-Workflowaktivität in Service Manager wird die Aktivität Aktivitätsstatus auf Abgeschlossen WF festlegen verwendet. Diese WF-Aktivität stellt in der Regel den letzten Schritt in einem Workflow dar, der eine automatisierte Service Manager-Aktivität implementiert, und legt den Status dieser Aktivität auf Abgeschlossenfest. Wenn dieser Status festgelegt wird, wird das System veranlasst, mit der nächsten Aktivität im Arbeitselement fortzufahren. Dieser Vorgang wird wiederholt, bis die letzte Aktivität im Arbeitselement abgeschlossen ist.
Die Aktivität Aktivitätsstatus auf Abgeschlossen festlegen nimmt eine Eingabe(Aktivitäts-ID) an, die die Service Manager Aktivität identifiziert, für die die Aktion ausgeführt werden soll. Die WF-Aktivität stellt dann eine Verbindung mit dem Service Manager-Verwaltungsserver her, ruft die angegebene Service Manager Aktivität aus der Datenbank ab, legt ihren Status auf Abgeschlossenfest und speichert sie dann wieder in der Datenbank. Die meisten Codebeispiele in diesem Beispiel stammen aus der Datei „SetActivityStatusToCompleted.cs“, einer zugrunde liegenden Datei, in der die Aktivität Aktivitätsstatus „Abgeschlossen“ festlegen beschrieben wird.
Initialisieren der WF-Beispielaktivität
Der erste Abschnitt der Datei „SetActivityStatusToCompleted.cs“ enthält die Deklaration und die Initialisierungsanweisungen. Diese Aktivität basiert auf der Klasse WorkflowActivityBase . Von ihr wird die Validatorklasse SetActivityStatusToCompletedValidator und die Designerklasse WorkflowActivityBaseDesignerverwendet.
Die WorkflowActivityBaseDesigner-Klasse enthält die Anpassungen, die im vorherigen Abschnitt "Vorteile der Verwendung der WorkflowActivityBase-Klasse" beschrieben wurden. Sie können diese Klasse weiter erweitern und anpassen.
Der erste Abschnitt der Aktivitätsdefinition für diese Beispielaktivität enthält folgenden Code:
namespace Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary
{
// ---------------------------------------------------------------------
/// <summary>
/// Activity to set an activity's status to complete
/// </summary>
// ---------------------------------------------------------------------
[ToolboxItem(typeof(ActivityToolboxItem))]
[ActivityValidator(typeof(Validators.SetActivityStatusToCompletedValidator))]
[Designer(typeof(WorkflowActivityBaseDesigner))]
public sealed partial class SetActivityStatusToCompleted : WorkflowActivityBase
{
Eingabeeigenschaften für die WF-Beispielaktivität
Mit dem Code wird eine Eigenschaft, ActivityId, als Abhängigkeitseigenschaft deklariert. Das bedeutet, dass diese Eigenschaft an Parameter gebunden werden kann, die auf der Workflowebene definiert wurden. In diesem Fall wird die ID der Service Manager Aktivität als Workflowparameter an den Workflow übergeben und als Eingabe in diese Aktivität übertragen.
// --------------------------------------------------------------------------------
/// <summary>
/// Dependency Property for ActivityId property
/// </summary>
// --------------------------------------------------------------------------------
public static DependencyProperty ActivityIdProperty =
DependencyProperty.Register("ActivityId", typeof(String), typeof(SetActivityStatusToCompleted));
// --------------------------------------------------------------------------------
/// <summary>
/// Activity ID
/// </summary>
// --------------------------------------------------------------------------------
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string ActivityId
{
get
{
return (string)this.GetValue(ActivityIdProperty);
}
set
{
this.SetValue(ActivityIdProperty, value);
}
}
Ausführungsverhalten in der WF-Beispielaktivität
Die eigentliche Arbeit dieser WF-Aktivität wird von der Methode Execute übernommen. Im Geltungsbereich der Methode Execute werden von der WF-Aktivität folgende Aufgaben ausgeführt:
Es wird erkannt, ob innerhalb einer ForEach-Schleife -Aktivität agiert wird. Ist dies der Fall, werden die entsprechenden WF-Aktivitätseigenschaften festgelegt.
Stellt eine Verbindung mit dem angegebenen Service Manager-Verwaltungsserver her und erstellt ein EnterpriseManagementGroup-Objekt.
Verwendet die ActivityId-Eigenschaft, um die identifizierte Service Manager Aktivität aus der Datenbank abzurufen.
Sucht die Klassendefinition der Service Manager-Aktivität, ruft die Status-Eigenschaft der abgerufenen Service Manager Aktivität ab und legt die -Eigenschaft auf den Completed-Enumerationslistenwert fest.
Committet die Änderungen an der Service Manager-Aktivität.
Mithilfe der Methode TrackData (Teil der WF-Infrastruktur) werden Nachverfolgungsinformationen zur Ausführung und zum Status der WF-Aktivität protokolliert.
// --------------------------------------------------------------------------------
/// <summary>
/// The execute method will have the implementation to set the activity status to complete.
/// </summary>
// --------------------------------------------------------------------------------
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
try
{
// Initialize the current item if the activity contained within the For-Each loop
base.Execute(executionContext);
// Validate Parameters
if (String.IsNullOrEmpty(ActivityId))
{
throw new ArgumentNullException("ActivityId");
}
string SMServer = "localhost";
Guid TaskGuid = new Guid(ActivityId);
EnterpriseManagementGroup _mg = new EnterpriseManagementGroup(SMServer);
EnterpriseManagementObject Activity = _mg.EntityObjects.GetObject
<EnterpriseManagementObject>(TaskGuid, ObjectQueryOptions.Default);
ManagementPack SystemMP = _mg.ManagementPacks.GetManagementPack(
SystemManagementPack.System);
ManagementPack ActivityMP = _mg.ManagementPacks.GetManagementPack(
Resources.ActivityManagementMP, SystemMP.KeyToken, SystemMP.Version);
ManagementPackClass activityClass = _mg.EntityTypes.GetClass(
Resources.WorkItemActivityClass, ActivityMP);
ManagementPackProperty status = activityClass.PropertyCollection["Status"];
ManagementPackEnumeration Completed =
_mg.EntityTypes.GetEnumeration("ActivityStatusEnum.Completed", ActivityMP);
Activity[status].Value = Completed;
Activity.Commit();
}
catch (ArgumentNullException argNullException)
{
// Log to Tracking Service
TrackData(argNullException.ToString());
throw;
}
catch (EnterpriseManagementException mgmtException)
{
TrackData(mgmtException.ToString());
throw;
}
return ActivityExecutionStatus.Closed;
}
}
}
Validierungsverhalten in der WF-Beispielaktivität
In der Datei „SetActivityStatusToCompletedValidator.cs“ wird das Überprüfungsverhalten der WF-Aktivität definiert. Mit diesem Verhalten wird festgelegt, wie der Entwickler angibt, ob diese WF-Aktivität vollständig definiert ist oder ob noch eine oder mehrere Eingaben definiert werden müssen. Das Authoring Tool gibt einen Validierungsfehler ähnlich wie Visual Studio an, indem ein rotes Ausrufezeichen(!) -Symbol für die Workflowaktivität im Erstellungsbereich verwendet wird.
namespace Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary.Validators
{
// --------------------------------------------------------------------------------
/// <summary>
/// Validator for the SetActivityStatusToCompleted activity
/// </summary>
// --------------------------------------------------------------------------------
internal class SetActivityStatusToCompletedValidator : ActivityValidator
{
// --------------------------------------------------------------------------------
/// <summary>
/// Validator for the SetActivityStatusToCompleted activity
/// </summary>
// --------------------------------------------------------------------------------
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
// Performing default validation
ValidationErrorCollection errorColl = base.Validate(manager, obj);
SetActivityStatusToCompleted setActivityStatusToCompletedObj =
(SetActivityStatusToCompleted)obj;
// Check if validation is happening during compilation of activity and
// not during the hosting of an activity
if (setActivityStatusToCompletedObj.Parent == null)
{
return errorColl;
}
string propertyName = Common.GetPropertyName(setActivityStatusToCompletedObj);
// Add validation error if ActivityId is null or empty
if (setActivityStatusToCompletedObj.ActivityId == null
&&
setActivityStatusToCompletedObj.GetBinding(SetActivityStatusToCompleted.ActivityIdProperty) == null
&&
String.Compare(propertyName, "ActivityId", false, CultureInfo.InvariantCulture) != 0)
{
errorColl.Add(new ValidationError(
Resources.SetActivityStatusToCompleted_ActivityId_DesignTimeValidation, 10, false));
}
return errorColl;
}
}
}
Verwenden der WF-Beispielaktivität in einem Workflow
Die Aktivität Aktivitätsstatus auf Abgeschlossen festlegen ist im Bereich Standardmäßige Aktivitätentooltool-Toolbox des Erstellungstools enthalten. Weitere Informationen zum Hinzufügen benutzerdefinierter Aktivitäten zum Bereich Aktivitätentoolbox finden Sie unter Installieren einer benutzerdefinierten Aktivitätsassembly.
Sie können den Erstellungsbereich des Authoring Tools verwenden, um Workflows auf eine Weise zu erstellen, die der Verwendung der Visual Studio Workflowentwurfsschnittstelle ähnelt. Das Authoring Tool bietet jedoch die folgenden Vorteile:
Benutzer ohne Kenntnisse in der Entwicklung können Workflows erstellen. Sie müssen nicht direkt mit Code arbeiten.
Wenn ein Benutzer einen Workflow im Authoring Tool speichert, generiert das Tool den entsprechenden Visual C#- und XOML-Code und kompiliert ihn in eine .dll-Datei. Das Tool integriert den Workflow auch in ein Management Pack, das direkt mit Service Manager interagieren kann.
Visual C#-Code für den Workflow
Das folgende Beispiel zeigt den Visual C#-Code, den das Authoring Tool für einen Beispielworkflow generiert, der die Aktivität Aktivitätsstatus auf Abgeschlossen festlegen verwendet. Mit diesem Code wird der einfache sequenzielle Workflow SetActivityStatusToCompleteWFgeneriert, der einen Workflowparameter, nämlich die Abhängigkeitseigenschaft ActivityId, enthält. Der Wert von ActivityID wird durch die Management Pack-Definitionen bestimmt, die weiter unten in diesem Beispiel dargestellt werden. Wenn der Workflow ausgeführt wird, identifiziert Service Manager den Wert und übergibt ihn an den Workflow.
namespace WorkflowAuthoring
{
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.ComponentModel.Compiler;
using System.Drawing;
using System.Collections;
using System.Workflow.Activities;
using System.Workflow.Runtime;
public partial class SetActivityStatusToCompleteWF : System.Workflow.Activities.SequentialWorkflowActivity
{
public static DependencyProperty ActivityIdProperty = DependencyProperty.Register("ActivityId", typeof(string), typeof(SetActivityStatusToCompleteWF));
[System.ComponentModel.DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
[System.ComponentModel.BrowsableAttribute(true)]
[System.ComponentModel.CategoryAttribute("Misc")]
public string ActivityId
{
get
{
return ((string)(this.GetValue(ActivityIdProperty)));
}
set
{
this.SetValue(ActivityIdProperty, value);
}
}
}
}
XOML-Code für den Workflow
Von WF wird für einige Workflowdefinitionen das XOML-Format verwendet. Im Fall des Beispielworkflows erstellt das Authoring Tool die Datei SetActivityStatusToCompleteWF.xoml mit folgendem Inhalt:
<SequentialWorkflowActivity x:Class="WorkflowAuthoring.SetActivityStatusToCompleteWF" x:Name="SetActivityStatusToCompleteWF" xmlns:ns0="clr-namespace:Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary;Assembly=Microsoft.ServiceManager.WorkflowAuthoring.ActivityLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" xmlns="https://schemas.microsoft.com/winfx/2006/xaml/workflow">
<ns0:SetActivityStatusToCompleted ActivityId="{ActivityBind SetActivityStatusToCompleteWF,Path=ActivityId}" x:Name="setActivityStatusToCompleted1" PropertyToBind="{x:Null}" />
</SequentialWorkflowActivity>
SetActivityStatusToCompleteWF.xoml deklariert, dass der Workflow, SetActivityStatusToCompleteWF,eine Workflowaktivität ausführt( Aktivitätsstatus auf Abgeschlossen festlegen). Diese Aktivität weist den Eingabeparameter ActivityIdauf, von dem der Wert aus der Eigenschaft ActivityId des Workflows abgerufen wird.
Deklarieren des Workflows und seiner Triggerbedingung in einem Management Pack
Service Manager können keinen isolierten Workflow .dll Datei verwenden. Der Workflow muss in ein Management Pack integriert werden. Vom Management Pack wird definiert, wenn der Workflow ausgeführt wird und welche Eingabewerte verwendet werden. Gleichzeitig, wenn der Workflowcode generiert und die Workflowdatei .dll kompiliert wird, fügt das Authoring Tool die workflowbezogenen Informationen einem Management Pack hinzu.
Der Beispielworkflow SetActivityStatusToCompleteWFist mit einem Beispiel-Management Pack mit dem Namen „Woodgrove.AutomatedActivity.AddComputerToGroupMP.xml“ verknüpft. Dieses Management Pack erweitert den Change Management-Prozess um eine neue automatisierte Service Manager Aktivität. Wenn die neue Aktivität bei einem Change-Management-Vorgang aktiv wird, wird von ihr der Workflow SetActivityStatusToCompleteWF ausgelöst.
Das Management Pack definiert den Trigger des Workflows (wenn sich der Status der neuen Service Manager Aktivität ändert) und definiert den Wert, der für die ActivityId-Eigenschaft verwendet werden soll (der eindeutige Bezeichner der neuen Service Manager-Aktivität). Wenn der Workflow ausgeführt wird, ändert er den Status der neuen Service Manager-Aktivität in Abgeschlossen. Bei einem normalen Workflow ist dies der letzte Schritt nach anderen Tasks, die von anderen WF-Aktivitäten im Workflow ausgeführt werden.
Der Abschnitt Monitoring des Management Packs enthält die Definition Rule für den Workflow. Die Definition Rule enthält wiederum zwei Teile: das Element DataSource und das Element WriteAction .
Im Fall des Beispielworkflows enthält das DataSource-Element ein Subscription-Element, das angibt, dass der Workflow ausgeführt werden soll, wenn eine Instanz der AddComputerToGroup-Klasse (eine benutzerdefinierte Service Manager-Klasse) den Zustand in Aktivändert.
<Monitoring>
<Rules>
<Rule ID="SetActivityToCompleteRule" Enabled="true" Target="SystemCenterLibrary!Microsoft.SystemCenter.SubscriptionWorkflowTarget" ConfirmDelivery="false" Remotable="true" Priority="Normal" DiscardLevel="100">
<Category>Notification</Category>
<DataSources>
<DataSource ID="DS" TypeID="Subscriptions!Microsoft.SystemCenter.CmdbInstanceSubscription.DataSourceModule">
<Subscription>
<InstanceSubscription Type="$MPElement[Name='AddComputerToGroup']$">
<UpdateInstance><Criteria><Expression><SimpleExpression>
<ValueExpression>
<Property State="Post">$Context/Property[Type='Activity!System.WorkItem.Activity']/Status$</Property>
</ValueExpression>
<Operator>Equal</Operator>
<ValueExpression>
<Value>$MPElement[Name='Activity!ActivityStatusEnum.Active']$</Value>
</ValueExpression>
</SimpleExpression></Expression></Criteria></UpdateInstance>
</InstanceSubscription>
<StartWatermark>1</StartWatermark>
<PollingIntervalInSeconds>60</PollingIntervalInSeconds>
<BatchSize>100</BatchSize>
</Subscription>
</DataSource>
</DataSources>
</Rule>
</Rules>
</Monitoring>
Mit dem Element WriteAction (insbesondere mit Microsoft.EnterpriseManagement.SystemCenter.Subscription.WindowsWorkflowTaskWriteAction) wird festgelegt, was geschehen soll, wenn die Auslöserbedingung erfüllt ist. Innerhalb dieses Elements wird von einem Element vom Typ Subscription die auszuführende Workflowassemblydatei (SetActivityStatusToCompleteWF.dll) und die Klasse in der Assembly identifiziert, von der der Workflow WorkflowTypeNamedargestellt wird.
Das Subscription-Element enthält auch ein WorkflowParameter-Element, das die ActivityId-Eigenschaft definiert und es mithilfe der Syntax $Data/BaseManagedEntityId$an den eindeutigen Bezeichner der Service Manager Aktivität bindet, die im DataSource-Element aufgezeichnet wird.
Im Element WriteAction werden zudem optionale Konfigurationsdetails für den Workflow gespeichert, z. B. die Anzahl der Wiederholungen, wenn beim Workflow ein Fehler auftritt, die Häufigkeit der Wiederholungen sowie die maximale Zeit in Sekunden, die ein Workflow ausgeführt wird, bevor er beendet wird.
<WriteActions>
<WriteAction ID="WA" TypeID="Subscriptions!Microsoft.EnterpriseManagement.SystemCenter.Subscription.WindowsWorkflowTaskWriteAction">
<Subscription>
<WindowsWorkflowConfiguration>
<AssemblyName>SetActivityStatusToCompleteWF</AssemblyName>
<WorkflowTypeName>WorkflowAuthoring.SetActivityStatusToCompleteWF</WorkflowTypeName>
<WorkflowParameters>
<WorkflowParameter Name="ActivityId" Type="string">
$Data/BaseManagedEntityId$
</WorkflowParameter>
</WorkflowParameters>
<RetryExceptions></RetryExceptions>
<RetryDelaySeconds>60</RetryDelaySeconds>
<MaximumRunningTimeSeconds>300</MaximumRunningTimeSeconds>
</WindowsWorkflowConfiguration>
</Subscription>
</WriteAction>
</WriteActions>
Importieren des Management Packs
Damit der Workflow auf einem bestimmten Service Manager Verwaltungsserver ausgeführt werden kann, müssen sich alle Dateien, die mit dem Workflow verknüpft sind, auf diesem Server befinden. Hierzu gehören die folgenden Dateien:
Die Assemblydateien der WF-Aktivität. Wenn Sie nur die Service Manager WF-Aktivitäten verwenden, werden standardmäßig die entsprechenden Dateien installiert. Wenn Sie benutzerdefinierte Aktivitäten verwenden, finden Sie weitere Informationen unter Installieren einer benutzerdefinierten Aktivitätsassembly.
Die Workflowassemblydatei. In diesem Fall die Datei „SetActivityStatusToCompleteWF.dll“. Sie müssen diese Datei manuell auf den Service Manager-Verwaltungsserver kopieren.
Die Management Pack-Datei. In diesem Fall die Datei „Woodgrove.AutomatedActivity.AddComputerToGroupMP.xml“. Sie müssen diese Datei manuell auf den Service Manager-Verwaltungsserver kopieren.
Wenn alle Dateien vorhanden sind, importieren Sie das Management Pack in Service Manager. Hierzu können Sie das mpimport.exe-Befehlszeilentool oder die Service Manager-Konsole verwenden. Nach dem Importieren des Management Packs kann der Workflow ausgeführt werden, sobald die als Auslöser definierte Bedingung erfüllt ist.