// Attempt to write the response over the wire to the client
private static void ProcessResponse(ICouchbaseListenerContext context, ICouchbaseResponseState responseState)
{
CouchbaseLiteResponse responseObject = CheckForAltMethod(context, responseState.Response);
if (!responseState.IsAsync)
{
try {
Log.To.Router.I(TAG, "Processing response for {0}...", context.RequestUrl.PathAndQuery);
Log.To.Router.V(TAG, "Processing request range...");
responseObject.ProcessRequestRanges();
Log.To.Router.V(TAG, "Writing headers...");
responseObject.WriteHeaders();
Log.To.Router.V(TAG, "Writing body...");
responseObject.WriteToContext();
Log.To.Router.I(TAG, "{0} {1} => {2} ({3})", context.Method, context.RequestUrl.PathAndQuery, responseObject.Status, responseObject.StatusMessage);
} catch (Exception e) {
Log.To.Router.E(TAG, "Exception writing response", e);
responseState = context.CreateResponse(StatusCode.Exception).AsDefaultState();
}
}
else
{
_UnfinishedResponses.Add(responseState);
}
}
// Attempt to write the response over the wire to the client
private static void ProcessResponse(ICouchbaseListenerContext context, ICouchbaseResponseState responseState)
{
CouchbaseLiteResponse responseObject = CheckForAltMethod(context, responseState.Response);
if (!responseState.IsAsync)
{
try {
responseObject.ProcessRequestRanges();
responseObject.WriteHeaders();
responseObject.WriteToContext();
} catch (Exception e) {
Log.E(TAG, "Exception writing response", e);
responseState = context.CreateResponse(StatusCode.Exception).AsDefaultState();
}
}
else
{
_UnfinishedResponses.Add(responseState);
}
}
/// <summary>
/// Inform the router that an async / continuous response has completed and can be
/// finalized.
/// </summary>
/// <param name="responseState">The response that finished</param>
public static void ResponseFinished(ICouchbaseResponseState responseState)
{
_UnfinishedResponses.Remove(responseState);
}
/// <summary>
/// The entry point for routing a request received by an CouchbaseLiteServiceListener
/// </summary>
/// <param name="context">The context containing information about the
/// request</param>
public void HandleRequest(ICouchbaseListenerContext context)
{
var method = context.Method;
if (OnAccessCheck != null)
{
Status result = null;
try {
result = OnAccessCheck(method, context.RequestUrl.AbsolutePath);
} catch (Exception e) {
result = new Status(StatusCode.Exception);
Log.E(TAG, "Unhandled non-Couchbase exception in OnAccessCheck", e);
}
if (result.IsError)
{
var r = context.CreateResponse(result.GetCode());
ProcessResponse(context, r.AsDefaultState());
return;
}
}
RestMethod logic = null;
if (method.Equals("GET") || method.Equals("HEAD"))
{
logic = _Get.LogicForRequest(context.RequestUrl);
}
else if (method.Equals("POST"))
{
logic = _Post.LogicForRequest(context.RequestUrl);
}
else if (method.Equals("PUT"))
{
logic = _Put.LogicForRequest(context.RequestUrl);
}
else if (method.Equals("DELETE"))
{
logic = _Delete.LogicForRequest(context.RequestUrl);
}
else
{
logic = NOT_ALLOWED; // Shouldn't happen
}
ICouchbaseResponseState responseState = null;
try {
responseState = logic(context);
} catch (Exception e) {
var ce = e as CouchbaseLiteException;
if (ce != null)
{
// This is in place so that a response can be written simply by throwing a couchbase lite exception
// in the routing logic
Log.I(TAG, "Couchbase exception in routing logic, this message can be ignored if intentional", e);
responseState = context.CreateResponse(ce.GetCBLStatus().GetCode()).AsDefaultState();
}
else
{
Log.E(TAG, "Unhandled non-Couchbase exception in routing logic", e);
responseState = context.CreateResponse(StatusCode.Exception).AsDefaultState();
}
}
ProcessResponse(context, responseState);
}
// Attempt to write the response over the wire to the client
private static void ProcessResponse(ICouchbaseListenerContext context, ICouchbaseResponseState responseState)
{
CouchbaseLiteResponse responseObject = CheckForAltMethod(context, responseState.Response);
if (!responseState.IsAsync) {
try {
responseObject.ProcessRequestRanges();
responseObject.WriteHeaders();
responseObject.WriteToContext();
} catch(Exception e) {
Log.E(TAG, "Exception writing response", e);
responseState = context.CreateResponse(StatusCode.Exception).AsDefaultState();
}
} else {
_UnfinishedResponses.Add(responseState);
}
}
/// <summary>
/// Inform the router that an async / continuous response has completed and can be
/// finalized.
/// </summary>
/// <param name="responseState">The response that finished</param>
public static void ResponseFinished(ICouchbaseResponseState responseState)
{
_UnfinishedResponses.Remove(responseState);
}
/// <summary>
/// The entry point for routing a request received by an CouchbaseLiteServiceListener
/// </summary>
/// <param name="context">The context containing information about the
/// request</param>
public void HandleRequest(ICouchbaseListenerContext context)
{
Log.To.Router.I(TAG, "Processing {0} request to {1}", context.Method, context.RequestUrl.PathAndQuery);
var method = context.Method;
if (OnAccessCheck != null)
{
Status result = null;
try {
result = OnAccessCheck(method, context.RequestUrl.AbsolutePath);
} catch (Exception e) {
result = new Status(StatusCode.Exception);
Log.To.Router.E(TAG, "Unhandled non-Couchbase exception in OnAccessCheck", e);
}
if (result.IsError)
{
var r = context.CreateResponse(result.Code);
ProcessResponse(context, r.AsDefaultState());
return;
}
}
var c = context as ICouchbaseListenerContext2;
var allowPrivate = InsecureMode || c?.IsLoopbackRequest == true;
RestMethod logic = null;
if (method.Equals("GET") || method.Equals("HEAD"))
{
logic = _Get.LogicForRequest(context.RequestUrl);
}
else if (method.Equals("POST"))
{
logic = _Post.LogicForRequest(context.RequestUrl);
if (logic == RouteCollection.NOT_FOUND)
{
logic = _PostPrivate.LogicForRequest(context.RequestUrl);
if (!allowPrivate && logic != RouteCollection.NOT_FOUND)
{
logic = FORBIDDEN;
}
}
}
else if (method.Equals("PUT"))
{
logic = _Put.LogicForRequest(context.RequestUrl);
}
else if (method.Equals("DELETE"))
{
logic = _Delete.LogicForRequest(context.RequestUrl);
}
else
{
logic = NOT_ALLOWED; // Shouldn't happen
}
ICouchbaseResponseState responseState = null;
try {
responseState = logic(context);
} catch (CouchbaseLiteException e) {
// This is in place so that a response can be written simply by throwing a couchbase lite exception
// in the routing logic
Log.To.Router.I(TAG, "Couchbase exception in routing logic, this message can be ignored if intentional", e);
responseState = context.CreateResponse(e.CBLStatus.Code).AsDefaultState();
} catch (Exception e) {
Log.To.Router.E(TAG, "Unhandled non-Couchbase exception in routing logic", e);
responseState = context.CreateResponse(StatusCode.Exception).AsDefaultState();
}
ProcessResponse(context, responseState);
}
// Attempt to write the response over the wire to the client
private static void ProcessResponse(ICouchbaseListenerContext context, ICouchbaseResponseState responseState)
{
CouchbaseLiteResponse responseObject = CheckForAltMethod(context, responseState.Response);
if (!responseState.IsAsync) {
try {
Log.To.Router.I(TAG, "Processing response for {0}...", context.RequestUrl.PathAndQuery);
Log.To.Router.V(TAG, "Processing request range...");
responseObject.ProcessRequestRanges();
Log.To.Router.V(TAG, "Writing headers...");
responseObject.WriteHeaders();
Log.To.Router.V(TAG, "Writing body...");
responseObject.WriteToContext();
Log.To.Router.I(TAG, "Response successfully processed!");
} catch(Exception e) {
Log.To.Router.E(TAG, "Exception writing response", e);
responseState = context.CreateResponse(StatusCode.Exception).AsDefaultState();
}
} else {
_UnfinishedResponses.Add(responseState);
}
}
