// loads all test-cases from a single folder
private IEnumerable <RhinoTestCase> LoadFromFolder(string folder)
{
// load test cases
var files = Directory.GetFiles(folder);
var testCases = files.SelectMany(LoadFromFile);
// results
logger?.DebugFormat("Total of [{0}] files loaded from [{1}].", files?.Length, folder);
return(testCases);
}
public void ExitMethod(ILogger logger, MethodBase currentMethod)
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("EXIT {0}.{1} ", currentMethod.DeclaringType.FullName, currentMethod.Name);
}
}
public static OperationResponse HandleUnknownOperationCode(OperationRequest operationRequest, ILogger logger)
{
if (logger != null && logger.IsDebugEnabled)
{
logger.DebugFormat("Unknown operation code: OpCode={0}", operationRequest.OperationCode);
}
return new OperationResponse { OperationCode = operationRequest.OperationCode, ReturnCode = (int)ErrorCode.OperationInvalid, DebugMessage = "Invalid operation code" };
}
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
Assembly assembly = null;
Logger?.DebugFormat("Try Resolve Assembly: {0}", args.Name);
foreach (var item in dirList)
{
string assemblyFile = $"{args.Name.Split(',').First()}.dll";
string assemblyPath = Path.Combine(item, assemblyFile);
if (File.Exists(assemblyPath))
{
assembly = Assembly.LoadFile(assemblyPath);
Logger?.DebugFormat("Resolve Assembly Suceess: {0} {1}", args.Name, assemblyPath);
break;
}
}
return(assembly);
}
public static OperationResponse HandleInvalidOperation(Operation operation, ILogger logger)
{
string errorMessage = operation.GetErrorMessage();
if (logger != null && logger.IsDebugEnabled)
{
logger.DebugFormat("Invalid operation: OpCode={0}; {1}", operation.OperationRequest.OperationCode, errorMessage);
}
return new OperationResponse { OperationCode = operation.OperationRequest.OperationCode, ReturnCode = (int)ErrorCode.OperationInvalid, DebugMessage = errorMessage };
}
/// <summary>
/// Returns a list of test cases for a project.
/// </summary>
/// <param name="ids">A list of test ids to get test cases by.</param>
/// <returns>A collection of Rhino.Api.Contracts.AutomationProvider.RhinoTestCase</returns>
public override IEnumerable <RhinoTestCase> OnGetTestCases(params string[] ids)
{
// constants: logging
const string M1 = "tests-repository parsed into integers";
const string M2 = "total of [{0}] distinct items found (test or test-suite)";
// parse as int
var idList = new List <(string schema, int id)>();
foreach (var id in Configuration.TestsRepository)
{
idList.Add(GetSchema(id));
}
logger?.Debug(M1);
// normalize
var cases = idList.Where(i => i.schema.Equals("C", Compare)).Select(i => i.id).Distinct();
var suits = idList.Where(i => !i.schema.Equals("C", Compare)).Select(i => i.id).Distinct();
logger?.DebugFormat(M2, idList.Count);
// get all test-cases
var bySuites = suits.SelectMany(i => casesClient.GetCases(project.Id, i)).Where(i => i != null) ?? Array.Empty <TestRailCase>();
var byCases = cases.Select(i => casesClient.GetCase(i)).Where(i => i != null) ?? Array.Empty <TestRailCase>();
return(bySuites.Concat(byCases).DistinctBy(i => i.Id).Select(ToConnectorTestCase));
}
public EnquiryFactory(ILogger logger, IEnumerable<IntegrationSystemConfigurationPoco> systemConfigs)
{
Logger = logger;
SystemConfigs = systemConfigs;
// set the configs
EnquiryEndPoint = SystemConfigs.GetValue(InfrastructureConstants.SiebelCustomerEnquiryEndpoint);
EnquiryUserId = SystemConfigs.GetValue(InfrastructureConstants.SiebelCustomerEnquiryUserId);
EnquiryPassword = SystemConfigs.GetValue(InfrastructureConstants.SiebelCustomerEnquiryPassword);
EnquiryTimeout = Int32.Parse(SystemConfigs.GetValue(InfrastructureConstants.SiebelCustomerEnquiryTimeout));
EnquiryMethod = SystemConfigs.GetValue(InfrastructureConstants.SiebelCustomerEnquiryMethod);
Logger.DebugFormat("EnquiryFactory created with configuration values EnquiryEndPoint: {0}; EnquiryUserId: {1}; EnquiryPassword: {2}; EnquiryTimeout: {3}; EnquiryMethod: {4}.", EnquiryEndPoint, EnquiryUserId, EnquiryPassword, EnquiryTimeout, EnquiryMethod);
}
public MasterServerCache(IEnumerable <Node> nodes)
{
foreach (var nodeInfo in nodes)
{
var endPoint = new PhotonEndpointInfo(nodeInfo);
this.servers.Add(endPoint);
}
if (log.IsDebugEnabled)
{
foreach (var endpoint in this.servers)
{
log.DebugFormat("Hostname - 1 {0}, UDP: {1}, HTTP: {2}", endpoint.UdpHostname, endpoint.UdpEndPoint, endpoint.HttpEndPoint);
}
}
}
public async Task CommitOffsetAsync(int partition, long offset)
{
// kafka not use broker in cluster mode
var topicPartitionOffset = new TopicPartitionOffset(new TopicPartition(Topic, partition), offset + 1);
var committedOffset = await _consumer.CommitAsync(new[] { topicPartitionOffset })
.ConfigureAwait(false);
if (committedOffset.Error.Code != ErrorCode.NoError)
{
_logger.Error($"{Id} committed offset failed {committedOffset.Error}");
}
else
{
_logger.DebugFormat($"{Id} committed offset {committedOffset.Offsets.FirstOrDefault()}");
}
}
public override bool OnHandleMessage(IMessage message, IServerPeer sPeer)
{
Log.DebugFormat("OnHandleMessage:TexasBetHandler");
var errorParam = new Dictionary <byte, object>
{
{ (byte)ServerParameterCode.PeerId, message.Parameters[(byte)ServerParameterCode.PeerId] },
{ (byte)ClientParameterCode.SubOperationCode, message.Parameters[(byte)ClientParameterCode.SubOperationCode] },
};
var serverPeer = sPeer as ServerOutbouncePeer;
var operation = new BetOperator(serverPeer.Protocol, message);
if (!operation.IsValid)
{
serverPeer.SendMessage(new Response((byte)TexasOperationCode.Bet, null, errorParam, operation.GetErrorMessage(), (int)RoomErrorCode.OperationInvalid));
return(false);
}
var peerId = new Guid((Byte[])operation.PeerId);
var roomID = operation.RoomID;
errorParam.Add((byte)RoomParameterCode.RoomID, roomID);
var facade = TexasApplication.GetRoom(roomID);
if (facade == null)
{
serverPeer.SendMessage(new Response((byte)TexasOperationCode.Bet, null, errorParam, "RoomId Not Found", (int)RoomErrorCode.RoomIdNotFound));
return(false);
}
var userItem = TexasApplication.GetRoomUser(roomID, peerId);
if (userItem == null)
{
serverPeer.SendMessage(new Response((byte)TexasOperationCode.Bet, null, errorParam, "User Not Yet Join Room", (int)RoomErrorCode.UserNotYetJoinRoom));
return(false);
}
TexasBetRequest texasBetRequest = JsonConvert.DeserializeObject <TexasBetRequest>(operation.TexasBetRequest);
texasBetRequest.UserKey = userItem.UserKey;
var stateMachine = facade.RetrieveMediator(TexasStateMachine.NAME) as TexasStateMachine;
stateMachine.Bet(texasBetRequest);
return(true);
}
public async Task SendMessageAsync(Producer producer, string messageType, string messageClass, EQueueMessage message, string routingKey, string messageId, IDictionary <string, string> messageExtensionItems)
{
try
{
var result = await producer.SendAsync(message, routingKey).ConfigureAwait(false);
if (result.SendStatus == SendStatus.Success)
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("ENode {0} message send success, equeueMessageId: {1}, routingKey: {2}, messageType: {3}, messageId: {4}, messageExtensionItems: {5}",
messageType,
result.MessageStoreResult.MessageId,
routingKey,
messageClass,
messageId,
_jsonSerializer.Serialize(messageExtensionItems)
);
}
}
else
{
_logger.ErrorFormat("ENode {0} message send failed, message: {1}, sendResult: {2}, routingKey: {3}, messageType: {4}, messageId: {5}, messageExtensionItems: {6}",
messageType,
message,
result,
routingKey,
messageClass,
messageId,
_jsonSerializer.Serialize(messageExtensionItems)
);
throw new IOException(result.ErrorMessage);
}
}
catch (Exception ex)
{
_logger.Error(string.Format("ENode {0} message send has exception, message: {1}, routingKey: {2}, messageType: {3}, messageId: {4}, messageExtensionItems: {5}",
messageType,
message,
routingKey,
messageClass,
messageId,
_jsonSerializer.Serialize(messageExtensionItems)
), ex);
throw new IOException("Send equeue message has exception.", ex);
}
}
/// <summary>
/// Gets the report builders that correspond to the given <paramref name="reportConfiguration" />.
/// </summary>
/// <param name="reportContext">The report context.</param>
/// <returns>
/// The report builders.
/// </returns>
public IEnumerable <IReportBuilder> GetReportBuilders(IReportContext reportContext)
{
Logger.DebugFormat(Resources.InitializingReportBuilders, string.Join(", ", reportContext.ReportConfiguration.ReportTypes));
var reportBuilders = this.pluginLoader.LoadInstancesOfType <IReportBuilder>()
.Where(r => reportContext.ReportConfiguration.ReportTypes.Contains(r.ReportType, StringComparer.OrdinalIgnoreCase))
.OrderBy(r => r.ReportType)
.ToArray();
var result = new List <IReportBuilder>();
foreach (var reportBuilderGroup in reportBuilders.GroupBy(r => r.ReportType))
{
if (reportBuilderGroup.Count() == 1)
{
result.Add(reportBuilderGroup.First());
}
else
{
var nonDefaultParsers = reportBuilderGroup
.Where(r => r.GetType().Assembly.GetName().Name != "ReportGenerator.Core")
.ToArray();
foreach (var reportBuilder in nonDefaultParsers)
{
result.Add(reportBuilder);
}
if (nonDefaultParsers.Length > 1)
{
Logger.WarnFormat(Resources.SeveralCustomReportBuildersWithSameReportType, reportBuilderGroup.Key);
}
if (nonDefaultParsers.Length < reportBuilderGroup.Count())
{
Logger.WarnFormat(Resources.DefaultReportBuilderReplaced, reportBuilderGroup.Key);
}
}
}
foreach (var reportBuilder in result)
{
reportBuilder.ReportContext = reportContext;
}
return(result);
}
/// <summary>
/// Attempt multiple calls to the MDM service until we are successful or exhaust the retries.
/// </summary>
/// <typeparam name="T">Type we are returning</typeparam>
/// <param name="service">MDM service to use</param>
/// <param name="func">Function to invoke against MDM</param>
/// <param name="logger">Action to perform on failure</param>
/// <param name="retries">Number of retries, defaults to 5</param>
/// <param name="sleep">Dwell time between retries, defaults to 100 ms</param>
/// <returns>Result of the MDM action</returns>
public static WebResponse <T> TrySearch <T>(this IMdmService service, Func <WebResponse <T> > func, ILogger logger, int retries = 5, int sleep = 100)
{
logger.DebugFormat("Start : IMdmService.TrySearch<{0}>", GetTypeName(typeof(T)));
var response = new WebResponse <T> {
IsValid = false
};
var i = 0;
var isServiceUnvailable = false;
Fault fault = null;
while (!response.IsValid && i++ < retries)
{
response = func.Invoke();
if (response.Fault != null)
{
fault = response.Fault;
// Logic to handle the Service Unavailable scenarios
if (fault.IsServiceUnavailable())
{
isServiceUnvailable = true;
}
else if (response.Code == HttpStatusCode.NotFound)
{
// NB NotFound is not an error under normal circumstances
response.IsValid = true;
}
}
else
{
isServiceUnvailable = false;
}
if (!response.IsValid)
{
logger.Debug("Try_" + GetTypeName(typeof(T)) + ": " + response.Code);
Thread.Sleep(sleep);
}
}
if (isServiceUnvailable)
{
logger.Error("Service Call to MDM Service has failed with the error: " + fault.Message);
}
response.LogResponse();
return(response);
}
private void ExecuteInternal(IProgress <ProgressInfo> progress)
{
var selectSql = PetaPoco.Sql.Builder.Select("ID", "ProjectID", "ProjectRun", "ProjectClone", "ProjectGen", "DownloadDateTime", "COUNT(*)")
.From("WuHistory")
.GroupBy("ProjectID", "ProjectRun", "ProjectClone", "ProjectGen", "DownloadDateTime")
.Append("HAVING COUNT(*) > 1");
int count = 0;
int totalCount = 0;
_logger.Info("Checking for duplicate WU History entries...");
using (var table = Select(_connection, selectSql.SQL))
{
int lastProgress = 0;
foreach (DataRow row in table.Rows)
{
var deleteSql = PetaPoco.Sql.Builder.Append("DELETE FROM WuHistory")
.Where("ID < @0 AND ProjectID = @1 AND ProjectRun = @2 AND ProjectClone = @3 AND ProjectGen = @4 AND datetime(DownloadDateTime) = datetime(@5)",
row.ItemArray[0], row.ItemArray[1], row.ItemArray[2], row.ItemArray[3], row.ItemArray[4], row.ItemArray[5]);
int result = Execute(_connection, deleteSql.SQL, deleteSql.Arguments);
if (result != 0)
{
_logger.DebugFormat("Deleted rows: {0}", result);
totalCount += result;
}
count++;
int progressPercentage = Convert.ToInt32((count / (double)table.Rows.Count) * 100);
if (progressPercentage != lastProgress)
{
string message = String.Format(CultureInfo.CurrentCulture, "Deleting duplicate {0} of {1}.", count, table.Rows.Count);
if (progress != null)
{
progress.Report(new ProgressInfo(progressPercentage, message));
}
lastProgress = progressPercentage;
}
}
}
if (totalCount != 0)
{
_logger.InfoFormat("Total number of duplicate WU History entries deleted: {0}", totalCount);
}
}
/// <summary>放入一个消息到MailBox，并自动尝试运行MailBox
/// </summary>
/// <param name="message"></param>
public virtual void EnqueueMessage(TMessage message)
{
lock (_lockObj)
{
message.Sequence = _nextSequence;
message.MailBox = this;
if (_messageDict.TryAdd(message.Sequence, message))
{
_nextSequence++;
_logger.DebugFormat("{0} enqueued new message, routingKey: {1}, messageSequence: {2}", GetType().Name, RoutingKey, message.Sequence);
LastActiveTime = DateTime.Now;
TryRun();
}
}
}
public void SaveHeader(Type248Header header)
{
logger.Trace("Start inserting header.");
var headerKey = marketDataAccess.InsertHeader(header);
logger.InfoFormat("Inserted Header \"{0}\".", headerKey);
foreach (var detail in header.Details)
{
detail.HeaderKey = headerKey;
var detailKey = marketDataAccess.InsertDetail(detail);
logger.DebugFormat("Inserted Detail \"{0}\" for Header \"{1}\".", detailKey, headerKey);
}
logger.Trace("Completed inserted header.");
}
/// <summary>
/// 处理来自客户端的请求
/// </summary>
/// <param name="operationRequest"></param>
/// <param name="sendParameters"></param>
protected override void OnOperationRequest(OperationRequest operationRequest, SendParameters sendParameters)
{
if (Log.IsDebugEnabled)
{
Log.DebugFormat("==> GameClientPeer :OnOperationRequest: pid={0}, op={1}", ConnectionId, (PvpCode)operationRequest.OperationCode);
}
//处理不可靠操作代码
if (sendParameters.Unreliable)
{
OnRecvTimeSync(operationRequest);
}
else
{
//TODO:处理可靠操作代码
}
}
public void EnqueueMessage(ProcessingCommand message)
{
lock (_lockObj)
{
message.Sequence = NextSequence;
message.MailBox = this;
if (_messageDict.TryAdd(message.Sequence, message))
{
NextSequence++;
_logger.DebugFormat("{0} enqueued new message, aggregateRootId: {1}, messageId: {2}, messageSequence: {3}", GetType().Name, AggregateRootId, message.Message.Id, message.Sequence);
LastActiveTime = DateTime.Now;
TryRun();
}
}
}
protected override void ProcessInternal()
{
Debug.Assert(_database.TableExists(SqlTable.WuHistory));
var selectSql = PetaPoco.Sql.Builder.Select("ID", "ProjectID", "ProjectRun", "ProjectClone", "ProjectGen", "DownloadDateTime", "COUNT(*)")
.From("WuHistory")
.GroupBy("ProjectID", "ProjectRun", "ProjectClone", "ProjectGen", "DownloadDateTime")
.Append("HAVING COUNT(*) > 1");
int count = 0;
int totalCount = 0;
_logger.Info("Checking for duplicate WU History entries...");
using (var table = _database.Select(selectSql.SQL))
{
int lastProgress = 0;
foreach (DataRow row in table.Rows)
{
var deleteSql = PetaPoco.Sql.Builder.Append("DELETE FROM WuHistory")
.Where("ID < @0 AND ProjectID = @1 AND ProjectRun = @2 AND ProjectClone = @3 AND ProjectGen = @4 AND datetime(DownloadDateTime) = datetime(@5)",
row.ItemArray[0], row.ItemArray[1], row.ItemArray[2], row.ItemArray[3], row.ItemArray[4], row.ItemArray[5]);
int result = _database.Execute(deleteSql.SQL, deleteSql.Arguments);
if (result != 0)
{
_logger.DebugFormat("Deleted rows: {0}", result);
totalCount += result;
}
count++;
int progress = Convert.ToInt32((count / (double)table.Rows.Count) * 100);
if (progress != lastProgress)
{
string message = String.Format(CultureInfo.CurrentCulture, "Deleting duplicate {0} of {1}.", count, table.Rows.Count);
OnProgressChanged(new ProgressChangedEventArgs(progress, message));
lastProgress = progress;
}
}
}
if (totalCount != 0)
{
_logger.InfoFormat("Total number of duplicate WU History entries deleted: {0}", totalCount);
}
}
public static T Get <T>()
{
var pickedType = typeof(T);
IRuntimeService service;
if (Services.TryGetValue(pickedType, out service))
{
return((T)service);
}
if (Log.IsDebugEnabled)
{
Log.DebugFormat($"Cannot get Runtime service '{pickedType}'!");
}
throw new ArgumentException("cannot find service");
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = this.types
.Where(type => this.assembliesByIdDictionary[type.Attribute(this.assemblyAttribute).Value].Equals(assemblyName) && !type.Attribute("name").Value.Contains("__"))
.Select(type => type.Attribute("name").Value)
.OrderBy(name => name)
.Distinct()
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return(assembly);
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
Contract.Ensures(_Lifestyle1 != null);
Contract.Ensures(Initialized);
// check ILoggerFactory is registered
if (kernel.HasComponent(typeof(ILoggerFactory)))
{
// get logger factory instance
var loggerFactory = kernel.Resolve <ILoggerFactory>();
// create logger
_Logger = loggerFactory.Create(typeof(WrapperResolveLifestyleManager <T>));
}
else
{
_Logger = NullLogger.Instance;
}
if (_Logger.IsDebugEnabled)
{
_Logger.DebugFormat("initializing (for component: {0})", string.Join(",", model.Services));
}
_LifestyleKernel.Register(Component.For <T>().LifeStyle.Transient.Named("T.lifestyle"));
kernel.AddChildKernel(_LifestyleKernel);
try
{
_Lifestyle1 = _LifestyleKernel.Resolve <T>();
}
finally
{
kernel.RemoveChildKernel(_LifestyleKernel);
}
_Lifestyle1.Init(componentActivator, kernel, model);
base.Init(componentActivator, kernel, model);
Contract.Assume(_Lifestyle1 != null,
"lifestyle1 can't be null because the Resolve<T> call will throw an exception if a matching service wasn't found");
_Logger.Debug("initialized");
_Initialized = true;
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="modules">The modules.</param>
/// <param name="assemblyName">Name of the assembly.</param>
/// <param name="innerMaxDegreeOfParallism">The max degree of parallism for the class iteration foreach loop</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(XElement[] modules, string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var files = modules
.Where(m => m.Attribute("name").Value.Equals(assemblyName))
.Elements("file")
.Where(f => this.FileFilter.IsElementIncludedInReport(f.Attribute("name").Value))
.OrderBy(f => f.Attribute("name").Value)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(files, file => this.ProcessFile(assembly, file));
return(assembly);
}
public void LogDebug(string message, params object[] args)
{
try
{
if (args.Length == 0)
{
_logger.Debug(message);
}
else
{
_logger.DebugFormat(message, args);
}
}
catch (Exception)
{
}
}
void IQueueMessageHandler.Handle(QueueMessage queueMessage, IMessageContext context)
{
var applicationMessageType = _typeNameProvider.GetType(queueMessage.Tag);
var message = _jsonSerializer.Deserialize(Encoding.UTF8.GetString(queueMessage.Body), applicationMessageType) as IApplicationMessage;
var processContext = new EQueueProcessContext(queueMessage, context);
var processingMessage = new ProcessingApplicationMessage(message, processContext);
_logger.DebugFormat("ENode application message received, messageId: {0}", message.Id);
Task.Factory.StartNew(obj =>
{
_messageDispatcher.DispatchMessageAsync(((ProcessingApplicationMessage)obj).Message).ContinueWith(x =>
{
processingMessage.Complete();
});
}, processingMessage);
}
public void RegisterCallbackMetaData(CallbackKey key, MethodInfo method)
{
if (_callbackMetaDataDict.ContainsKey(key))
{
throw new EventSourcingException(string.Format("聚合根（{0}）上定义了重复的事件（{1}）响应函数。", key.AggregateRootType.FullName, key.EventType.FullName));
}
_callbackMetaDataDict.Add(key, method);
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat(
"Cached AggregateRoot Internal Callback Method, AggregateRoot Type:{0}, Event Type:{1}, Method Name:{2}",
key.AggregateRootType.FullName,
key.EventType.FullName,
method.Name
);
}
}
public async Task <AsyncTaskResult> SendMessageAsync(Producer producer, string messageType, string messageClass, EQueueMessage message, string routingKey, string messageId, IDictionary <string, string> messageExtensionItems)
{
try
{
var result = await producer.SendAsync(message, routingKey);
if (result.SendStatus != SendStatus.Success)
{
_logger.ErrorFormat("ENode {0} message send failed, message: {1}, sendResult: {2}, routingKey: {3}, messageType: {4}, messageId: {5}, messageExtensionItems: {6}",
messageType,
message,
result,
routingKey,
messageClass,
messageId,
_jsonSerializer.Serialize(messageExtensionItems)
);
return(new AsyncTaskResult(AsyncTaskStatus.IOException, result.ErrorMessage));
}
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("ENode {0} message send success, equeueMessageId: {1}, routingKey: {2}, messageType: {3}, messageId: {4}, messageExtensionItems: {5}",
messageType,
result.MessageStoreResult.MessageId,
routingKey,
messageClass,
messageId,
_jsonSerializer.Serialize(messageExtensionItems)
);
}
return(AsyncTaskResult.Success);
}
catch (Exception ex)
{
_logger.Error(string.Format("ENode {0} message send has exception, message: {1}, routingKey: {2}, messageType: {3}, messageId: {4}, messageExtensionItems: {5}",
messageType,
message,
routingKey,
messageClass,
messageId,
_jsonSerializer.Serialize(messageExtensionItems)
), ex);
return(new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message));
}
}
/// <summary>
/// Creates the controller instance.
/// </summary>
/// <param name="area">The area.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
protected virtual IController CreateControllerInstance(String area, String name)
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("Creating controller instance. Area '{0}' Name '{1}'", area, name);
}
var type = Tree.GetController(area, name);
if (type == null)
{
logger.ErrorFormat("Controller not found. Area '{0}' Name '{1}'", area, name);
throw new ControllerNotFoundException(area, name);
}
return(CreateController(type));
}
internal StatelessSessionImpl(IDbConnection connection, SessionFactoryImpl factory)
: base(factory)
{
using (new SessionIdLoggingContext(SessionId))
{
temporaryPersistenceContext = new StatefulPersistenceContext(this);
connectionManager = new ConnectionManager(this, connection, ConnectionReleaseMode.AfterTransaction,
new EmptyInterceptor());
if (log.IsDebugEnabled)
{
log.DebugFormat("[session-id={0}] opened session for session factory: [{1}/{2}]",
SessionId, factory.Name, factory.Uuid);
}
CheckAndUpdateSessionStatus();
}
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = this.types
.Where(type => type.Attribute("asm").Value.Equals(assemblyName) &&
!Regex.IsMatch(type.Attribute("name").Value, "<.*>.+__"))
.Select(type => type.Attribute("name").Value)
.OrderBy(name => name)
.Distinct()
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return(assembly);
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = this.methods
.Where(m => m.Attribute("assembly").Value.Equals(assemblyName))
.Select(m => m.Attribute("class").Value)
.Where(c => !c.Contains(".`1c__") && c != "`1")
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return(assembly);
}
/// <summary>
/// Implementors should collect the layout information
/// and return a descriptor instance, or null if none
/// was found.
/// </summary>
/// <param name="memberInfo">The controller type or action (MethodInfo)</param>
/// <returns>
/// An <see cref="LayoutDescriptor"/> instance
/// </returns>
public LayoutDescriptor CollectLayout(MemberInfo memberInfo)
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("Collecting layout information for {0}", memberInfo.Name);
}
var attributes = memberInfo.GetCustomAttributes(typeof(ILayoutDescriptorBuilder), true);
if (attributes.Length == 1)
{
var desc = (attributes[0] as ILayoutDescriptorBuilder).BuildLayoutDescriptor();
return(desc);
}
return(null);
}
private IRegistration RegisterSession(Data x, uint index)
{
Contract.Requires(index < 3,
"there are only three supported lifestyles; per transaction, per web request and transient");
Contract.Requires(x != null);
Contract.Ensures(Contract.Result <IRegistration>() != null);
return(GetLifeStyle(
Component.For <ISession>()
.UsingFactoryMethod((k, c) =>
{
var factory = k.Resolve <ISessionFactory>(x.Instance.SessionFactoryKey);
var s = x.Instance.Interceptor.Do(y => factory.OpenSession(y)).OrDefault(factory.OpenSession());
s.FlushMode = flushMode;
logger.DebugFormat("resolved session component named '{0}'", c.Handler.ComponentModel.Name);
return s;
}), index, x.Instance.SessionFactoryKey));
}
private void OnPeerRemoveCallBack(string key, object value, CacheItemRemovedReason reason)
{
PhotonHttpPeer peer = (PhotonHttpPeer)value;
if (log.IsDebugEnabled)
{
log.DebugFormat("Removed peer: id={0}, reason={1}", new object[] { peer.GetConnectionID(), reason });
}
if ((reason == CacheItemRemovedReason.Expired) || (reason == CacheItemRemovedReason.Underused))
{
Interlocked.Decrement(ref currentConnectionCount);
Action <PhotonHttpPeer> onPeerExpired = this.OnPeerExpired;
if (onPeerExpired != null)
{
onPeerExpired(peer);
}
}
}
/// <summary>
/// The constructor for UnityWebResponseData.
/// </summary>
/// <param name="wwwRequest">
/// An instance of WWW after the web request has
/// completed and response fields are set
/// </param>
public UnityWebResponseData(WWW wwwRequest)
{
_logger= Logger.GetLogger(this.GetType());
_headers = wwwRequest.responseHeaders;
try
{
_responseBody = wwwRequest.bytes;
}
catch (Exception)
{
_logger.DebugFormat(@"setting response body to null");
_responseBody = null;
}
if (wwwRequest.error == null)
{
_logger.DebugFormat(@"recieved successful response");
}
else
{
_logger.DebugFormat(@"recieved error response");
_logger.DebugFormat(@"recieved = {0}", wwwRequest.error);
}
if ((_responseBody != null && _responseBody.Length > 0) || (_responseBody.Length == 0 && wwwRequest.error == null))
{
_logger.DebugFormat(@"{0}", System.Text.UTF8Encoding.UTF8.GetString(_responseBody));
_responseStream = new MemoryStream(_responseBody);
}
this.ContentLength = wwwRequest.bytesDownloaded;
string contentType = null;
this._headers.TryGetValue(
HeaderKeys.ContentTypeHeader.ToUpperInvariant(), out contentType);
this.ContentType = contentType;
try
{
if(string.IsNullOrEmpty(wwwRequest.error))
{
string statusHeader = string.Empty;
this._headers.TryGetValue(HeaderKeys.StatusHeader.ToUpperInvariant(),out statusHeader);
if(!string.IsNullOrEmpty(statusHeader))
{
this.StatusCode = (HttpStatusCode)Enum.Parse(
typeof(HttpStatusCode),
statusHeader.Substring(9, 3).Trim());
}
else
{
this.StatusCode = 0;
}
}
else
{
int statusCode;
if (Int32.TryParse(wwwRequest.error.Substring(0,3), out statusCode))
this.StatusCode = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode),
wwwRequest.error.Substring(3).Replace(" ", "").Replace(":","").Trim(),true);//ignored case
else
this.StatusCode = 0;
}
}
catch
{
this.StatusCode = 0;
}
_logger.DebugFormat(@"Status = {0}", StatusCode);
this.IsSuccessStatusCode = wwwRequest.error == null?true:false;
}
public void ShowPPDTrace(ILogger logger, string slotName, SlotStatus status, PpdCalculationType calculationType, BonusCalculationType calculateBonus)
{
// test the level
if (!logger.IsDebugEnabled) return;
if (CurrentProtein.IsUnknown())
{
logger.DebugFormat(Constants.ClientNameFormat, slotName, "Protein is unknown... 0 PPD.");
return;
}
// Issue 125
if (calculateBonus.Equals(BonusCalculationType.DownloadTime))
{
// Issue 183
if (status.Equals(SlotStatus.RunningAsync) ||
status.Equals(SlotStatus.RunningNoFrameTimes))
{
logger.DebugFormat(Constants.ClientNameFormat, slotName, "Calculate Bonus PPD by Frame Time.");
}
else
{
logger.DebugFormat(Constants.ClientNameFormat, slotName, "Calculate Bonus PPD by Download Time.");
}
}
else if (calculateBonus.Equals(BonusCalculationType.FrameTime))
{
logger.DebugFormat(Constants.ClientNameFormat, slotName, "Calculate Bonus PPD by Frame Time.");
}
else
{
logger.DebugFormat(Constants.ClientNameFormat, slotName, "Calculate Standard PPD.");
}
TimeSpan frameTime = GetFrameTime(calculationType);
var values = CurrentProtein.GetProductionValues(frameTime, GetEftByDownloadTime(frameTime), GetEftByFrameTime(frameTime), calculateBonus.IsEnabled());
logger.Debug(values.ToMultiLineString());
}
public void Process()
{
try
{
_logger = _container.Resolve<ILogger>();
}
catch
{
}
try
{
if (_logger.IsDebugEnabled)
_logger.DebugFormat("Begin async process for request coming from {0}...", IncomingUri);
var operationFactory = _container.Resolve<IRemoraOperationFactory>();
var kindIdentifier = _container.Resolve<IRemoraOperationKindIdentifier>();
var pipelineFactory = _container.Resolve<IPipelineFactory>();
var pipelineEngine = _container.Resolve<IPipelineEngine>();
IRemoraOperation operation = null;
switch (_kind)
{
case ContextKind.Web:
operation = operationFactory.Get(new UniversalRequest(HttpWebContext.Request));
operation.ExecutionProperties[ContextKey] = HttpWebContext;
break;
case ContextKind.Net:
operation = operationFactory.Get(new UniversalRequest(HttpListenerContext.Request));
operation.ExecutionProperties[ContextKey] = HttpListenerContext;
break;
}
operation.Kind = kindIdentifier.Identify(operation);
var pipeline = pipelineFactory.Get(operation);
if (pipeline == null)
throw new InvalidConfigurationException(
string.Format("Unable to select an appropriate pipeline for operation {0}.", operation));
pipelineEngine.RunAsync(operation, pipeline, EngineCallback);
}
catch (Exception ex)
{
_logger.ErrorFormat(ex, "There has been an error when processing request coming from {0}.", IncomingUri);
WriteGenericException(ex);
IsCompleted = true;
_callback(this);
}
}
public void ProcessResult(RawMessage message, ITransport transport, ILogger log)
{
log.DebugFormat("Delaying message {0} until {1}", message.ToString(), this.DelayUntil.ToString());
message.DelayUntil = this.DelayUntil;
transport.SendToDelay(message);
}
public void ProcessResult(RawMessage message, ITransport transport, ILogger log)
{
log.DebugFormat("Message {0} ignored for reason {1}", message.ToString(), this.reason);
}
