/// <summary> /// Accepts anything and tries to convert it to a live SMO Database object /// </summary> /// <param name="Item">The item to convert</param> public DbaDatabaseSmoParameter(object Item) { if (Item == null) { throw new ArgumentException("Input must not be null!"); } InputObject = Item; PSObject tempInput = new PSObject(Item); if (tempInput.TypeNames.Contains("Microsoft.SqlServer.Management.Smo.Database")) { Database = Item; Name = (string)tempInput.Properties["Name"].Value; return; } foreach (PSPropertyInfo prop in tempInput.Properties) { if (UtilityHost.IsLike(prop.Name, "Database") && (prop.Value != null)) { PSObject tempDB = new PSObject(prop.Value); if (tempDB.TypeNames.Contains("Microsoft.SqlServer.Management.Smo.Database")) { Database = prop.Value; Name = (string)tempDB.Properties["Name"].Value; return; } } } throw new ArgumentException("Cannot interpret input as SMO Database object"); }
/// <summary> /// Applies a transformation rule to the columns stored in this view /// </summary> /// <param name="Transform">The transformation rule to apply</param> public void TransformColumn(ColumnTransformation Transform) { if (!UtilityHost.IsLike(Name, Transform.FilterViewName)) { return; } bool applied = false; foreach (Column column in Columns) { if ((!String.IsNullOrEmpty(Transform.FilterColumnName)) && (UtilityHost.IsLike(column.SortableName, Transform.FilterColumnName))) { Transform.Apply(column); applied = true; } } if (!applied && Transform.Append && (Transform.ScriptBlock != null)) { Column tempColumn = new Column(); Transform.Apply(tempColumn); Columns.Add(tempColumn); } }
/// <summary> /// Invokes the callback scriptblock as configured. /// </summary> /// <param name="Caller">The object containing the information pertaining to the calling command.</param> /// <param name="Invoker">The meta object representing the invoking command.</param> /// <param name="Data">Extra data that was passed to the event</param> public void Invoke(CallerInfo Caller, PSCmdlet Invoker, object Data) { Hashtable table = new Hashtable(StringComparer.InvariantCultureIgnoreCase); table["Command"] = Invoker.MyInvocation.MyCommand.Name; table["ModuleName"] = Invoker.MyInvocation.MyCommand.ModuleName; table["CallerFunction"] = Caller.CallerFunction; table["CallerModule"] = Caller.CallerModule; table["Data"] = Data; try { if (BreakAffinity) { lock (_InvokeLock) { UtilityHost.ImportScriptBlock(ScriptBlock); ScriptBlock.Invoke(table); } } else { ScriptBlock.Invoke(table); } } catch (Exception e) { throw new CallbackException(this, e); } }
/// <summary> /// Clones the specified scriptblock maintaining its language mode. /// </summary> /// <param name="ScriptBlock">The Scriptblock to clone</param> /// <returns>A clone of the scriptblock with the languagemode intact</returns> public static ScriptBlock Clone(this ScriptBlock ScriptBlock) { ScriptBlock newBlock = (ScriptBlock)UtilityHost.InvokePrivateMethod("Clone", ScriptBlock, null); UtilityHost.SetPrivateProperty("LanguageMode", newBlock, UtilityHost.GetPrivateProperty("LanguageMode", ScriptBlock)); return(newBlock); }
public static Script CreateScriptRuntime(LuaScriptHost host) { host.CoroutineManager = new LuaCoroutineManager(host); var script = new Script(CoreModules.Preset_Default | CoreModules.Debug); script.Options.UseLuaErrorLocations = false; script.Globals["_host"] = host; script.Globals["console"] = typeof(LuaRuntime.Console); script.Globals["scene"] = new SceneHost(); script.Globals["resources"] = new ResourcesHost(); script.Globals["game"] = new GameHost(host); script.Globals["vec2"] = (Func <float, float, Vector2>)MathUtilities.vec2; script.Globals["vec3"] = (Func <float, float, float, Vector3>)MathUtilities.vec3; var utility = new UtilityHost(host); script.Globals["timeout"] = (Func <Closure, float, int>)utility.SetTimeout; script.Globals["interval"] = (Func <Closure, float, int>)utility.Interval; script.Globals["removeTimeout"] = (Action <int>)utility.RemoveTimeout; script.Globals["removeInterval"] = (Action <int>)utility.RemoveInterval; script.Globals["waitForSeconds"] = (Func <float, YieldInstruction>)utility.WaitForSeconds; script.Globals["Time"] = typeof(Time); script.Globals["timer"] = (Func <float, IEnumerable <float> >)Utility.Timer; script.Globals["entity"] = host.GetComponent <GameEntity>(); script.Globals["startCoroutine"] = (Func <Closure, UnityEngine.Coroutine>)host.CoroutineManager.StartCoroutine; script.Globals["stopCoroutine"] = (Action <UnityEngine.Coroutine>)host.CoroutineManager.StopCoroutine; script.Globals["utility"] = utility; script.Globals["camera"] = SceneCamera.Instance; script.Globals["wait"] = (Func <string, UnityEngine.Coroutine>)((t) => host.StartCoroutine(Wait(host, t))); script.Globals["sign"] = (Func <float, int>)MathUtility.SignInt; GUIHost.InitHost(host, script); return(script); }
/// <summary> /// Tests, whether the completion set applies to the specified parameter / command combination /// </summary> /// <param name="Command">The command to test</param> /// <param name="Parameter">The parameter of the command to test</param> /// <returns>Whether this completion set applies to the specified combination of parameter / command</returns> public bool Applies(string Command, string Parameter) { if ((UtilityHost.IsLike(Command, this.Command)) && (UtilityHost.IsLike(Parameter, this.Parameter))) { return(true); } return(false); }
/// <summary> /// This will import the events into the current execution context, breaking runspace affinity /// </summary> public void LocalizeEvents() { UtilityHost.ImportScriptBlock(BeginEvent, true); UtilityHost.ImportScriptBlock(StartEvent, true); UtilityHost.ImportScriptBlock(MessageEvent, true); UtilityHost.ImportScriptBlock(ErrorEvent, true); UtilityHost.ImportScriptBlock(EndEvent, true); UtilityHost.ImportScriptBlock(FinalEvent, true); }
/// <summary> /// Parses an input string as timespan /// </summary> /// <param name="Value">The string to interpret</param> /// <returns>The interpreted timespan value</returns> internal static TimeSpan ParseTimeSpan(string Value) { if (String.IsNullOrWhiteSpace(Value)) { throw new ArgumentNullException("Cannot parse empty string!"); } try { return(TimeSpan.Parse(Value, CultureInfo.CurrentCulture)); } catch { } try { return(TimeSpan.Parse(Value, CultureInfo.InvariantCulture)); } catch { } bool positive = !(Value.Contains('-')); TimeSpan timeResult = new TimeSpan(); string tempValue = Value.Replace("-", "").Trim(); foreach (string element in tempValue.Split(' ')) { if (Regex.IsMatch(element, @"^\d+$")) { timeResult = timeResult.Add(new TimeSpan(0, 0, Int32.Parse(element))); } else if (UtilityHost.IsLike(element, "*ms") && Regex.IsMatch(element, @"^\d+ms$", RegexOptions.IgnoreCase)) { timeResult = timeResult.Add(new TimeSpan(0, 0, 0, 0, Int32.Parse(Regex.Match(element, @"^(\d+)ms$", RegexOptions.IgnoreCase).Groups[1].Value))); } else if (UtilityHost.IsLike(element, "*s") && Regex.IsMatch(element, @"^\d+s$", RegexOptions.IgnoreCase)) { timeResult = timeResult.Add(new TimeSpan(0, 0, Int32.Parse(Regex.Match(element, @"^(\d+)s$", RegexOptions.IgnoreCase).Groups[1].Value))); } else if (UtilityHost.IsLike(element, "*m") && Regex.IsMatch(element, @"^\d+m$", RegexOptions.IgnoreCase)) { timeResult = timeResult.Add(new TimeSpan(0, Int32.Parse(Regex.Match(element, @"^(\d+)m$", RegexOptions.IgnoreCase).Groups[1].Value), 0)); } else if (UtilityHost.IsLike(element, "*h") && Regex.IsMatch(element, @"^\d+h$", RegexOptions.IgnoreCase)) { timeResult = timeResult.Add(new TimeSpan(Int32.Parse(Regex.Match(element, @"^(\d+)h$", RegexOptions.IgnoreCase).Groups[1].Value), 0, 0)); } else if (UtilityHost.IsLike(element, "*d") && Regex.IsMatch(element, @"^\d+d$", RegexOptions.IgnoreCase)) { timeResult = timeResult.Add(new TimeSpan(Int32.Parse(Regex.Match(element, @"^(\d+)d$", RegexOptions.IgnoreCase).Groups[1].Value), 0, 0, 0)); } else { throw new ArgumentException(String.Format("Failed to parse as timespan: {0} at {1}", Value, element)); } } if (!positive) { return(timeResult.Negate()); } return(timeResult); }
public void ShouldExecute_Dispose_Correctly() { var host = new UtilityHost(); CreateApplication(); eventFired = false; host.Init(application); WebCoreEvents.Instance.HostStop += Instance_Fired; host.Dispose(); WebCoreEvents.Instance.HostStop -= Instance_Fired; Assert.IsTrue(eventFired); }
/// <summary> /// Returns a list of callbacks /// </summary> /// <param name="Name">The name to filter by</param> /// <param name="All">Whether also callbacks from other runspaces should be included</param> /// <returns>The list of matching callbacks</returns> public static List <Callback> Get(string Name, bool All = false) { List <Callback> callbacks = new List <Callback>(); foreach (Callback callback in Callbacks.Values) { if (UtilityHost.IsLike(callback.Name, Name) && (All || callback.Runspace == null || callback.Runspace == System.Management.Automation.Runspaces.Runspace.DefaultRunspace.InstanceId)) { callbacks.Add(callback); } } return(callbacks); }
/// <summary> /// Checks, whether a given entry matches the filter defined in this subscription /// </summary> /// <param name="Entry">The entry to validate</param> /// <returns>Whether the subscription should react to this entry</returns> public bool Applies(LogEntry Entry) { if (MessageFilterSet && !UtilityHost.IsLike(Entry.Message, MessageFilter)) { return(false); } if (ModuleNameFilterSet && !UtilityHost.IsLike(Entry.ModuleName, ModuleNameFilter)) { return(false); } if (FunctionNameFilterSet && !UtilityHost.IsLike(Entry.FunctionName, FunctionNameFilter)) { return(false); } if (TargetFilterSet && (Entry.TargetObject != TargetFilter)) { return(false); } if (LevelFilterSet && !LevelFilter.Contains(Entry.Level)) { return(false); } if (TagFilterSet) { bool test = false; foreach (string tag in TagFilter) { foreach (string tag2 in Entry.Tags) { if (tag == tag2) { test = true; } } } if (!test) { return(false); } } if (RunspaceFilterSet && RunspaceFilter != Entry.Runspace) { return(false); } return(true); }
/// <summary> /// Whether the callback applies to the current command. /// </summary> /// <param name="ModuleName">Module the current command is part of</param> /// <param name="CommandName">Command that is currently executing</param> /// <returns>True if it applies, otherwise False</returns> public bool Applies(string ModuleName, string CommandName) { if (!ModuleName.Equals(ModuleName, StringComparison.InvariantCultureIgnoreCase)) { return(false); } if ((Runspace != null) & (Runspace != System.Management.Automation.Runspaces.Runspace.DefaultRunspace.InstanceId)) { return(false); } if (!UtilityHost.IsLike(CommandName, this.CommandName)) { return(false); } return(true); }
/// <summary> /// Returns the first transform whose filter is similar enough to work out. /// </summary> /// <param name="TypeName">The name of the type to check for a transform</param> /// <param name="ModuleName">The module of the command that wrote the message with the transformable object</param> /// <param name="Functionname">The command that wrote the message with the transformable object</param> /// <returns>Either a transform or null, if no fitting transform was found</returns> public TransformCondition Get(string TypeName, string ModuleName, string Functionname) { foreach (TransformCondition con in list) { if (!UtilityHost.IsLike(TypeName, con.TypeName)) { continue; } if (!UtilityHost.IsLike(ModuleName, con.ModuleName)) { continue; } if (!UtilityHost.IsLike(Functionname, con.FunctionName)) { continue; } return(con); } return(null); }
public void ShouldExecute_Init_Correctly() { eventFired = false; var routesRegistered = false; using (var fakeProvider = new ContextScopeProviderHelper()) { var registration = new Mock <IWebModulesRegistration>(); registration .Setup(r => r.RegisterKnownModuleRoutes(It.IsAny <RouteCollection>())) .Callback <RouteCollection>(rc => routesRegistered = true); fakeProvider.RegisterFakeServiceInstance(registration.Object, typeof(IWebModulesRegistration)); var host = new UtilityHost(); CreateApplication(); WebCoreEvents.Instance.HostStart += Instance_Fired; host.Init(application); WebCoreEvents.Instance.HostStart -= Instance_Fired; } Assert.IsTrue(eventFired); Assert.IsTrue(routesRegistered); }
/// <summary> /// Validates that the parameter argument is not untrusted /// </summary> /// <param name="arguments">Object to validate</param> /// <param name="engineIntrinsics"> /// The engine APIs for the context under which the validation is being /// evaluated. /// </param> /// <exception cref="ValidationMetadataException"> /// if the argument is untrusted. /// </exception> protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics) { bool everConstrained = false; bool isFullLanguage = false; MethodInfo marked = null; try { object executionContextTLS = UtilityHost.GetExecutionContextFromTLS(); everConstrained = (bool)UtilityHost.GetPrivateStaticProperty(executionContextTLS.GetType(), "HasEverUsedConstrainedLanguage"); isFullLanguage = (PSLanguageMode)UtilityHost.GetPrivateProperty("LanguageMode", executionContextTLS) == PSLanguageMode.FullLanguage; marked = UtilityHost.GetPrivateStaticMethod(executionContextTLS.GetType(), "IsMarkedAsUntrusted"); } catch { } if (everConstrained && isFullLanguage) { if ((bool)marked.Invoke(null, BindingFlags.NonPublic | BindingFlags.Static, null, new object[] { arguments }, System.Globalization.CultureInfo.CurrentCulture)) { throw new ValidationMetadataException(String.Format(Localization.LocalizationHost.Read("PSFramework.Assembly.Validation.UntrustedData"), arguments)); } } }
private IWebApplicationHost CreateHost() { var host = new UtilityHost(); return(host); }
/// <summary> /// Tests whether an error record applies to the provider instance /// </summary> /// <param name="Record">The error record to test</param> /// <returns>Whether it applies to the provider instance</returns> public bool MessageApplies(Message.PsfExceptionRecord Record) { // Modules if (IncludeModules.Count > 0) { bool test = false; foreach (string module in IncludeModules) { if (string.Equals(Record.ModuleName, module, StringComparison.InvariantCultureIgnoreCase)) { test = true; } } if (!test) { return(false); } } foreach (string module in ExcludeModules) { if (string.Equals(Record.ModuleName, module, StringComparison.InvariantCultureIgnoreCase)) { return(false); } } // Functions if (IncludeFunctions.Count > 0) { bool test = false; foreach (string function in IncludeFunctions) { if (UtilityHost.IsLike(Record.FunctionName, function)) { test = true; } } if (!test) { return(false); } } foreach (string function in ExcludeFunctions) { if (UtilityHost.IsLike(Record.FunctionName, function)) { return(false); } } // Tags if (IncludeTags.Count > 0) { if (IncludeTags.Except(Record.Tags).ToList().Count == IncludeTags.Count) { return(false); } } if (ExcludeTags.Except(Record.Tags).ToList().Count < ExcludeTags.Count) { return(false); } return(true); }
/// <summary> /// Resets the current scriptblock's sessionstate to either the current runspace's current sessionstate or its global sessionstate. /// </summary> /// <param name="ScriptBlock">The scriptblock to import</param> /// <param name="Global">Whether to import into the global sessionstate</param> /// <returns>The imported ScriptBlock</returns> public static ScriptBlock Import(this ScriptBlock ScriptBlock, bool Global = false) { UtilityHost.ImportScriptBlock(ScriptBlock, Global); return(ScriptBlock); }
/// <summary> /// Resets the current scriptblock's sessionstate to the current runspace's current sessionstate. /// </summary> /// <param name="ScriptBlock">The scriptblock to import</param> /// <returns>The imported scriptblock</returns> public static ScriptBlock ToLocal(this ScriptBlock ScriptBlock) { UtilityHost.ImportScriptBlock(ScriptBlock); return(ScriptBlock); }
/// <summary> /// Resets the current scriptblock's sessionstate to the current runspace's global sessionstate. /// </summary> /// <param name="ScriptBlock">The scriptblock to globalize</param> /// <returns>The globalized scriptblock</returns> public static ScriptBlock ToGlobal(this ScriptBlock ScriptBlock) { UtilityHost.ImportScriptBlock(ScriptBlock, true); return(ScriptBlock); }
/// <summary> /// Creates a DBA Instance Parameter from string /// </summary> /// <param name="Name">The name of the instance</param> public DbaInstanceParameter(string Name) { InputObject = Name; if (string.IsNullOrWhiteSpace(Name)) { throw new BloodyHellGiveMeSomethingToWorkWithException("Please provide an instance name", "DbaInstanceParameter"); } if (Name == ".") { _ComputerName = Name; _NetworkProtocol = SqlConnectionProtocol.NP; return; } string tempString = Name.Trim(); tempString = Regex.Replace(tempString, @"^\[(.*)\]$", "$1"); if (UtilityHost.IsLike(tempString, @".\*")) { _ComputerName = Name; _NetworkProtocol = SqlConnectionProtocol.NP; string instanceName = tempString.Substring(2); if (!Utility.Validation.IsValidInstanceName(instanceName)) { throw new ArgumentException(String.Format("Failed to interpret instance name: '{0}' is not a legal name!", instanceName)); } _InstanceName = instanceName; return; } if (UtilityHost.IsLike(tempString, "*.WORKGROUP")) { tempString = Regex.Replace(tempString, @"\.WORKGROUP$", "", RegexOptions.IgnoreCase); } // Named Pipe path notation interpretation if (Regex.IsMatch(tempString, @"^\\\\[^\\]+\\pipe\\([^\\]+\\){0,1}sql\\query$", RegexOptions.IgnoreCase)) { try { _NetworkProtocol = SqlConnectionProtocol.NP; _ComputerName = Regex.Match(tempString, @"^\\\\([^\\]+)\\").Groups[1].Value; if (Regex.IsMatch(tempString, @"\\MSSQL\$[^\\]+\\", RegexOptions.IgnoreCase)) { _InstanceName = Regex.Match(tempString, @"\\MSSQL\$([^\\]+)\\", RegexOptions.IgnoreCase).Groups[1].Value; } } catch (Exception e) { throw new ArgumentException(String.Format("Failed to interpret named pipe path notation: {0} | {1}", InputObject, e.Message), e); } return; } // Connection String interpretation try { System.Data.SqlClient.SqlConnectionStringBuilder connectionString = new System.Data.SqlClient.SqlConnectionStringBuilder(tempString); DbaInstanceParameter tempParam = new DbaInstanceParameter(connectionString.DataSource); _ComputerName = tempParam.ComputerName; if (tempParam.InstanceName != "MSSQLSERVER") { _InstanceName = tempParam.InstanceName; } if (tempParam.Port != 1433) { _Port = tempParam.Port; } _NetworkProtocol = tempParam.NetworkProtocol; if (UtilityHost.IsLike(tempString, @"(localdb)\*")) { _NetworkProtocol = SqlConnectionProtocol.NP; } IsConnectionString = true; return; } catch (ArgumentException ex) { string name = "unknown"; try { name = ex.TargetSite.GetParameters()[0].Name; } catch { } if (name == "keyword") { throw; } } catch (FormatException) { throw; } catch { } // Handle and clear protocols. Otherwise it'd make port detection unneccessarily messy if (Regex.IsMatch(tempString, "^TCP:", RegexOptions.IgnoreCase)) //TODO: Use case insinsitive String.BeginsWith() { _NetworkProtocol = SqlConnectionProtocol.TCP; tempString = tempString.Substring(4); } if (Regex.IsMatch(tempString, "^NP:", RegexOptions.IgnoreCase)) // TODO: Use case insinsitive String.BeginsWith() { _NetworkProtocol = SqlConnectionProtocol.NP; tempString = tempString.Substring(3); } // Case: Default instance | Instance by port if (tempString.Split('\\').Length == 1) { if (Regex.IsMatch(tempString, @"[:,]\d{1,5}$") && !Regex.IsMatch(tempString, RegexHelper.IPv6) && ((tempString.Split(':').Length == 2) || (tempString.Split(',').Length == 2))) { char delimiter; if (Regex.IsMatch(tempString, @"[:]\d{1,5}$")) { delimiter = ':'; } else { delimiter = ','; } try { Int32.TryParse(tempString.Split(delimiter)[1], out _Port); if (_Port > 65535) { throw new PSArgumentException("Failed to parse instance name: " + tempString); } tempString = tempString.Split(delimiter)[0]; } catch { throw new PSArgumentException("Failed to parse instance name: " + Name); } } if (Utility.Validation.IsValidComputerTarget(tempString)) { _ComputerName = tempString; } else { throw new PSArgumentException("Failed to parse instance name: " + Name); } } // Case: Named instance else if (tempString.Split('\\').Length == 2) { string tempComputerName = tempString.Split('\\')[0]; string tempInstanceName = tempString.Split('\\')[1]; if (Regex.IsMatch(tempComputerName, @"[:,]\d{1,5}$") && !Regex.IsMatch(tempComputerName, RegexHelper.IPv6)) { char delimiter; if (Regex.IsMatch(tempComputerName, @"[:]\d{1,5}$")) { delimiter = ':'; } else { delimiter = ','; } try { Int32.TryParse(tempComputerName.Split(delimiter)[1], out _Port); if (_Port > 65535) { throw new PSArgumentException("Failed to parse instance name: " + Name); } tempComputerName = tempComputerName.Split(delimiter)[0]; } catch { throw new PSArgumentException("Failed to parse instance name: " + Name); } } else if (Regex.IsMatch(tempInstanceName, @"[:,]\d{1,5}$") && !Regex.IsMatch(tempInstanceName, RegexHelper.IPv6)) { char delimiter; if (Regex.IsMatch(tempString, @"[:]\d{1,5}$")) { delimiter = ':'; } else { delimiter = ','; } try { Int32.TryParse(tempInstanceName.Split(delimiter)[1], out _Port); if (_Port > 65535) { throw new PSArgumentException("Failed to parse instance name: " + Name); } tempInstanceName = tempInstanceName.Split(delimiter)[0]; } catch { throw new PSArgumentException("Failed to parse instance name: " + Name); } } // LocalDBs mostly ignore regular Instance Name rules, so that validation is only relevant for regular connections if (UtilityHost.IsLike(tempComputerName, "(localdb)") || (Utility.Validation.IsValidComputerTarget(tempComputerName) && Utility.Validation.IsValidInstanceName(tempInstanceName, true))) { if (UtilityHost.IsLike(tempComputerName, "(localdb)")) { _ComputerName = "(localdb)"; } else { _ComputerName = tempComputerName; } if ((tempInstanceName.ToLower() != "default") && (tempInstanceName.ToLower() != "mssqlserver")) { _InstanceName = tempInstanceName; } } else { throw new PSArgumentException(string.Format("Failed to parse instance name: {0}. Computer Name: {1}, Instance {2}", Name, tempComputerName, tempInstanceName)); } } // Case: Bad input else { throw new PSArgumentException("Failed to parse instance name: " + Name); } }
/// <summary> /// Removes all value entries whose corresponding Runspace has been destroyed /// </summary> public void PurgeExpired() { // Store IDs first, so parallel access is not an issue and a new value gets accidentally discarded Guid[] IDs = Values.Keys.ToArray(); ICollection <System.Management.Automation.Runspaces.Runspace> runspaces = UtilityHost.GetRunspaces(); ICollection <Guid> runspaceIDs = (ICollection <Guid>)runspaces.Select(o => o.InstanceId); foreach (Guid ID in IDs) { if (!runspaceIDs.Contains(ID)) { Values.Remove(ID); } } }
/// <summary> /// Tests whether a log entry applies to the provider instance /// </summary> /// <param name="Entry">The Entry to validate</param> /// <returns>Whether it applies</returns> public bool MessageApplies(Message.LogEntry Entry) { // Level if (!IncludeWarning && (Entry.Level == Message.MessageLevel.Warning)) { return(false); } if (((_MinLevel != 1) || (_MaxLevel != 9)) && (Entry.Level != Message.MessageLevel.Warning)) { if (Entry.Level < (Message.MessageLevel)_MinLevel) { return(false); } if (Entry.Level > (Message.MessageLevel)_MaxLevel) { return(false); } } // Modules if (IncludeModules.Count > 0) { bool test = false; foreach (string module in IncludeModules) { if (string.Equals(Entry.ModuleName, module, StringComparison.InvariantCultureIgnoreCase)) { test = true; } } if (!test) { return(false); } } foreach (string module in ExcludeModules) { if (string.Equals(Entry.ModuleName, module, StringComparison.InvariantCultureIgnoreCase)) { return(false); } } // Functions if (IncludeFunctions.Count > 0) { bool test = false; foreach (string function in IncludeFunctions) { if (UtilityHost.IsLike(Entry.FunctionName, function)) { test = true; } } if (!test) { return(false); } } foreach (string function in ExcludeFunctions) { if (UtilityHost.IsLike(Entry.FunctionName, function)) { return(false); } } // Tags if (IncludeTags.Count > 0) { if (IncludeTags.Except(Entry.Tags, StringComparer.InvariantCultureIgnoreCase).ToList().Count == IncludeTags.Count) { return(false); } } if (ExcludeTags.Except(Entry.Tags, StringComparer.InvariantCultureIgnoreCase).ToList().Count < ExcludeTags.Count) { return(false); } return(true); }
/// <summary> /// Returns the correct results, either by executing the scriptblock or consulting the cache /// </summary> /// <returns></returns> public string[] Invoke() { if (!ShouldExecute) { return(LastResult); } List <string> results = new List <string>(); CallStackFrame callerFrame = null; InvocationInfo info = null; try { object CurrentCommandProcessor = UtilityHost.GetPrivateProperty("CurrentCommandProcessor", UtilityHost.GetExecutionContextFromTLS()); object CommandObject = UtilityHost.GetPrivateProperty("Command", CurrentCommandProcessor); info = UtilityHost.GetPublicProperty("MyInvocation", CommandObject) as InvocationInfo; } catch (Exception e) { if (PSFCore.PSFCoreHost.DebugMode) { PSFCore.PSFCoreHost.WriteDebug(String.Format("Script Container {0} | Error accessing Current Command Processor", Name), e); } } if (info == null) { IEnumerable <CallStackFrame> _callStack = Utility.UtilityHost.Callstack; object errorItem = null; try { if (_callStack.Count() > 0) { callerFrame = _callStack.Where(frame => frame.InvocationInfo != null && frame.InvocationInfo.MyCommand != null).First(); } } catch (Exception e) { errorItem = e; } if (PSFCore.PSFCoreHost.DebugMode) { PSFCore.PSFCoreHost.WriteDebug(String.Format("Script Container {0} | Callframe selected", Name), callerFrame); PSFCore.PSFCoreHost.WriteDebug(String.Format("Script Container {0} | Script Callstack", Name), new Message.CallStack(Utility.UtilityHost.Callstack)); if (errorItem != null) { PSFCore.PSFCoreHost.WriteDebug(String.Format("Script Container {0} | Error when selecting Callframe", Name), errorItem); } } } if (info == null && callerFrame != null) { info = callerFrame.InvocationInfo; } // ScriptBlock scriptBlock = ScriptBlock.Create(ScriptBlock.ToString()); if (info != null) { foreach (PSObject item in ScriptBlock.Invoke(info.MyCommand.Name, "", "", null, info.BoundParameters)) { results.Add((string)item.Properties["CompletionText"].Value); } } else { foreach (PSObject item in ScriptBlock.Invoke("<ScriptBlock>", "", "", null, new Dictionary <string, object>(StringComparer.InvariantCultureIgnoreCase))) { results.Add((string)item.Properties["CompletionText"].Value); } } return(results.ToArray()); }
/// <summary> /// Generates a Computer Parameter object from string /// </summary> /// <param name="ComputerName">The name to use as input</param> public ComputerParameter(string ComputerName) { InputObject = ComputerName; if (string.IsNullOrWhiteSpace(ComputerName)) { throw new ArgumentException("Computername cannot be empty!"); } string tempString = ComputerName.Trim(); if (ComputerName == ".") { this.ComputerName = "localhost"; return; } if (UtilityHost.IsLike(tempString, "*.WORKGROUP")) { tempString = Regex.Replace(tempString, @"\.WORKGROUP$", "", RegexOptions.IgnoreCase); } if (UtilityHost.IsValidComputerTarget(tempString)) { this.ComputerName = tempString; return; } // Named Pipe path notation interpretation if (Regex.IsMatch(tempString, @"^\\\\[^\\]+\\pipe\\([^\\]+\\){0,1}sql\\query$", RegexOptions.IgnoreCase)) { try { this.ComputerName = Regex.Match(tempString, @"^\\\\([^\\]+)\\").Groups[1].Value; return; } catch (Exception e) { throw new ArgumentException(String.Format("Failed to interpret named pipe path notation: {0} | {1}", InputObject, e.Message), e); } } // Connection String interpretation try { System.Data.SqlClient.SqlConnectionStringBuilder connectionString = new System.Data.SqlClient.SqlConnectionStringBuilder(tempString); ComputerParameter tempParam = new ComputerParameter(connectionString.DataSource); this.ComputerName = tempParam.ComputerName; return; } catch (ArgumentException ex) { string name = "unknown"; try { name = ex.TargetSite.GetParameters()[0].Name; } catch { } if (name == "keyword") { throw; } } catch (FormatException) { throw; } catch { } throw new ArgumentException(String.Format("Could not resolve computer name: {0}", ComputerName)); }