Provedor de Descoberta de Serviços do SharePoint

Microsoft.SharePoint.2013.SPService.DiscoveryProvider (DataSourceModuleType)

É o provedor de descoberta para o preenchimento de instâncias de serviço do SharePoint em execução em servidores SharePoint.

Element properties:

Member Modules:

Overrideable Parameters:

Source Code:

<DataSourceModuleType ID="Microsoft.SharePoint.2013.SPService.DiscoveryProvider" Accessibility="Internal" RunAs="WSS!Microsoft.SharePoint.AdminAccount">

  <Configuration>

    <xsd:element name="ComputerName" type="xsd:string"/>

    <xsd:element name="IntervalSeconds" type="xsd:integer"/>

    <xsd:element name="SyncTime" type="xsd:string"/>

    <xsd:element name="TimeoutSeconds" type="xsd:integer"/>

    <xsd:element name="DebugTrace" type="xsd:boolean"/>

  </Configuration>

  <OverrideableParameters>

    <OverrideableParameter ID="IntervalSeconds" Selector="$Config/IntervalSeconds$" ParameterType="int"/>

    <OverrideableParameter ID="SyncTime" Selector="$Config/SyncTime$" ParameterType="string"/>

    <OverrideableParameter ID="TimeoutSeconds" Selector="$Config/TimeoutSeconds$" ParameterType="int"/>

    <OverrideableParameter ID="DebugTrace" Selector="$Config/DebugTrace$" ParameterType="bool"/>

  </OverrideableParameters>

  <ModuleImplementation Isolation="Any">

    <Composite>

      <MemberModules>

        <DataSource ID="DS" TypeID="Microsoft.SharePoint.2013.CommandExecuterDiscoveryDataSource">

          <IntervalSeconds>$Config/IntervalSeconds$</IntervalSeconds>

          <SyncTime>$Config/SyncTime$</SyncTime>

          <ApplicationName/>

          <WorkingDirectory/>

          <CommandLine>powershell.exe -NoLogo -NoProfile -Noninteractive "$ep = get-executionpolicy; if ($ep -gt 'RemoteSigned') {set-executionpolicy remotesigned} &amp; '$file/WSSSvcDiscovery.ps1$' '$MPElement$' '$Target/Id$' '$Config/ComputerName$' '$Config/DebugTrace$'"</CommandLine>

          <TimeoutSeconds>$Config/TimeoutSeconds$</TimeoutSeconds>

          <RequireOutput>true</RequireOutput>

          <Files>

            <File>

              <Name>WSSStrings.ps1</Name>

              <Contents><Script>$global:EventLog_Fail_Create_Discovery_Package = "Failed to create Discovery transmission package.";

$global:EventLog_Fail_Return_Discovery_Package = "Failed to return Discovery transmission package.";

$global:EventLog_Fail_Create_Discovery_ScriptAPI = "Failed to initiate MOM.ScriptAPI object.";

$global:EventLog_Fail_Create_Class = "Failed to create {0} class instance.";

$global:EventLog_Fail_Create_Relationship = "Failed to create {0} relationship instance.";

$global:EventLog_Fail_LoadBalancer_Operation = "Addresses for this application may not have been fetched yet.";



$global:EventLog_Exit_On_NonExist = "This machine does not have SharePoint installed."

$global:EventLog_Fail_On_Error = "{0} Discovery/Monitoring script continues under this error! ";

$global:EventLog_Exit_On_Error = "{0} Discovery/Monitoring script was terminated! ";



$global:EventLog_Format = @"

Current User: {0}

Current PID: {1}

InvocationInfo.MyCommand: {2}

InvocationInfo.ScriptLineNumber: {3}

InvocationInfo.OffsetInLine: {4}

InvocationInfo.ScriptName: {5}

InvocationInfo.Line: {6}

InvocationInfo.PositionMessage: {7}

InvocationInfo.InvocationName: {8}

InvocationInfo.PipelineLength: {9}

InvocationInfo.PipelinePosition: {10}

"@;



$global:EventLog_Template = "[{0} in Discovery/Monitoring script] {1} {2}";



$global:EventLog_Debug_StartedArgs = "[Debug] {0} Started. Args[]={1}, {2}, {3}, {4}.";

$global:EventLog_Debug_MajorServer = "[Debug] This is the major server detected by {0}.";



$global:EventLog_Fail_Identify_Farm = "Cannot identify which SharePoint farm this server is associated with. Check the management pack guide for troubleshooting information.";

$global:EventLog_Fail_Retrieve_Farm_And_Local = "Failed on retrieving information for SharePoint farm and Sharepoint local machine. Check the management pack guide for troubleshooting information.";

$global:EventLog_Fail_Retrieve_OM_Value = "Failed on retrieving values from SharePoint object model.";

$global:EventLog_Fail_Retrieve_Service = "Failed on retrieving {0} service from SharePoint farm {1}.";

$global:EventLog_Fail_Retrieve_Object = "Failed to find {0} in SharePoint object model.";



$global:DisplayName_ServerGroup = "Server Group";

$global:DisplayName_ServiceGroup = "Service Group";

$global:DisplayName_WebApplicationGroup = "Web Application Group";

$global:DisplayName_SharedServiceGroup = "Shared Service Group";

$global:DisplayName_SharedProxyGroup = "Shared Service Proxy Group";

$global:DisplayName_ProxyClient = "Proxy Client ({0})";

$global:DisplayName_TimerJobs = "Timer Jobs";

$global:DisplayName_HostCollection = "Host Collection";

$global:DisplayName_DatabaseCollection = "Database Collection";



$global:DisplayName_SPTrace = "SPTraceV4";

$global:DisplayName_WindowsTracingService = "SharePoint Tracing Service";

$global:DisplayName_AdminWord = " - Admin";

</Script></Contents>

            </File>

            <File>

              <Name>WSSDiscoveryLibrary.ps1</Name>

              <Contents><Script>$error.Clear();

$ErrorActionPreference = "SilentlyContinue";



$global:EventObject = New-Object Diagnostics.EventLog

$global:EventObject.Source = "Operations Manager"



function global:Write-Event ([string] $LogContent, $LogType = [Diagnostics.EventLogEntryType]::Information)

{

  if ($error)

  {

    $error.Clear()

    $LogType = [Diagnostics.EventLogEntryType]::Error

  }



  $EventObject.WriteEntry($LogContent, $LogType)

}



function global:LogScriptTime($InvocationObj)

{

  $dtEnd = [DateTime]::Now



  $msg = @"

[Debug] {0} ended.

Current User: {1}

Current PID: {2}

start time: {3}

stop time: {4}

time taken: {5}

"@ -f $InvocationObj.MyCommand,

[Environment]::UserName,

$pid,

$dtStart,

$dtEnd,

(New-TimeSpan $dtStart $dtEnd).TotalMilliseconds



  Write-Event $msg

}



.\WSSStrings.ps1



$global:Arguments = $Args;



$global:Farm = $null;

$global:LocalServer = $null;

$global:DiscData = $null;

$global:Port = "_port";

$global:Http = "_http";



function global:Get-Farm()

{

  if ($global:Farm -eq $null)

  {



    $global:Farm = [Microsoft.SharePoint.Administration.SPFarm]::Local;

  }

}



function global:Get-LocalServer()

{

  if ($global:LocalServer -eq $null)

  {



    $global:LocalServer = [Microsoft.SharePoint.Administration.SPServer]::Local;

  }

}



function global:Get-ServiceProxy([string] $ClassType)

{

  Get-Farm;

  foreach ($ServiceProxy in $global:Farm.ServiceProxies)

  {

    if ($ClassType.ToLower() -eq $ServiceProxy.GetType().FullName.ToLower())

    {

      return $ServiceProxy;

    }

  }

  return $null;

}



function global:Get-Service([string] $ClassType)

{

  Get-Farm;

  foreach ($Service in $global:Farm.Services)

  {

    if ($ClassType.ToLower() -eq $Service.GetType().FullName.ToLower())

    {

      return $Service;

    }

  }

  return $null;

}



function global:Get-ServiceEx([string] $ClassType, [string] $Name)

{

  Get-Farm;

  foreach ($Service in $global:Farm.Services)

  {

    if ($ClassType.ToLower() -eq $ServiceInstance.GetType().FullName.ToLower())

    {

      if ($Name.ToLower() -eq $ServiceInstance.Name.ToLower())

      {

        return $ServiceInstance;

      }

    }

  }

  return $null;

}



function global:Get-ServiceInstance([string] $ClassType)

{

  Get-LocalServer;



  if (! $ClassType.EndsWith("Instance"))

  {

    $ClassType += "Instance";

  }



  foreach ($ServiceInstance in $global:LocalServer.ServiceInstances)

  {

    if ($ClassType.ToLower() -eq $ServiceInstance.GetType().FullName.ToLower())

    {

      return $ServiceInstance;

    }

  }

  return $null;

}



function global:Get-ServiceInstanceEx([string] $ClassType, [string] $Name)

{

  Get-LocalServer;



  if (! $ClassType.EndsWith("Instance"))

  {

    $ClassType += "Instance";

  }



  foreach ($ServiceInstance in $global:LocalServer.ServiceInstances)

  {

    if ($ClassType.ToLower() -eq $ServiceInstance.GetType().FullName.ToLower())

    {

      if ($Name.ToLower() -eq $ServiceInstance.Name.ToLower())

      {

        return $ServiceInstance;

      }

    }

  }

  return $null;

}



function global:Create-DiscoveryData()

{

  if ($global:DiscData -eq $null)

  {

    $global:DiscData = $global:MomScriptAPIObject.CreateDiscoveryData(0, $global:Arguments[0], $global:Arguments[1]);

    Handle-Errors($global:EventLog_Fail_Create_Discovery_Package, $true, $false);



    $global:HealthSvc = $global:DiscData.CreateClassInstance("$MPElement[Name='SC!Microsoft.SystemCenter.HealthService']$");

    $global:HealthSvc.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

    Handle-Errors($global:EventLog_Fail_Create_Class -f "Microsoft.SystemCenter.HealthService");

  }

  return $global:DiscData;

}



function global:Deliver-DiscoveryData([Object] $DiscData)

{

  $global:MomScriptAPIObject.Return($DiscData);

  Handle-Errors($global:EventLog_Fail_Return_Discovery_Package, $true, $false);

  $DiscData = $null;

}



function global:IsMainServer([System.Boolean] $UseLastServer)

{

  $Servers = $global:Farm.Servers;



  if ($UseLastServer)

  {

    $Count = $Servers.Count;

    $ServerArray = new-object string[][] $Count,2;

    $Index = 0;



    foreach ($Server in $Servers)

    {

      $ServerArray[$Index][0] = $Server.Name;

      $ServerArray[$Index++][1] = $Server.Role.ToString();

    }



    for ($Index--; $Index -ge 0; $Index--)

    {



      if ($ServerArray[$Index][1] -ne "Invalid")

      {

        return ($ServerArray[$Index][0] -eq $global:LocalServer.Name);

      }

    }

  }

  else

  {

    foreach ($Server in $Servers)

    {



      if ($Server.Role -ne "Invalid")

      {

        return ($Server.Name -eq $global:LocalServer.Name);

      }

    }

  }



  return $false;

}



function global:Release-Resources()

{

  $global:HashData = $null;

  $global:DiscData = $null;

  $global:HealthSvc = $null;

  $global:MomScriptAPIObject = $null;



  $global:WSSAssembly = $null;



  $global:EventObject = $null;

  $global:EventAssembly = $null;

}



function global:Handle-Errors([System.Object] $Arguments)

{

  if (! $error)

  {

    return;

  }



  $ErrMsg = "";

  $IsExit = $true;

  $IsReturn = $true;

  $IsLog = $true;



  if ("System.String" -eq $Arguments.GetType().FullName)

  {

    $ErrMsg = $Arguments;

  }

  else

  {

    $ErrMsg = $Arguments[0];

    $IsExit = $Arguments[1];

    if ($Arguments.Count -gt 2)

    {

      $IsReturn = $Arguments[2];

    }

    if ("" -eq $ErrMsg)

    {

      $IsLog = $false;

    }

  }



  if ($IsLog.Equals($true))

  {

    $ErrorString = "";

    if ($IsExit.Equals($false))

    {

      $ErrorString = $global:EventLog_Fail_On_Error -f $ErrMsg;

    }

    else

    {

      $ErrorString = $global:EventLog_Exit_On_Error -f $ErrMsg;

    }



    $Exception = $error[$error.Count - 1];

    if ($Exception.InvocationInfo -ne $null)

    {

      $ErrorString += ($global:EventLog_Format -f [Environment]::UserName, $pid, $Exception.InvocationInfo.MyCommand,

                       $Exception.InvocationInfo.ScriptLineNumber, $Exception.InvocationInfo.OffsetInLine, $Exception.InvocationInfo.ScriptName,

                       $Exception.InvocationInfo.Line, $Exception.InvocationInfo.PositionMessage, $Exception.InvocationInfo.InvocationName,

                       $Exception.InvocationInfo.PipelineLength, $Exception.InvocationInfo.PipelinePosition);

    }



    if ($null -ne $Exception.Exception)

    {

      $Exception = $Exception.Exception;

    }

    $InnerException = $Exception;

    if ($null -ne $Exception.InnerException)

    {

      $InnerException = $Exception.InnerException;

    }



    $global:EventObject.WriteEntry(($global:EventLog_Template -f $InnerException.GetType().FullName, $ErrorString, $Exception.Message), [System.Diagnostics.EventLogEntryType]::Error);

  }



  if ($IsExit.Equals($true))

  {

    if ($IsReturn.Equals($true))

    {

      Deliver-DiscoveryData($global:DiscData);

    }

    Release-Resources;

    break;

  }



  $error.Clear();

}



function global:GetDebugSetting($DebugTrace)

{



  if ($DebugTrace.ToUpper() -eq "TRUE")

  {

    $global:Debug = $True;

  }

  else

  {

    $global:Debug = $False;

  }



}



$global:MomScriptAPIObject = new-object -comObject "MOM.ScriptAPI";

Handle-Errors($global:EventLog_Fail_Create_Discovery_ScriptAPI, $true, $false);



$global:WSSAssembly = [System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint");

if ($null -eq $global:WSSAssembly)

{

  throw $global:EventLog_Exit_On_NonExist;

}

Handle-Errors("", $true, $false);



if ($WSSAssembly.GetName().Version.Major -ne 15)

{

  Release-Resources;

  break;

}



$global:WSSConfig = "Microsoft.SharePoint.Administration.SPConfigurationDatabase";

$global:WSSAdmin = "Microsoft.SharePoint.Administration.SPWebService";

$global:SPAdmin = "Microsoft.SharePoint.Administration.SPAdministrationService";

$global:SPSearch = "Microsoft.SharePoint.Search.Administration.SPSearchService";

$global:SPIncomingMail = "Microsoft.SharePoint.Administration.SPIncomingEmailService";

$global:SPHelpSearch = "Microsoft.SharePoint.Search.Administration.SPSearchService";

$global:SPTimer = "Microsoft.SharePoint.Administration.SPTimerService";

$global:SPWebApp = "Microsoft.SharePoint.Administration.SPWebService";

$global:SPUserCode = "Microsoft.SharePoint.Administration.SPUserCodeService";

$global:SPDatabase = "Microsoft.SharePoint.Administration.SPDatabaseService";



$global:SPTopology = "Microsoft.SharePoint.SPTopologyWebService";

$global:SPUsage = "Microsoft.SharePoint.Administration.SPUsageService";

$global:SPBDC = "Microsoft.SharePoint.BusinessData.SharedService.BdcService";

$global:SPSecurityToken = "Microsoft.SharePoint.Administration.Claims.SPSecurityTokenService";



</Script></Contents>

            </File>

            <File>

              <Name>WSSSvcDiscovery.ps1</Name>

              <Contents><Script>.\WSSDiscoveryLibrary.ps1 $Args[0] $Args[1]



GetDebugSetting $Args[3]



if ($global:Debug) { $global:dtStart = [DateTime]::Now }

if ($global:Debug) { Write-Event($global:EventLog_Debug_StartedArgs -f $MyInvocation.MyCommand, $Args[0], $Args[1], $Args[2], $Args[3]) }



$global:FarmID = "";

$global:ComputerName = $Args[2];

Get-Farm;

Get-LocalServer;



$global:DiscData = Create-DiscoveryData;

if ($null -ne $global:Farm)

{

  $global:FarmID = $global:LocalServer.Farm.Id.ToString();

  Handle-Errors($global:EventLog_Fail_Retrieve_Farm_And_Local);



  .\WSSServiceDiscovery.ps1

  .\WSSApplicationDiscovery.ps1

  .\WSSNonStandardDiscovery.ps1

}

Deliver-DiscoveryData($global:DiscData);



if ($global:Debug) { LogScriptTime($MyInvocation) }



Release-Resources;

</Script></Contents>

            </File>

            <File>

              <Name>WSSServiceDiscovery.ps1</Name>

              <Contents><Script>function Get-SCOMServiceClasses([object] $ServiceInstance)

{

  $ServiceInstanceClass = $null;

  $ServiceClass = $null;



  $ServiceClassType = $ServiceInstance.Service.GetType().FullName;

  $ServiceInstanceClassType = $ServiceInstance.GetType().FullName;

  $ServiceTypeName = $ServiceInstance.Service.TypeName;

  $ServiceInstanceTypeName = $ServiceInstance.TypeName;

  $ServiceID = $ServiceInstance.Service.Id.ToString();



  switch ($ServiceClassType)

  {

    $global:SPWebApp  

    {

      $AdminInstance = [Microsoft.SharePoint.Administration.SPWebServiceInstance]::LocalAdministration;

      if ($ServiceInstance.Id -eq $AdminInstance.Id)

      {

        $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.CentralAdmin']$";

        $ServiceInstanceClassType += $global:DisplayName_AdminWord;

        $ServiceClassType += $global:DisplayName_AdminWord;

      }

      else

      {

        $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.Web']$";

      }

      $ServiceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPService.Web']$";

    };

    $global:SPAdmin

    {

      $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.Admin']$";

      $ServiceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPService.Admin']$";

    };

    $global:SPIncomingMail

    {

      $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.IncomingMail']$";

      $ServiceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPService.IncomingMail']$";

    };

    $global:SPTimer

    {

      $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.Timer']$";

      $ServiceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPService.Timer']$";

    };

    $global:SPUserCode

    {

      $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.UserCode']$";

      $ServiceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPService.UserCode']$";

    };

  }



  return @($ServiceInstanceClassType, $ServiceClassType, $ServiceInstanceClass, $ServiceClass, $ServiceInstanceTypeName, $ServiceTypeName, $ServiceID);

}



$ServerInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPServer']$");

$ServerInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

$ServerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServer']/ComputerID$", $global:ComputerName);

$ServerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServer']/FarmID$", $global:FarmID);



foreach ($ServiceInstance in $global:LocalServer.ServiceInstances)

{

  $Classes = Get-SCOMServiceClasses($ServiceInstance);

  $ServiceInstanceClassType = $Classes[0];

  $ServiceClassType = $Classes[1];

  $ServiceInstanceClass = $Classes[2];

  $ServiceClass = $Classes[3];

  $ServiceInstanceTypeName = $Classes[4];

  $ServiceTypeName = $Classes[5];

  $ServiceID = $Classes[6];



  if ($null -eq $ServiceInstanceClass)

  {

    continue;

  }



  if (($ServiceInstance.Status -ne [Microsoft.SharePoint.Administration.SPObjectStatus]::Disabled) -and ($ServiceInstance.Status -ne [Microsoft.SharePoint.Administration.SPObjectStatus]::Unprovisioning))

  {



    $ServiceInst = $global:DiscData.CreateClassInstance($ServiceInstanceClass);

    $ServiceInst.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $ServiceInstanceTypeName);

    $ServiceInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

    $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/FarmID$", $global:FarmID);

    $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/HostServer$", $ServiceInstance.Server.Name);

    $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/TypeName$", $ServiceInstanceClassType);

    $global:DiscData.AddInstance($ServiceInst);

    Handle-Errors(($global:EventLog_Fail_Create_Class -f $ServiceInstanceClass), $false);



    $ServerServiceInstanceRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPServer.Contains.SPServiceInstance']$");

    $ServerServiceInstanceRel.Source = $ServerInst;

    $ServerServiceInstanceRel.Target = $ServiceInst;

    $global:DiscData.AddInstance($ServerServiceInstanceRel);

    Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPServer.Contains.SPServiceInstance"), $false);



    if ($null -ne $ServiceClass)

    {



      $Service = $global:DiscData.CreateClassInstance($ServiceClass);

      $Service.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $ServiceTypeName);

      $Service.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPService']/FarmID$", $global:FarmID);

      $Service.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPService']/ServiceID$", $ServiceID);

      $Service.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPService']/TypeName$", $ServiceClassType);

      $Service.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPService']/NotShared$", "True");

      $global:DiscData.AddInstance($Service);

      Handle-Errors(($global:EventLog_Fail_Create_Class -f $ServiceClass), $false);



      $ServiceGroup = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPServiceGroup']$");

      $ServiceGroup.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceGroup']/FarmID$", $global:FarmID);



      $ServiceGroupServiceRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceGroup.Contains.SPService']$");

      $ServiceGroupServiceRel.Source = $ServiceGroup;

      $ServiceGroupServiceRel.Target = $Service;

      $global:DiscData.AddInstance($ServiceGroupServiceRel);

      Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPServiceGroup.Contains.SPService"), $false);



      $ServiceServiceInstanceRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPService.Contains.SPServiceInstance']$");

      $ServiceServiceInstanceRel.Source = $Service;

      $ServiceServiceInstanceRel.Target = $ServiceInst;

      $global:DiscData.AddInstance($ServiceServiceInstanceRel);

      Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPService.Contains.SPServiceInstance"), $false);

    }



    if ($ServiceInstanceClass -eq "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.Timer']$")

    {



      $TimerJobName = $global:DisplayName_TimerJobs;

      $TimerInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPSystemTimerJobHost']$");

      $TimerInst.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $TimerJobName);

      $TimerInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

      $TimerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/FarmID$", $global:FarmID);

      $TimerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/HostServer$", $ServiceInstance.Server.Name);

      $TimerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/TypeName$", $ServiceInstanceClassType);

      $global:DiscData.AddInstance($TimerInst);

      Handle-Errors(($global:EventLog_Fail_Create_Class -f "SPSystemTimerJobHost"), $false);

    }

  }

}



</Script></Contents>

            </File>

            <File>

              <Name>WSSNonStandardDiscovery.ps1</Name>

              <Contents><Script>function Create-TraceServiceDiscovery([object] $ServerInst)

{

  $ClassType = $global:DisplayName_SPTrace;

  $DisplayName = $global:DisplayName_WindowsTracingService;



  $ServiceInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.Trace']$");

  $ServiceInst.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $DisplayName);

  $ServiceInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

  $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/FarmID$", $global:FarmID);

  $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/HostServer$", $global:LocalServer.Name);

  $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/TypeName$", $ClassType);

  $global:DiscData.AddInstance($ServiceInst);

  Handle-Errors(($global:EventLog_Fail_Create_Class -f "SPServiceInstance.Trace"), $false);



  $ServerServiceInstanceRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPServer.Contains.SPServiceInstance']$");

  $ServerServiceInstanceRel.Source = $ServerInst;

  $ServerServiceInstanceRel.Target = $ServiceInst;

  $global:DiscData.AddInstance($ServerServiceInstanceRel);

  Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPServer.Contains.SPServiceInstance"), $false);

}



$ServerInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPServer']$");

$ServerInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

$ServerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServer']/ComputerID$", $global:ComputerName);

$ServerInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServer']/FarmID$", $global:FarmID);



Create-TraceServiceDiscovery($ServerInst);



</Script></Contents>

            </File>

            <File>

              <Name>WSSApplicationDiscovery.ps1</Name>

              <Contents><Script>function Create-WebApplication([System.Object] $WebAppObjects)

{

  $WebAppGroup = $WebAppObjects[0];

  $WebApp = $WebAppObjects[1];

  $IsAdminWebApp = $WebAppObjects[2];



  if ([Microsoft.SharePoint.Administration.SPObjectStatus]::Online -ne $WebApp.Status)

  {

    break;

  }



  $DefaultZone = [Microsoft.SharePoint.Administration.SPUrlZone]::Default;

  $LocalPath = $WebApp.IisSettings[$DefaultZone].Path;

  $Uri = $WebApp.GetResponseUri($DefaultZone).AbsoluteUri;

  $Authentication = $WebApp.IisSettings[$DefaultZone].AuthenticationMode.ToString();

  Handle-Errors($global:EventLog_Fail_Retrieve_OM_Value);



  $WebTypeName = $WebApp.GetType().FullName;

  $WebAppName = $WebApp.DisplayName;



  $WebAppInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplication']$");

  $WebAppInst.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $WebAppName);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/FarmID$", $global:FarmID);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/AppPath$", $LocalPath);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/ResponseUri$", $Uri);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/Name$", $WebAppName);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/Authentication$", $Authentication);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/AppPool$", $WebApp.ApplicationPool.Name);

  $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/AppUser$", $WebApp.ApplicationPool.Username);

  $global:DiscData.AddInstance($WebAppInst);

  Handle-Errors(($global:EventLog_Fail_Create_Class -f ("SPWebApplication: " +  $WebTypeName)), $false);



  $WebApplicationGroupWebApplicationRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplicationGroup.Contains.SPWebApplication']$");

  $WebApplicationGroupWebApplicationRel.Source = $WebAppGroup;

  $WebApplicationGroupWebApplicationRel.Target = $WebAppInst;

  $global:DiscData.AddInstance($WebApplicationGroupWebApplicationRel);

  Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPWebApplicationGroup.Contains.SPWebApplication"), $false);



  Create-HostInstance($WebAppInst, $WebApp, $IsAdminWebApp);

  Create-ContentDBInstance($WebAppInst, $WebApp, $IsAdminWebApp);

}



function Create-HostInstance([System.Object] $WebAppInfos)

{

  $WebAppInst = $WebAppInfos[0];

  $WebApp = $WebAppInfos[1];

  $IsAdminWebApp = $WebAppInfos[2];



  $WebServiceInstance = $null;

  $ServiceInstanceClass = $null;

  if ($IsAdminWebApp)

  {

    $WebServiceInstance = [Microsoft.SharePoint.Administration.SPWebServiceInstance]::LocalAdministration;

    $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.CentralAdmin']$";

    $ServiceInstanceClassType = $WebServiceInstance.GetType().FullName + $global:DisplayName_AdminWord;

  }

  else

  {

    $WebServiceInstance = [Microsoft.SharePoint.Administration.SPWebServiceInstance]::LocalContent;

    $ServiceInstanceClass = "$MPElement[Name='Microsoft.SharePoint.2013.SPServiceInstance.Web']$";

    $ServiceInstanceClassType = $WebServiceInstance.GetType().FullName;

  }



  if ($null -ne $WebServiceInstance)

  {

    $LocalPath = $WebApp.IisSettings[$DefaultZone].Path;

    $WebHostCollection = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplication.SPHostInstanceCollection']$");

    $WebHostCollection.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstanceCollection']/FarmID$", $global:FarmID);

    $WebHostCollection.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstanceCollection']/CollectionPath$", $LocalPath);

    $WebHostCollection.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $global:DisplayName_HostCollection);

    $global:DiscData.AddInstance($WebHostCollection);

    Handle-Errors(($global:EventLog_Fail_Create_Class -f "SPWebApplication.SPHostInstanceCollection"), $false);



    $WebAppHostedRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.Contains.SPHostInstanceCollection']$");

    $WebAppHostedRel.Source = $WebAppInst;

    $WebAppHostedRel.Target = $WebHostCollection;

    $global:DiscData.AddInstance($WebAppHostedRel);

    Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPWebApplication.Contains.SPHostInstanceCollection"), $false);



    if ([Microsoft.SharePoint.Administration.SPObjectStatus]::Online -eq $WebServiceInstance.Status)

    {

      $HostSrvInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplication.SPHostInstance']$");

      $HostSrvInst.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $WebApp.ApplicationPool.Name + "(" + $global:LocalServer.Name + ")");

      $HostSrvInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

      $HostSrvInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstance']/FarmID$", $global:FarmID);

      $HostSrvInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstance']/HostPath$", $LocalPath);

      $HostSrvInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstance']/HostServer$", $global:LocalServer.Name);

      $HostSrvInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstance']/AppPool$", $WebApp.ApplicationPool.Name);

      $global:DiscData.AddInstance($HostSrvInst);

      Handle-Errors(($global:EventLog_Fail_Create_Class -f ("SPWebApplication.SPHostInstance: " + $WebSvcInst.TypeName)), $false);



      $WebAppSvcInstanceRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPHostInstanceCollection.Contains.SPHostInstance']$");

      $WebAppSvcInstanceRel.Source = $WebHostCollection;

      $WebAppSvcInstanceRel.Target = $HostSrvInst;

      $global:DiscData.AddInstance($WebAppSvcInstanceRel);

      Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPWebApplication.SPHostInstanceCollection.Contains.SPHostInstance"), $false);



      $ServiceInst = $global:DiscData.CreateClassInstance($ServiceInstanceClass);

      $ServiceInst.AddProperty("$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$", $global:ComputerName);

      $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/FarmID$", $global:FarmID);

      $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/HostServer$", $WebServiceInstance.Server.Name);

      $ServiceInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance']/TypeName$", $ServiceInstanceClassType);



      $ServiceHostInstanceRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPServiceInstance.Web.Contains.SPHostInstance']$");

      $ServiceHostInstanceRel.Source = $ServiceInst;

      $ServiceHostInstanceRel.Target = $HostSrvInst;

      $global:DiscData.AddInstance($ServiceHostInstanceRel);

      Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPServiceInstance.Web.Contains.SPHostInstance"), $false);

    }

  }

}



function Create-ContentDBInstance([System.Object] $WebAppInfos)

{

  $WebAppInst = $WebAppInfos[0];

  $WebApp = $WebAppInfos[1];

  $IsAdminWebApp = $WebAppInfos[2];



  $LocalPath = $WebApp.IisSettings[$DefaultZone].Path;

  $WebAppName = $WebApp.Name;

  if ($IsAdminWebApp)

  {



    $WebAppName = $global:WSSAdmin;

  }



  $DBCollection = $null;

  $ContentDBCollection = $WebApp.ContentDatabases;

  if ($ContentDBCollection.Count -ne 0)

  {

    $DBCollection = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplication.SPContentDBCollection']$");

    $DBCollection.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $global:DisplayName_DatabaseCollection);

    $DBCollection.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPContentDBCollection']/FarmID$", $global:FarmID);

    $DBCollection.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPContentDBCollection']/DBPath$", $LocalPath);

    $DBCollection.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPContentDBCollection']/Name$", $WebAppName);

    $global:DiscData.AddInstance($DBCollection);

    Handle-Errors(($global:EventLog_Fail_Create_Class -f "SPWebApplication.SPContentDBCollection"), $false);



    $WebAppInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplication']$");

    $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/FarmID$", $global:FarmID);

    $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/AppPath$", $LocalPath);

    $WebAppInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication']/Name$", $WebAppName);



    $WebAppDBCollectionRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.Contains.SPContentDBCollection']$");

    $WebAppDBCollectionRel.Source = $WebAppInst;

    $WebAppDBCollectionRel.Target = $DBCollection;

    $global:DiscData.AddInstance($WebAppDBCollectionRel);

    Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPWebApplication.Contains.SPContentDBCollection"), $false);

  }



  foreach ($ContentDB in $ContentDBCollection)

  {

    if ($ContentDB) 

    {

      $ServerValue = $ContentDB.Server;

      $NameValue = $ContentDB.Name;



      $ContentDBInst = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplication.SPContentDB']$");

      $ContentDBInst.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", $ServerValue + "\" + $NameValue);

      $ContentDBInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPDatabase']/FarmID$", $global:FarmID);

      $ContentDBInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPDatabase']/DatabaseID$", $ContentDB.Id.ToString());

      $ContentDBInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPDatabase']/ConnectionString$", $ContentDB.DatabaseConnectionString);

      $ContentDBInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPDatabase']/LegacyConnectionString$", $ContentDB.LegacyDatabaseConnectionString);

      $ContentDBInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPContentDB']/Database$", $NameValue);

      $ContentDBInst.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPContentDB']/Server$", $ServerValue);

      $global:DiscData.AddInstance($ContentDBInst);

      Handle-Errors(($global:EventLog_Fail_Create_Class -f ("SPWebApplication.SPContentDB class" + $ConnectionStringValue)), $false);



      $DBCollectionDBRel = $global:DiscData.CreateRelationshipInstance("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplication.SPContentDBCollection.Contains.SPContentDB']$");

      $DBCollectionDBRel.Source = $DBCollection;

      $DBCollectionDBRel.Target = $ContentDBInst;

      $global:DiscData.AddInstance($DBCollectionDBRel);

      Handle-Errors(($global:EventLog_Fail_Create_Relationship -f "SPWebApplication.SPContentDBCollection.Contains.SPContentDB"), $false);

    }

  }

}



$WebApplicationGroup = $global:DiscData.CreateClassInstance("$MPElement[Name='Microsoft.SharePoint.2013.SPWebApplicationGroup']$");

$WebApplicationGroup.AddProperty("$MPElement[Name='WSS!Microsoft.SharePoint.SPWebApplicationGroup']/FarmID$", $global:FarmID);



$AdminWebService = [Microsoft.SharePoint.Administration.SPWebService]::AdministrationService;

Handle-Errors(($global:EventLog_Fail_Retrieve_Service -f $AdminWebService.TypeName, $global:Farm.Name), $false);

$ContentWebService = [Microsoft.SharePoint.Administration.SPWebService]::ContentService;

Handle-Errors(($global:EventLog_Fail_Retrieve_Service -f $ContentWebService.TypeName, $global:Farm.Name), $false);



foreach ($WebApp in $AdminWebService.WebApplications)

{

  Create-WebApplication($WebApplicationGroup, $WebApp, $true);

}



foreach ($WebApp in $ContentWebService.WebApplications)

{

  Create-WebApplication($WebApplicationGroup, $WebApp, $false);

}



</Script></Contents>

            </File>

          </Files>

        </DataSource>

      </MemberModules>

      <Composition>

        <Node ID="DS"/>

      </Composition>

    </Composite>

  </ModuleImplementation>

  <OutputType>System!System.Discovery.Data</OutputType>

</DataSourceModuleType>