public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
Tracer tracer = new Tracer();
tracer.Correlate();
if (sessionConfigurationData != null)
{
if (senderInfo != null)
{
if (!string.IsNullOrEmpty(configProviderId))
{
if (Interlocked.CompareExchange(ref PSWorkflowSessionConfiguration._modulesLoaded, 1, 0) == 0)
{
try
{
PSWorkflowConfigurationProvider configuration = WorkflowJobSourceAdapter.GetInstance().GetPSWorkflowRuntime().Configuration;
if (configuration != null)
{
configuration.Populate(sessionConfigurationData.PrivateData, configProviderId, senderInfo);
if (sessionConfigurationData.ModulesToImport != null)
{
foreach (string modulesToImport in sessionConfigurationData.ModulesToImport)
{
PSWorkflowSessionConfiguration.InitialSessionState.ImportPSModulesFromPath(modulesToImport);
}
}
}
else
{
throw new InvalidOperationException("PSWorkflowConfigurationProvider is null");
}
}
catch (Exception exception)
{
Interlocked.CompareExchange(ref PSWorkflowSessionConfiguration._modulesLoaded, 0, 1);
throw;
}
}
if (configProviderId.ToLower(CultureInfo.InvariantCulture).Equals("http://schemas.microsoft.com/powershell/microsoft.windows.servermanagerworkflows"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return(PSWorkflowSessionConfiguration.InitialSessionState);
}
else
{
throw new ArgumentNullException("configProviderId");
}
}
else
{
throw new ArgumentNullException("senderInfo");
}
}
else
{
throw new ArgumentNullException("sessionConfigurationData");
}
}
internal static PSWorkflowExecutionOption LoadConfig(string privateData, PSWorkflowConfigurationProvider configuration)
{
PSWorkflowExecutionOption pSWorkflowExecutionOption = new PSWorkflowExecutionOption();
if (!string.IsNullOrEmpty(privateData))
{
XmlReaderSettings xmlReaderSetting = new XmlReaderSettings();
xmlReaderSetting.CheckCharacters = false;
xmlReaderSetting.IgnoreComments = true;
xmlReaderSetting.IgnoreProcessingInstructions = true;
xmlReaderSetting.MaxCharactersInDocument = (long)0x2710;
xmlReaderSetting.XmlResolver = null;
xmlReaderSetting.ConformanceLevel = ConformanceLevel.Fragment;
XmlReaderSettings xmlReaderSetting1 = xmlReaderSetting;
XmlReader xmlReader = XmlReader.Create(new StringReader(privateData), xmlReaderSetting1);
using (xmlReader)
{
if (xmlReader.ReadToFollowing("PrivateData"))
{
HashSet <string> strs = new HashSet <string>();
bool descendant = xmlReader.ReadToDescendant("Param");
while (descendant)
{
if (xmlReader.MoveToAttribute("Name"))
{
string value = xmlReader.Value;
if (xmlReader.MoveToAttribute("Value"))
{
if (!strs.Contains(value.ToLower(CultureInfo.InvariantCulture)))
{
string str = xmlReader.Value;
PSWorkflowConfigurationProvider.Update(value, str, pSWorkflowExecutionOption, configuration);
strs.Add(value.ToLower(CultureInfo.InvariantCulture));
descendant = xmlReader.ReadToFollowing("Param");
}
else
{
throw new PSArgumentException(Resources.ParamSpecifiedMoreThanOnce, value);
}
}
else
{
throw new PSArgumentException(Resources.ValueNotSpecifiedForParam);
}
}
else
{
throw new PSArgumentException(Resources.NameNotSpecifiedForParam);
}
}
}
}
return(pSWorkflowExecutionOption);
}
else
{
return(pSWorkflowExecutionOption);
}
}
public PSWorkflowRuntime()
{
this._syncObject = new object();
this._configuration = new PSWorkflowConfigurationProvider();
this._configuration.Runtime = this;
PSCounterSetRegistrar pSCounterSetRegistrar = new PSCounterSetRegistrar(PSWorkflowPerformanceCounterSetInfo.ProviderId, PSWorkflowPerformanceCounterSetInfo.CounterSetId, PSWorkflowPerformanceCounterSetInfo.CounterSetType, PSWorkflowPerformanceCounterSetInfo.CounterInfoArray, null);
PSWorkflowRuntime._psPerfCountersMgrInst.AddCounterSetInstance(pSCounterSetRegistrar);
PSModuleInfo.UseAppDomainLevelModuleCache = true;
}
internal static PSWorkflowExecutionOption LoadConfig(string privateData, PSWorkflowConfigurationProvider configuration)
{
PSWorkflowExecutionOption target = new PSWorkflowExecutionOption();
if (String.IsNullOrEmpty(privateData))
{
return(target);
}
XmlReaderSettings readerSettings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreComments = true,
IgnoreProcessingInstructions = true,
MaxCharactersInDocument = 10000,
XmlResolver = null,
ConformanceLevel = ConformanceLevel.Fragment
};
using (XmlReader reader = XmlReader.Create(new StringReader(privateData), readerSettings))
{
// read the header <PrivateData>
if (reader.ReadToFollowing(PrivateDataToken))
{
HashSet <string> assignedParams = new HashSet <string>();
bool found = reader.ReadToDescendant(ParamToken);
while (found)
{
if (!reader.MoveToAttribute(NameToken))
{
throw new PSArgumentException(Resources.NameNotSpecifiedForParam);
}
string optionName = reader.Value;
if (!reader.MoveToAttribute(ValueToken))
{
throw new PSArgumentException(Resources.ValueNotSpecifiedForParam);
}
if (assignedParams.Contains(optionName.ToLower(CultureInfo.InvariantCulture)))
{
throw new PSArgumentException(Resources.ParamSpecifiedMoreThanOnce, optionName);
}
string optionValue = reader.Value;
Update(optionName, optionValue, target, configuration);
assignedParams.Add(optionName.ToLower(CultureInfo.InvariantCulture));
found = reader.ReadToFollowing(ParamToken);
}
}
}
return(target);
}
internal PSOutOfProcessActivityController(PSWorkflowRuntime runtime)
: base(runtime)
{
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
Debug.Assert(runtime.Configuration != null, "For now only expecting PSWorkflowConfigurationProvider");
this._configuration = runtime.Configuration;
InitializeActivityHostProcesses();
}
/// <summary>
/// PSWorkflowValidator
/// </summary>
/// <param name="configuration"></param>
public PSWorkflowValidator(PSWorkflowConfigurationProvider configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (TestMode)
{
System.Threading.Interlocked.Increment(ref ObjectCounter);
}
this.Configuration = configuration;
}
/// <summary>
/// Default constructor
/// </summary>
public PSWorkflowRuntime()
{
_configuration = new PSWorkflowConfigurationProvider();
_configuration.Runtime = this;
PSCounterSetRegistrar registrar =
new PSCounterSetRegistrar(
PSWorkflowPerformanceCounterSetInfo.ProviderId,
PSWorkflowPerformanceCounterSetInfo.CounterSetId,
PSWorkflowPerformanceCounterSetInfo.CounterSetType,
PSWorkflowPerformanceCounterSetInfo.CounterInfoArray);
_psPerfCountersMgrInst.AddCounterSetInstance(registrar);
// Enable caching module paths appdomain-wide.
System.Management.Automation.PSModuleInfo.UseAppDomainLevelModuleCache = true;
}
public PSWorkflowValidator(PSWorkflowConfigurationProvider configuration)
{
this._validationCache = new ConcurrentDictionary <Guid, PSWorkflowValidationResults>();
if (configuration != null)
{
if (PSWorkflowValidator.TestMode)
{
Interlocked.Increment(ref PSWorkflowValidator.ObjectCounter);
}
this.Configuration = configuration;
return;
}
else
{
throw new ArgumentNullException("configuration");
}
}
internal PSOutOfProcessActivityController(PSWorkflowRuntime runtime) : base(runtime)
{
this._hostProcesses = new Collection <ActivityHostProcess>();
this._requests = new ConcurrentQueue <ActivityInvoker>();
this._structuredTracer = new Tracer();
this._failedRequests = new ConcurrentQueue <ActivityInvoker>();
if (runtime != null)
{
this._configuration = runtime.Configuration;
this.InitializeActivityHostProcesses();
return;
}
else
{
throw new ArgumentNullException("runtime");
}
}
private void OnWSManServerShuttingDownEventRaised(object sender, EventArgs e)
{
try
{
this.IsShutdownInProgress = true;
PSWorkflowConfigurationProvider configuration = PSWorkflowRuntime.Instance.Configuration;
int workflowShutdownTimeoutMSec = configuration.WorkflowShutdownTimeoutMSec;
this.GetJobManager().ShutdownWorkflowManager(workflowShutdownTimeoutMSec);
}
catch (Exception exception1)
{
Exception exception = exception1;
object[] objArray = new object[1];
objArray[0] = exception;
this._tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, "Shutting down WSMan server: Exception details: {0}", objArray));
}
}
/// <summary>
/// Constructs runtime based on configuration
/// </summary>
/// <param name="configuration"></param>
public PSWorkflowRuntime(PSWorkflowConfigurationProvider configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
// Only allow FullLanguage or ConstraintLanguage or it can be null in that case system wide default will take an affect
PSLanguageMode?langMode = configuration.LanguageMode;
if (langMode != null && langMode.HasValue && (langMode.Value == PSLanguageMode.NoLanguage || langMode.Value == PSLanguageMode.RestrictedLanguage))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.NotSupportedLanguageMode, langMode.Value.ToString()));
}
_configuration = configuration;
_configuration.Runtime = this;
}
/// <summary>
/// Handles the wsman server shutting down event.
/// </summary>
/// <param name="sender">sender of this event</param>
/// <param name="e">arguments describing the event</param>
private void OnWSManServerShuttingDownEventRaised(object sender, EventArgs e)
{
try
{
IsShutdownInProgress = true;
PSWorkflowConfigurationProvider _configuration = (PSWorkflowConfigurationProvider)PSWorkflowRuntime.Instance.Configuration;
int timeout = _configuration.WorkflowShutdownTimeoutMSec;
GetJobManager().ShutdownWorkflowManager(timeout);
}
catch (Exception exception)
{
// when exception on shutdown, not much to do much other than logging the exception
_tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture,
"Shutting down WSMan server: Exception details: {0}",
exception));
Dbg.Assert(false, "Exception has happened during the shutdown API. [Message] " + exception.Message + "[StackTrace] " + exception.StackTrace);
}
}
private bool IsOutOfProcessActivity(Type activityType)
{
IEnumerable <string> strs = this.OutOfProcessActivity;
IEnumerable <string> strs1 = strs;
if (strs == null)
{
strs1 = (IEnumerable <string>)(new string[0]);
}
return(strs1.Any <string>((string outOfProcessActivity) => {
if (PSWorkflowConfigurationProvider.IsMatched(outOfProcessActivity, activityType.Name) || PSWorkflowConfigurationProvider.IsMatched(outOfProcessActivity, activityType.FullName) || PSWorkflowConfigurationProvider.IsMatched(outOfProcessActivity, string.Concat(activityType.Assembly.GetName().Name, "\\", activityType.Name)) || PSWorkflowConfigurationProvider.IsMatched(outOfProcessActivity, string.Concat(activityType.Assembly.GetName().Name, "\\", activityType.FullName)) || PSWorkflowConfigurationProvider.IsMatched(outOfProcessActivity, string.Concat(activityType.Assembly.GetName().FullName, "\\", activityType.Name)))
{
return true;
}
else
{
return PSWorkflowConfigurationProvider.IsMatched(outOfProcessActivity, string.Concat(activityType.Assembly.GetName().FullName, "\\", activityType.FullName));
}
}
));
}
public PSWorkflowRuntime(PSWorkflowConfigurationProvider configuration)
{
this._syncObject = new object();
if (configuration != null)
{
PSLanguageMode?languageMode = configuration.LanguageMode;
if (!languageMode.HasValue || !languageMode.HasValue || languageMode.Value != PSLanguageMode.NoLanguage && languageMode.Value != PSLanguageMode.RestrictedLanguage)
{
this._configuration = configuration;
this._configuration.Runtime = this;
return;
}
else
{
object[] str = new object[1];
str[0] = languageMode.Value.ToString();
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.NotSupportedLanguageMode, str));
}
}
else
{
throw new ArgumentNullException("configuration");
}
}
public void Populate(string applicationPrivateData, string configProviderId)
{
string str;
if (!this._isPopulated)
{
lock (this._syncObject)
{
if (!this._isPopulated)
{
this._privateData = applicationPrivateData;
char[] chrArray = new char[1];
chrArray[0] = '/';
string[] strArrays = configProviderId.Split(chrArray, StringSplitOptions.RemoveEmptyEntries);
PSWorkflowConfigurationProvider pSWorkflowConfigurationProvider = this;
if ((int)strArrays.Length > 0)
{
str = strArrays[(int)strArrays.Length - 1];
}
else
{
str = configProviderId;
}
pSWorkflowConfigurationProvider._configProviderId = str;
this._isPopulated = true;
this._wfOptions = PSWorkflowConfigurationProvider.LoadConfig(this._privateData, this);
this.ResetCaching();
}
}
return;
}
else
{
return;
}
}
private static void Update(string optionName, string value, PSWorkflowExecutionOption target, PSWorkflowConfigurationProvider configuration)
{
bool flag = false;
bool flag1 = false;
string lower = optionName.ToLower(CultureInfo.InvariantCulture);
string str = lower;
if (lower != null)
{
if (str == "workflowapplicationpersistunloadtimeoutsec")
{
target.WorkflowApplicationPersistUnloadTimeoutSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "activityprocessidletimeoutsec")
{
target.ActivityProcessIdleTimeoutSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "allowedactivity")
{
char[] chrArray = new char[1];
chrArray[0] = ',';
string[] strArrays = value.Split(chrArray, StringSplitOptions.RemoveEmptyEntries);
PSWorkflowExecutionOption array = target;
string[] strArrays1 = strArrays;
array.AllowedActivity = strArrays1.Select <string, string>((string activity) => activity.Trim()).ToArray <string>();
return;
}
else if (str == "enablevalidation")
{
if (!bool.TryParse(value, out flag))
{
return;
}
target.EnableValidation = flag;
return;
}
else if (str == "persistencepath")
{
target.PersistencePath = Environment.ExpandEnvironmentVariables(value);
return;
}
else if (str == "maxpersistencestoresizegb")
{
target.MaxPersistenceStoreSizeGB = (long)LanguagePrimitives.ConvertTo(value, typeof(long), CultureInfo.InvariantCulture);
return;
}
else if (str == "persistwithencryption")
{
if (!bool.TryParse(value, out flag1))
{
return;
}
target.PersistWithEncryption = flag1;
return;
}
else if (str == "remotenodesessionidletimeoutsec")
{
target.RemoteNodeSessionIdleTimeoutSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
if (configuration == null)
{
return;
}
configuration._remoteNodeSessionIdleTimeoutSec = target.RemoteNodeSessionIdleTimeoutSec;
return;
}
else if (str == "maxactivityprocesses")
{
target.MaxActivityProcesses = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "maxconnectedsessions")
{
target.MaxConnectedSessions = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "maxdisconnectedsessions")
{
target.MaxDisconnectedSessions = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "maxrunningworkflows")
{
target.MaxRunningWorkflows = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
configuration._maxInProcRunspaces = target.MaxRunningWorkflows * 2;
return;
}
else if (str == "maxsessionsperremotenode")
{
target.MaxSessionsPerRemoteNode = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "maxsessionsperworkflow")
{
target.MaxSessionsPerWorkflow = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "outofprocessactivity")
{
char[] chrArray1 = new char[1];
chrArray1[0] = ',';
string[] strArrays2 = value.Split(chrArray1, StringSplitOptions.RemoveEmptyEntries);
PSWorkflowExecutionOption pSWorkflowExecutionOption = target;
string[] strArrays3 = strArrays2;
pSWorkflowExecutionOption.OutOfProcessActivity = strArrays3.Select <string, string>((string activity) => activity.Trim()).ToArray <string>();
return;
}
else if (str == "sessionthrottlelimit")
{
target.SessionThrottleLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "validationcachelimit")
{
if (configuration == null)
{
return;
}
configuration._validationCacheLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "compiledassemblycachelimit")
{
if (configuration == null)
{
return;
}
configuration._compiledAssemblyCacheLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "outofprocessactivitycachelimit")
{
if (configuration == null)
{
return;
}
configuration._outOfProcessActivityCacheLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "workflowshutdowntimeoutmsec")
{
target.WorkflowShutdownTimeoutMSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
else if (str == "maxinprocrunspaces")
{
if (configuration == null)
{
return;
}
configuration._maxInProcRunspaces = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
return;
}
return;
}
}
/// <summary>
/// Using optionName and optionValue updates the current object
/// </summary>
/// <param name="optionName"></param>
/// <param name="value"></param>
/// <param name="target"></param>
/// <param name="configuration"></param>
private static void Update(string optionName, string value, PSWorkflowExecutionOption target, PSWorkflowConfigurationProvider configuration)
{
switch (optionName.ToLower(CultureInfo.InvariantCulture))
{
case TokenWorkflowApplicationPersistUnloadTimeoutSec:
target.WorkflowApplicationPersistUnloadTimeoutSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenWSManPluginReportCompletionOnZeroActiveSessionsWaitIntervalMSec:
target.WSManPluginReportCompletionOnZeroActiveSessionsWaitIntervalMSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenActivitiesCacheCleanupIntervalMSec:
target.ActivitiesCacheCleanupIntervalMSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenActivityProcessIdleTimeoutSec:
target.ActivityProcessIdleTimeoutSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenAllowedActivity:
string[] activities = value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
target.AllowedActivity = activities.Select(activity => activity.Trim()).ToArray();
break;
case TokenEnableValidation:
bool enableValidation;
if (bool.TryParse(value, out enableValidation))
{
target.EnableValidation = enableValidation;
}
break;
case TokenPersistencePath:
target.PersistencePath = Environment.ExpandEnvironmentVariables(value);
break;
case TokenMaxPersistenceStoreSizeGB:
target.MaxPersistenceStoreSizeGB = (long)LanguagePrimitives.ConvertTo(value, typeof(long), CultureInfo.InvariantCulture);
break;
case TokenPersistWithEncryption:
bool persistWithEncryption;
if (bool.TryParse(value, out persistWithEncryption))
{
target.PersistWithEncryption = persistWithEncryption;
}
break;
case TokenRemoteNodeSessionIdleTimeoutSec:
target.RemoteNodeSessionIdleTimeoutSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
if (configuration != null)
{
configuration._remoteNodeSessionIdleTimeoutSec = target.RemoteNodeSessionIdleTimeoutSec;
}
break;
case TokenMaxActivityProcesses:
target.MaxActivityProcesses = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenMaxConnectedSessions:
target.MaxConnectedSessions = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenMaxDisconnectedSessions:
target.MaxDisconnectedSessions = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenMaxRunningWorkflows:
target.MaxRunningWorkflows = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
configuration._maxInProcRunspaces = target.MaxRunningWorkflows * 2;
break;
case TokenMaxSessionsPerRemoteNode:
target.MaxSessionsPerRemoteNode = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenMaxSessionsPerWorkflow:
target.MaxSessionsPerWorkflow = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenOutOfProcessActivity:
string[] outofProcActivities = value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
target.OutOfProcessActivity = outofProcActivities.Select(activity => activity.Trim()).ToArray();
break;
case TokenSessionThrottleLimit:
{
target.SessionThrottleLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
}
break;
case TokenValidationCacheLimit:
if (configuration != null)
{
configuration._validationCacheLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
}
break;
case TokenCompiledAssemblyCacheLimit:
if (configuration != null)
{
configuration._compiledAssemblyCacheLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
}
break;
case TokenOutOfProcessActivityCacheLimit:
if (configuration != null)
{
configuration._outOfProcessActivityCacheLimit = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
}
break;
case TokenWorkflowShutdownTimeoutMSec:
target.WorkflowShutdownTimeoutMSec = (int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
break;
case TokenMaxInProcRunspaces:
{
if (configuration != null)
{
configuration._maxInProcRunspaces =
(int)LanguagePrimitives.ConvertTo(value, typeof(int), CultureInfo.InvariantCulture);
}
}
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="sessionConfigurationData"></param>
/// <param name="senderInfo"></param>
/// <param name="configProviderId"></param>
/// <returns></returns>
public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
Tracer structuredTracer = new Tracer();
structuredTracer.Correlate();
if (sessionConfigurationData == null)
{
throw new ArgumentNullException("sessionConfigurationData");
}
if (senderInfo == null)
{
throw new ArgumentNullException("senderInfo");
}
if (string.IsNullOrEmpty(configProviderId))
{
throw new ArgumentNullException("configProviderId");
}
if (Interlocked.CompareExchange(ref _modulesLoaded, ModulesLoaded, ModulesNotLoaded) == ModulesNotLoaded)
{
// it is sufficient if Populate() is called the first time and
// modules are loaded once
try
{
IsWorkflowTypeEndpoint = true;
PSWorkflowConfigurationProvider workflowConfiguration = WorkflowJobSourceAdapter.GetInstance().GetPSWorkflowRuntime().Configuration;
if (workflowConfiguration == null)
{
throw new InvalidOperationException("PSWorkflowConfigurationProvider is null");
}
workflowConfiguration.Populate(sessionConfigurationData.PrivateData, configProviderId, senderInfo);
// now get all the modules in the specified path and import the same
if (sessionConfigurationData.ModulesToImport != null)
{
foreach (var module in sessionConfigurationData.ModulesToImport)
{
ModuleSpecification moduleSpec = null;
if (ModuleSpecification.TryParse(module, out moduleSpec))
{
var modulesToImport = new Collection <ModuleSpecification> {
moduleSpec
};
InitialSessionState.ImportPSModule(modulesToImport);
}
else
{
InitialSessionState.ImportPSModule(new[] { Environment.ExpandEnvironmentVariables(module) });
}
}
}
// Start the workflow job manager, if not started, to add an event handler for zero active sessions changed events
// This is required to auto shutdown the workflow type shared process when no workflow jobs have scheduled/inprogress and when no active sessions
WorkflowJobSourceAdapter.GetInstance().GetJobManager();
}
catch (Exception)
{
// if there is an exception in either Populate() or Importing modules
// we consider that it is not loaded
Interlocked.CompareExchange(ref _modulesLoaded, ModulesNotLoaded, ModulesLoaded);
throw;
}
}
if (configProviderId.ToLower(CultureInfo.InvariantCulture).Equals("http://schemas.microsoft.com/powershell/microsoft.windows.servermanagerworkflows"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return(InitialSessionState);
}
