/// <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>
/// 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>
/// 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);
}
/// <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);
}
/// <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>
/// 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));
}
/// <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>
/// 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);
}