/// <summary>
/// For webapplications always
/// <ul>
/// <li>convert IResources using the current context.</li>
/// <li>use "web" as default resource protocol</li>
/// <li>use <see cref="HybridContextStorage"/> as default threading storage</li>
/// </ul>
/// </summary>
static WebSupportModule()
{
s_log = LogManager.GetLogger(typeof(WebSupportModule));
#if NET_2_0
// required to enable accessing HttpContext.Request during IHttpModule.Init() in integrated mode
ContextHideRequestResponse = null;
try
{
fiHideRequestResponse = typeof(HttpContext).GetField("HideRequestResponse", BindingFlags.Instance | BindingFlags.NonPublic);
// fiHideRequestResponse.SetValue(HttpContext.Current, false);
ContextHideRequestResponse = (fiHideRequestResponse != null)?new SafeField(fiHideRequestResponse):null;
}
catch (SecurityException sec)
{
s_log.Warn(string.Format("failed reflecting field HttpContext.HideRequestResponse due to security restrictions {0}", sec));
}
#endif
// register additional resource handler
ResourceHandlerRegistry.RegisterResourceHandler(WebUtils.DEFAULT_RESOURCE_PROTOCOL, typeof(WebResource));
// replace default IResource converter
TypeConverterRegistry.RegisterConverter(typeof(IResource),
new ResourceConverter(
new ConfigurableResourceLoader(WebUtils.DEFAULT_RESOURCE_PROTOCOL)));
// default to hybrid thread storage implementation
LogicalThreadContext.SetStorage(new HybridContextStorage());
s_log.Debug("Set default resource protocol to 'web' and installed HttpContext-aware HybridContextStorage");
}
/// <summary>
/// Registers custom IResource implementations. The supplied
/// <paramref name="factory"/> is not used since IResourse implementations
/// are registered with a global <see cref="Spring.Core.IO.ResourceHandlerRegistry"/>
/// </summary>
/// <param name="factory">
/// The object factory.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public override void PostProcessObjectFactory(
IConfigurableListableObjectFactory factory)
{
if (resourceHandlers != null)
{
foreach (DictionaryEntry entry in resourceHandlers)
{
string protocolName = entry.Key.ToString();
Type type = ResolveRequiredType(entry.Value, "value", "custom IResource implementation");
ResourceHandlerRegistry.RegisterResourceHandler(protocolName, type);
}
}
}
/// <summary>
/// Registers resource handlers that are specified in
/// the <c>resources</c> config section with the <see cref="ResourceHandlerRegistry"/>.
/// </summary>
/// <param name="parent">
/// The configuration settings in a corresponding parent
/// configuration section. Ignored.
/// </param>
/// <param name="configContext">
/// The configuration context when called from the ASP.NET
/// configuration system. Otherwise, this parameter is reserved and
/// is <see langword="null"/>.
/// </param>
/// <param name="section">
/// The <see cref="System.Xml.XmlNode"/> for the section.
/// </param>
/// <returns>
/// This method always returns <c>null</c>, because resource handlers are registered
/// as a sideffect of its execution and there is no need to return anything.
/// </returns>
public object Create(object parent, object configContext, XmlNode section)
{
if (section != null)
{
XmlNodeList resourceHandlers = ((XmlElement)section).GetElementsByTagName(HandlerElement);
foreach (XmlElement handler in resourceHandlers)
{
string protocolName = GetRequiredAttributeValue(handler, ProtocolAttribute, section);
string typeName = GetRequiredAttributeValue(handler, TypeAttribute, section);
ResourceHandlerRegistry.RegisterResourceHandler(protocolName, typeName);
}
}
return(null);
}
private void CreateConfigurerAndTestNewProtcol(IDictionary resourceHandlers)
{
ResourceHandlerConfigurer resourceHandlerConfiguer = new ResourceHandlerConfigurer();
resourceHandlerConfiguer.ResourceHandlers = resourceHandlers;
resourceHandlerConfiguer.Order = 1;
resourceHandlerConfiguer.PostProcessObjectFactory((IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory)));
//todo investigate mocking the typeregistry, for now ask the actual one for information.
Assert.IsTrue(ResourceHandlerRegistry.IsHandlerRegistered("httpsss"),
"ResourceHandlerConfigurer did not register a protocol handler with the ResourceHandlerRegistry");
Assert.IsTrue(ResourceHandlerRegistry.IsHandlerRegistered("httpsss"), "Custom IResource not registered.");
Assert.AreEqual(1, resourceHandlerConfiguer.Order);
}
public ResourceRequestHandler(ResourceHandlerRegistry <CefResourceHandler> resourceHandlerRegistry, BridgeObjectRegistry bridgeObjectRegistry, IResourceRequestHandler?resourceRequestHandler)
{
this.logic = new ResourceRequestHandlerLogic <CefRequest, CefResponse, CefResourceHandler>(CefRequestAdapter.Instance, CefResponseAdapter.Instance, resourceHandlerRegistry, resourceRequestHandler);
this.bridgeObjectRegistry = bridgeObjectRegistry;
}
public CefResourceRequestHandler(ResourceHandlerRegistry <IResourceHandler> resourceHandlerRegistry, IResourceRequestHandler resourceRequestHandler)
{
this.logic = new ResourceRequestHandlerLogic <IRequest, IResponse, IResourceHandler>(CefRequestAdapter.Instance, CefResponseAdapter.Instance, resourceHandlerRegistry, resourceRequestHandler);
}
public ResourceRequestHandlerFactoryLogic(IRequestAdapter <TRequest> requestAdapter, TResourceRequestHandler handler, ResourceHandlerRegistry <TResourceHandler> registry)
{
this.handler = handler;
this.registry = registry;
this.requestAdapter = requestAdapter;
}
void Application_Start(object sender, EventArgs e)
{
log4net.Config.XmlConfigurator.Configure();
ResourceHandlerRegistry.RegisterResourceHandler("web", typeof(WebResource));
}
public SoundNotification(ResourceHandlerRegistry <IResourceHandler> registry)
{
this.registry = registry;
}
/// <summary>
/// Handles an HTTP request
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <IResponse> HandleRequest(IRequest request)
{
try
{
// add access control header first
request.Response.WithHeader("Access-Control-Allow-Origin", "*");
Logger.Debug("Handling request to {0} {1}. Parsing resource descriptor from path...", request.Method, request.Path);
// get the resource descriptor
var resourceDescriptor = ResourceDescriptorHelper.GetResourceDescriptor(request.Path);
if (resourceDescriptor == null)
{
return(request.Response.WithStatus(HttpStatusCode.NotFound));
}
Logger.Debug("Parsing resource descriptor from path...");
// if the resource type is not valid for this service, it's an unrecognized route
if (!ResourceHandlerRegistry.IsSupported(resourceDescriptor.RootType))
{
return(request.Response.WithStatus(HttpStatusCode.NotFound));
}
Logger.Debug("Successfully parsed resource descriptor for type {0} from path. Creating resource handler...",
resourceDescriptor.Type.FullName);
// get handler for resource type
var resourceHandler = ResourceHandlerRegistry.Get(resourceDescriptor.Type);
if (resourceHandler == null)
{
Logger.Error("Failed to created resource handler for type '{0}' even though its a supported type for this API.",
resourceDescriptor.Type);
return(request.Response.WithStatus(HttpStatusCode.InternalServerError));
}
Logger.Debug("Successfully created resource handler of type {0} for resource type {1}. Processing {2} request...",
resourceHandler.GetType().FullName,
resourceDescriptor.Type.Name,
request.Method);
// get or delete do not have a body - just use the route
if (HttpMethods.IsGet(request.Method))
{
await HandleGet(request, resourceHandler, resourceDescriptor);
}
else if (HttpMethods.IsDelete(request.Method))
{
await HandleDelete(request, resourceHandler, resourceDescriptor);
}
else
{
// read body of request as JSON
var resource = await ResourceSerializer.Deserialize(await request.ReadBodyAsText());
// ensure that the provided resource ID matches the ID from the route
// in the case of a POST, this should be null
if (resource.Id != null && resource.Id != resourceDescriptor.Url)
{
return(request.Response
.WithStatus(HttpStatusCode.BadRequest)
.WithPlainTextBody(
$"Resource ID does not match ID in payload ('{resourceDescriptor.Id}' != '{resource.Id}'"));
}
// create or update based on the POST vs PUT
// if we have an ID for a POST or no ID for a PUT, the method is not supported for the route
if (HttpMethods.IsPost(request.Method) && resourceDescriptor.Id == null)
{
await HandlePost(request, resourceHandler, resourceDescriptor, resource);
}
else if (HttpMethods.IsPut(request.Method) && resourceDescriptor.Id != null)
{
await HandlePut(request, resourceHandler, resourceDescriptor, resource);
}
else
{
return(request.Response.WithStatus(HttpStatusCode.MethodNotAllowed));
}
}
return(request.Response);
}
catch (Exception e)
{
return(request.Response.WithStatus(HttpStatusCode.InternalServerError).WithPlainTextBody(e.ToString()));
}
}
public ResourceRequestHandlerFactory(IResourceRequestHandler?resourceRequestHandler, ResourceHandlerRegistry <CefResourceHandler> resourceHandlerRegistry, BridgeObjectRegistry bridgeObjectRegistry)
{
this.logic = new ResourceRequestHandlerFactoryLogic <ResourceRequestHandler, CefResourceHandler, CefRequest>(CefRequestAdapter.Instance, new ResourceRequestHandler(resourceHandlerRegistry, bridgeObjectRegistry, resourceRequestHandler), resourceHandlerRegistry);
}
public CefResourceRequestHandlerFactory(IResourceRequestHandler resourceRequestHandler, ResourceHandlerRegistry <IResourceHandler> registry)
{
this.logic = new ResourceRequestHandlerFactoryLogic <CefResourceRequestHandler, IResourceHandler, IRequest>(CefRequestAdapter.Instance, new CefResourceRequestHandler(registry, resourceRequestHandler), registry);
}