/// <summary>
/// Создает обертку
/// </summary>
/// <param name="c"></param>
public ComponentDefinitionWrapper(IComponentDefinition c)
{
Name = c.Name;
var impltype = c.Implementation == null
? c.ImplementationType
: c.Implementation.GetType();
ImplAssembly = impltype.Assembly.GetName().Name;
ImplNs = impltype.Namespace;
ImplType = impltype.Name;
ServiceAssembly = c.ServiceType.Assembly.GetName().Name;
ServiceNs = c.ServiceType.Namespace;
ServiceType = c.ServiceType.Name;
Lifestyle = c.Lifestyle;
Tag = c.Tag;
Role = c.Role;
Priority = c.Priority;
ActivationCount = c.ActivationCount;
CreationCount = c.CreationCount;
Parameters = c.Parameters;
Help = c.Help;
Id = c.ContainerId;
if (null != c.Source)
{
FileName = Path.GetFileName(c.Source.Attribute("_file").Value);
Line = c.Source.Attribute("_line").Value;
}
}
/// <summary>
/// Отменяет регистрацию компонента
/// </summary>
/// <param name="component"> компонент, который должен быть убран из контейнера </param>
/// <remarks>
/// <note>Очевидно что, такой метод обязан присутствовать в интерфейсе контейнера, однако его использование в задачах помимо тестирования,
/// обозначает недостатки архитектуры приложения, так как в нормальном варианте использования контейнер меняет свое поведение по принципу наращивания
/// обслуживаемых классов и компонентов, тогда как удаление части компонент может привести к неожиданным эффектам в случае кэширования более
/// ранеей выдвачи клиентской стороной</note>
/// </remarks>
public void Unregister(IComponentDefinition component)
{
lock (this) {
if (null == component)
{
return;
}
if (!Components.Contains(component))
{
return;
}
Components.Remove(component);
ByTypeCache[component.ServiceType].Remove(component);
if (component.Name.IsNotEmpty())
{
ByNameCache[component.Name].Remove(component);
}
foreach (var componentDefinition in OutgoingCache.ToArray())
{
if (Equals(componentDefinition.Value, component))
{
DropObject(componentDefinition.Key);
OutgoingCache.Remove(componentDefinition.Key);
}
}
if (Lifestyle.PerThread == component.Lifestyle)
{
foreach (var threadCache in ThreadOutgoingCache.ToArray())
{
foreach (var componentDefinition in threadCache.Value.ToArray())
{
if (Equals(componentDefinition.Value, component))
{
DropObject(componentDefinition.Key);
OutgoingCache.Remove(componentDefinition.Key);
}
}
}
}
if (Lifestyle.Pooled == component.Lifestyle)
{
if (Pool.ContainsKey(component))
{
foreach (var obj in Pool[component])
{
DropObject(obj);
}
Pool.Remove(component);
}
}
// hook for extensions - UnRegisterComponent extensions can do something after it's
// native unregistration
ProcessExtensions(new ContainerContext {
Operation = ContainerOperation.UnregisterComponent, Component = component
});
}
}
private void ProcessExplicitInjections(IComponentDefinition component, object result)
{
var ca = result as IContainerBound;
if (null != ca)
{
ca.SetContainerContext(this, component);
}
}
public override void EndAsyncProcess(IRemoraOperation operation, IComponentDefinition componentDefinition,
Action callback)
{
if (operation.Kind == RemoraOperationKind.Soap)
{
EndRecordSoapOperation(operation, componentDefinition);
}
callback();
}
private void ProcessParametersInjection(object result, IComponentDefinition component)
{
if (component.Parameters.IsNotEmpty())
{
foreach (var parameter in component.Parameters)
{
//applys parameters in very save mode
result.SetValue(parameter.Key, parameter.Value, ignoreNotFound: true, publicOnly: false,
ignoreTypeConversionError: true);
}
}
}
public override void EndAsyncProcess(IRemoraOperation operation, IComponentDefinition componentDefinition,
Action callback)
{
try
{
TraceOperation(operation, componentDefinition);
}
catch (Exception ex)
{
Logger.WarnFormat(ex, "There has been an error while tracing operation {0}.", operation);
}
callback();
}
/// <summary>
/// Проверяет наличие в реестре компонента по внутренней логике сравнения
/// </summary>
/// <param name="component"> </param>
/// <returns> </returns>
protected bool ComponentExists(IComponentDefinition component)
{
var existed = FindComponent(component.ServiceType, component.Name);
if (null == existed)
{
return(false);
}
if (component.ServiceType != existed.ServiceType)
{
return(false); //был найден унаследованный тип
}
if (component.Name != existed.Name)
{
return(false); //при поиске без имени был найден именованный компонент
}
if (component.Lifestyle != existed.Lifestyle)
{
return(false);
}
if (component.Priority != existed.Priority)
{
return(false);
}
if (component.ImplementationType != existed.ImplementationType)
{
return(false);
}
if (component.Implementation != existed.Implementation)
{
return(false);
}
if (component.Parameters.Count != existed.Parameters.Count)
{
return(false);
}
foreach (var p in component.Parameters)
{
if (!existed.Parameters.ContainsKey(p.Key))
{
return(false);
}
if (p.Value != existed.Parameters[p.Key])
{
return(false);
}
}
return(true);
}
public override void BeginAsyncProcess(IRemoraOperation operation, IComponentDefinition componentDefinition,
Action<bool> callback)
{
if (operation.Kind == RemoraOperationKind.Soap)
{
RecordSoapOperation(operation);
}
else
{
Logger.WarnFormat("Unable to record operation {0} because it appears to not be a soap request.",
operation);
}
callback(true);
}
/// <summary>
/// Unregesters component
/// </summary>
/// <param name="component"> </param>
public void Unregister(IComponentDefinition component)
{
if (component == null)
{
return; // hack:
}
if (!_typemap.ContainsKey(component.ServiceType))
{
return;
}
//do not unregister not component's types
if (!(_typemap[component.ServiceType] == component.ImplementationType))
{
return;
}
_typemap.Remove(component.ServiceType);
}
public override void BeginAsyncProcess(IRemoraOperation operation, IComponentDefinition componentDefinition,
Action<bool> callback)
{
var category = GetCategory(componentDefinition);
var executionPropertyKey = GetStopwatchExecutionPropertyKey(category);
if (operation.ExecutionProperties.ContainsKey(executionPropertyKey))
{
Logger.WarnFormat(
"There may exists two tracer with the same category ({0}) in the same pipeline. Results may be inacurate.",
category);
}
var stopwatch = new Stopwatch();
stopwatch.Start();
operation.ExecutionProperties[executionPropertyKey] = stopwatch;
callback(true);
}
public override void BeginAsyncProcess(IRemoraOperation operation, IComponentDefinition componentDefinition,
Action<bool> callback)
{
if (operation == null) throw new ArgumentNullException("operation");
if (componentDefinition == null) throw new ArgumentNullException("componentDefinition");
if (callback == null) throw new ArgumentNullException("callback");
Contract.EndContractBlock();
switch (operation.Kind)
{
case RemoraOperationKind.Soap:
PlaySoapOperation(operation, componentDefinition);
break;
default:
throw new SoapPlayerException(
string.Format("Unable to playback operation {0} because it is not a soap operation.", operation));
}
callback(false);
}
/// <summary>
/// comparising method for components - find most preferable component in set
/// </summary>
/// <param name="a"> A. </param>
/// <param name="b"> The b. </param>
/// <returns> </returns>
/// <remarks>
/// </remarks>
protected internal int CompareComponents(IComponentDefinition a, IComponentDefinition b)
{
var ap = a.Priority;
var bp = b.Priority;
if (ap == -1)
{
ap = 10000;
}
if (bp == -1)
{
bp = 10000;
}
var result = ap.CompareTo(bp); // if priority not equal- less - first
if (0 == result)
{
result = -a.ContainerId.CompareTo(b.ContainerId); //otherwise last (by containerId) is in priority
}
return(result);
}
/// <summary>
/// creates new instance of component's object, IContainerBound.SetContainerContext called
/// </summary>
/// <param name="component"> The component. </param>
/// <param name="arguments"> аргументы для конструктора, если <c>null</c> , то будет использован конструктор по умолчанию </param>
/// <returns> </returns>
/// <remarks>
/// </remarks>
protected internal object CreateInstance(IComponentDefinition component, object[] arguments)
{
try {
object result = Activator.CreateInstance(component.ImplementationType,
BindingFlags.Instance | BindingFlags.CreateInstance | BindingFlags.Public |
BindingFlags.NonPublic,
null,
arguments, CultureInfo.InvariantCulture);
component.CreationCount++;
ProcessAttributedInjections(result);
ProcessParametersInjection(result, component);
ProcessExplicitInjections(component, result);
var context = new ContainerContext
{
Component = component,
Operation = ContainerOperation.AfterCreate,
Object = result,
};
ProcessExtensions(context);
var o = context.Object as IContainerBound;
if (o != null)
{
o.OnContainerCreateInstanceFinished();
}
return(context.Object);
}
catch (ContainerException ex) {
Log.Error("CreateInstance of" + component, ex);
throw;
}
catch (Exception ex) {
Log.Error("CreateInstance of" + component, ex);
throw new ContainerException("CreateInstance " + component, ex);
}
}
/// <summary>
/// Конвертирует строку с описанием сборки или типа в перечисление типов расширений
/// </summary>
/// <param name="extensionDescriptor"></param>
/// <returns></returns>
private IEnumerable <Type> GetExtensionTypes(string extensionDescriptor)
{
if (extensionDescriptor.IsLiteral(EscapingType.JsonLiteral))
{
IComponentDefinition pkg = Container.FindComponent(typeof(IBSharpBuilderExtension), extensionDescriptor + ".bsbext");
if (null != pkg)
{
yield return(pkg.ImplementationType);
}
else
{
throw new Exception("cannot find IBSharpBuilderExtension for " + extensionDescriptor + ".bsbext");
}
}
else
{
if (extensionDescriptor.Contains(","))
{
yield return(Type.GetType(extensionDescriptor));
}
else
{
Assembly assembly = Assembly.Load(extensionDescriptor);
foreach (Type t in assembly.GetTypes())
{
if (typeof(IBSharpBuilderExtension).IsAssignableFrom(t))
{
if (!t.IsAbstract)
{
yield return(t);
}
}
}
}
}
}
private void TraceOperation(IRemoraOperation operation, IComponentDefinition componentDefinition)
{
var category = GetCategory(componentDefinition);
if (!componentDefinition.Properties.ContainsKey("directory"))
{
Logger.WarnFormat(
"Unable to trace operation {0}: no directory has been provided. You must use the directory attribute in the component configuration.",
operation);
return;
}
var directoryPath = componentDefinition.Properties["directory"];
if (!Directory.Exists(directoryPath))
{
try
{
Directory.CreateDirectory(directoryPath);
}
catch (Exception ex)
{
Logger.WarnFormat(ex,
"Unable to trace operation {0}: the directory {1} does not exists and there has been an error when creating it.",
operation, directoryPath);
return;
}
}
var fileName = Path.Combine(directoryPath,
string.Format("{0}-{1}-{2}.xml",
DateTime.UtcNow.ToString("s").MakeValidFileName(),
category.MakeValidFileName(), operation.OperationId));
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: saving trace ({1}) in {2}...", operation, category, fileName);
var serializableOperation = new SerializableOperation(operation);
var stopwatchExecutionProperty = GetStopwatchExecutionPropertyKey(category);
if (operation.ExecutionProperties.ContainsKey(stopwatchExecutionProperty))
{
var stopwatch = (Stopwatch) operation.ExecutionProperties[stopwatchExecutionProperty];
stopwatch.Stop();
serializableOperation.ElapsedMilliseconds = stopwatch.ElapsedMilliseconds;
}
using (var writeStream = File.OpenWrite(fileName))
{
serializableOperation.Serialize(writeStream);
}
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: successfully traced ({1}) in {1}.", operation, category, fileName);
}
/// <summary>
/// Register new component
/// </summary>
/// <param name="component"> </param>
public void Register(IComponentDefinition component)
{
_typemap[component.ServiceType] = component.ImplementationType;
}
public void SetContainerContext(IContainer container, IComponentDefinition component) {
this.Container = container;
}
public override void BeginAsyncProcess(IRemoraOperation operation, IComponentDefinition componentDefinition,
Action<bool> callback)
{
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Preparing to send {0}...", operation);
if (operation.Request.Uri == null)
{
throw new UnknownDestinationException(
string.Format(
"Unable to send {0}: no destination uri is defined. Either use a rewrite attribute on the pipeline or create a custom IPipelineComponent that will determine the destination uri.",
operation));
}
if (!HttpSchemeRx.IsMatch(operation.Request.Uri.Scheme))
{
throw new InvalidDestinationUriException(
string.Format(
"The destination uri for {0} is not a valid uri: {1}. Remora supports only http(s) destinations.",
operation, operation.Request.Uri));
}
var webRequest = (HttpWebRequest) WebRequest.Create(operation.Request.Uri);
if ((operation.ExecutingPipeline != null)
&& (operation.ExecutingPipeline.Definition != null)
&& (!string.IsNullOrEmpty(operation.ExecutingPipeline.Definition.ClientCertificateFilePath))
)
{
ManageCertificate(webRequest, operation.ExecutingPipeline.Definition.ClientCertificateFilePath,
operation.ExecutingPipeline.Definition.ClientCertificatePassword);
}
webRequest.Method = operation.Request.Method ?? "POST";
SetHttpHeaders(operation, webRequest);
if (webRequest.Method.ToLowerInvariant() != "get")
{
WriteData(operation, webRequest);
}
else
{
webRequest.ContentLength = 0;
}
webRequest.BeginGetResponse((result) =>
{
webRequest = (HttpWebRequest) result.AsyncState;
try
{
var response = (HttpWebResponse) webRequest.EndGetResponse(result);
ReadResponse(operation, response, componentDefinition);
if (Logger.IsDebugEnabled)
Logger.DebugFormat(
"Successfully received response from {0} for {1}.",
webRequest.RequestUri, operation);
}
catch (WebException webEx)
{
if (webEx.Status == WebExceptionStatus.ProtocolError)
{
ReadResponse(operation, (HttpWebResponse) webEx.Response,
componentDefinition);
if (Logger.IsDebugEnabled)
Logger.DebugFormat(
"Successfully received response from {0} for {1}.",
webRequest.RequestUri, operation);
}
else
{
var message =
string.Format(
"There has been an error while sending {0} to {1}.",
operation, webRequest.RequestUri);
Logger.Error(message, webEx);
operation.Exception = new SendException(message, webEx);
}
}
catch (Exception ex)
{
var message =
string.Format(
"There has been an error while sending {0} to {1}.",
operation, webRequest.RequestUri);
Logger.Error(message, ex);
operation.Exception = new SendException(message, ex);
}
finally
{
callback(false);
}
}, webRequest);
}
private static string GetCategory(IComponentDefinition componentDefinition)
{
return componentDefinition.Properties.ContainsKey("category")
? componentDefinition.Properties["category"]
: "default";
}
public void SetContainerContext(IContainer container, IComponentDefinition component)
{
ContainerBoundTest = component.Parameters.GetValue <int>("cbt", -1);
ContainerBoundCalled = true;
}
/// <summary>
/// Регистрирует новый компонент в контейнере
/// </summary>
public void Register(IComponentDefinition component)
{
lock (this) {
#if PARANOID
if (component.ServiceType == typeof(IRoleResolver))
{
if (component.ImplementationType != typeof(DefaultRoleResolver))
{
throw new ParanoidException(ParanoidState.InvalidRoleResolver);
}
}
if (component.ServiceType == typeof(IPrincipalSource))
{
if (component.ImplementationType != typeof(DefaultPrincipalSource))
{
throw new ParanoidException(ParanoidState.InvalidPrincipalSource);
}
}
#endif
Log.Debug("Start register " + component, this);
// redirect logic for container extensions - they are processed on their own manner
// and container extensions don't trigger RegisterComponent event
if (component.Lifestyle == Lifestyle.ContainerExtension)
{
if (null == _extensions.FirstOrDefault(x => x.GetType() == component.ImplementationType))
{
RegisterExtension((IContainerExtension)Activator.CreateInstance(component.ImplementationType));
}
return;
}
// hook for extensions - RegisterComponent extensions can replace/update/Prepare component to be registered
// it can be used only BEFORE native registration due to index integrity
component =
ProcessExtensions(new ContainerContext
{
Operation = ContainerOperation.BeforeRegisterComponent, Component = component
}).Component;
//no need double registration
if (ComponentExists(component))
{
return;
}
component.ContainerId = CurrentComponentId++;
Components.Add(component);
if (!ByTypeCache.ContainsKey(component.ServiceType))
{
ByTypeCache[component.ServiceType] = new List <IComponentDefinition>();
}
ByTypeCache[component.ServiceType].Add(component);
ByTypeCache[component.ServiceType].Sort(CompareComponents);
if (component.Name.IsNotEmpty())
{
if (!ByNameCache.ContainsKey(component.Name))
{
ByNameCache[component.Name] = new List <IComponentDefinition>();
}
ByNameCache[component.Name].Add(component);
ByNameCache[component.Name].Sort(CompareComponents);
}
ProcessExtensions(new ContainerContext
{
Operation = ContainerOperation.AfterRegisterComponent, Component = component
});
Log.Debug("Registered " + component, this);
}
}
private bool MockMatch(SerializableOperation serializableOperation, XDocument requestDoc,
IComponentDefinition componentDefinition)
{
var refDoc = XDocument.Parse(serializableOperation.Request.Content).Normalize();
var refBody = _soapTransformer.GetBody(refDoc);
var currentBody = _soapTransformer.GetBody(requestDoc);
return XNode.DeepEquals(refBody, currentBody);
}
/// <summary>
/// called on object after creation in IoC with current component context
/// object can perform container bound logic here
/// </summary>
/// <param name="container"> The container. </param>
/// <param name="component"> The component. </param>
/// <remarks>
/// </remarks>
public override void SetContainerContext(IContainer container, IComponentDefinition component) {
base.SetContainerContext(container, component);
container.RegisterExtension(new LogManagerContainerExtension(this));
}
/// <summary>
/// called on object after creation in IoC with current component context
/// object can perform container bound logic here
/// </summary>
/// <param name="container"> The container. </param>
/// <param name="component"> The component. </param>
/// <remarks>
/// </remarks>
public override void SetContainerContext(IContainer container, IComponentDefinition component)
{
base.SetContainerContext(container, component);
container.RegisterExtension(new LogManagerContainerExtension(this));
}
public PipelineDefinition()
{
ComponentDefinitions = new IComponentDefinition[0];
Properties = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
}
protected virtual void ReadResponse(IRemoraOperation operation, HttpWebResponse response,
IComponentDefinition componentDefinition)
{
operation.Response.StatusCode = (int) response.StatusCode;
operation.Response.Uri = response.ResponseUri;
foreach (var header in response.Headers.AllKeys)
{
operation.Response.HttpHeaders.Add(header, response.Headers[header]);
}
using (var stream = response.GetResponseStream())
{
operation.Response.Data = stream.ReadFully(_config.MaxMessageSize);
}
ReadEncoding(operation, response, componentDefinition);
}
private void EndRecordSoapOperation(IRemoraOperation operation, IComponentDefinition componentDefinition)
{
if (!operation.ExecutionProperties.ContainsKey(SoapActionKey))
return;
var soapActionName = (string) operation.ExecutionProperties[SoapActionKey];
if (!componentDefinition.Properties.ContainsKey("directory"))
{
Logger.WarnFormat(
"Unable to record operation {0}: no directory has been provided. You must use the directory attribute in the component configuration.",
operation);
return;
}
var directoryPath = componentDefinition.Properties["directory"];
if (!Directory.Exists(directoryPath))
{
try
{
Directory.CreateDirectory(directoryPath);
}
catch (Exception ex)
{
Logger.WarnFormat(ex,
"Unable to record operation {0}: the directory {1} does not exists and there has been an error when creating it.",
operation, directoryPath);
return;
}
}
var randomAppendToFileName = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
var fileName = Path.Combine(directoryPath,
string.Format("{0}.{1}.xml", soapActionName.MakeValidFileName(),
randomAppendToFileName));
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: saving record for {1} in {2}...", operation, soapActionName, fileName);
var serializableOperation = new SerializableOperation(operation);
try
{
using (var writeStream = File.OpenWrite(fileName))
{
serializableOperation.Serialize(writeStream);
}
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: successfully recorded in {1}.", operation, fileName);
}
catch (Exception ex)
{
Logger.WarnFormat(ex, "There has been an error while saving record file {0} for operation {1}.",
fileName, operation);
}
}
public void Configure(IComponentDefinition component, AttributeSet attributes)
{
if (ReferenceEquals(component, null))
{
return;
}
var validationErrros = _attributeMatrix.Validate <IComponentDefinition>(attributes);
if (validationErrros != null)
{
var message = "There are invalid attributes on component of type " + component.GetType().DisplayName();
if (attributes.IsComponent != null && string.IsNullOrEmpty(attributes.IsComponent.Name))
{
message += " called '" + attributes.IsComponent.Name + "'.";
}
foreach (var error in validationErrros)
{
message += Environment.NewLine + error;
}
throw new ComponentBuilderException(message);
}
if (!ReferenceEquals(attributes.IsComponent, null))
{
component.Name(attributes.IsComponent.Name);
}
if (!ReferenceEquals(attributes.DeployCsss, null))
{
foreach (var css in attributes.DeployCsss.OrderBy(c => c.Order))
{
component.DeployCss(css.CssSelector, css.CssStyle);
}
}
if (!ReferenceEquals(attributes.DeployFunctions, null))
{
foreach (var function in attributes.DeployFunctions)
{
component.DeployFunction(
function.ReturnType,
function.FunctionName,
function.Parameters,
function.Body,
function.IsPublic);
}
}
if (!ReferenceEquals(attributes.NeedsDatas, null))
{
foreach (var dataNeed in attributes.NeedsDatas)
{
if (!string.IsNullOrEmpty(dataNeed.DataProviderName))
{
component.DataProvider(dataNeed.DataProviderName);
}
if (dataNeed.DataType != null)
{
component.BindTo(dataNeed.DataType, dataNeed.Scope);
}
}
}
if (!ReferenceEquals(attributes.PartOf, null))
{
component.PartOf(attributes.PartOf.PackageName);
}
if (!ReferenceEquals(attributes.DeployedAs, null))
{
component
.DeployIn(attributes.DeployedAs.ModuleName)
.AssetDeployment(attributes.DeployedAs.Deployment);
}
if (!ReferenceEquals(attributes.NeedsComponents, null))
{
foreach (var need in attributes.NeedsComponents)
{
component.NeedsComponent(need.ComponentName);
}
}
if (!ReferenceEquals(attributes.RenderHtmls, null))
{
foreach (var html in attributes.RenderHtmls.OrderBy(h => h.Order))
{
component.Render(html.TextName, html.Html);
}
}
}
public void SetContainerContext(IContainer container, IComponentDefinition component)
{
}
private void PlaySoapOperation(IRemoraOperation operation, IComponentDefinition componentDefinition)
{
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Trying to reply with a mock for {0}...", operation);
if (!componentDefinition.Properties.ContainsKey("directory"))
{
throw new SoapPlayerException(
"Unable to playback because no directory has been provided. Please specify a source directory in the component definition.");
}
var directoryPath = componentDefinition.Properties["directory"];
if (!operation.Request.HttpHeaders.ContainsKey("SOAPAction"))
{
throw new SoapPlayerException(
string.Format("Unable to playback operation {0} because it doesn't have a SOAPAction header.",
operation));
}
var soapAction = operation.Request.HttpHeaders["SOAPAction"];
IEnumerable<string> candidateFiles;
try
{
candidateFiles = Directory.EnumerateFiles(directoryPath, soapAction.MakeValidFileName() + ".*");
}
catch (Exception ex)
{
throw new SoapPlayerException(
string.Format("There has been an error while enumerating files in {0}", directoryPath), ex);
}
var requestDoc = _soapTransformer.LoadSoapDocument(operation.Request).Normalize();
foreach (var candidateFile in candidateFiles)
{
try
{
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Opening file {0}...", candidateFile);
SerializableOperation serializableOperation;
using (var readStream = File.OpenRead(candidateFile))
{
serializableOperation = SerializableOperation.Deserialize(readStream);
if (MockMatch(serializableOperation, requestDoc, componentDefinition))
{
if (Logger.IsInfoEnabled)
Logger.InfoFormat("Found appropriate mock for {0}: {1}.", operation, candidateFile);
operation.Response.ContentEncoding =
Encoding.GetEncoding(serializableOperation.Response.ContentEncoding);
foreach (var header in serializableOperation.Response.Headers)
{
operation.Response.HttpHeaders.Add(header.Name, header.Value);
}
operation.Response.StatusCode = serializableOperation.Response.StatusCode;
operation.Response.Data = serializableOperation.Response.GetData();
return;
}
}
}
catch (Exception ex)
{
throw new SoapPlayerException(string.Format("Error while opening mock file {0}.", candidateFile), ex);
}
}
throw new SoapPlayerException(
string.Format("Unable to find appropriate mock for operation {0} in directory {1}.", operation,
directoryPath));
}
/// <summary>
/// Вызывается в момент создания экземпляра после применения стандартных инъекций.
/// </summary>
/// <param name="container"> Контейнер, создающий объект </param>
/// <param name="component"> Компонент, описывающий объект </param>
/// <remarks>
/// Стандартная реализация контейнера <see href="Qorpent.IoC~Qorpent.IoC.Container.html" /> автоматически
/// выполняет инъекции зависимоостей на основе параметров <see cref="IComponentDefinition.Parameters" /> и на освное <see
/// cref="InjectAttribute" />,
/// данный метод в базовой реализации устанавливает свойства <see cref="SourceContainer" /> и <see cref="Component" />,
/// при перекрытии вы можете расширить логику собственным кодом связывания экземпляра с создавшим его контейнером и компонентом
/// </remarks>
public virtual void SetContainerContext(IContainer container, IComponentDefinition component)
{
SourceContainer = container;
Component = component;
}
protected virtual void ReadEncoding(IRemoraOperation operation, HttpWebResponse response,
IComponentDefinition componentDefinition)
{
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Determining encoding for response from {0} for operation {1}...",
response.ResponseUri, operation);
if ((operation.ExecutingPipeline != null)
&& (operation.ExecutingPipeline.Definition != null)
&& (operation.ExecutingPipeline.Definition.Properties.ContainsKey("forceResponseEncoding"))
)
{
try
{
operation.Response.ContentEncoding =
Encoding.GetEncoding(operation.ExecutingPipeline.Definition.Properties["forceResponseEncoding"]);
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: encoding forced to {1}.", operation,
operation.Response.ContentEncoding);
}
catch (ArgumentException ex)
{
Logger.ErrorFormat(ex,
"There has been an error while loading encoding defined in forceResponseEncoding property: {0}",
operation.ExecutingPipeline.Definition.Properties["forceResponseEncoding"]);
throw;
}
}
else
{
var encoding = Encoding.UTF8; // default;
if (!string.IsNullOrEmpty(response.CharacterSet))
{
try
{
encoding = Encoding.GetEncoding(response.CharacterSet);
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: loaded encoding {1} from character set: {2}", operation,
encoding.EncodingName, response.CharacterSet);
}
catch (ArgumentException ex)
{
Logger.WarnFormat(ex, "Operation {0}: unable to load a proper encoding for character set {1}",
operation, response.CharacterSet);
}
}
else
{
if (Logger.IsDebugEnabled)
Logger.DebugFormat("Operation {0}: using default encoding {0}", operation, encoding.EncodingName);
}
operation.Response.ContentEncoding = encoding;
}
}
