public void Should_be_possible_to_build_a_WMI_Query_Language()
{
string wql = new WQLBuilder()
.WithWmiClass("cim_logicalfile")
.AddParameter("drive", "c:")
.AddParameter("path", "\\temp\\")
.Build().ToLower().Trim();
List <String> wqlLines = this.GetSplittedWQL(wql);
Assert.AreEqual(3, wqlLines.Count);
Assert.AreEqual("select * from cim_logicalfile", wqlLines[0].ToLower().Trim());
Assert.AreEqual("where drive = 'c:'", wqlLines[1].ToLower().Trim());
Assert.AreEqual("and path = '\\temp\\'", wqlLines[2].ToLower().Trim());
}
private IEnumerable <WindowsAccount> GetAllLocalGroups()
{
var wqlToGetAllLocalGroups =
new WQLBuilder()
.WithWmiClass("Win32_Group")
.AddParameter("localaccount", "1")
.Build();
var wqlResult = this.WmiProvider.ExecuteWQL(wqlToGetAllLocalGroups);
return
(wqlResult
.Select(g =>
new WindowsAccount(
g.GetFieldValueAsString("Name"),
(bool?)g.GetValueOf("Disabled"),
g.GetFieldValueAsString("SID"),
AccountType.Group)
).ToList());
}
private IEnumerable <WindowsAccount> GetAllBuiltinAccounts()
{
var wqlAllGetBuiltinAccounts = new WQLBuilder().WithWmiClass("Win32_SystemAccount").Build();
var wqlResult = this.WmiProvider.ExecuteWQL(wqlAllGetBuiltinAccounts);
if (wqlResult != null && wqlResult.Count() > 0)
{
return
(wqlResult.Select(
wql =>
new WindowsAccount(
wql.GetFieldValueAsString("Name"),
(bool?)true,
wql.GetFieldValueAsString("SID"),
AccountType.User)));
}
return(new WindowsAccount[] { });
}
public void Should_be_possible_to_build_a_WMI_Query_Language_adding_all_parameters_at_once()
{
Dictionary <string, string> allParameters = new Dictionary <string, string>();
allParameters.Add("drive", "d:");
allParameters.Add("path", "\\fakedirectory\\");
allParameters.Add("filename", "fakefile");
allParameters.Add("extension", "fex");
string wql = new WQLBuilder().WithWmiClass("cim_logicalfile").AddParameters(allParameters).Build();
List <String> wqlLines = this.GetSplittedWQL(wql);
Assert.AreEqual(5, wqlLines.Count);
Assert.AreEqual("select * from cim_logicalfile", wqlLines[0].ToLower().Trim());
Assert.AreEqual("where drive = 'd:'", wqlLines[1].ToLower().Trim());
Assert.AreEqual("and path = '\\fakedirectory\\'", wqlLines[2].ToLower().Trim());
Assert.AreEqual("and filename = 'fakefile'", wqlLines[3].ToLower().Trim());
Assert.AreEqual("and extension = 'fex'", wqlLines[4].ToLower().Trim());
}
private WmiDataProvider GetWmiProviderMockWithNoWmiResultBehavior()
{
// This mocked WmiDataProvider must be used in order to test GetAllGroupsByUser method.
var mocks = new MockRepository();
var fakeWmiProvider = mocks.StrictMock <WmiDataProvider>();
// Create expectation for first calling (to get computer name).
var wqlToGetComputerName = new WQLBuilder().WithWmiClass("Win32_ComputerSystem").Build();
var fakeWin32ComputerSystemRecord = new WmiObject();
fakeWin32ComputerSystemRecord.Add("Name", FAKE_COMPUTER_NAME);
fakeWin32ComputerSystemRecord.Add("DomainRole", 1);
Expect.Call(fakeWmiProvider.ExecuteWQL(wqlToGetComputerName)).Return(new[] { fakeWin32ComputerSystemRecord });
// Create expectation for second calling (to get all local groups);
var wqlToGetAllLocalGroups = new WQLBuilder().WithWmiClass("Win32_Group").AddParameter("localaccount", "1").Build();
var fakeWin32GroupRecords = new List <WmiObject>();
fakeWin32GroupRecords.Add(NewWmiObjectForFakeLocalGroup("Administrators", "S-1-5-32-544"));
fakeWin32GroupRecords.Add(NewWmiObjectForFakeLocalGroup("Backup Operators", "S-1-5-32-551"));
fakeWin32GroupRecords.Add(NewWmiObjectForFakeLocalGroup("Users", "S-1-5-32-545"));
Expect.Call(fakeWmiProvider.ExecuteWQL(wqlToGetAllLocalGroups)).Return(fakeWin32GroupRecords);
// Create expectation for each get group component calling...
CreateExpectationForGetGroupComponent(fakeWmiProvider, "Administrators");
CreateExpectationForGetGroupComponent(fakeWmiProvider, "Backup Operators");
CreateExpectationForGetGroupComponent(fakeWmiProvider, "Users");
// Create expectation for each get user details calling (3 first times) and get user SID (3 last times)
Expect.Call(fakeWmiProvider.ExecuteWQL(null)).IgnoreArguments().Repeat.Times(6).Return(null);
var wqlAllGetBuiltinAccounts = new WQLBuilder().WithWmiClass("Win32_SystemAccount").Build();
Expect.Call(fakeWmiProvider.ExecuteWQL(wqlAllGetBuiltinAccounts)).Return(null);
mocks.ReplayAll();
return(fakeWmiProvider);
}
public bool FileExists(string localFilepath)
{
/* IMPORTANT
* BEFORE CHANGING OR REFACTORING THIS METHOD, YOU MUST READ THIS NOTICE.
*
* The code below sounds confusing, but there is a reason to be like that.
* The first issue is that the System.IO.File.Exists and Directory.Exists behavior (see Remarks Session in http://msdn.microsoft.com/en-us/library/system.io.file.exists.aspx).
* If an error such as "Acess Denied" or "Invalid Path" occurs during those methods calling,
* .NET API will return FALSE instead of throwing an exception. Thus, when the return is false,
* maybe the file or directory exists, but some error occurred.
* The best way to find out if a file or directory exists is trying to open them. The methods
* that open a file (or directory) will throw an exception if it does not exist.
*
* Now, we have a second issue:
* To do the above, it is necessary that the administrative share on the remote machine is enabled.
* It´s very common that is not enabled.
* The solution to this issue is to make another attempt in order to check file (or directory) existence.
* You can make that through a WMI query.
*
* So, we have three ways to check File Existence. Why not use only WMI ?
* Because, we have a third issue: performance.
* In some scenarios, this WMI Query can be really slow.
* OK, but why the code below still using File.Exists and Directory.Exists methods?
* When those methods return TRUE, we can safely say that file (or directory) really exists.
* Besides, those methods are very fast. Hence, we can stop the method if one of those methods return TRUE.
*/
try
{
var windowsConnectionProvider = new StraightNetworkConnectionProvider();
var adminShareFilePath = GetAdministrativeSharePathFromLocalFilepath(TargetInfo.GetAddress(), localFilepath);
try
{
// To use Administrative Share resource, we need open a straight connection to remote machine.
windowsConnectionProvider.Connect(TargetInfo);
try
{
// If one of these methods return TRUE, we can return this result.
if (System.IO.File.Exists(adminShareFilePath) || System.IO.Directory.Exists(adminShareFilePath))
{
return(true);
}
// If both methods above return FALSE, we CAN NOT rely on in this.
try
{
// So, we will try to open the file...
System.IO.File.Open(adminShareFilePath, FileMode.Open);
// If we could open it, the file exists.
return(true);
}
catch (FileNotFoundException)
{
// obviously we can return FALSE if File.Open thrown FileNotFoundException.
return(false);
}
}
catch (Exception)
{
try
{
// If any else Exception was thrown, maybe the passed path is a directory...
// So, we will try to open it.
System.IO.Directory.EnumerateFiles(adminShareFilePath, "*");
return(true);
}
catch (FileNotFoundException)
{
return(false);
}
}
}
finally
{
windowsConnectionProvider.Disconnect();
}
}
catch (Exception)
{
// At last, if it was not possible to check file (or directory) existence due to any error,
// we will try to find this information out through WMI.
var wmiParametersForFileSearching = this.CreateWmiParameters(localFilepath);
var wqlForFileSearching = new WQLBuilder().WithWmiClass("CIM_LogicalFile").AddParameters(wmiParametersForFileSearching).Build();
var wmiQueryResult = this.WmiDataProvider.ExecuteWQL(wqlForFileSearching);
return((wmiQueryResult != null) && (wmiQueryResult.Count() > 0));
}
}
