public InternalRule(FileImportRule rule)
{
RuleName = rule.RuleName;
HostName = rule.HostName;
Instance = rule.Instance;
Disabled = rule.Disabled;
DebugEnabled = rule.DebugEnabled;
DebugProperties = new NamedValueSet(rule.DebugProperties);
MonitorPeriod = rule.MonitorPeriod != null?TimeSpan.Parse(rule.MonitorPeriod) : TimeSpan.FromMinutes(5);
CheckConstraint = rule.CheckConstraintExpr != null?Expr.Create(rule.CheckConstraintExpr) : Expr.Const(true);
EffectiveDateExpr = rule.EffectiveDateExpr != null?Expr.Create(rule.EffectiveDateExpr) : Expr.FuncToday();
ImportDelayExpr = rule.ImportDelayExpr != null?Expr.Create(rule.ImportDelayExpr) : Expr.Const(TimeSpan.Zero);
ImportCondition = rule.ImportConditionExpr != null?Expr.Create(rule.ImportConditionExpr) : Expr.Const(true);
DateUpdateExpr = rule.DateUpdateExpr != null?Expr.Create(rule.DateUpdateExpr) : Expr.FuncToday();
SourceSystem = rule.SourceSystem;
SourceLocation = rule.SourceLocation;
TargetLocation = rule.TargetLocation;
Properties = new NamedValueSet(rule.OtherProperties);
AsAtDateOffset = rule.AsAtDateOffset;
CopyFilePatterns = rule.CopyFilePatterns;
FileContentType = rule.FileContentType;
OnlyCopyUpdatedFiles = rule.OnlyCopyUpdatedFiles;
RemoveOldTargetFiles = rule.RemoveOldTargetFiles;
LastMonitored = DateTimeOffset.MinValue;
}
public void TestFileImportServer()
{
// start the server, connect a client1, and shutdown
using (ILogger logger = new TraceLogger(true))
{
const EnvId env = EnvId.Utt_UnitTest;
var logRef = Reference <ILogger> .Create(logger);
var random = new Random(Environment.TickCount);
int port = random.Next(8000, 8099);
using (var server = new CoreServer(logRef, env.ToString(), NodeType.Router, port, WcfConst.NetTcp))
{
// start server
server.Start();
// connect client
using (ICoreClient client = new CoreClientFactory(logRef).SetEnv(env.ToString()).Create())
{
// create test import rule
var rule = new FileImportRule
{
RuleName = "UnitTest",
SourceLocation = @"C:\windows\system32",
TargetLocation = @"c:\temp",
CopyFilePatterns = "notep*.exe"
};
var name = rule.RuleName;
// start the file import server
//DateTimeOffset waitCompleted;
var target = new FileImportServer {
Client = Reference <ICoreClient> .Create(client)
};
client.SaveObject(rule, "UnitTest", null, true, TimeSpan.MaxValue);
using (target)//logger, env
{
target.Start();
Thread.Sleep(TimeSpan.FromSeconds(5));
//waitCompleted = DateTimeOffset.Now;
target.Stop();
}
{
var results1 = client.LoadItem <FileImportRule>(name);
Assert.IsNotNull(results1);
//List<ImportRuleResult> results = client.LoadObjects<ImportRuleResult>(Expr.ALL);//IRuleObject ImportRuleResult
//Assert.AreEqual(1, results.Count);
//ImportRuleResult result = results[0];
//Assert.AreEqual("UnitTest", result.RuleName);
//Assert.AreEqual("Completed", result.ImportResult);
//Assert.AreEqual(1, result.FileNames.Length);
//Assert.AreEqual("notepad.exe", result.FileNames[0].ToLower());
}
//{
// List<ImportFileResult> results = client.LoadObjects<ImportFileResult>(Expr.ALL);
// Assert.AreEqual(1, results.Count);
// ImportFileResult result = results[0];
// Assert.AreEqual("UnitTest", result.RuleName);
// Assert.AreEqual("Completed", result.ImportResult);
// Assert.AreEqual("notepad.exe", result.FileName.ToLower());
//}
}
// explicit shutdown
// - not necessary in a "using" block but run it anyway
server.Stop();
}
}
}
private void ProcessRuleUpdate(CacheChangeData update)
{
// update the rules
if (update != null)
{
switch (update.Change)
{
case CacheChange.CacheCleared:
_ruleStore.Clear();
break;
case CacheChange.ItemExpired:
case CacheChange.ItemRemoved:
{
FileImportRule oldImportRule = (FileImportRule)update.OldItem.Data;
_ruleStore.Remove(oldImportRule.PrivateKey.ToLower());
Logger.LogDebug("Rule {0}: Removed.", oldImportRule.RuleName);
}
break;
case CacheChange.ItemCreated:
{
var newImportRule = (FileImportRule)update.NewItem.Data;
_ruleStore[newImportRule.PrivateKey.ToLower()] = new InternalRule(newImportRule);
Logger.LogDebug("Rule {0}: Created.", newImportRule.RuleName);
}
break;
case CacheChange.ItemUpdated:
{
//var oldImportRule = (FileImportRule)update.OldItem.Data;
var newImportRule = (FileImportRule)update.NewItem.Data;
//InternalRule oldRule = _RuleStore.GetValue(newImportRulePrivateKey.ToLower(), null);
var newRule = new InternalRule(newImportRule);
_ruleStore[newImportRule.PrivateKey.ToLower()] = newRule;
Logger.LogDebug("Rule {0}: Updated.", newImportRule.RuleName);
}
break;
}
}
long requestsDispatched = Interlocked.Decrement(ref _updateRequestsDispatched);
if (requestsDispatched > 0)
{
// more requests following - just exit
return;
}
// process the rules
DateTimeOffset currentTime = DateTimeOffset.Now;
foreach (InternalRule rule in _ruleStore.Values)
{
try
{
if (rule.LastMonitored + rule.MonitorPeriod < currentTime)
{
// update LastMonitored first to prevent infinite looping
// when there are repeated expression evaluation exceptions
rule.LastMonitored = currentTime;
ProcessRule(IntClient.Target, rule, currentTime);
}
}
catch (Exception ruleExcp)
{
Logger.LogError("Rule {0}: EXCEPTION! {1}'", rule.RuleName, ruleExcp);
}
}
}
