public List<Snapshot> Run(IPolicyEngineFactory agent, ProcessLevel level, RunAt runAt, bool forceGc)
{
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
IContentScanner scanner = agent.CreateContentScanner(null);
IContentEnforcer enforcer = m_Enforce ? agent.CreateContentEnforcer(null) : null;
List<Snapshot> snapshots = new List<Snapshot>();
for (int iteration = 0; iteration < m_Iterations; ++iteration)
{
snapshots.Add(new Snapshot("PreLoadRequest", forceGc));
Request request = ContractSerialization.LoadRequest(m_RequestPath);
snapshots.Add(new Snapshot("PreScan", forceGc));
Response response = scanner.Scan(request, null, level, runAt);
if (enforcer != null)
{
snapshots.Add(new Snapshot("PreEnforce", forceGc));
enforcer.Enforce(request, response);
snapshots.Add(new Snapshot("PostEnforce", forceGc));
}
else
{
snapshots.Add(new Snapshot("PostScan", forceGc));
}
}
snapshots.Add(new Snapshot("PostGcFinal", true));
return snapshots;
}
/// <summary>
/// 删除
/// </summary>
/// <param name="p_Entity">实体类</param>
/// <returns>操作影响的记录行数</returns>
public override int Delete(BaseEntity p_Entity)
{
try
{
ProcessLevel MasterEntity = (ProcessLevel)p_Entity;
if (MasterEntity.ID == 0)
{
return(0);
}
//删除主表数据
string Sql = "";
Sql = "DELETE FROM Enum_ProcessLevel WHERE " + "ID=" + SysString.ToDBString(MasterEntity.ID);
//执行
int AffectedRows = 0;
if (!this.sqlTransFlag)
{
AffectedRows = this.ExecuteNonQuery(Sql);
}
else
{
AffectedRows = sqlTrans.ExecuteNonQuery(Sql);
}
return(AffectedRows);
}
catch (BaseException E)
{
throw new BaseException(E.Message, E);
}
catch (Exception E)
{
throw new BaseException(FrameWorkMessage.GetAlertMessage((int)Message.CommonDBDelete), E);
}
}
/// <summary>
/// 删除
/// </summary>
public override void EntityDelete()
{
ProcessLevelRule rule = new ProcessLevelRule();
ProcessLevel entity = EntityGet();
rule.RDelete(entity);
}
/// <summary>
/// 获得实体
/// </summary>
/// <returns></returns>
private ProcessLevel EntityGet()
{
ProcessLevel entity = new ProcessLevel();
entity.ID = HTDataID;
return(entity);
}
/// <summary>
/// 新增
/// </summary>
public override int EntityAdd()
{
ProcessLevelRule rule = new ProcessLevelRule();
ProcessLevel entity = EntityGet();
rule.RAdd(entity);
return(entity.ID);
}
/// <summary>
/// 获得实体
/// </summary>
/// <returns></returns>
private ProcessLevel EntityGet()
{
ProcessLevel entity = new ProcessLevel();
entity.ID = HTDataID;
entity.SelectByID();
entity.Code = txtCode.Text.Trim();
entity.Name = txtName.Text.Trim();
entity.Remark = txtRemark.Text.Trim();
return(entity);
}
/// <summary>
/// 设置
/// </summary>
public override void EntitySet()
{
ProcessLevel entity = new ProcessLevel();
entity.ID = HTDataID;
bool findFlag = entity.SelectByID();
txtCode.Text = entity.Code.ToString();
txtName.Text = entity.Name.ToString();
txtRemark.Text = entity.Remark.ToString();
if (!findFlag)
{
}
}
/// <summary>
/// 新增
/// </summary>
/// <param name="p_Entity">实体类</param>
/// <returns>操作影响的记录行数</returns>
public override int AddNew(BaseEntity p_Entity)
{
try
{
ProcessLevel MasterEntity = (ProcessLevel)p_Entity;
if (MasterEntity.ID == 0)
{
return(0);
}
//新增主表数据
StringBuilder MasterField = new StringBuilder();
StringBuilder MasterValue = new StringBuilder();
MasterField.Append("INSERT INTO Enum_ProcessLevel(");
MasterValue.Append(" VALUES(");
MasterField.Append("ID" + ",");
MasterValue.Append(SysString.ToDBString(MasterEntity.ID) + ",");
MasterField.Append("Code" + ",");
MasterValue.Append(SysString.ToDBString(MasterEntity.Code) + ",");
MasterField.Append("Name" + ",");
MasterValue.Append(SysString.ToDBString(MasterEntity.Name) + ",");
MasterField.Append("Remark" + ")");
MasterValue.Append(SysString.ToDBString(MasterEntity.Remark) + ")");
//执行
int AffectedRows = 0;
if (!this.sqlTransFlag)
{
AffectedRows = this.ExecuteNonQuery(MasterField.Append(MasterValue.ToString()).ToString());
}
else
{
AffectedRows = sqlTrans.ExecuteNonQuery(MasterField.Append(MasterValue.ToString()).ToString());
}
return(AffectedRows);
}
catch (BaseException E)
{
throw new BaseException(E.Message, E);
}
catch (Exception E)
{
throw new BaseException(FrameWorkMessage.GetAlertMessage((int)Message.CommonDBInsert), E);
}
}
/// <summary>
/// Gets the response time (in millisec) for the engine to process the given file.
/// </summary>
/// <param name="filePath">The file you are testing</param>
/// <returns>measurement in milliseconds</returns>
internal static long GetResponseTimeForFile(IContentScanner scanner, string filePath, ProcessLevel level, RunAt runAt)
{
using (var cs = new ContractSerialization())
{
Request request = cs.LoadRequest(filePath);
Response response = null;
TimeSpan timeSpan = Measure(delegate()
{
response = scanner.Scan(request, null, level, runAt);
});
AssertValidResponse(response); //Essential to validate, but it should not be part of what is timed.
return Convert.ToInt64(timeSpan.TotalMilliseconds);
}
}
/// <summary>
/// 删除
/// </summary>
/// <param name="p_BE">要删除的实体</param>
/// <param name="sqlTrans">事务类</param>
public void RDelete(BaseEntity p_BE, IDBTransAccess sqlTrans)
{
try
{
this.CheckCorrect(p_BE);
ProcessLevel entity = (ProcessLevel)p_BE;
ProcessLevelCtl control = new ProcessLevelCtl(sqlTrans);
control.Delete(entity);
}
catch (BaseException)
{
throw;
}
catch (Exception E)
{
throw new BaseException(E.Message);
}
}
/// <summary>
/// 修改
/// </summary>
/// <param name="p_Entity">实体类</param>
/// <returns>操作影响的记录行数</returns>
public override int Update(BaseEntity p_Entity)
{
try
{
ProcessLevel MasterEntity = (ProcessLevel)p_Entity;
if (MasterEntity.ID == 0)
{
return(0);
}
//更新主表数据
StringBuilder UpdateBuilder = new StringBuilder();
UpdateBuilder.Append("UPDATE Enum_ProcessLevel SET ");
UpdateBuilder.Append(" ID=" + SysString.ToDBString(MasterEntity.ID) + ",");
UpdateBuilder.Append(" Code=" + SysString.ToDBString(MasterEntity.Code) + ",");
UpdateBuilder.Append(" Name=" + SysString.ToDBString(MasterEntity.Name) + ",");
UpdateBuilder.Append(" Remark=" + SysString.ToDBString(MasterEntity.Remark));
UpdateBuilder.Append(" WHERE " + "ID=" + SysString.ToDBString(MasterEntity.ID));
//执行
int AffectedRows = 0;
if (!this.sqlTransFlag)
{
AffectedRows = this.ExecuteNonQuery(UpdateBuilder.ToString());
}
else
{
AffectedRows = sqlTrans.ExecuteNonQuery(UpdateBuilder.ToString());
}
return(AffectedRows);
}
catch (BaseException E)
{
throw new BaseException(E.Message, E);
}
catch (Exception E)
{
throw new BaseException(FrameWorkMessage.GetAlertMessage((int)Message.CommonDBUpdate), E);
}
}
/// <summary>
/// 新增(传入事务处理)
/// </summary>
/// <param name="p_BE">要新增的实体</param>
/// <param name="sqlTrans">事务类</param>
public void RAdd(BaseEntity p_BE, IDBTransAccess sqlTrans)
{
try
{
this.CheckCorrect(p_BE);
ProcessLevel entity = (ProcessLevel)p_BE;
ProcessLevelCtl control = new ProcessLevelCtl(sqlTrans);
//entity.ID=(int)EntityIDTable.GetID((long)SysEntity.Enum_ProcessLevel,sqlTrans);
control.AddNew(entity);
}
catch (BaseException)
{
throw;
}
catch (Exception E)
{
throw new BaseException(E.Message);
}
}
public Response Scan(Request request, string user, ProcessLevel level, RunAt runat)
{
Logger.LogDebug(Properties.Resources.LOG_SCAN_BEGIN);
if (PolicyCache.Instance().IsCacheEmpty)
{
Logger.LogInfo(Properties.Resources.LOG_CATEGORY_NO_MATCHES);
return null;
}
try
{
return HandleContentScanning(request, user, level, runat, SkipDiscovery, TotalAttachmentSize);
}
catch (Exception ex)
{
Logger.LogError(ex);
return ErrorResponse(ex);
}
finally
{
Logger.LogDebug(Properties.Resources.LOG_SCAN_END);
}
}
private static IPolicyResponseObject GetPolicyResponseFromScanner(IBaseContentScanner scanner, IUniversalRequestObject uro, ProcessLevel level, bool skipDiscovery)
{
Workshare.Policy.Interfaces.ProcessLevel translatedProcessLevel =
(Workshare.Policy.Interfaces.ProcessLevel) Enum.Parse(typeof(Workshare.Policy.Interfaces.ProcessLevel), level.ToString());
Logger.LogDebug(string.Format(CultureInfo.InvariantCulture, Properties.Resources.LOG_CALLING_SCANNER, scanner));
scanner.SkipDiscovery = skipDiscovery;
return scanner.Scan(uro, translatedProcessLevel);
}
public IPolicyResponseObject Scan(IUniversalRequestObject uro, ProcessLevel processLevel)
{
PerformanceCounters.Instance.StartTimer(PerformanceCounters.CounterType.ContentScan);
PolicyResponseObject pro = new PolicyResponseObject();
GeneralPolicyProcessor gpp = GetGeneralPolicyProcessor(uro);
if ( null == gpp)
return pro;
try
{
SetupPolicyProcessor(gpp, uro);
InitialisePro(pro, uro);
ProcessExpressions(gpp, pro);
if (processLevel >= ProcessLevel.Routing)
{
ProcessRouting(gpp, pro);
if (processLevel >= ProcessLevel.Actions)
{
ProcessActions(gpp, pro, m_skipDiscovery);
}
}
}
finally
{
TearDownPolicyProcessor(gpp);
PerformanceCounters.Instance.StopTimer(PerformanceCounters.CounterType.ContentScan, 0);
}
return pro;
}
private static Response HandleContentScanning(Request request, string user, ProcessLevel level, RunAt runat, bool skipDiscovery, Int64 totalAttachmentSize)
{
PolicyType policyType = (PolicyType)Enum.Parse(typeof(PolicyType), request.PolicyType );
List<string> users = new List<string>();
users.Add(user);
Collection<Lease<EngineLookupKey, IBaseContentScanner>> scanners = PolicyCacheManager.Instance.GetScanners(
policyType,
users.ToArray(),
runat.ToString());
if ( 0 == scanners.Count )
{
string userParam = string.IsNullOrEmpty(user) ? "NULL" : user;
Logger.LogInfo( string.Format(CultureInfo.InvariantCulture, Properties.Resources.LOG_CATEGORY_NO_MATCHES, policyType.ToString(), userParam));
return new Response();
}
List<IDisposable> disposeList = new List<IDisposable>();
try
{
IUniversalRequestObject uro = RequestAdaptor.GetURO(request);
disposeList.Add(uro as IDisposable);
List<IPolicyResponseObject> pros = new List<IPolicyResponseObject>();
bool verified = VerifyRequest(request);
foreach (Lease<EngineLookupKey, IBaseContentScanner> scannerLease in scanners)
{
using (scannerLease)
{
IBaseContentScanner scanner = scannerLease.Object;
if (scanner != null)
{
scanner.TotalAttachmentSize = totalAttachmentSize;
}
IPolicyResponseObject pro = GetPolicyResponseFromScanner(scannerLease.Object, uro, level, skipDiscovery);
if (verified)
pro.VerifiedOnClient = true;
pros.Add(pro);
disposeList.Add(pro as IDisposable);
scannerLease.Object.PrepareForRecycle();
}
}
IPolicyResponseObject consolidatedPro = PROConsolidator.Consolidate(pros);
disposeList.Add(consolidatedPro as IDisposable);
UpdateIncidentProperties(consolidatedPro);
Response result = ResponseAdaptor.GetResponse(consolidatedPro);
//Copy Routing over from Request
result.Routing = new RoutingEntity[] { request.Source, request.Destination };
PopulateRunAt(result, runat);
DocumentReaderCache.Instance.Clear();
RemoveExpressionDetail(result);
return result;
}
finally
{
foreach (IDisposable disposable in disposeList)
{
if ( disposable != null)
disposable.Dispose();
}
disposeList.Clear();
}
}
public Protect.Service.Response Scan(Request request, ProcessLevel processLevel)
{
return null;
}
private static void AssertValid(Response resp, ProcessLevel processLevel)
{
Assert.IsNotNull(resp.Contents, "A NULL Contents is invalid");
Assert.IsNotNull(resp.Routing, "A NULL Routing is invalid");
if (processLevel == ProcessLevel.Actions)
{
Assert.IsNotNull(resp.ResolvedActions, "A NULL ResolvedActions is invalid");
}
foreach (ContentItem item in resp.Contents)
{
Assert.IsFalse(string.IsNullOrEmpty(item.Id), "All content items must have a populated id");
}
}
/// <summary>
/// 检查将要操作的数据是否符合业务规则
/// </summary>
/// <param name="p_BE"></param>
private void CheckCorrect(BaseEntity p_BE)
{
ProcessLevel entity = (ProcessLevel)p_BE;
}
internal static ResultStat[] MeasureFolder(IContentScanner scanner, string basePath, ProcessLevel scanLevel, RunAt runAt)
{
FileInfo[] requestFiles = new DirectoryInfo(basePath).GetFiles("*.xml", SearchOption.AllDirectories);
Assert.IsTrue(requestFiles.Length > 0);
List<ResultStat> resultStats = new List<ResultStat>();
//do it twice, take the second result.
for (int i = 0; i < 2; ++i)
{
long totalBytes = 0;
List<long> results = new List<long>();
foreach (FileInfo requestFile in requestFiles)
{
long responseTime = PerfTestHelp.GetResponseTimeForFile(scanner, requestFile.FullName, scanLevel, runAt);
results.Add(responseTime);
totalBytes += PerfTestHelp.GetRequestSizeInBytes(requestFile);
}
//JIT paranoia.
//For consistency, disregard the first iteration of every test.
if (i > 0)
{
long totalMillisec = 0;
results.ForEach(delegate(long responseTime) { totalMillisec += responseTime; });
resultStats.Add(new ResultStat(totalMillisec, requestFiles.Length, totalBytes));
}
}
return resultStats.ToArray();
}
public RoleProviderAttribute(ProcessLevel level, ProcessEvent eventType)
{
this.name = level.ToString();
this.level = level;
this.eventType = eventType;
}
private ResultStat[] MeasureFolder(string basepath, ProcessLevel level)
{
try
{
return PerfTestHelp.MeasureFolder(GetContentScanner(), basepath, level, RunAt.Client);
}
catch
{
//do not upload records if anything fails.
m_success = false;
throw;
}
}
