public TaskEndPointHandler(ITaskRetriever taskRetriever, ITaskListRetriever taskListRetriever, IAmACommandProcessor commandProcessor, ICommunicationContext communicationContext)
{
this.taskRetriever = taskRetriever;
this.taskListRetriever = taskListRetriever;
this.commandProcessor = commandProcessor;
this.communicationContext = communicationContext;
}
public override void ProcessRequest(ICommunicationContext ctx)
{
var serviceName = GetServiceName(ctx);
var instanceId = GetInstanceID(ctx);
var bookmark = GetBookmark(ctx);
var postDataListID = GetDataListID(ctx);
var workspaceID = GetWorkspaceID(ctx);
var requestTO = new WebRequestTO();
var xml = GetPostData(ctx, postDataListID);
if(!String.IsNullOrEmpty(xml))
{
requestTO.RawRequestPayload = xml;
}
requestTO.ServiceName = serviceName;
requestTO.InstanceID = instanceId;
requestTO.Bookmark = bookmark;
requestTO.WebServerUrl = ctx.Request.Uri.ToString();
requestTO.Dev2WebServer = String.Format("{0}://{1}", ctx.Request.Uri.Scheme, ctx.Request.Uri.Authority);
// Execute in its own thread to give proper context ;)
Thread.CurrentPrincipal = ctx.Request.User;
var responseWriter = CreateForm(requestTO, serviceName, workspaceID, ctx.FetchHeaders(), PublicFormats, ctx.Request.User);
ctx.Send(responseWriter);
}
ICodec ResolveCodec(ICommunicationContext context)
{
var codecInstance = context.Response.Entity.Codec;
if (codecInstance != null)
{
Log.WriteDebug("Codec instance with type {0} has already been defined.",
codecInstance.GetType().Name);
}
else
{
context.Response.Entity.Codec =
codecInstance =
DependencyManager.GetService(context.PipelineData.ResponseCodec.CodecType) as ICodec;
}
if (codecInstance == null)
throw new CodecNotFoundException(
$"Codec {context.PipelineData.ResponseCodec.CodecType} couldn't be initialized.");
Log.WriteDebug("Codec {0} selected.", codecInstance.GetType().Name);
if (context.PipelineData.ResponseCodec?.Configuration != null)
codecInstance.Configuration = context.PipelineData.ResponseCodec.Configuration;
return codecInstance;
}
public void SetupCommunicationContext(ICommunicationContext context)
{
Log.WriteDebug("Adding communication context data");
Resolver.AddDependencyInstance<ICommunicationContext>(context, DependencyLifetime.PerRequest);
Resolver.AddDependencyInstance<IRequest>(context.Request, DependencyLifetime.PerRequest);
Resolver.AddDependencyInstance<IResponse>(context.Response, DependencyLifetime.PerRequest);
}
async Task<PipelineContinuation> WriteResponseBuffered(ICommunicationContext context)
{
if (context.Response.Entity.Instance == null)
{
Log.WriteDebug("There was no response entity, not rendering.");
await SendEmptyResponse(context);
return PipelineContinuation.Continue;
}
var codecInstance = ResolveCodec(context);
var writer = CreateWriter(codecInstance);
using (Log.Operation(this, "Generating response entity."))
{
await writer(
context.Response.Entity.Instance,
context.Response.Entity,
context.Request.CodecParameters.ToArray());
await PadErrorMessageForIE(context);
if (context.Response.Entity.Stream.CanSeek)
context.Response.Entity.ContentLength = context.Response.Entity.Stream.Length;
}
return PipelineContinuation.Continue;
}
public override PipelineContinuation ExecuteBefore(ICommunicationContext context)
{
if ((InRoles == null || InRoles.Length == 0) && (Users == null || Users.Length == 0))
return PipelineContinuation.Continue;
if (base.ExecuteBefore(context) == PipelineContinuation.Continue)
{
try
{
if (InRoles != null)
foreach (string role in InRoles)
if (context.User.IsInRole(role))
return PipelineContinuation.Continue;
if (Users != null)
foreach (string user in Users)
if (context.User.Identity.Name == user)
return PipelineContinuation.Continue;
}
catch
{
// todo: decide where to log this error.
}
}
context.OperationResult = new OperationResult.Unauthorized();
return PipelineContinuation.RenderNow;
}
public PipelineContinuation StripResponseElement(ICommunicationContext context)
{
var passedApiUrl
= (string)context.PipelineData["ApiUrl"];
if (string.IsNullOrEmpty(passedApiUrl))
return PipelineContinuation.Continue;
var xmlDocument
= (XmlDocument)context.PipelineData["ApiXmlResponse"];
// read and remove response header to get result
var responseElement = xmlDocument.SelectSingleNode("/response");
var responseStatusAttribute = responseElement.Attributes["status"];
var innerXml = responseElement.InnerXml;
var stringReader = new StringReader(innerXml);
// get the type
Type generatedType = responseStatusAttribute.InnerText == "ok"
? _typeGenerator.GenerateType(passedApiUrl)
: typeof(Error);
var serializer = new XmlSerializer(generatedType);
object deserialized = serializer.Deserialize(stringReader);
if (responseStatusAttribute.InnerText == "ok")
context.OperationResult = new OperationResult.OK(deserialized);
else
context.OperationResult = new OperationResult.BadRequest { ResponseResource = deserialized };
return PipelineContinuation.Continue;
}
static string GenerateEtag(ICommunicationContext context, string partialEtag)
{
// we should only include components for the headers present in the Vary header
// can't do it now as Vary is not set by OR, bug to fix in 2.1
return Etag.StrongEtag(partialEtag);
}
PipelineContinuation PostExecution(ICommunicationContext context)
{
if (context.OperationResult.ResponseResource == null)
return PipelineContinuation.Continue;
var registration = _config.ResourceRegistrations.SingleOrDefault(_ => _.ResourceKey == context.PipelineData.ResourceKey);
if (registration == null || registration.Properties.ContainsKey(Keys.LAST_MODIFIED) == false)
return PipelineContinuation.Continue;
var now = ServerClock.UtcNow();
var mapper = (Func<object, DateTimeOffset?>)registration.Properties[Keys.LAST_MODIFIED];
var lastModified = mapper(context.OperationResult.ResponseResource);
if (lastModified > now)
lastModified = now;
var ifModifiedSinceHeader = context.Request.Headers["if-modified-since"];
if (NoIncompatiblePreconditions(context) &&
ifModifiedSinceHeader != null)
{
DateTimeOffset modifiedSince;
var validIfModifiedSince = DateTimeOffset.TryParse(
ifModifiedSinceHeader,
out modifiedSince);
if (!validIfModifiedSince)
_log.WriteWarning("Invalid If-Modified-Since value, not RFC1123 compliant: {0}", ifModifiedSinceHeader);
else if (lastModified <= modifiedSince)
context.PipelineData[Keys.REWRITE_TO_304] = true;
}
if (lastModified != null)
WriteLastModifiedHeader(context, lastModified);
return PipelineContinuation.Continue;
}
public override void ProcessRequest(ICommunicationContext ctx)
{
var postDataListID = GetDataListID(ctx);
if(postDataListID != null)
{
new WebPostRequestHandler().ProcessRequest(ctx);
return;
}
var serviceName = GetServiceName(ctx);
var workspaceID = GetWorkspaceID(ctx);
var requestTO = new WebRequestTO { ServiceName = serviceName, WebServerUrl = ctx.Request.Uri.ToString(), Dev2WebServer = String.Format("{0}://{1}", ctx.Request.Uri.Scheme, ctx.Request.Uri.Authority) };
var data = GetPostData(ctx);
if(!String.IsNullOrEmpty(data))
{
requestTO.RawRequestPayload = data;
}
var variables = ctx.Request.BoundVariables;
if(variables != null)
{
foreach(string key in variables)
{
requestTO.Variables.Add(key, variables[key]);
}
}
// Execute in its own thread to give proper context ;)
Thread.CurrentPrincipal = ctx.Request.User;
var responseWriter = CreateForm(requestTO, serviceName, workspaceID, ctx.FetchHeaders());
ctx.Send(responseWriter);
}
public PipelineContinuation FindResponseCodec(ICommunicationContext context)
{
if (context.Response.Entity.Instance == null || context.PipelineData.ResponseCodec != null)
{
LogNoResponseEntity();
return PipelineContinuation.Continue;
}
string acceptHeader = context.Request.Headers[HEADER_ACCEPT];
IEnumerable<MediaType> acceptedContentTypes =
MediaType.Parse(string.IsNullOrEmpty(acceptHeader) ? "*/*" : acceptHeader);
IType responseEntityType = _typeSystem.FromInstance(context.Response.Entity.Instance);
IEnumerable<CodecRegistration> sortedCodecs = _codecs.FindMediaTypeWriter(responseEntityType,
acceptedContentTypes);
int codecsCount = sortedCodecs.Count();
CodecRegistration negotiatedCodec = sortedCodecs.FirstOrDefault();
if (negotiatedCodec != null)
{
LogCodecSelected(responseEntityType, negotiatedCodec, codecsCount);
context.Response.Entity.ContentType = negotiatedCodec.MediaType.WithoutQuality();
context.PipelineData.ResponseCodec = negotiatedCodec;
}
else
{
context.OperationResult = ResponseEntityHasNoCodec(acceptHeader, responseEntityType);
return PipelineContinuation.RenderNow;
}
return PipelineContinuation.Continue;
}
public PageHandler(IPageRepository pageRepository, ICommunicationContext context, IUriResolver uriResolver, IMarkdown markdown)
{
this.pageRepository = pageRepository;
this.context = context;
this.uriResolver = uriResolver;
this.markdown = markdown;
}
protected override void OnExecute(ICommunicationContext context)
{
context.Request.Entity.Errors.AddRange(this.Errors);
context.Response.Entity.Errors.AddRange(context.Request.Entity.Errors);
base.OnExecute(context);
}
private PipelineContinuation ResolveResource(ICommunicationContext context)
{
if (context.PipelineData.SelectedResource == null)
{
var uriToMath = context.GetRequestUriRelativeToRoot();
var uriMatch = this.uriRepository.Match(uriToMath);
if (uriMatch != null)
{
context.PipelineData.SelectedResource = uriMatch;
context.PipelineData.ResourceKey = uriMatch.ResourceKey;
context.Request.UriName = uriMatch.UriName;
}
else
{
context.OperationResult = this.CreateNotFound(context);
return PipelineContinuation.RenderNow;
}
}
else
{
this.Log.WriteInfo(
"Not resolving any resource as a resource with key {0} has already been selected.".With(
context.PipelineData.SelectedResource.ResourceKey));
}
return PipelineContinuation.Continue;
}
private PipelineContinuation InitializeContainer(ICommunicationContext arg)
{
var container = new TinyIoCAdapter(new TinyIoCContainer());
//HACK! For now dependencies may need to be in both containers to allow resolution
container.Register<IHandleRequests<AddTaskCommand>, AddTaskCommandHandler>().AsMultiInstance();
container.Register<ITaskListRetriever, TaskListRetriever>().AsMultiInstance();
container.Register<ITasksDAO, TasksDAO>().AsMultiInstance();
var logger = LogManager.GetLogger("TaskList");
container.Register<ILog, ILog>(logger);
container.Register<IAmARequestContextFactory, InMemoryRequestContextFactory>().AsMultiInstance();
MessageStoreFactory.InstallRavenDbMessageStore(container);
container.Register<IAmAMessageStore<Message>, RavenMessageStore>().AsSingleton();
container.Register<IAmAMessagingGateway, RMQMessagingGateway>().AsSingleton();
container.Register<Policy>(CommandProcessor.RETRYPOLICY, GetRetryPolicy());
container.Register<Policy>(CommandProcessor.CIRCUITBREAKER, GetCircuitBreakerPolicy());
var commandProcessor = new CommandProcessorFactory(container).Create();
container.Register<IAmACommandProcessor, IAmACommandProcessor>(commandProcessor);
resolver.AddDependencyInstance<IAdaptAnInversionOfControlContainer>(container, DependencyLifetime.Singleton);
resolver.AddDependencyInstance<IAmARequestContextFactory>(new InMemoryRequestContextFactory(), DependencyLifetime.PerRequest);
resolver.AddDependencyInstance<IAmACommandProcessor>(commandProcessor, DependencyLifetime.Singleton);
resolver.AddDependency<ITaskRetriever, TaskRetriever>(DependencyLifetime.Singleton);
resolver.AddDependency<ITaskListRetriever, TaskListRetriever>(DependencyLifetime.Singleton);
return PipelineContinuation.Continue;
}
public static Control BuildIssueQueryTemplate(this IMasonBuilderContext masonContext, ICommunicationContext communicationContext)
{
string issueQueryUrl = communicationContext.ApplicationBaseUri.AbsoluteUri + "/" + UrlPaths.IssueQuery;
Control issueQueryTemplate = masonContext.NewLinkTemplate(RelTypes.IssueQuery, issueQueryUrl, "Search for issues", "This is a simple search that do not check attachments.");
if (!masonContext.PreferMinimalResponse)
{
issueQueryTemplate.schema = new
{
properties = new
{
text = new
{
description = "Substring search for text in title and description",
type = "string"
},
severity = new
{
description = "Issue severity (exact value, 1..5)",
type = "string"
},
pid = new
{
description = "Project ID",
type = "string"
}
}
};
// FIXME - schema
//issueQueryTemplate.AddHrefTemplateParameter(new HrefTemplateParameter("text", description: "Substring search for text in title and description"));
//issueQueryTemplate.AddHrefTemplateParameter(new HrefTemplateParameter("severity", description: "Issue severity (exact value, 1..5)"));
//issueQueryTemplate.AddHrefTemplateParameter(new HrefTemplateParameter("pid", description: "Project ID"));
}
return issueQueryTemplate;
}
public PipelineContinuation ProcessDecorators(ICommunicationContext context)
{
Uri currentUri = context.Request.Uri;
IList<DecoratorPointer> decorators = CreateDecorators();
/* Whenever we execute the decorators, each decorator gets a say in matching a url.
* Whenever a decorator fails, it is ignored.
* Whenever a decorator succeeds, it is marked as such so that its Apply() method gets called
* Whenever a decorator that succeeded has changed the url, we reprocess all the decorators that failed before with the new url.
* */
for (int i = 0; i < decorators.Count; i++)
{
DecoratorPointer decorator = decorators[i];
Uri processedUri;
if (!decorator.Successful
&& decorator.Decorator.Parse(currentUri, out processedUri))
{
decorator.Successful = true;
if (currentUri != processedUri && processedUri != null)
{
currentUri = processedUri;
i = -1;
continue;
}
}
}
foreach (var decorator in decorators)
{
if (decorator.Successful)
decorator.Decorator.Apply();
}
context.Request.Uri = currentUri;
return PipelineContinuation.Continue;
}
public WebFormsDefaultHandler(ICommunicationContext context, ITypeSystem typeSystem, IDependencyResolver resolver)
{
_context = context;
_typeSystem = typeSystem;
_resolver = resolver;
_pageType = typeSystem.FromClr<Page>();
}
public PipelineContinuation ExecuteBefore(ICommunicationContext context)
{
if ((this.InRoles == null || this.InRoles.Length == 0) && (this.Users == null || this.Users.Length == 0))
{
return PipelineContinuation.Continue;
}
if (this.ExecuteBefore(context) == PipelineContinuation.Continue)
{
if (this.InRoles != null)
{
if (this.InRoles.Any(role => context.User.IsInRole(role)))
{
return PipelineContinuation.Continue;
}
}
if (this.Users != null)
{
if (this.Users.Any(user => context.User.Identity.Name == user))
{
return PipelineContinuation.Continue;
}
}
}
context.OperationResult = new OperationResult.Unauthorized();
return PipelineContinuation.RenderNow;
}
public void Execute(ICommunicationContext context)
{
context.Response.StatusCode = StatusCode;
if (RedirectLocation != null)
context.Response.Headers["Location"] = RedirectLocation.AbsoluteUri;
OnExecute(context);
}
public override async Task Invoke(ICommunicationContext env)
{
env.PipelineData.PipelineStage.CurrentState
= await Contributor(env);
if (env.PipelineData.PipelineStage.CurrentState == PipelineContinuation.Abort)
throw new PipelineAbortedException();
await Next.Invoke(env);
}
private PipelineContinuation WriteBookmark(
ICommunicationContext arg)
{
var uri = Database.Documents.CreateUri();
arg.Response.Headers["Link"] += @", <" + uri + ">;" +
"rel=\"http:/rels.openwrap.org/OpenDoc/index\"";
return PipelineContinuation.Continue;
}
public void SetUp()
{
_communicationContext = MockRepository.GenerateStub<ICommunicationContext>();
_communicationContext.Stub(x => x.Request).Return(MockRepository.GenerateStub<IRequest>());
_authenticationScheme = MockRepository.GenerateStub<IAuthenticationScheme>();
_operation = MockRepository.GenerateStub<IOperation>();
}
bool ShouldProcessConditional(ICommunicationContext context)
{
return context.Response.StatusCode == 200 &&
!context.Request.Headers.ContainsKey(HttpHeaders.IF_RANGE) &&
(context.Request.HttpMethod == "GET" ||
context.Request.HttpMethod == "HEAD") &&
!InvalidHeaderConbination(context);
}
public async Task Invoke(ICommunicationContext env)
{
await InvokeSafe(_requestPipeline,env);
await InvokeSafe(_responsePipeline, env);
if (env.PipelineData.PipelineStage.CurrentState == PipelineContinuation.Abort)
await _catastrophicFail.Invoke(env);
await _cleanup.Invoke(env);
}
PipelineContinuation WrapOperations(ICommunicationContext context)
{
context.PipelineData.Operations = from op in context.PipelineData.Operations
let interceptors = _resolver.Resolve<IOperationInterceptorProvider>().GetInterceptors(op)
select (IOperation)new OperationWithInterceptors(op, interceptors);
return PipelineContinuation.Continue;
}
void GZipReponseEntity(ICommunicationContext context)
{
var compressedStream = new GZippedStream(context.Response.Entity.Stream);
context.Response.Entity.Stream = compressedStream;
context.Response.Headers.Add("Content-Encoding", "gzip");
context.Response.Headers.Add("Vary", "Accept-Encoding");
}
public PipelineContinuation InitializeSession(ICommunicationContext context)
{
var session = _sessionFactory.OpenSession();
_resolver.AddDependencyInstance<ISession>(session, DependencyLifetime.PerRequest);
return PipelineContinuation.Continue;
}
public PipelineContinuation ResolveSession(ICommunicationContext context)
{
var session = _resolver.Resolve<ISession>();
session.Dispose();
return PipelineContinuation.Continue;
}
public PipelineContinuation Close(ICommunicationContext context)
{
if (context.Request.Uri.ToString().Contains("favicon")) return PipelineContinuation.Continue;
var repository = context.PipelineData[ContextKeys.Repository] as IRepository;
if (repository != null) repository.Dispose();
return PipelineContinuation.Continue;
}
public static string GetWebsite(this ICommunicationContext ctx) => ctx.Request.BoundVariables["website"];
public static string GetPath(this ICommunicationContext ctx) => ctx.Request.BoundVariables["path"];
public static string GetWorkspaceID(this ICommunicationContext ctx)
{
return(ctx.Request.QueryString["wid"]);
}
void SendResponseHeaders(ICommunicationContext context)
{
Log.WriteDebug("Writing http headers.");
context.Response.WriteHeaders();
}
public PipelineContinuation Do(ICommunicationContext context)
{
WasCalled = true;
return(PipelineContinuation.Continue);
}
public static string GetDataListID(this ICommunicationContext ctx) => ctx.Request.QueryString[GlobalConstants.DLID];
public static string GetInstanceID(this ICommunicationContext ctx) => ctx.Request.BoundVariables["instanceid"];
protected virtual void FinishPipeline(ICommunicationContext context)
{
PipelineLog.WriteInfo("Pipeline finished.");
}
public UriNameOperationFilter(ICommunicationContext commContext)
{
_commContext = commContext;
Log = NullLogger <OperationModelLogSource> .Instance;
}
public void Run(ICommunicationContext context)
{
throw new NotImplementedException("Backward compatibility implementation, should never be called.");
}
static bool ShouldProcessConditional(ICommunicationContext context)
{
return(context.Response.StatusCode == 200 &&
!context.Request.Headers.ContainsKey(CachingHttpHeaders.IfRange) &&
(context.Request.HttpMethod == "HEAD" || context.Request.HttpMethod == "GET"));
}
bool Is404NotMapped(ICommunicationContext context)
{
return(context.OperationResult is OperationResult.NotFound notFound &&
notFound.Reason == NotFoundReason.NotMapped);
}
bool ShouldSendEmptyResponseBody(ICommunicationContext context)
{
return(Is404NotMapped(context) == false);
}
public static string GetMethodName(this ICommunicationContext ctx) => ctx.Request.BoundVariables["action"];
public OperationContextErrorCollector(ICommunicationContext context)
{
_context = context;
}
public TaskEndPointHandler(ITaskRetriever taskRetriever, ITaskListRetriever taskListRetriever, IAmACommandProcessor commandProcessor, ICommunicationContext communicationContext)
{
_taskRetriever = taskRetriever;
_taskListRetriever = taskListRetriever;
_commandProcessor = commandProcessor;
_communicationContext = communicationContext;
}
public static string GetBookmark(this ICommunicationContext ctx) => ctx.Request.BoundVariables["bookmark"];
protected override ApplicationOctetStreamCodec CreateCodec(ICommunicationContext context)
{
return(new ApplicationOctetStreamCodec());
}
public void Run(ICommunicationContext context)
{
}
PipelineContinuation DoNowt(ICommunicationContext arg)
{
return(PipelineContinuation.Continue);
}
public Task Invoke(ICommunicationContext env)
{
return(LoggingInvoke(env));
}
public TaskListRetriever(ICommunicationContext context, ITasksDAO tasksDAO)
: this(context.ApplicationBaseUri.Host, tasksDAO)
{
}
public static PipelineContinuation Respond <T>(this ICommunicationContext env) where T : OperationResult, new()
{
env.OperationResult = new T();
return(PipelineContinuation.RenderNow);
}
public static PipelineContinuation Respond(this ICommunicationContext env, OperationResult result)
{
env.Response.Entity.Instance = result;
return(PipelineContinuation.RenderNow);
}
public void RunCallGraph(ICommunicationContext context, bool renderNow)
{
}
Task SendEmptyResponse(ICommunicationContext context)
{
Log.WriteDebug("Writing http headers.");
context.Response.WriteHeaders();
return(context.Response.Entity.Stream.FlushAsync());
}
static OperationResult.MethodNotAllowed CreateMethodNotAllowed(ICommunicationContext context)
{
return(new OperationResult.MethodNotAllowed(context.Request.Uri, context.Request.HttpMethod,
context.PipelineData.ResourceKey));
}
public static string GetClassName(this ICommunicationContext ctx) => ctx.Request.BoundVariables["name"];
public PipelineContinuation DoNothing(ICommunicationContext c)
{
return(PipelineContinuation.Continue);
}
public static string GetServiceName(this ICommunicationContext ctx) => ctx.Request.BoundVariables["servicename"];
