void HttpRequestCallback(IHttpResponse response, object userState)
{
if (response.Status == HttpRequestQueueResult.Error)
{
this.PluginHost.BroadcastErrorInfoEvent(response.Reason);
}
}
public new void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
if (!AssertAccess(httpReq, httpRes, httpReq.QueryString["op"])) return;
var operationTypes = EndpointHost.Metadata.GetAllTypes();
if (httpReq.QueryString["xsd"] != null)
{
var xsdNo = Convert.ToInt32(httpReq.QueryString["xsd"]);
var schemaSet = XsdUtils.GetXmlSchemaSet(operationTypes);
var schemas = schemaSet.Schemas();
var i = 0;
if (xsdNo >= schemas.Count)
{
throw new ArgumentOutOfRangeException("xsd");
}
httpRes.ContentType = "text/xml";
foreach (XmlSchema schema in schemaSet.Schemas())
{
if (xsdNo != i++) continue;
schema.Write(httpRes.OutputStream);
break;
}
return;
}
using (var sw = new StreamWriter(httpRes.OutputStream))
{
var writer = new HtmlTextWriter(sw);
httpRes.ContentType = "text/html";
ProcessOperations(writer, httpReq, httpRes);
}
}
public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName)
{
response.ContentType = "text/plain";
response.StatusCode = 403;
response.Write("Forbidden\n\n");
response.Write("\nRequest.HttpMethod: " + request.HttpMethod);
response.Write("\nRequest.PathInfo: " + request.PathInfo);
response.Write("\nRequest.QueryString: " + request.QueryString);
response.Write("\nRequest.RawUrl: " + request.RawUrl);
if (IsIntegratedPipeline.HasValue)
response.Write("\nApp.IsIntegratedPipeline: " + IsIntegratedPipeline);
if (!WebHostPhysicalPath.IsNullOrEmpty())
response.Write("\nApp.WebHostPhysicalPath: " + WebHostPhysicalPath);
if (!WebHostRootFileNames.IsEmpty())
response.Write("\nApp.WebHostRootFileNames: " + TypeSerializer.SerializeToString(WebHostRootFileNames));
if (!ApplicationBaseUrl.IsNullOrEmpty())
response.Write("\nApp.ApplicationBaseUrl: " + ApplicationBaseUrl);
if (!DefaultRootFileName.IsNullOrEmpty())
response.Write("\nApp.DefaultRootFileName: " + DefaultRootFileName);
if (!DefaultHandler.IsNullOrEmpty())
response.Write("\nApp.DefaultHandler: " + DefaultHandler);
if (!ServiceStackHttpHandlerFactory.DebugLastHandlerArgs.IsNullOrEmpty())
response.Write("\nApp.DebugLastHandlerArgs: " + ServiceStackHttpHandlerFactory.DebugLastHandlerArgs);
ServiceStack.WebHost.Endpoints.EndpointHost.AddGlobalResponseHeaders(response);
//Apache+mod_mono doesn't like this
//response.OutputStream.Flush();
//response.Close();
}
protected bool AssertAccess(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
if (!EndpointHost.Config.HasFeature(Feature.Metadata))
{
EndpointHost.Config.HandleErrorResponse(httpReq, httpRes, HttpStatusCode.Forbidden, "Metadata Not Available");
return false;
}
if (EndpointHost.Config.MetadataVisibility != EndpointAttributes.Any)
{
var actualAttributes = httpReq.GetAttributes();
if ((actualAttributes & EndpointHost.Config.MetadataVisibility) != EndpointHost.Config.MetadataVisibility)
{
EndpointHost.Config.HandleErrorResponse(httpReq, httpRes, HttpStatusCode.Forbidden, "Metadata Not Visible");
return false;
}
}
if (operationName == null) return true; //For non-operation pages we don't need to check further permissions
if (!EndpointHost.Config.EnableAccessRestrictions) return true;
if (!EndpointHost.Config.MetadataPagesConfig.IsVisible(httpReq, Format, operationName))
{
EndpointHost.Config.HandleErrorResponse(httpReq, httpRes, HttpStatusCode.Forbidden, "Service Not Available");
return false;
}
return true;
}
public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request)
{
var requestContentType = ContentType.GetEndpointAttributes(httpReq.ResponseContentType);
return ExecuteService(request,
HandlerAttributes | requestContentType | GetEndpointAttributes(httpReq), httpReq, httpRes);
}
private void SimplePreRequestFilter(IHttpRequest req, IHttpResponse res)
{
if (Path.GetFileName(req.PathInfo).StartsWith("_"))
{
throw new HttpException("Files with leading underscores ('_') cannot be served.");
}
}
public new void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
EndpointHost.Config.AssertFeatures(Feature.Metadata);
var operations = EndpointHost.ServiceOperations;
if (httpReq.QueryString["xsd"] != null)
{
var xsdNo = Convert.ToInt32(httpReq.QueryString["xsd"]);
var schemaSet = XsdUtils.GetXmlSchemaSet(operations.AllOperations.Types);
var schemas = schemaSet.Schemas();
var i = 0;
if (xsdNo >= schemas.Count)
{
throw new ArgumentOutOfRangeException("xsd");
}
httpRes.ContentType = "text/xml";
foreach (XmlSchema schema in schemaSet.Schemas())
{
if (xsdNo != i++) continue;
schema.Write(httpRes.Output);
break;
}
return;
}
var writer = new HtmlTextWriter(httpRes.Output);
httpRes.ContentType = "text/html";
ProcessOperations(writer, httpReq);
writer.Flush();
}
public static bool WriteToOutputStream(IHttpResponse response, object result, byte[] bodyPrefix, byte[] bodySuffix)
{
var streamWriter = result as IStreamWriter;
if (streamWriter != null)
{
if (bodyPrefix != null) response.OutputStream.Write(bodyPrefix, 0, bodyPrefix.Length);
streamWriter.WriteTo(response.OutputStream);
if (bodySuffix != null) response.OutputStream.Write(bodySuffix, 0, bodySuffix.Length);
return true;
}
var stream = result as Stream;
if (stream != null)
{
if (bodyPrefix != null) response.OutputStream.Write(bodyPrefix, 0, bodyPrefix.Length);
stream.WriteTo(response.OutputStream);
if (bodySuffix != null) response.OutputStream.Write(bodySuffix, 0, bodySuffix.Length);
return true;
}
var bytes = result as byte[];
if (bytes != null)
{
response.ContentType = ContentType.Binary;
if (bodyPrefix != null) response.OutputStream.Write(bodyPrefix, 0, bodyPrefix.Length);
response.OutputStream.Write(bytes, 0, bytes.Length);
if (bodySuffix != null) response.OutputStream.Write(bodySuffix, 0, bodySuffix.Length);
return true;
}
return false;
}
//Also shared by RequiredRoleAttribute and RequiredPermissionAttribute
public static User AuthenticateBasicAuth(IHttpRequest req, IHttpResponse res)
{
var userCredentialsPair = req.GetBasicAuthUserAndPassword();
var email = userCredentialsPair.HasValue ? userCredentialsPair.Value.Key : String.Empty;
var password = userCredentialsPair.HasValue ? userCredentialsPair.Value.Value : String.Empty;
User user = null;
bool isValid = false;
using (var session = NHibernateHelper.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var userQuery = session.QueryOver<User>()
.Where(table => table.Email == email)
.And(table => table.Password == password);
user = userQuery.SingleOrDefault();
transaction.Commit();
isValid = (user != null);
}
}
if (!isValid)
{
res.StatusCode = (int)HttpStatusCode.Unauthorized;
res.EndServiceStackRequest();
}
return user;
}
public static void WriteDebugResponse(IHttpResponse httpRes, object response)
{
httpRes.WriteToResponse(response, WriteDebugRequest,
new SerializationContext(ContentType.PlainText));
//httpRes.Close();
}
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
var isDebugRequest = httpReq.RawUrl.ToLower().Contains("debug");
if (!isDebugRequest)
{
base.ProcessRequest(httpReq, httpRes, operationName);
return;
}
try
{
var request = CreateRequest(httpReq, operationName);
var response = ExecuteService(request,
HandlerAttributes | GetEndpointAttributes(httpReq), httpReq);
WriteDebugResponse(httpRes, response);
}
catch (Exception ex)
{
var errorMessage = string.Format("Error occured while Processing Request: {0}", ex.Message);
httpRes.WriteErrorToResponse(EndpointAttributes.Jsv, operationName, errorMessage, ex);
}
}
public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request)
{
var response = ExecuteService(request,
HandlerAttributes | httpReq.GetAttributes(), httpReq, httpRes);
return response;
}
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
try
{
EndpointHost.Config.AssertFeatures(format);
if (EndpointHost.ApplyPreRequestFilters(httpReq, httpRes)) return;
httpReq.ResponseContentType = httpReq.GetQueryStringContentType() ?? this.HandlerContentType;
var callback = httpReq.QueryString["callback"];
var doJsonp = EndpointHost.Config.AllowJsonpRequests
&& !string.IsNullOrEmpty(callback);
var request = CreateRequest(httpReq, operationName);
if (EndpointHost.ApplyRequestFilters(httpReq, httpRes, request)) return;
var response = GetResponse(httpReq, httpRes, request);
if (EndpointHost.ApplyResponseFilters(httpReq, httpRes, response)) return;
if (doJsonp && !(response is CompressedResult))
httpRes.WriteToResponse(httpReq, response, (callback + "(").ToUtf8Bytes(), ")".ToUtf8Bytes());
else
httpRes.WriteToResponse(httpReq, response);
}
catch (Exception ex)
{
if (!EndpointHost.Config.WriteErrorsToResponse) throw;
HandleException(httpReq, httpRes, operationName, ex);
}
}
internal CouchServerResponse(IHttpResponse response)
{
try
{
var resp = JsonConvert.DeserializeObject<CouchServerResponseDefinition>(response.Data, CouchService.JsonSettings);
Id = resp.Id;
Revision = resp.Revision;
if(resp.IsOk.HasValue)
{
IsOk = resp.IsOk.Value;
}
else
{
IsOk = response.StatusCode == HttpStatusCode.Created;
}
ErrorType = resp.Error;
ErrorMessage = resp.Reason;
}
catch(Exception ex)
{
if (ex is JsonReaderException)
{
IsOk = false;
ErrorType = "CouchNet Deserialization Error";
ErrorMessage = "Failed to deserialize server response (" + response.Data + ") Extra Info : " + ex.Message;
}
}
}
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
httpRes.ContentType = ContentType.Html;
if (RazorFormat == null)
RazorFormat = RazorFormat.Instance;
var contentPage = RazorPage ?? RazorFormat.FindByPathInfo(PathInfo);
if (contentPage == null)
{
httpRes.StatusCode = (int)HttpStatusCode.NotFound;
httpRes.EndHttpRequest();
return;
}
if (RazorFormat.WatchForModifiedPages)
RazorFormat.ReloadIfNeeeded(contentPage);
//Add good caching support
//if (httpReq.DidReturn304NotModified(contentPage.GetLastModified(), httpRes))
// return;
var model = Model;
if (model == null)
httpReq.Items.TryGetValue("Model", out model);
if (model == null)
{
var modelType = RazorPage != null ? RazorPage.GetRazorTemplate().ModelType : null;
model = modelType == null || modelType == typeof(DynamicRequestObject)
? null
: DeserializeHttpRequest(modelType, httpReq, httpReq.ContentType);
}
RazorFormat.ProcessRazorPage(httpReq, contentPage, model, httpRes);
}
/// <summary>
/// This is called by the hosting environment via CatchAll usually for content pages.
/// </summary>
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
httpRes.ContentType = ContentType.Html;
ResolveAndExecuteRazorPage(httpReq, httpRes, null);
httpRes.EndRequest(skipHeaders: true);
}
/// <summary>
/// Non ASP.NET requests
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="operationName"></param>
public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName)
{
if (string.IsNullOrEmpty(RelativeUrl) && string.IsNullOrEmpty(AbsoluteUrl))
throw new ArgumentNullException("RelativeUrl or AbsoluteUrl");
if (!string.IsNullOrEmpty(AbsoluteUrl))
{
response.StatusCode = (int)HttpStatusCode.Redirect;
response.AddHeader(HttpHeaders.Location, this.AbsoluteUrl);
}
else
{
var absoluteUrl = request.GetApplicationUrl();
if (!string.IsNullOrEmpty(RelativeUrl))
{
if (this.RelativeUrl.StartsWith("/"))
absoluteUrl = absoluteUrl.CombineWith(this.RelativeUrl);
else if (this.RelativeUrl.StartsWith("~/"))
absoluteUrl = absoluteUrl.CombineWith(this.RelativeUrl.Replace("~/", ""));
else
absoluteUrl = request.AbsoluteUri.CombineWith(this.RelativeUrl);
}
response.StatusCode = (int)HttpStatusCode.Redirect;
response.AddHeader(HttpHeaders.Location, absoluteUrl);
}
response.EndHttpRequest(skipClose:true);
}
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto)
{
var applicationRequest = requestDto as ApplicationRequest;
var appKey = GetAppKeyFromRequest(req, applicationRequest);
var appSecret = GetAppSecretFromRequest(req, applicationRequest);
var app = ApplicationAuthenticationService.Authenticate(appKey,appSecret);
if (app == null)
{
res.StatusCode = (int)HttpStatusCode.Forbidden;
// Some Android devices require a body, otherwise the response code is ignored and set 0
res.Write(HttpStatusCode.Forbidden.ToString());
res.Close();
}
if (applicationRequest != null)
{
applicationRequest.AppKey = appKey;
applicationRequest.AppSecret = appSecret;
applicationRequest.Application = ApplicationRepository.FindApplication(appKey, appSecret);
applicationRequest.Account = AccountApplicationRepository.GetForApplication(applicationRequest.Application.Id);
}
var validationErrors = ValidateRequest(applicationRequest);
if (validationErrors.Any())
{
res.StatusCode = (int)HttpStatusCode.BadRequest;
// Some Android devices require a body, otherwise the response code is ignored and set 0
res.Write(HttpStatusCode.BadRequest.ToString());
foreach (var error in validationErrors)
{
res.Write(error);
}
res.Close();
}
}
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
httpRes.ContentType = MimeTypes.Html;
if (RazorFormat == null)
RazorFormat = RazorFormat.Instance;
var contentPage = RazorPage ?? RazorFormat.FindByPathInfo(PathInfo);
if (contentPage == null)
{
httpRes.StatusCode = (int)HttpStatusCode.NotFound;
httpRes.EndHttpHandlerRequest();
return;
}
var model = Model;
if (model == null)
httpReq.Items.TryGetValue("Model", out model);
if (model == null)
{
var modelType = RazorPage != null ? RazorPage.ModelType : null;
model = modelType == null || modelType == typeof(DynamicRequestObject)
? null
: DeserializeHttpRequest(modelType, httpReq, httpReq.ContentType);
}
RazorFormat.ProcessRazorPage(httpReq, contentPage, model, httpRes);
}
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto)
{
if (AuthenticateService.AuthProviders == null)
throw new InvalidOperationException(
"The AuthService must be initialized by calling AuthService.Init to use an authenticate attribute");
var matchingOAuthConfigs = AuthenticateService.AuthProviders.Where(x =>
this.Provider.IsNullOrEmpty()
|| x.Provider == this.Provider).ToList();
if (matchingOAuthConfigs.Count == 0)
{
res.WriteError(req, requestDto, "No OAuth Configs found matching {0} provider"
.Fmt(this.Provider ?? "any"));
res.EndRequest();
return;
}
if (matchingOAuthConfigs.Any(x => x.Provider == DigestAuthProvider.Name))
AuthenticateIfDigestAuth(req, res);
if (matchingOAuthConfigs.Any(x => x.Provider == BasicAuthProvider.Name))
AuthenticateIfBasicAuth(req, res);
var session = req.GetSession();
if (session == null || !matchingOAuthConfigs.Any(x => session.IsAuthorized(x.Provider)))
{
if (this.DoHtmlRedirectIfConfigured(req, res, true)) return;
AuthProvider.HandleFailedAuth(matchingOAuthConfigs[0], session, req, res);
}
}
public static void RequestFilter(IHttpRequest req, IHttpResponse res, object requestDto)
{
var validator = ValidatorCache.GetValidator(req, requestDto.GetType());
if (validator == null) return;
var validatorWithHttpRequest = validator as IRequiresHttpRequest;
if (validatorWithHttpRequest != null)
validatorWithHttpRequest.HttpRequest = req;
var ruleSet = req.HttpMethod;
var validationResult = validator.Validate(
new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet)));
if (validationResult.IsValid) return;
var errorResponse = DtoUtils.CreateErrorResponse(
requestDto, validationResult.ToErrorResult());
var validationFeature = EndpointHost.GetPlugin<ValidationFeature>();
if (validationFeature != null && validationFeature.ErrorResponseFilter != null)
{
errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse);
}
res.WriteToResponse(req, errorResponse);
}
private void reactFire(IHttpResponse resp)
{
Console.WriteLine("Fire!");
usbToys.FireMissile();
resp.Status = System.Net.HttpStatusCode.OK;
close(resp, "Fire!");
}
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
try
{
var contentType = httpReq.GetQueryStringContentType() ?? this.HandlerContentType;
var callback = httpReq.QueryString["callback"];
var doJsonp = EndpointHost.Config.AllowJsonpRequests
&& !string.IsNullOrEmpty(callback);
var request = CreateRequest(httpReq, operationName);
var response = GetResponse(httpReq, request);
var serializer = GetStreamSerializer(contentType);
if (doJsonp) httpRes.Write(callback + "(");
httpRes.WriteToResponse(response, serializer, contentType);
if (doJsonp) httpRes.Write(")");
}
catch (Exception ex)
{
var errorMessage = string.Format("Error occured while Processing Request: {0}", ex.Message);
Log.Error(errorMessage, ex);
httpRes.WriteErrorToResponse(HandlerContentType, operationName, errorMessage, ex);
}
}
public static bool WriteToOutputStream(IHttpResponse response, object result)
{
//var responseStream = response.OutputStream;
var streamWriter = result as IStreamWriter;
if (streamWriter != null)
{
streamWriter.WriteTo(response.OutputStream);
return true;
}
var stream = result as Stream;
if (stream != null)
{
stream.WriteTo(response.OutputStream);
return true;
}
var bytes = result as byte[];
if (bytes != null)
{
response.ContentType = ContentType.Binary;
response.OutputStream.Write(bytes, 0, bytes.Length);
return true;
}
return false;
}
public byte[] ApplyResponseBodyFilter(IHttpResponse response, byte[] body, IEnumerable<Func<IHttpResponse, string, byte[], byte[]>> bodyCallbacks)
{
Contract.Requires(response != null);
Contract.Requires(bodyCallbacks != null);
return null;
}
public Task Replay(IHttpResponse response)
{
_writes.Each(x => x(response));
return Task.CompletedTask;
}
/// <summary>Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler" /> interface.</summary>
///
/// <param name="request"> The request.</param>
/// <param name="response"> The response.</param>
/// <param name="operationName">Name of the operation.</param>
public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName)
{
response.ContentType = "text/plain";
response.StatusCode = 403;
response.EndHttpHandlerRequest(skipClose: true, afterBody: r => {
r.Write("Forbidden\n\n");
r.Write("\nRequest.HttpMethod: " + request.HttpMethod);
r.Write("\nRequest.PathInfo: " + request.PathInfo);
r.Write("\nRequest.QueryString: " + request.QueryString);
r.Write("\nRequest.RawUrl: " + request.RawUrl);
if (IsIntegratedPipeline.HasValue)
r.Write("\nApp.IsIntegratedPipeline: " + IsIntegratedPipeline);
if (!WebHostPhysicalPath.IsNullOrEmpty())
r.Write("\nApp.WebHostPhysicalPath: " + WebHostPhysicalPath);
if (!WebHostRootFileNames.IsEmpty())
r.Write("\nApp.WebHostRootFileNames: " + TypeSerializer.SerializeToString(WebHostRootFileNames));
if (!ApplicationBaseUrl.IsNullOrEmpty())
r.Write("\nApp.ApplicationBaseUrl: " + ApplicationBaseUrl);
if (!DefaultRootFileName.IsNullOrEmpty())
r.Write("\nApp.DefaultRootFileName: " + DefaultRootFileName);
if (!DefaultHandler.IsNullOrEmpty())
r.Write("\nApp.DefaultHandler: " + DefaultHandler);
if (!NServiceKitHttpHandlerFactory.DebugLastHandlerArgs.IsNullOrEmpty())
r.Write("\nApp.DebugLastHandlerArgs: " + NServiceKitHttpHandlerFactory.DebugLastHandlerArgs);
});
}
public override bool Process(IHttpRequest request, IHttpResponse response, IHttpSession session)
{
if (_ignoredPaths.Contains(request.Uri.AbsolutePath))
return true;
TextWriter writer = new StreamWriter(response.Body);
try
{
string fileContents = File.ReadAllText("resources" + request.Uri.AbsolutePath);
writer.Write(fileContents);
}
catch (Exception ex)
{
response.ContentType = "text/plain; charset=UTF-8";
writer.WriteLine(ex.Message);
writer.WriteLine(ex.StackTrace);
}
finally
{
writer.Flush();
}
return true;
}
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto)
{
if (AuthService.AuthProviders == null) throw new InvalidOperationException("The AuthService must be initialized by calling "
+ "AuthService.Init to use an authenticate attribute");
var matchingOAuthConfigs = AuthService.AuthProviders.Where(x =>
this.Provider.IsNullOrEmpty()
|| x.Provider == this.Provider).ToList();
if (matchingOAuthConfigs.Count == 0)
{
res.WriteError(req, requestDto, "No OAuth Configs found matching {0} provider"
.Fmt(this.Provider ?? "any"));
res.Close();
return;
}
AuthenticateIfBasicAuth(req, res);
using (var cache = req.GetCacheClient())
{
var sessionId = req.GetSessionId();
var session = sessionId != null ? cache.GetSession(sessionId) : null;
if (session == null || !matchingOAuthConfigs.Any(x => session.IsAuthorized(x.Provider)))
{
AuthProvider.HandleFailedAuth(matchingOAuthConfigs[0], session, req, res);
}
}
}
private void reactLaser(IHttpResponse resp)
{
Console.WriteLine("Laser!");
usbToys.ToggleLaser();
resp.Status = System.Net.HttpStatusCode.OK;
close(resp, "Laser!");
}
private void NewFileAgentInventoryVariablePriceUploadHandler(NewFileAgentInventoryVariablePriceMessage message, Capability cap,
IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = request.GetBody();
UUID assetID = UUID.Zero;
LLInventoryItem item = null;
m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)");
if (assetData != null && assetData.Length > 0)
{
string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType);
// Create the asset
if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID))
{
// Create the inventory item
item = new LLInventoryItem();
item.AssetID = assetID;
item.ContentType = contentType;
item.CreationDate = DateTime.UtcNow;
item.CreatorID = cap.OwnerID;
item.Description = message.Description;
item.ID = UUID.Random();
item.Name = message.Name;
item.OwnerID = cap.OwnerID;
item.ParentID = message.FolderID;
Permissions perms = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions;
perms.EveryoneMask = message.EveryoneMask;
perms.GroupMask = message.GroupMask;
perms.NextOwnerMask = message.NextOwnerMask;
item.Permissions = perms;
item.SalePrice = 10;
item.SaleType = SaleType.Not;
if (!m_inventoryClient.TryCreateItem(cap.OwnerID, item))
{
m_log.Warn("Failed to create inventory item for uploaded asset " + assetID);
}
}
else
{
m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length);
}
}
else
{
m_log.Warn("Inventory asset upload contained no data");
}
// Build the response message
NewFileAgentInventoryUploadReplyMessage reply = new NewFileAgentInventoryUploadReplyMessage();
reply.NewAsset = assetID;
if (item != null)
{
reply.NewInventoryItem = item.ID;
reply.NewBaseMask = item.Permissions.BaseMask;
reply.NewEveryoneMask = item.Permissions.EveryoneMask;
reply.NewNextOwnerMask = item.Permissions.NextOwnerMask;
reply.NewOwnerMask = item.Permissions.OwnerMask;
}
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
/// <summary>
/// Initializes a new instance based on the specified <paramref name="response"/>.
/// </summary>
/// <param name="response">The instance of <see cref="IHttpResponse"/> the response should be based on.</param>
protected FlickrResponse(IHttpResponse response) : base(response)
{
ValidateResponse(response);
}
private FlickrGetPhotosetInfoResponse(IHttpResponse response) : base(response)
{
Body = ParseXmlElement(response.Body, FlickrGetPhotosetInfoResponseBody.Parse);
}
/// <summary>
/// Creates a new <see cref="NotFoundException"/>.
/// </summary>
/// <param name="request">The original request.</param>
/// <param name="response">The response.</param>
/// <exception cref="ArgumentNullException"><paramref name="request"/> or <paramref name="response"/> is <c>null</c>.</exception>
public NotFoundException(IHttpRequest request, IHttpResponse <ErrorObject> response) :
base(request, response, response.Content.Message)
{
}
public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request)
{
return(null);
}
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto)
{
}
private void NewFileAgentInventoryHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryMessage message;
if (LLUtil.TryGetMessage <NewFileAgentInventoryMessage>(request.Body, out message))
{
m_log.Error("Implement NewFileAgentInventory");
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventory");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void NewFileAgentInventoryVariablePriceHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryVariablePriceMessage message;
if (LLUtil.TryGetMessage <NewFileAgentInventoryVariablePriceMessage>(request.Body, out message))
{
NewFileAgentInventoryVariablePriceReplyMessage reply = new NewFileAgentInventoryVariablePriceReplyMessage();
reply.ResourceCost = 0;
reply.UploadPrice = 0;
// Create a one time upload capability
reply.Rsvp = m_scene.Capabilities.AddOneTimeCapability(cap.OwnerID, true,
delegate(Capability _cap, IHttpClientContext _context, IHttpRequest _request, IHttpResponse _response)
{ NewFileAgentInventoryVariablePriceUploadHandler(message, _cap, _context, _request, _response); }
);
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventoryVariablePrice");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
public IReadOnlyCollection <TogglEntry> GetEntries(DateTime from, DateTime to)
{
IReadOnlyCollection <TogglEntry> entries = null;
string errorMessage = string.Empty;
string completeUrl = GetFormattedEntriesUrl(from, to);
Logger.DebugFormat("Getting entries from Toggl updated between {0} and {1}", GetFormattedTime(from), GetFormattedTime(to));
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(completeUrl);
CookieContainer cookieContainer = new CookieContainer();
cookieContainer.Add(request.RequestUri, AuthCookie);
request.CookieContainer = cookieContainer;
request.Method = "GET";
request.ContentType = "application/json";
try
{
using (IHttpResponse response = DataSource.GetResponse(request))
{
if (response.StatusCode == HttpStatusCode.OK)
{
Logger.Debug("Got a OK when getting entries from Toggl");
try
{
entries = response.GetResponseData <TogglEntry[]>();
}
catch (FormatException fe)
{
errorMessage = "Invalid response from server";
Logger.Error("Error while parsing Toggl server response", fe);
}
if (entries == null)
{
Logger.Error("Serializing Toggl server response gave null");
errorMessage = "Invalid response from server";
}
else if (entries.Any())
{
Logger.DebugFormat("Got {0} entries from Toggl", entries.Count());
}
else
{
Logger.Debug("Got an empty array of entries from Toggl");
}
}
else
{
errorMessage = $"Server returned '{response.StatusCode}'";
Logger.WarnFormat("Did not get an OK when fetching entries from Toggle {0}", response.StatusCode);
}
}
}
catch (WebException we)
{
errorMessage = we.Message;
Logger.Error("Exception while getting Toggl entries", we);
}
if (entries != null)
{
EncounteredError = false;
entries = RemoveTooShortEntries(entries);
}
else
{
EncounteredError = true;
FetchingEntriesFailed?.Invoke(errorMessage);
}
return(entries);
}
private void NewFileAgentInventoryUploadHandler(NewFileAgentInventoryMessage message, Capability cap,
IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = request.GetBody();
UUID assetID = UUID.Zero;
UUID itemID = UUID.Zero;
m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)");
if (assetData != null && assetData.Length > 0)
{
string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType);
// Create the asset
if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID))
{
// Create the inventory item
LLInventoryItem item = new LLInventoryItem();
item.AssetID = assetID;
item.ContentType = contentType;
item.CreationDate = DateTime.UtcNow;
item.CreatorID = cap.OwnerID;
item.Description = message.Description;
item.ID = UUID.Random();
item.Name = message.Name;
item.OwnerID = cap.OwnerID;
item.ParentID = message.FolderID;
item.Permissions = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions;
item.SalePrice = 10;
item.SaleType = SaleType.Not;
if (m_inventoryClient.TryCreateItem(cap.OwnerID, item))
{
itemID = item.ID;
}
else
{
m_log.Warn("Failed to create inventory item for uploaded asset " + assetID);
}
}
else
{
m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length);
}
}
else
{
m_log.Warn("Inventory asset upload contained no data");
}
// Build the response message
OSDMap reply = new OSDMap
{
{ "state", OSD.FromString("complete") },
{ "new_asset", OSD.FromUUID(assetID) },
{ "new_inventory_item", OSD.FromUUID(itemID) }
};
LLUtil.SendLLSDXMLResponse(response, reply);
}
private async Task <bool> GetStatus(IComputer computer, Task interrupt)
{
logger.Log("Process " + Id + " getting status on computer " + computer.Name + " at " + computer.Host);
// use a 2 minute heartbeat for now
int timeout = 120000;
StringBuilder sb = new StringBuilder(directory);
sb.AppendFormat("?version={0}", statusVersion);
sb.AppendFormat("&timeout={0}", timeout);
Task <IHttpResponse> completed;
try
{
IHttpRequest request = HttpClient.Create(computer.ProcessServer + sb.ToString());
request.Timeout = timeout + 30000;
Task <IHttpResponse> bail = interrupt.ContinueWith((t) => null as IHttpResponse);
completed = await Task.WhenAny(bail, request.GetResponseAsync());
if (completed == bail)
{
logger.Log("Process " + Id + " abandoned status due to finishWaiter");
ToExited(ProcessExitState.StatusFailed, DateTime.Now.ToFileTimeUtc(), 1, "Service stopped while waiting for status");
return(true);
}
}
catch (NotHttpException e)
{
string error = "Status fetch failed message " + e.Message + " status " + e.Response.StatusCode + ": " + e.Response.StatusDescription;
logger.Log("Process " + Id + " got remote process status failure " + error);
ToExited(ProcessExitState.StatusFailed, DateTime.Now.ToFileTimeUtc(), 1, error);
return(true);
}
catch (Exception e)
{
string error = "Status fetch failed message " + e.Message;
logger.Log("Process " + Id + " got remote process status failure " + error);
ToExited(ProcessExitState.StatusFailed, DateTime.Now.ToFileTimeUtc(), 1, error);
return(true);
}
using (IHttpResponse response = completed.Result)
{
try
{
// read the empty payload to the end to keep the protocol happy
using (Stream payloadStream = response.GetResponseStream())
{
}
}
catch (NotHttpException e)
{
string error = "Status fetch failed message " + e.Message + " status " + e.Response.StatusCode + ": " + e.Response.StatusDescription;
logger.Log("Process " + Id + " got remote process status failure " + error);
ToExited(ProcessExitState.StatusFailed, DateTime.Now.ToFileTimeUtc(), 1, error);
return(true);
}
catch (Exception e)
{
string error = "Status fetch failed message " + e.Message;
logger.Log("Process " + Id + " got remote process status failure " + error);
ToExited(ProcessExitState.StatusFailed, DateTime.Now.ToFileTimeUtc(), 1, error);
return(true);
}
return(UpdateProcessStatus(response));
}
}
/// <summary>Initializes a new instance of the NServiceKit.ServiceHost.HttpRequestContext class.</summary>
///
/// <param name="httpReq">The HTTP request.</param>
/// <param name="httpRes">The HTTP resource.</param>
/// <param name="dto"> The dto.</param>
public HttpRequestContext(IHttpRequest httpReq, IHttpResponse httpRes, object dto)
: this(httpReq, httpRes, dto, EndpointAttributes.None)
{
}
/// <summary>
/// Send an HTTP response with an XML body content.
/// </summary>
/// <param name="response">
/// The HTTP response that needs to be sent.
/// </param>
/// <param name="statusCode">
/// WebDAV status code that should be set.
/// </param>
/// <param name="xDocument">
/// XML document that should be sent as the body of the message.
/// </param>
/// <returns>
/// A task that represents the asynchronous response send.
/// </returns>
public static async Task SendResponseAsync(this IHttpResponse response, DavStatusCode statusCode, XDocument xDocument)
{
// Make sure an XML document is specified
if (xDocument == null)
{
throw new ArgumentNullException(nameof(xDocument));
}
// Make sure the XML document has a root node
if (xDocument.Root == null)
{
throw new ArgumentException("The specified XML document doesn't have a root node", nameof(xDocument));
}
// Set the response
response.SetStatus(statusCode);
// Obtain the result as an XML document
using (var ms = new MemoryStream())
{
using (var xmlWriter = XmlWriter.Create(ms, new XmlWriterSettings
{
OmitXmlDeclaration = false,
#if DEBUG
Indent = true,
#else
Indent = false,
#endif
Encoding = s_utf8Encoding,
}))
{
// Add the namespaces (Win7 WebDAV client requires them like this)
xDocument.Root.SetAttributeValue(XNamespace.Xmlns + WebDavNamespaces.DavNsPrefix, WebDavNamespaces.DavNs);
xDocument.Root.SetAttributeValue(XNamespace.Xmlns + WebDavNamespaces.Win32NsPrefix, WebDavNamespaces.Win32Ns);
// Write the XML document to the stream
xDocument.WriteTo(xmlWriter);
}
// Flush
ms.Flush();
#if DEBUG
// Dump the XML document to the logging
if (s_log.IsLogEnabled(NWebDav.Server.Logging.LogLevel.Debug))
{
// Reset stream and write the stream to the result
ms.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(ms);
s_log.Log(NWebDav.Server.Logging.LogLevel.Debug, () => reader.ReadToEnd());
}
#endif
// Set content type/length
response.SetHeaderValue("Content-Type", "text/xml; charset=\"utf-8\"");
response.SetHeaderValue("Content-Length", ms.Position.ToString(CultureInfo.InvariantCulture));
// Reset stream and write the stream to the result
ms.Seek(0, SeekOrigin.Begin);
await ms.CopyToAsync(response.Stream).ConfigureAwait(false);
}
}
public async Task GetKeyStatus(IProcessKeyStatus status)
{
logger.Log("Process " + Id + " sending key/value fetch for " +
status.GetKey() + ":" + status.GetVersion() + ":" + status.GetTimeout());
IComputer remote;
Task computerInterrupt;
lock (this)
{
// use a lock to ensure memory safety since these are set on another thread
remote = computer;
computerInterrupt = computerCancellation;
}
Task interrupt = Task.WhenAny(computerInterrupt, AsyncCancelTask);
StringBuilder sb = new StringBuilder(directory);
sb.AppendFormat("?key={0}", status.GetKey());
sb.AppendFormat("&timeout={0}", status.GetTimeout());
sb.AppendFormat("&version={0}", status.GetVersion());
Task <IHttpResponse> completed;
try
{
IHttpRequest request = HttpClient.Create(remote.ProcessServer + sb.ToString());
request.Timeout = status.GetTimeout() + 30000;
Task <IHttpResponse> bail = interrupt.ContinueWith((t) => null as IHttpResponse);
completed = await Task.WhenAny(bail, request.GetResponseAsync());
if (completed == bail)
{
logger.Log("Process " + Id + " abandoned property fetch due to interrupt");
return;
}
}
catch (NotHttpException e)
{
string error = "Status fetch failed message " + e.Message + " status " + e.Response.StatusCode + ": " + e.Response.StatusDescription;
logger.Log("Process " + Id + " got remote property fetch failure from " + remote.Name +
" at " + remote.Host + ": " + error);
status.OnCompleted(0, null, 1, error);
return;
}
catch (Exception e)
{
string error = "Status fetch failed message " + e.ToString();
logger.Log("Process " + Id + " got remote property fetch failure from " + remote.Name +
" at " + remote.Host + ": " + error);
status.OnCompleted(0, null, 1, error);
return;
}
using (IHttpResponse response = completed.Result)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
Task payload;
using (Stream payloadStream = response.GetResponseStream())
{
payload = await Task.WhenAny(interrupt, payloadStream.CopyToAsync(ms));
}
if (payload == interrupt)
{
logger.Log("Process " + Id + " abandoned property fetch due to interrupt");
return;
}
logger.Log("Process " + Id + " completed property fetch");
UInt64 newVersion = UInt64.Parse(response.Headers["X-Dryad-ValueVersion"]);
string stateString = response.Headers["X-Dryad-ProcessStatus"];
int exitCode = Int32.Parse(response.Headers["X-Dryad-ProcessExitCode"]);
logger.Log("Process " + Id + " property fetch: " + status.GetKey() + ":" + newVersion + ":" + stateString);
status.OnCompleted(newVersion, ms.ToArray(), exitCode, null);
}
}
catch (NotHttpException e)
{
string error = "Status fetch failed message " + e.Message + " status " + e.Response.StatusCode + ": " + e.Response.StatusDescription;
logger.Log("Process " + Id + " got remote property fetch failure from " + remote.Name +
" at " + remote.Host + ": " + error);
status.OnCompleted(0, null, 1, error);
}
catch (Exception e)
{
string error = "Header fetch failed message " + e.ToString() + " headers " + response.Headers;
logger.Log("Process " + Id + " got remote property fetch failure from " + remote.Name +
" at " + remote.Host + ": " + error);
status.OnCompleted(0, null, 1, error);
}
}
}
private void PrepareResponce(IHttpResponse httpResponse)
{
byte[] byteSegments = httpResponse.GetBytes();
this.client.Send(byteSegments, SocketFlags.None);
}
public void Intercept(IHttpResponse httpResponse)
{
// intentionally empty, due to null object pattern
}
public virtual void OnFailedAuthentication(IAuthSession session, IHttpRequest httpReq, IHttpResponse httpRes)
{
httpRes.StatusCode = (int)HttpStatusCode.Unauthorized;
httpRes.AddHeader(HttpHeaders.WwwAuthenticate, "{0} realm=\"{1}\"".Fmt(this.Provider, this.AuthRealm));
httpRes.EndServiceStackRequest();
}
private static readonly UTF8Encoding s_utf8Encoding = new UTF8Encoding(false); // Suppress BOM (not compatible with WebDrive)
/// <summary>
/// Set status of the HTTP response.
/// </summary>
/// <param name="response">
/// The HTTP response that should be changed.
/// </param>
/// <param name="statusCode">
/// WebDAV status code that should be set.
/// </param>
/// <param name="statusDescription">
/// The human-readable WebDAV status description. If no status
/// description is set (or <see langword="null"/>), then the
/// default status description is written.
/// </param>
/// <remarks>
/// Not all HTTP infrastructures allow to set the status description,
/// so it should only be used for informational purposes.
/// </remarks>
public static void SetStatus(this IHttpResponse response, DavStatusCode statusCode, string statusDescription = null)
{
// Set the status code and description
response.Status = (int)statusCode;
response.StatusDescription = statusDescription ?? statusCode.GetStatusDescription();
}
public virtual ICookies GetCookies(IHttpResponse res) => Cookies.CreateCookies(res);
public static void HandleFailedAuth(IAuthProvider authProvider,
IAuthSession session, IHttpRequest httpReq, IHttpResponse httpRes)
{
var baseAuthProvider = authProvider as AuthProvider;
if (baseAuthProvider != null)
{
baseAuthProvider.OnFailedAuthentication(session, httpReq, httpRes);
return;
}
httpRes.StatusCode = (int)HttpStatusCode.Unauthorized;
httpRes.AddHeader(HttpHeaders.WwwAuthenticate, "{0} realm=\"{1}\""
.Fmt(authProvider.Provider, authProvider.AuthRealm));
httpRes.EndServiceStackRequest();
}
public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName)
{
response.EndHttpRequest(skipClose: true, afterBody: r => {
var fileName = request.GetPhysicalPath();
var fi = new FileInfo(fileName);
if (!fi.Exists)
{
if ((fi.Attributes & FileAttributes.Directory) != 0)
{
foreach (var defaultDoc in EndpointHost.Config.DefaultDocuments)
{
var defaultFileName = Path.Combine(fi.FullName, defaultDoc);
if (!File.Exists(defaultFileName))
{
continue;
}
r.Redirect(request.GetPathUrl() + '/' + defaultDoc);
return;
}
}
if (!fi.Exists)
{
var originalFileName = fileName;
if (Env.IsMono)
{
//Create a case-insensitive file index of all host files
if (allFiles == null)
{
allFiles = CreateFileIndex(request.ApplicationFilePath);
}
if (allDirs == null)
{
allDirs = CreateDirIndex(request.ApplicationFilePath);
}
if (allFiles.TryGetValue(fileName.ToLower(), out fileName))
{
fi = new FileInfo(fileName);
}
}
if (!fi.Exists)
{
var msg = "Static File '" + request.PathInfo + "' not found.";
log.WarnFormat("{0} in path: {1}", msg, originalFileName);
throw new HttpException(404, msg);
}
}
}
TimeSpan maxAge;
if (r.ContentType != null && EndpointHost.Config.AddMaxAgeForStaticMimeTypes.TryGetValue(r.ContentType, out maxAge))
{
r.AddHeader(HttpHeaders.CacheControl, "max-age=" + maxAge.TotalSeconds);
}
if (request.HasNotModifiedSince(fi.LastWriteTime))
{
r.ContentType = MimeTypes.GetMimeType(fileName);
r.StatusCode = 304;
return;
}
try
{
r.AddHeaderLastModified(fi.LastWriteTime);
r.ContentType = MimeTypes.GetMimeType(fileName);
if (fileName.EqualsIgnoreCase(this.DefaultFilePath))
{
if (fi.LastWriteTime > this.DefaultFileModified)
{
SetDefaultFile(this.DefaultFilePath); //reload
}
r.OutputStream.Write(this.DefaultFileContents, 0, this.DefaultFileContents.Length);
r.Close();
return;
}
if (!Env.IsMono)
{
r.TransmitFile(fileName);
}
else
{
r.WriteFile(fileName);
}
}
catch (Exception ex)
{
log.ErrorFormat("Static file {0} forbidden: {1}", request.PathInfo, ex.Message);
throw new HttpException(403, "Forbidden.");
}
});
}
public void ProcessRequest(IHttpRequest request, IHttpResponse response, string operationName)
{
var fileName = request.GetPhysicalPath();
var fi = new FileInfo(fileName);
if (!fi.Exists)
{
if ((fi.Attributes & FileAttributes.Directory) != 0)
{
foreach (var defaultDoc in EndpointHost.Config.DefaultDocuments)
{
var defaultFileName = Path.Combine(fi.FullName, defaultDoc);
if (!File.Exists(defaultFileName))
{
continue;
}
response.Redirect(request.GetPathUrl() + '/' + defaultDoc);
return;
}
}
if (!fi.Exists)
{
throw new HttpException(404, "File '" + request.PathInfo + "' not found.");
}
}
TimeSpan maxAge;
if (response.ContentType != null && EndpointHost.Config.AddMaxAgeForStaticMimeTypes.TryGetValue(response.ContentType, out maxAge))
{
response.AddHeader(HttpHeaders.CacheControl, "max-age=" + maxAge.TotalSeconds);
}
if (request.HasNotModifiedSince(fi.LastWriteTime))
{
response.ContentType = MimeTypes.GetMimeType(fileName);
response.StatusCode = 304;
return;
}
try
{
response.AddHeaderLastModified(fi.LastWriteTime);
response.ContentType = MimeTypes.GetMimeType(fileName);
if (fileName.EqualsIgnoreCase(this.DefaultFilePath))
{
if (fi.LastWriteTime > this.DefaultFileModified)
{
SetDefaultFile(this.DefaultFilePath); //reload
}
response.OutputStream.Write(this.DefaultFileContents, 0, this.DefaultFileContents.Length);
return;
}
if (!Env.IsMono)
{
response.TransmitFile(fileName);
}
else
{
response.WriteFile(fileName);
}
}
catch (Exception)
{
throw new HttpException(403, "Forbidden.");
}
}
public override void Execute(IHttpRequest req, IHttpResponse res, object requestDto)
{
throw new NotImplementedException();
}
public void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
var metadata = new MetadataTypes
{
Config = Config,
};
var existingTypes = new HashSet <Type> {
typeof(ResponseStatus),
typeof(ErrorResponse),
};
var meta = EndpointHost.Metadata;
foreach (var operation in meta.Operations)
{
if (!meta.IsVisible(httpReq, operation))
{
continue;
}
metadata.Operations.Add(new MetadataOperationType
{
Actions = operation.Actions,
Request = operation.RequestType.ToType(),
Response = operation.ResponseType.ToType(),
});
existingTypes.Add(operation.RequestType);
if (operation.ResponseType != null)
{
existingTypes.Add(operation.ResponseType);
}
}
foreach (var type in meta.GetAllTypes())
{
if (existingTypes.Contains(type))
{
continue;
}
metadata.Operations.Add(new MetadataOperationType
{
Request = type.ToType(),
});
existingTypes.Add(type);
}
var considered = new HashSet <Type>(existingTypes);
var queue = new Queue <Type>(existingTypes);
while (queue.Count > 0)
{
var type = queue.Dequeue();
foreach (var pi in type.GetSerializableProperties())
{
if (pi.PropertyType.IsUserType())
{
if (considered.Contains(pi.PropertyType))
{
continue;
}
considered.Add(pi.PropertyType);
queue.Enqueue(pi.PropertyType);
metadata.Types.Add(pi.PropertyType.ToType());
}
}
if (type.BaseType != null &&
type.BaseType.IsUserType() &&
!considered.Contains(type.BaseType))
{
considered.Add(type.BaseType);
queue.Enqueue(type.BaseType);
metadata.Types.Add(type.BaseType.ToType());
}
}
var json = metadata.ToJson();
//httpRes.ContentType = "application/json";
//httpRes.Write(json);
//return;
httpRes.ContentType = "application/x-ssz-metatypes";
var encJson = CryptUtils.Encrypt(EndpointHostConfig.PublicKey, json, RsaKeyLengths.Bit2048);
httpRes.Write(encJson);
}
protected Message ExecuteMessage(Message message, EndpointAttributes endpointAttributes, IHttpRequest httpRequest, IHttpResponse httpResponse)
{
var soapFeature = endpointAttributes.ToSoapFeature();
EndpointHost.Config.AssertFeatures(soapFeature);
var httpReq = HttpContext.Current != null && httpRequest == null
? new HttpRequestWrapper(HttpContext.Current.Request)
: httpRequest;
var httpRes = HttpContext.Current != null && httpResponse == null
? new HttpResponseWrapper(HttpContext.Current.Response)
: httpResponse;
if (httpReq == null)
{
throw new ArgumentNullException("httpRequest");
}
if (httpRes == null)
{
throw new ArgumentNullException("httpResponse");
}
if (EndpointHost.ApplyPreRequestFilters(httpReq, httpRes))
{
return(PrepareEmptyResponse(message, httpReq));
}
var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream);
string requestXml = GetRequestXml(requestMsg);
var requestType = GetRequestType(requestMsg, requestXml);
if (!EndpointHost.Metadata.CanAccess(endpointAttributes, soapFeature.ToFormat(), requestType.Name))
{
throw EndpointHost.Config.UnauthorizedAccess(endpointAttributes);
}
try
{
var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>();
var request = useXmlSerializerRequest
? XmlSerializableDeserializer.Instance.Parse(requestXml, requestType)
: DataContractDeserializer.Instance.Parse(requestXml, requestType);
var requiresSoapMessage = request as IRequiresSoapMessage;
if (requiresSoapMessage != null)
{
requiresSoapMessage.Message = requestMsg;
}
httpReq.OperationName = requestType.Name;
httpReq.SetItem("SoapMessage", requestMsg);
var hasRequestFilters = EndpointHost.RequestFilters.Count > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters && EndpointHost.ApplyRequestFilters(httpReq, httpRes, request))
{
return(EmptyResponse(requestMsg, requestType));
}
var response = ExecuteService(request, endpointAttributes, httpReq, httpRes);
var hasResponseFilters = EndpointHost.ResponseFilters.Count > 0 ||
FilterAttributeCache.GetResponseFilterAttributes(response.GetType()).Any();
if (hasResponseFilters && EndpointHost.ApplyResponseFilters(httpReq, httpRes, response))
{
return(EmptyResponse(requestMsg, requestType));
}
var httpResult = response as IHttpResult;
if (httpResult != null)
{
response = httpResult.Response;
}
var useXmlSerializerResponse = response.GetType().HasAttribute <XmlSerializerFormatAttribute>();
if (useXmlSerializerResponse)
{
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response, new XmlSerializerWrapper(response.GetType()))
: Message.CreateMessage(requestMsg.Version, requestType.Name + "Response", response, new XmlSerializerWrapper(response.GetType())));
}
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response)
: Message.CreateMessage(requestMsg.Version, requestType.Name + "Response", response));
}
catch (Exception ex)
{
throw new SerializationException("3) Error trying to deserialize requestType: "
+ requestType
+ ", xml body: " + requestXml, ex);
}
}
/// <summary>
/// End a ServiceStack Request
/// </summary>
public static void EndRequest(this IHttpResponse httpRes, bool skipHeaders = false)
{
httpRes.EndHttpHandlerRequest(skipHeaders: skipHeaders);
EndpointHost.CompleteRequest();
}
protected void SendOneWay(Message requestMsg, IHttpRequest httpRequest, IHttpResponse httpResponse)
{
var endpointAttributes = EndpointAttributes.OneWay | this.HandlerAttributes;
ExecuteMessage(requestMsg, endpointAttributes, httpRequest, httpResponse);
}
/// <summary>
/// Initializes a new instance based on the specified <paramref name="response"/>.
/// </summary>
/// <param name="response">The instance of <see cref="IHttpResponse"/> representing the raw response.</param>
protected VimeoResponse(IHttpResponse response) : base(response)
{
RateLimiting = VimeoRateLimiting.GetFromResponse(response);
ValidateResponse(response);
}
public override object GetResponse(IHttpRequest httpReq, IHttpResponse httpRes, object request)
{
throw new NotImplementedException();
}
protected Message Send(Message requestMsg, IHttpRequest httpRequest, IHttpResponse httpResponse)
{
var endpointAttributes = EndpointAttributes.Reply | this.HandlerAttributes;
return(ExecuteMessage(requestMsg, endpointAttributes, httpRequest, httpResponse));
}
