public void Configure(IApplicationBuilder app, IReplicationService service, ReplicatorTestCase.MockErrorConfig mockErrorConfig)
{
// Middleware to throw an exception conditionally from our test server.
app.Use(async(context, next) =>
{
if (mockErrorConfig.RespondWithError)
{
throw new ReplicatorTestCase.HttpResponseException();
}
await next();
});
app.Run(async(context) =>
{
// LUCENENET: This is to allow synchronous IO to happen for these requests.
// LUCENENET TODO: Allow async operations from Replicator.
var syncIoFeature = context.Features.Get <IHttpBodyControlFeature>();
if (syncIoFeature != null)
{
syncIoFeature.AllowSynchronousIO = true;
}
await Task.Yield();
service.Perform(context.Request, context.Response);
});
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IReplicationService service)
{
app.Run(async context =>
{
await Task.Yield();
service.Perform(context.Request, context.Response);
});
}
// Token: 0x060001D3 RID: 467 RVA: 0x0000BCD4 File Offset: 0x00009ED4
public override void Confirm(IReplicationService service)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
service.Confirm(this);
}
public void Initialize(string ipAddress, string port, string endpoint)
{
var factory = new DuplexChannelFactory <IReplicationService>(this,
new NetTcpBinding()
{
OpenTimeout = TimeSpan.MaxValue
},
new EndpointAddress($"net.tcp://{ipAddress}:{port}/ReplicationService/{endpoint}"));
proxy = factory.CreateChannel();
}
public static TestServer NewHttpServer <TStartUp>(IReplicationService service) where TStartUp : class
{
var server = new TestServer(new WebHostBuilder()
.ConfigureServices(container =>
{
container.AddSingleton(service);
}).UseStartup <TStartUp>());
server.BaseAddress = new Uri("http://localhost" + ReplicationService.REPLICATION_CONTEXT);
return(server);
}
public bool Initialize(string address, string port, string endpoint, IReplicationService replicationService)
{
try
{
host = new ServiceHost(replicationService, new Uri($"net.tcp://{address}:{port}"));
host.AddServiceEndpoint(typeof(IReplicationService), new NetTcpBinding(), $"ReplicationService/{endpoint}");
info = $"net.tcp://{address}:{port}/ReplicationService/{endpoint}";
return(true);
}
catch (Exception e)
{
Console.WriteLine($"Error while initializing replication service host: {e.Message}");
return(false);
}
}
/// <summary>
/// Call this overload to use <see cref="ReplicationServiceMiddleware"/> to host <see cref="ReplicationService"/>.
/// </summary>
/// <param name="service">The <see cref="ReplicationService"/> that will be registered as singleton.</param>
/// <param name="mockErrorConfig">The <see cref="MockErrorConfig"/> that will be registered as singleton.</param>
/// <returns>A configured <see cref="TestServer"/> instance.</returns>
public static TestServer NewHttpServer(IReplicationService service, MockErrorConfig mockErrorConfig)
{
var builder = new WebHostBuilder()
.ConfigureServices(container =>
{
container.AddRouting();
container.AddSingleton(service);
container.AddSingleton(mockErrorConfig);
container.AddSingleton <ReplicationServiceMiddleware>();
container.AddSingleton <MockErrorMiddleware>();
})
.Configure(app =>
{
app.UseRouting();
// Middleware so we can mock a server exception and toggle the exception on and off.
app.UseMiddleware <MockErrorMiddleware>();
app.UseEndpoints(endpoints =>
{
// This is to define the endpoint for Replicator.
// All URLs with the pattern /replicate/{shard?}/{action?} terminate here and any middleware that
// is expected to run for Replicator must be registered before this call.
endpoints.MapReplicator(ReplicationService.REPLICATION_CONTEXT + "/{shard?}/{action?}");
endpoints.MapGet("/{controller?}/{action?}/{id?}", async context =>
{
// This is just to demonstrate allowing requests to other services/controllers in the same
// application. This isn't required, but is allowed.
await context.Response.WriteAsync("Hello World!");
});
});
});
var server = new TestServer(builder);
return(server);
}
/// <summary>
/// Клиент для репликации объектов
/// </summary>
public ReplicationClient()
{
var settings = ReplicationSettingsReader.ReadSettings();
String serviceAddress = String.IsNullOrEmpty(settings.ServiceAddress)? DefaultserviceAddress: settings.ServiceAddress;
var pipeChannelFactory = new DuplexChannelFactory <IReplicationService>(new InstanceContext(this),
new NetNamedPipeBinding(), new EndpointAddress(serviceAddress));
_channel = pipeChannelFactory.CreateChannel();
_replicationObjects = new List <IReplicationObject>();
PropertyChangedHandler += async(sender, args) =>
{
var replicationInfo = GetReplicationInfo(sender, UidKey, args.PropertyName);
try
{
await Task.Factory.StartNew(() => _channel.SetObject(replicationInfo, OperationType.Update));
}
catch (Exception)
{
}
};
}
static int Main(string[] args)
{
try
{
Console.WriteLine("User profile path detected: " + Environment.GetEnvironmentVariable(Environment.SpecialFolder.UserProfile.ToString()));
Console.WriteLine("Checking for existence of WMI namespace and class");
try
{
createOrUpdateWmi();
}
catch (Exception e)
{
if (e.Message.StartsWith("Access denied"))
{
Console.WriteLine("Access to WMI denied, you must run this application as administrator");
return(1);
}
else
{
throw e;
}
}
string hashedPassword = null;
if (args.Length > 0 && args[0] != null)
{
foreach (string arg in args)
{
if (arg.ToLower().StartsWith("password="******"Using ImageManager password supplied from command line (" + unhashedPassword.Length + " characters)");
PasswordHash hash = new PasswordHash();
hashedPassword = hash.ComputeAsBase64(unhashedPassword);
}
}
}
if (hashedPassword == null)
{
Console.WriteLine("Looking for ImageManager hashed password from settings file");
DirectoryInfo testFolder = new DirectoryInfo("C:\\windows\\SysWOW64\\config\\systemprofile\\AppData\\local\\StorageCraft_Technology_C");
if (!testFolder.Exists)
{
testFolder = new DirectoryInfo("C:\\windows\\SysWOW64\\config\\systemprofile\\AppData\\local\\StorageCraft_Technology_C");
if (!testFolder.Exists)
{
Console.WriteLine("Unable to locate StorageCraft_Technology_C under the local system profile path. Check that the ImageManager service is running under the Local System account and that a password has been set.");
return(1);
}
}
Console.WriteLine("Found StorageCraft data folder at " + testFolder.FullName);
DirectoryInfo[] directories = testFolder.GetDirectories();
if (directories.Length == 0)
{
Console.WriteLine("Error: No subdirectory found under " + testFolder.Name);
return(1);
}
Console.WriteLine("Navigating down first subdirectory of " + testFolder.Name);
DirectoryInfo imageManagerDataFolder = new DirectoryInfo(directories[0].FullName);
directories = imageManagerDataFolder.GetDirectories();
if (directories.Length == 0)
{
Console.WriteLine("Error: No subdirectory found under " + testFolder.Name);
return(1);
}
Console.WriteLine("Navigating down newest subdirectory of " + imageManagerDataFolder.Name);
IEnumerator <DirectoryInfo> orderedDirectories = directories.OrderByDescending(d => d.Name).GetEnumerator();
orderedDirectories.MoveNext();
string userConfigFile = orderedDirectories.Current.FullName + "\\user.config";
Console.WriteLine("Attempting to read hashed password from '" + userConfigFile + "'");
XPathDocument reader = new XPathDocument(userConfigFile);
XPathNavigator navigator = reader.CreateNavigator();
XPathNodeIterator iterator = navigator.Select("/configuration/userSettings/StorageCraft.ImageManager.Properties.Settings/setting[@name='password']/value");
iterator.MoveNext();
hashedPassword = iterator.Current.Value;
Console.WriteLine("Password obtained from file");
}
Console.WriteLine("Connecting to ImageManager service");
// using the IAgent interface instead of IAgent3 for compatibility with older versions.
// None of the data we query for monitoring relies on the IAgent3 interface.
IAgent agent = (IAgent)Client.Connect("localhost", 56765, hashedPassword);
if (agent == null)
{
Console.WriteLine("Incorrect password provided for local ImageManager service");
return(1);
}
agent.Ping();
Console.WriteLine("Retrieving list of Managed Folders");
List <ManagedFolder> allFolders = agent.ManagedFolders;
string allFoldersText = "";
// we put all managed folders in each folder instance, because the StorageCraft ImageManager Job List service just grabs the first one
foreach (ManagedFolder folder in allFolders)
{
allFoldersText = allFoldersText + eqLine + folder.Path;
}
foreach (ManagedFolder folder in allFolders)
{
Console.WriteLine("--------------------------------------------");
Console.WriteLine("Found folder: '" + folder.Path);
Console.WriteLine(" State: " + folder.State);
int stateValue;
switch (folder.State)
{
case FolderState.Active: stateValue = 0; break;
case FolderState.Syncing: stateValue = 1; break;
case FolderState.Offline: stateValue = 2; break;
case FolderState.Failure: stateValue = 3; break;
default: throw new Exception("Unhandled job state value " + folder.State.ToString());
}
Console.WriteLine(" State Value: " + stateValue);
Console.WriteLine(" Machine Name: " + folder.ImagedComputer);
Console.WriteLine(" File Count: " + folder.ImageFileCount);
IFolderServiceLocator locator = agent.Services;
Console.WriteLine("Querying verification data");
IVerificationService verificationService = locator.Find <IVerificationService>(folder.Id);
String lastSuccessfulVerification = (DateTime.MinValue.Equals(verificationService.LastSuccessTime) ? "Never" : verificationService.LastSuccessTime.ToString());
Console.WriteLine("Verification Policy:");
Console.WriteLine(" VerifyNewImages:" + verificationService.Policy.VerifyNewImages);
Console.WriteLine(" ReverifyExistingImages:" + verificationService.Policy.ReverifyExistingImages);
Console.WriteLine(" ReverifyInterval: " + verificationService.Policy.ReverifyInterval);
Console.WriteLine("Last successful verification: " + lastSuccessfulVerification);
Console.WriteLine("Number of failures detected: " + verificationService.Failures.Count);
List <VerificationFailure> sortedVerificationFailures = verificationService.Failures.OrderByDescending(o => o.FailureTime).ToList();
string verificationFailureDetails = (verificationService.Failures.Count > 0 ? "" : "N/A");
foreach (VerificationFailure failure in sortedVerificationFailures)
{
Console.WriteLine("Verification failure detected - " + failure.FailureTime.ToString() + ": " + failure.Reason);
verificationFailureDetails += dashline + " " + failure.FailureTime.ToString() + ": " + failure.Reason + " ";
}
Console.WriteLine("Querying consolidation data");
IConsolidationService consolidationService = locator.Find <IConsolidationService>(folder.Id);
Console.WriteLine("Consolidation Policy:");
Console.WriteLine(" ConsolidationEnabled:" + consolidationService.Policy.IsEnabled);
Console.WriteLine(" MonthlyConsolidationDay:" + consolidationService.Policy.MonthlyConsolidationDay);
Console.WriteLine(" MonthlyConsolidationDayOfWeek:" + consolidationService.Policy.MonthlyConsolidationDayOfWeek);
Console.WriteLine(" MonthlyConsolidationWeek:" + consolidationService.Policy.MonthlyConsolidationWeek);
Console.WriteLine(" WeeklyConsolidationDay:" + consolidationService.Policy.WeeklyConsolidationDay);
String lastSuccessfulConsolidation = (DateTime.MinValue.Equals(consolidationService.LastSuccessTime) ? "Never" : consolidationService.LastSuccessTime.ToString());
Console.WriteLine("Last successful consolidation: " + lastSuccessfulConsolidation + ", number of failures detected: " + consolidationService.Failures.Count);
Console.WriteLine("last consolidation success message: " + consolidationService.LastSuccessMessage);
List <ConsolidationFailure> sortedConsolidationFailures = consolidationService.Failures.OrderByDescending(o => o.FailureTime).ToList();
string consolidationFailureDetails = (consolidationService.Failures.Count > 0 ? eqLine : "N/A");
foreach (ConsolidationFailure failure in consolidationService.Failures)
{
Console.WriteLine("Consolidation failure detected - " + failure.FailureTime.ToString() + ": " + failure.Reason);
consolidationFailureDetails += " " + failure.FailureTime.ToString() + ": " + failure.Reason + " " + dashline;
}
Console.WriteLine("Querying replication data");
// using the IReplicationService interface instead of IReplicationService2 for compatibility with older versions.
// None of the data we query for monitoring relies on the IReplicationService2 interface.
IReplicationService replicationService = locator.Find <IReplicationService>(folder.Id);
int failedReplications = 0;
int queuedFiles = 0;
string replicationTargetsText = (replicationService.Targets.Count > 0 ? "" : "N/A");
foreach (ReplicationTarget target in replicationService.Targets)
{
Console.WriteLine("Replication Target Found: " + target.FullPath);
Console.WriteLine(" Type: " + target.Destination.Type.ToString() + ", Successful: " + target.IsSuccessful + ", Status: " + target.Status.Text + ", Queued Files: " + target.Status.QueuedFiles);
if (!target.IsSuccessful)
{
failedReplications++;
}
queuedFiles += (int)target.Status.QueuedFiles;
replicationTargetsText += eqLine + "Path: " + target.FullPath + eqLine +
"Type: " + target.Destination.Type.ToString() + dashline +
"Queued Files Count: " + target.Status.QueuedFiles + dashline +
"Status: " + target.Status.Text + dashline +
"Successful: " + target.IsSuccessful + dashline;
}
Console.WriteLine("Failed replication targets: " + failedReplications);
Console.WriteLine("Querying retention data");
IRetentionService retentionService = locator.Find <IRetentionService>(folder.Id);
Console.WriteLine("Number of retention issues: " + retentionService.Issues.Count);
Console.WriteLine("Retention Policy:");
bool retentionPolicyInheritedFromGlobal = retentionService.Policy == null;
RetentionPolicy retentionPolicy = null;
if (retentionPolicyInheritedFromGlobal)
{
try
{
retentionPolicy = agent.AgentSettings.AgentRetentionPolicy;
}
catch (TypeLoadException e)
{
// type won't exist in the dll prior to 6.0
}
}
else
{
retentionPolicy = retentionService.Policy;
}
Console.WriteLine(" InheritedFromGlobal:" + retentionPolicyInheritedFromGlobal);
Console.WriteLine(" RetentionEnabled:" + retentionPolicy.IsEnabled);
Console.WriteLine(" DaysToRetainIntraDailyImages:" + retentionPolicy.DaysToRetainIntraDailyImages);
Console.WriteLine(" DaysToRetainConsolidatedDailyImages:" + retentionPolicy.DaysToRetainConsolidatedDailyImages);
Console.WriteLine(" DaysToRetainConsolidatedWeeklyImages:" + retentionPolicy.DaysToRetainConsolidatedWeeklyImages);
try
{
retentionPolicy.MonthsToRetainConsolidatedMonthlyImages = -1;
Console.WriteLine(" MonthsToRetainConsolidatedMonthlyImages:" + retentionPolicy.MonthsToRetainConsolidatedMonthlyImages);
Console.WriteLine(" MonthlyRetentionIsSupported:" + retentionPolicy.MonthlyRetentionIsSupported);
}
catch (TypeLoadException e)
{
// type won't exist in the dll prior to 6.0
}
Console.WriteLine(" MoveConsolidatedImages:" + retentionPolicy.MoveConsolidatedImages);
string retentionIssuesText = (retentionService.Issues.Count > 0 ? "" : "N/A");
foreach (RetentionIssue issue in retentionService.Issues)
{
Console.WriteLine(issue.IssueTime + " Reason: " + issue.Reason);
retentionIssuesText += dashline + " " + issue.IssueTime.ToString() + ": " + issue.Reason + " ";
}
Console.WriteLine("Querying Headstart Restore data");
// using the IHeadStartService interface instead of IHeadStartService2 for compatibility with older versions.
// None of the data we query for monitoring relies on the IHeadStartService2 interface.
IHeadStartService headStartService = locator.Find <IHeadStartService>(folder.Id);
int failedHeadstartJobs = 0;
string headstartJobsText = (headStartService.FindAllJobs().Count > 0 ? "" : "N/A");
foreach (HeadStartJob job in headStartService.FindAllJobs())
{
Console.WriteLine("Headstart Restore Job Found: " + job.Name + ", Destination: '" + job.Destination.Path + "', State: " + job.State.ToString());
if (job.State.Equals(HeadStartState.Failure))
{
failedHeadstartJobs++;
}
headstartJobsText += eqLine + "Job Name: " + job.Name + eqLine +
"Destination Path: " + job.Destination.Path + dashline +
"State: " + job.State.ToString() + dashline;
foreach (HeadStartTarget target in job.Targets)
{
headstartJobsText += "Target " + target.Id + tildaline +
"Status: " + target.Status.Text + tildaline +
"LastAppliedSnapshotTime: " + target.Status.LastAppliedSnapshotTime + tildaline +
"UnappliedSnapshotDays: " + target.UnappliedSnapshotDays.Count + dashline;
}
}
Console.WriteLine("Failed headstart restore jobs: " + failedHeadstartJobs);
PutOptions options = new PutOptions();
options.Type = PutType.UpdateOrCreate;
ManagementClass objHostSettingClass = new ManagementClass(wmiNamespaceString, wmiClassString, null);
ManagementObject wmiObject = objHostSettingClass.CreateInstance();
wmiObject.SetPropertyValue("ManagedFolder", folder.Path);
wmiObject.SetPropertyValue("MachineName", folder.ImagedComputer);
wmiObject.SetPropertyValue("OverallState", folder.State);
wmiObject.SetPropertyValue("OverallStateValue", stateValue);
wmiObject.SetPropertyValue("FileCount", folder.ImageFileCount);
wmiObject.SetPropertyValue("NumberOfFilesFailingVerification", verificationService.Failures.Count);
wmiObject.SetPropertyValue("VerificationFailureDetails", verificationFailureDetails);
wmiObject.SetPropertyValue("LastSuccessfulVerification", lastSuccessfulVerification);
wmiObject.SetPropertyValue("VerifyNewImages", verificationService.Policy.VerifyNewImages);
wmiObject.SetPropertyValue("ReverifyExistingImages", verificationService.Policy.ReverifyExistingImages);
wmiObject.SetPropertyValue("ReverifyInterval", verificationService.Policy.ReverifyInterval);
wmiObject.SetPropertyValue("ConsolidationEnabled", consolidationService.Policy.IsEnabled);
wmiObject.SetPropertyValue("LastSuccessfulConsolidation", lastSuccessfulConsolidation);
wmiObject.SetPropertyValue("NumberOfFilesFailingConsolidation", consolidationService.Failures.Count);
wmiObject.SetPropertyValue("ConsolidationFailureDetails", consolidationFailureDetails);
wmiObject.SetPropertyValue("ReplicationTargetDetails", replicationTargetsText);
wmiObject.SetPropertyValue("FailedReplications", failedReplications);
wmiObject.SetPropertyValue("NumberOfFilesQueuedForReplication", queuedFiles);
wmiObject.SetPropertyValue("RetentionIssues", retentionService.Issues.Count);
wmiObject.SetPropertyValue("RetentionIssueDetails", retentionIssuesText);
wmiObject.SetPropertyValue("RetentionEnabled", retentionPolicy.IsEnabled);
wmiObject.SetPropertyValue("RetentionPolicyInheritedFromGlobal", retentionPolicyInheritedFromGlobal);
wmiObject.SetPropertyValue("DaysToRetainIntraDailyImages", retentionPolicy.DaysToRetainIntraDailyImages);
wmiObject.SetPropertyValue("DaysToRetainConsolidatedDailyImages", retentionPolicy.DaysToRetainConsolidatedDailyImages);
wmiObject.SetPropertyValue("DaysToRetainConsolidatedWeeklyImages", retentionPolicy.DaysToRetainConsolidatedWeeklyImages);
wmiObject.SetPropertyValue("MonthsToRetainConsolidatedMonthlyImages", retentionPolicy.MonthsToRetainConsolidatedMonthlyImages);
wmiObject.SetPropertyValue("MonthlyRetentionIsSupported", retentionPolicy.MonthlyRetentionIsSupported);
wmiObject.SetPropertyValue("MoveConsolidatedImages", retentionPolicy.MoveConsolidatedImages);
wmiObject.SetPropertyValue("FailedHeadstartJobs", failedHeadstartJobs);
wmiObject.SetPropertyValue("HeadstartJobDetails", headstartJobsText);
wmiObject.SetPropertyValue("LastScriptRunTime", DateTime.Now.ToString());
SelectQuery selectQuery = new SelectQuery("select * from win32_utctime");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(selectQuery);
ManagementObjectCollection utcTimeFromWmi = searcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator enumerator = utcTimeFromWmi.GetEnumerator();
enumerator.MoveNext();
ManagementBaseObject mbo = enumerator.Current;
UInt32 year = (UInt32)mbo.GetPropertyValue("Year");
UInt32 month = (UInt32)mbo.GetPropertyValue("Month");
UInt32 day = (UInt32)mbo.GetPropertyValue("Day");
UInt32 hour = (UInt32)mbo.GetPropertyValue("Hour");
UInt32 min = (UInt32)mbo.GetPropertyValue("Minute");
UInt32 second = (UInt32)mbo.GetPropertyValue("Second");
long timestamp = ((((((year - 1970) * 31556926) + ((month - 1) * 2678400)) + ((day - 1) * 86400)) + (hour * 3600)) + (min * 60)) + (second);
wmiObject.SetPropertyValue("Timestamp", timestamp);
wmiObject.SetPropertyValue("ListOfAllManagedFolders", allFoldersText);
wmiObject.Put(options);
}
Console.WriteLine("--------------------------------------------");
Console.WriteLine("Poll complete");
return(0);
}
catch (Exception e)
{
Console.WriteLine("Fatal error: " + e.Message);
return(1);
}
}
public ReplicationServiceMiddleware(RequestDelegate next, IReplicationService service)
{
this.next = next ?? throw new ArgumentNullException(nameof(next));
this.service = service ?? throw new ArgumentNullException(nameof(service));
}
// Token: 0x060001C0 RID: 448 public abstract void Confirm(IReplicationService service);
/// <summary>
/// Extension method that mirrors the signature of <see cref="IReplicationService.Perform"/> using AspNetCore as implementation.
/// </summary>
public static void Perform(this IReplicationService self, HttpRequest request, HttpResponse response)
{
self.Perform(new AspNetCoreReplicationRequest(request), new AspNetCoreReplicationResponse(response));
}
