private Result<DreamMessage> SubmitRequestAsync(string verb, XUri uri, IPrincipal user, DreamMessage request, Result<DreamMessage> response, Action completion)
{
if(string.IsNullOrEmpty(verb)) {
if(completion != null) {
completion();
}
throw new ArgumentNullException("verb");
}
if(uri == null) {
if(completion != null) {
completion();
}
throw new ArgumentNullException("uri");
}
if(request == null) {
if(completion != null) {
completion();
}
throw new ArgumentNullException("request");
}
if(response == null) {
if(completion != null) {
completion();
}
throw new ArgumentNullException("response");
}
// ensure environment is still running
if(!IsRunning) {
response.Return(DreamMessage.InternalError("host not running"));
if(completion != null) {
completion();
}
return response;
}
try {
Interlocked.Increment(ref _requestCounter);
// check if we were not able to begin processing the request
DreamMessage failed = BeginRequest(completion, uri, request);
if(failed != null) {
response.Return(failed);
EndRequest(completion, uri, request);
return response;
}
// check if 'verb' is overwritten by a processing parameter
verb = verb.ToUpperInvariant();
string requestedVerb = (uri.GetParam(DreamInParam.VERB, null) ?? request.Headers.MethodOverride ?? verb).ToUpperInvariant();
if(
verb.EqualsInvariant(Verb.POST) || (
verb.EqualsInvariant(Verb.GET) && (
requestedVerb.EqualsInvariant(Verb.OPTIONS) ||
requestedVerb.EqualsInvariant(Verb.HEAD)
)
)
) {
verb = requestedVerb;
}
// check if an origin was specified
request.Headers.DreamOrigin = uri.GetParam(DreamInParam.ORIGIN, request.Headers.DreamOrigin);
// check if a public uri is supplied
XUri publicUri = XUri.TryParse(uri.GetParam(DreamInParam.URI, null) ?? request.Headers.DreamPublicUri);
XUri transport = XUri.TryParse(request.Headers.DreamTransport) ?? uri.WithoutCredentialsPathQueryFragment();
if(publicUri == null) {
// check if request is local
if(transport.Scheme.EqualsInvariantIgnoreCase("local")) {
// local:// uris with no public-uri specifier default to the configured public-uri
publicUri = _publicUri;
} else {
// check if the request was forwarded through Apache mod_proxy
string proxyOverride = uri.GetParam(DreamInParam.HOST, null);
if(string.IsNullOrEmpty(proxyOverride)) {
proxyOverride = request.Headers.ForwardedHost;
}
string serverPath = string.Join("/", transport.Segments);
if(proxyOverride != null) {
// request used an override, append path of public-uri
serverPath = string.Join("/", _publicUri.Segments);
}
// set the uri scheme based-on the incoming scheme and the override header
string scheme = transport.Scheme;
if("On".EqualsInvariantIgnoreCase(request.Headers.FrontEndHttps ?? "")) {
scheme = Scheme.HTTPS;
}
scheme = uri.GetParam(DreamInParam.SCHEME, scheme);
// set the host port
string hostPort = proxyOverride ?? request.Headers.Host ?? uri.HostPort;
publicUri = new XUri(string.Format("{0}://{1}", scheme, hostPort)).AtPath(serverPath);
}
request.Headers.DreamPublicUri = publicUri.ToString();
}
// set host header
request.Headers.Host = publicUri.HostPort;
// convert incoming uri to local://
XUri localFeatureUri = uri.ChangePrefix(uri.WithoutPathQueryFragment(), _localMachineUri);
// check if path begins with public uri path
if((transport.Segments.Length > 0) && localFeatureUri.PathStartsWith(transport.Segments)) {
localFeatureUri = localFeatureUri.WithoutFirstSegments(transport.Segments.Length);
}
// check if the path is the application root and whether we have special behavior for that
if(localFeatureUri.Path.IfNullOrEmpty("/") == "/") {
if(!string.IsNullOrEmpty(_rootRedirect)) {
localFeatureUri = localFeatureUri.AtAbsolutePath(_rootRedirect);
} else if(IsDebugEnv) {
localFeatureUri = localFeatureUri.AtAbsolutePath("/host/services");
}
}
// find the requested feature
List<DreamFeature> features;
lock(_features) {
features = _features.Find(localFeatureUri);
}
DreamFeature feature = null;
if(features != null) {
// TODO (steveb): match the incoming mime-type to the feature's acceptable mime-types (mime-type overloading)
// match the request verb to the feature verb
foreach(DreamFeature entry in features) {
if((entry.Verb == "*") || entry.Verb.EqualsInvariant(verb)) {
feature = entry;
break;
}
}
// check if this is an OPTIONS request and there is no defined feature for it
if(verb.EqualsInvariant(Verb.OPTIONS) && ((feature == null) || feature.Verb.EqualsInvariant("*"))) {
// list all allowed methods
List<string> methods = new List<string>();
foreach(DreamFeature entry in features) {
if(!methods.Contains(entry.Verb)) {
methods.Add(entry.Verb);
}
}
methods.Sort(StringComparer.Ordinal.Compare);
DreamMessage result = DreamMessage.Ok();
result.Headers.Allow = string.Join(", ", methods.ToArray());
response.Return(result);
// decrease counter for external requests
EndRequest(completion, uri, request);
return response;
}
}
// check if a feature was found
if(feature == null) {
DreamMessage result;
// check if any feature was found
if((features == null) || (features.Count == 0)) {
string msg = verb + " URI: " + uri.ToString(false) + " LOCAL: " + localFeatureUri.ToString(false) + " PUBLIC: " + publicUri + " TRANSPORT: " + transport;
_log.WarnMethodCall("ProcessRequest: feature not found", msg);
result = DreamMessage.NotFound("resource not found");
} else {
string msg = verb + " " + uri.ToString(false);
_log.WarnMethodCall("ProcessRequest: method not allowed", msg);
List<string> methods = new List<string>();
foreach(DreamFeature entry in features) {
if(!methods.Contains(entry.Verb)) {
methods.Add(entry.Verb);
}
}
methods.Sort(StringComparer.Ordinal.Compare);
result = DreamMessage.MethodNotAllowed(methods.ToArray(), "allowed methods are " + string.Join(", ", methods.ToArray()));
}
response.Return(result);
// decrease counter for external requests
EndRequest(completion, uri, request);
return response;
}
// add uri to aliases list
if(_memorizeAliases) {
lock(_aliases) {
_aliases[transport] = transport;
_aliases[publicUri] = publicUri;
}
}
// create context
DreamContext context = new DreamContext(this, verb, localFeatureUri, feature, publicUri, _publicUri, request, CultureInfo.InvariantCulture, GetRequestLifetimeScopeFactory(feature.Service));
// attach request id to the context
context.SetState(DreamHeaders.DREAM_REQUEST_ID, request.Headers.DreamRequestId);
// add user to context
context.User = user;
// build linked-list of feature calls
var chain = new Result<DreamMessage>(TimeSpan.MaxValue, TaskEnv.Current).WhenDone(result => {
// extract message
DreamMessage message;
if(result.HasValue) {
message = result.Value;
} else if(result.Exception is DreamAbortException) {
message = ((DreamAbortException)result.Exception).Response;
} else if(result.Exception is DreamCachedResponseException) {
message = ((DreamCachedResponseException)result.Exception).Response;
} else {
_log.ErrorExceptionFormat(response.Exception, "Failed Feature '{0}' Chain [{1}:{2}]: {3}",
feature.MainStage.Name,
verb,
localFeatureUri.Path,
response.Exception.Message
);
message = DreamMessage.InternalError(result.Exception);
}
// decrease counter for external requests
EndRequest(completion, uri, request);
// need to manually dispose of the context, since we're already attaching and detaching it by hand to TaskEnvs throughout the chain
if(response.IsCanceled) {
_log.DebugFormat("response for '{0}' has already returned", context.Uri.Path);
response.ConfirmCancel();
((ITaskLifespan)context).Dispose();
} else {
((ITaskLifespan)context).Dispose();
response.Return(message);
}
});
for(int i = feature.Stages.Length - 1; i >= 0; --i) {
var link = new DreamFeatureChain(feature.Stages[i], i == feature.MainStageIndex, context, chain, (i > 0) ? feature.Stages[i - 1].Name : "first");
chain = new Result<DreamMessage>(TimeSpan.MaxValue, TaskEnv.Current).WhenDone(link.Handler);
}
// kick-off new task
AsyncUtil.Fork(
() => chain.Return(request),
TaskEnv.New(TimerFactory),
new Result(TimeSpan.MaxValue, response.Env).WhenDone(res => {
if(!res.HasException) {
return;
}
_log.ErrorExceptionFormat(res.Exception, "handler for {0}:{1} failed", context.Verb, context.Uri.ToString(false));
((ITaskLifespan)context).Dispose();
// forward exception to recipient
response.Throw(res.Exception);
// decrease counter for external requests
EndRequest(completion, uri, request);
})
);
} catch(Exception e) {
response.Throw(e);
EndRequest(completion, uri, request);
}
return response;
}
public Yield UserLogin(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
string userSuppliedIdentifier = context.GetParam("url", null);
if (String.IsNullOrEmpty(userSuppliedIdentifier)) {
_log.Info("No identifier was specified");
throw new DreamBadRequestException("No identifier was specified.");
}
XUri returnUri = new XUri(context.GetParam("returnurl", null));
String realm = context.GetParam("realm", null);
if (String.IsNullOrEmpty(realm)) {
realm = returnUri.WithoutPathQueryFragment().ToString();
}
IAuthenticationRequest openIdRequest;
// dummy parameters required by DotNetOpenId 2.x; in 3.x, you can
// just pass null to the OpenIdRelyingParty constructor.
Uri identifierUri = new Uri(userSuppliedIdentifier);
NameValueCollection queryCol = System.Web.HttpUtility.ParseQueryString(identifierUri.Query);
OpenIdRelyingParty openid = new OpenIdRelyingParty(null, identifierUri, queryCol);
// creating an OpenID request will authenticate that
// the endpoint exists and is an OpenID provider.
_log.DebugFormat("Creating OpenID request: identifier {0}, return URL {1}, realm {2}", userSuppliedIdentifier, returnUri.ToString(), realm);
try {
openIdRequest = openid.CreateRequest(
userSuppliedIdentifier,
realm,
returnUri.ToUri());
} catch (OpenIdException ex) {
_log.WarnFormat("'{0}' rejected as OpenID identifier: {1}", userSuppliedIdentifier, ex.Message);
throw new DreamBadRequestException(string.Format("'{0}' is not a valid OpenID identifier. {1}", userSuppliedIdentifier, ex.Message));
}
// Ask for the e-mail address on this request.
// Use both SREG and AX, to increase the odds of getting it.
openIdRequest.AddExtension(new ClaimsRequest{
Email = DemandLevel.Require,
});
var fetch = new FetchRequest();
fetch.AddAttribute(new AttributeRequest(WellKnownAttributes.Contact.Email, true));
openIdRequest.AddExtension(fetch);
// The RedirectingResponse either contains a "Location" header for
// a HTTP GET, which will return in the response as 'endpoint', or
// a HTML FORM which needs to be displayed to the user, which will
// return in the response as 'form'.
IResponse wr = openIdRequest.RedirectingResponse;
XDoc result = new XDoc("openid");
if (String.IsNullOrEmpty(wr.Headers["Location"])) {
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
string formBody = enc.GetString(wr.Body);
_log.DebugFormat("OpenID redirect by HTML FORM: {0}", formBody);
result.Attr("form", formBody);
} else {
string redirectUrl = wr.Headers["Location"];
_log.DebugFormat("OpenID redirect URL: {0}", redirectUrl);
result.Attr("endpoint", redirectUrl);
}
response.Return(DreamMessage.Ok(result));
yield break;
}
//--- Class Methods ---
internal static AMedia New(XUri uri) {
// check if the uri is a youtube video
if(
uri.Host.EndsWithInvariantIgnoreCase(".youtube.com") ||
uri.Host.EqualsInvariantIgnoreCase("youtube.com") ||
uri.Host.EndsWithInvariantIgnoreCase(".youtube-nocookie.com") ||
uri.Host.EqualsInvariantIgnoreCase("youtube-nocookie.com")
) {
if(uri.GetParam("v") != null) {
return new YouTubeVideo(uri.WithoutPathQueryFragment().At("v", uri.GetParam("v")));
}
if(!ArrayUtil.IsNullOrEmpty(uri.Segments) && (uri.Segments.Length == 2) && (uri.Segments[0].EqualsInvariantIgnoreCase("v"))) {
return new YouTubeVideo(uri);
}
}
return null;
}
