/// <summary>
/// WebResponseをApiErrorFormatに変換する
/// </summary>
/// <param name="response">変換するWebResponse</param>
/// <returns>変換後のApiErrorFormat</returns>
public ApiErrorFormat ConvertError(IWebResponse response)
{
if (response.IsNetworkError)
{
return(new ApiErrorFormat()
{
code = "NETWORK_ERROR",
message = response.RawErrorMessage
});
}
else if (response.IsHttpError)
{
try
{
ApiResponseTemplate <EmptySerializer> templateJson = JsonConvert.DeserializeObject <ApiResponseTemplate <EmptySerializer> >(response.Text);
return(templateJson.error);
}
catch
{
return(new ApiErrorFormat()
{
code = "HTTP_ERROR",
message = "An HTTP error occurred. Status code: " + response.StatusCode.ToString()
});
}
}
else
{
return(new ApiErrorFormat()
{
code = "UNKNOWN_ERROR",
message = "Maybe the request was successful"
});
}
}
public async Task <GetStatusResult> GetFullStatusAsync()
{
if (_sessionProvider.IsSessionExpired)
{
return(new GetStatusResult(WebServiceError.SessionTokenExpired, new SessionExpiredException()));
}
string url = string.Format("{0}/v2/mobile/user.{1}", _sessionProvider.TransportUrl, _sessionProvider.UserId);
var request = GetGetRequest(url);
SetAuthorizationHeaderOnRequest(request, _sessionProvider.AccessToken);
Exception exception = null;
try {
IWebResponse response = await request.GetResponseAsync();
string responseString = await response.GetResponseStringAsync();
var structures = _deserializer.ParseStructuresFromGetStatusResult(responseString, _sessionProvider.UserId);
_analyticsService.LogEvent("Structures: {0}, Devices: {1}", structures.Count(), structures.Sum(s => s.Thermostats.Count()));
return(new GetStatusResult(structures));
}
catch (Exception ex) {
exception = ex;
}
var error = await _deserializer.ParseWebServiceErrorAsync(exception);
return(new GetStatusResult(error, exception));
}
public AllocateJobChunkResponse Parse(AllocateJobChunkRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK, HttpStatusCode.ServiceUnavailable, HttpStatusCode.NotFound);
using (var responseStream = response.GetResponseStream())
{
switch (response.StatusCode)
{
case HttpStatusCode.OK:
return(AllocateJobChunkResponse.Success(
JobResponseParser <AllocateJobChunkRequest> .ParseObjectList(
XmlExtensions
.ReadDocument(responseStream)
.ElementOrThrow("Objects")
)
));
case HttpStatusCode.ServiceUnavailable:
return(AllocateJobChunkResponse.RetryAfter(TimeSpan.FromSeconds(int.Parse(response.Headers["retry-after"]))));
case HttpStatusCode.NotFound:
return(AllocateJobChunkResponse.ChunkGone);
default:
throw new NotSupportedException(Resources.InvalidEnumValueException);
}
}
}
}
public GetJobListResponse Parse(GetJobListRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK);
using (var stream = response.GetResponseStream())
{
return(new GetJobListResponse(
jobs: XmlExtensions
.ReadDocument(stream)
.ElementOrThrow("Jobs")
.Elements("Job")
.Select(jobElement => new JobInfo(
jobElement.AttributeText("BucketName"),
jobElement.AttributeText("StartDate"),
Guid.Parse(jobElement.AttributeText("JobId")),
jobElement.AttributeText("Priority"),
jobElement.AttributeText("RequestType"),
ResponseParseUtilities.ParseJobStatus(jobElement.AttributeText("Status"))
))
.ToList()
));
}
}
}
protected virtual async Task OnListenAsync()
{
HttpListener listener = Listener;
while (listener.IsListening)
{
Log.Debug("Http listener processing.");
try
{
HttpListenerContext context = await listener.GetContextAsync();
try
{
IWebRequest request = await OnCreateRequestAsync(context);
IWebResponse response = await OnCreateResponseAsync(request, context);
await OnProcessResponse(response, context);
}
catch (Exception exception)
{
await OnProcessError(exception, context);
}
}
catch (Exception exception)
{
Log.Warning("Listener processing error has occurred.", exception);
await Task.Yield();
}
}
}
public async Task <WebServiceResult> UpdateTransportUrlAsync()
{
IWebRequest request = GetPostJsonRequest("https://home.nest.com/user/service_urls");
SetAuthorizationHeaderOnRequest(request, _sessionProvider.AccessToken);
Exception exception = null;
try {
IWebResponse response = await request.GetResponseAsync();
string strContent = await response.GetResponseStringAsync();
var transportUrl = _deserializer.ParseTransportUrlFromResult(strContent);
_sessionProvider.UpdateTransportUrl(transportUrl);
return(new WebServiceResult());
}
catch (Exception ex) {
exception = ex;
}
var error = await _deserializer.ParseWebServiceErrorAsync(exception);
return(new WebServiceResult(error, exception));
}
internal static async Task ManageRequest(IWebResponse response)
{
response.SetEncoding("UTF-8");
string path = GetQueryPath(response.GetRequestedPath());
var content = GetResourceStream(path);
//Manage Index content
if (path == Constants.DefaultPage)
{
content = ManageIndexPageRendering(content);
}
response.AddResponseHeader("Cache-Control", "no-cache");
response.AddResponseHeader("Access-Control-Allow-Origin", GetBaseURL());
if (content == null)
{
//Content not found
response.SetStatutCode(404);
response.SetReasonPhrase("Not found");
response.SetMimeType("text/plain");
return;
}
response.SetStatutCode(200);
response.SetReasonPhrase("OK");
response.SetMimeType(GetContentType(path));
await response.SetDataAsync(content);
}
/// <summary>
/// Returns a value indicating if a connection can be made to the resource.
/// </summary>
public void CheckConnection()
{
if (State != WebOperationState.Idle)
{
return;
}
State = WebOperationState.InProgress;
Result = WebOperationResult.None;
_webRequest.Method = GetWebCheckConnectionMethod();
IWebResponse response = null;
try
{
OnWebOperationProgress(new WebOperationProgressChangedEventArgs(0, 0, State, Result));
response = _webRequest.GetResponse();
Result = WebOperationResult.Completed;
}
finally
{
if (response != null)
{
response.Close();
}
State = WebOperationState.Idle;
OnWebOperationProgress(new WebOperationProgressChangedEventArgs(0, 0, State, Result));
}
}
public virtual void SetContent(IWebResponse response, Content <Stream> content)
{
bool closeStream = this.IsStreamOwner;
lock (lockObject) {
closeStream = !response.IsStreamOwner;
WebServer.ContentGetter = response.Getter(content);
WebBrowser.MakeReady();
if (UseProxy)
{
var browserWithProxy = this.Backend as IWebBrowserWithProxy;
if (browserWithProxy != null)
{
browserWithProxy.SetProxy(WebServer.Addr, WebServer.Port, this.Backend);
}
}
WebBrowser.Navigate(response.AbsoluteUri);
WebBrowser.WaitFor(() =>
response.Done
);
Trace.WriteLine("Navigated to " + response.AbsoluteUri);
}
}
private async Task <GetThermostatStatusResult> GetSharedThermostatPropertiesAsync(Thermostat thermostat)
{
string url = string.Format("{0}/v2/subscribe", _sessionProvider.TransportUrl);
IWebRequest request = GetPostJsonRequest(url);
SetAuthorizationHeaderOnRequest(request, _sessionProvider.AccessToken);
SetNestHeadersOnRequest(request, _sessionProvider.UserId);
string requestString = string.Format("{{\"keys\":[{{\"key\":\"shared.{0}\"}}]}}", thermostat.ID);
await request.SetRequestStringAsync(requestString);
Exception exception;
try {
IWebResponse response = await request.GetResponseAsync();
string strContent = await response.GetResponseStringAsync();
var updatedThermostat = new Thermostat(thermostat.ID);
_deserializer.UpdateThermostatStatusFromSharedStatusResult(strContent, updatedThermostat);
return(new GetThermostatStatusResult(updatedThermostat));
}
catch (Exception ex) {
exception = ex;
}
var error = await _deserializer.ParseWebServiceErrorAsync(exception);
return(new GetThermostatStatusResult(error, exception));
}
private async Task <GetStatusResult> GetStructureStatusAsync(Structure structure)
{
string url = string.Format("{0}/v2/subscribe", _sessionProvider.TransportUrl);
var request = GetPostJsonRequest(url);
SetAuthorizationHeaderOnRequest(request, _sessionProvider.AccessToken);
SetNestHeadersOnRequest(request, _sessionProvider.UserId);
string requestString = string.Format("{{\"keys\":[{{\"key\":\"structure.{0}\"}}]}}", structure.ID);
await request.SetRequestStringAsync(requestString);
Exception exception;
try {
IWebResponse response = await request.GetResponseAsync();
string responseString = await response.GetResponseStringAsync();
Structure parsedStructure = _deserializer.ParseStructureFromGetStructureStatusResult(responseString, structure.ID);
return(new GetStatusResult(new[] { parsedStructure }));
}
catch (Exception ex) {
exception = ex;
}
var error = await _deserializer.ParseWebServiceErrorAsync(exception);
return(new GetStatusResult(error, exception));
}
public DeleteObjectListResponse Parse(DeleteObjectListRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK);
using (var content = response.GetResponseStream())
{
var deleteResult = XmlExtensions
.ReadDocument(content)
.ElementOrThrow("DeleteResult");
return(new DeleteObjectListResponse(
deletedObjects: deleteResult
.Elements("Deleted")
.Select(el => el.TextOf("Key"))
.ToList(),
deleteErrors: deleteResult
.Elements("Error")
.Select(el => new DeleteDs3ObjectError(
el.TextOf("Key"),
el.TextOf("Code"),
el.TextOf("Message")
))
.ToList()
));
}
}
}
/// <summary>
/// WebResponseを指定したDataModelに変換する
/// </summary>
/// <param name="response">変換するWebResponse</param>
/// <param name="onSuccess">変換に成功した時のコールバック</param>
/// <param name="onError">エラー発生時のコールバック</param>
/// <typeparam name="T">成功した時の戻り値の型</typeparam>
public override void Convert(IWebResponse response, Action <ApiResponseTemplate <T> > onSuccess, Action <ApiErrorFormat> onError)
{
if (onSuccess == null)
{
return;
}
ApiResponseTemplate <T> templateJson;
try
{
templateJson = JsonConvert.DeserializeObject <ApiResponseTemplate <T> >(response.Text);
}
catch (Exception e)
{
if (onError != null)
{
onError(new ApiErrorFormat()
{
code = "JSON_DESERIALIZE_ERROR",
message = e.Message
});
}
return;
}
onSuccess(templateJson);
}
public ModelBinder(IWebResponse response)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
this.binder = getCompoundModelBinder(response);
}
private static Stream CheckResponseStream(IWebResponse webResponse)
{
Stream responseStream = webResponse.GetResponseStream();
if (responseStream == null)
throw new Exception("Error: Response stream cannot be read");
return responseStream;
}
internal static PrtgClient Initialize_Client(IWebResponse response, RequestVersion version)
{
var client = Initialize_Client(response);
SetVersion(client, version);
return(client);
}
/// <summary>
/// Instantiates a new process contrext for inversion.
/// </summary>
/// <remarks>You can think of this type here as "being Inversion". This is the thing.</remarks>
/// <param name="underlyingContext">The underlying http context to wrap.</param>
/// <param name="services">The service container the context will use.</param>
/// <param name="resources">The resources available to the context.</param>
public OwinProcessContext(IOwinContext underlyingContext, IServiceContainer services, IResourceAdapter resources)
: base(services, resources)
{
_underlyingContext = underlyingContext;
_application = null;
_response = new OwinResponse(this.UnderlyingContext.Response);
_request = new OwinRequest(this.UnderlyingContext.Request);
}
public static PrtgClient Initialize_Client(IWebResponse response)
{
var webClient = new MockWebClient(response);
var client = new PrtgClient("prtg.example.com", "username", "12345678", AuthMode.PassHash, webClient);
return(client);
}
public static T BindTo <T>(this IWebResponse response, T instance, IModelBinder <T> binder = null)
{
if (binder == null)
{
binder = new ModelBinder <T>(response);
}
binder.Bind(instance);
return(instance);
}
public ApiResponse(IWebResponse response)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
this.response = response;
}
public override void Process(IWebResponse response)
{
//response.Send(Encoding.ASCII.GetBytes(TestResponse.Header));
Status = 200;
StatusDescription = "OK";
ResponseHeaders.Add("Content-Type", "text/html; charset=utf-8");
response.Send(Encoding.ASCII.GetBytes(TestResponse.Response));
response.CompleteResponse();
}
public override void Process(IWebResponse response)
{
//response.Send(Encoding.ASCII.GetBytes(TestResponse.Header));
Status = 200;
StatusDescription = "OK";
ResponseHeaders.Add("Content-Type","text/html; charset=utf-8");
response.Send(Encoding.ASCII.GetBytes(TestResponse.Response));
response.CompleteResponse ();
}
/// <summary>
/// Downloads the resource to a stream.
/// </summary>
/// <param name="stream">The stream used to receive the data.</param>
public void Download(Stream stream)
{
if (State != WebOperationState.Idle)
{
return;
}
State = WebOperationState.InProgress;
Result = WebOperationResult.None;
_webRequest.Method = GetWebDownloadMethod();
long totalBytesRead = 0;
long totalLength;
IWebResponse response = _webRequest.GetResponse();
using (Stream responseStream = response.GetResponseStream())
{
totalLength = response.ContentLength;
if (AutoSizeBuffer)
{
Buffer = CalculateBufferSize(totalLength);
}
var buffer = new byte[Buffer];
int bytesRead = 0;
do
{
if (_cancel)
{
Result = WebOperationResult.Canceled;
break;
}
if (responseStream != null)
{
bytesRead = responseStream.Read(buffer, 0, buffer.Length);
}
stream.Write(buffer, 0, bytesRead);
totalBytesRead += bytesRead;
OnWebOperationProgress(new WebOperationProgressChangedEventArgs(totalBytesRead, totalLength, State, Result));
}while (bytesRead > 0);
}
if (Result != WebOperationResult.Canceled && (totalLength < 0 || totalBytesRead == totalLength))
{
Result = WebOperationResult.Completed;
}
// Close the Response Stream
response.Close();
State = WebOperationState.Idle;
OnWebOperationProgress(new WebOperationProgressChangedEventArgs(totalBytesRead, totalLength, State, Result));
}
protected IWebResponse ErrorResponseBody(string message, HttpStatusCode statusCode, object body = null)
{
IWebResponse response = _responseFactory.GetErrorResponse();
response.Message = message;
response.StatusCode = statusCode;
response.Body = body;
return(response);
}
protected IWebResponse SuccessResponseBody(object body, string message = "")
{
IWebResponse response = _responseFactory.GetSuccessReponse();
response.Body = body;
response.StatusCode = HttpStatusCode.OK;
response.Message = message;
return(response);
}
public static void HandleStatusCode(IWebResponse response, params HttpStatusCode[] expectedStatusCodes)
{
HttpStatusCode actualStatusCode = response.StatusCode;
if (!expectedStatusCodes.Contains(actualStatusCode))
{
var responseContent = GetResponseContent(response);
var error = ParseError(responseContent);
throw new Ds3BadStatusCodeException(expectedStatusCodes, actualStatusCode, error, responseContent);
}
}
protected async Task <IWebResponse> HandleRequestAsync(IWebRequest request)
{
IWebResponse response = await Handler.ExecuteAsync(this, request);
if (response == null)
{
throw new ArgumentNullException(nameof(response), "Value cannot be null or empty.");
}
return(response);
}
public static void HandleStatusCode(IWebResponse response, params HttpStatusCode[] expectedStatusCodes)
{
HttpStatusCode actualStatusCode = response.StatusCode;
if (!expectedStatusCodes.Contains(actualStatusCode))
{
var responseContent = GetResponseContent(response);
var error = ParseError(responseContent);
throw new Ds3BadStatusCodeException(expectedStatusCodes, actualStatusCode, error, responseContent);
}
}
public JobResponse Parse(TRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK);
using (Stream content = response.GetResponseStream())
{
return(ParseResponseContent(content));
}
}
}
public HeadObjectResponse Parse(HeadObjectRequest request, IWebResponse response)
{
using (response)
{
return(new HeadObjectResponse(
long.Parse(response.Headers.Single(kvp => kvp.Key.ToLowerInvariant() == "content-length").Value),
response.Headers.Single(kvp => kvp.Key.ToLowerInvariant() == "etag").Value,
ResponseParseUtilities.ExtractCustomMetadata(response.Headers)
));
}
}
/// <summary>
/// WebResponseをバイト配列のデータに変換する
/// </summary>
/// <param name="response">変換するWebResponse</param>
/// <param name="onSuccess">変換に成功した時のコールバック</param>
/// <param name="onError">エラー発生時のコールバック</param>
public override void Convert(IWebResponse response, Action <ApiResponseTemplate <byte[]> > onSuccess, Action <ApiErrorFormat> onError)
{
if (onSuccess != null)
{
onSuccess(new ApiResponseTemplate <byte[]>()
{
data = response.Data,
error = new ApiErrorFormat(),
_links = new ApiLinksFormat(),
});
}
}
public static T BindTo <T>(this IWebResponse response, IModelBinder <T> binder = null)
where T : new()
{
if (binder == null)
{
binder = new ModelBinder <T>(response);
}
T instance = new T();
binder.Bind(instance);
return(instance);
}
private void BuildResponse(IMutableWebResponse response, IWebResponse proxyResponse)
{
response.ProtocolVersion = proxyResponse.ProtocolVersion;
response.ContentType = proxyResponse.ContentType;
response.StatusCode = (int)proxyResponse.StatusCode;
response.StatusDescription = proxyResponse.StatusDescription;
if (proxyResponse.ContentLength >= 0)
{
response.ContentLength = proxyResponse.ContentLength;
}
if (proxyResponse.Headers.ContainsKey("Content-Encoding") && !String.IsNullOrWhiteSpace(proxyResponse.ContentEncoding))
{
response.ContentEncoding = Encoding.GetEncoding(proxyResponse.ContentEncoding);
}
if (proxyResponse.Headers.ContainsKey("Location"))
{
response.RedirectLocation = proxyResponse.Headers["Location"];
}
if (proxyResponse.Headers.ContainsKey("Keep-Alive"))
{
bool keepAlive;
if (Boolean.TryParse(proxyResponse.Headers["Keep-Alive"], out keepAlive))
{
response.KeepAlive = keepAlive;
}
}
foreach (var cookie in proxyResponse.Cookies)
{
response.Cookies.Add(cookie);
}
foreach (var header in proxyResponse.Headers)
{
if (header.Key.StartsWith("Proxy-"))
{
continue; // Ignore proxy headers
}
if (PropertyHeaders.Contains(header.Key))
{
continue;
}
response.Headers.Add(header.Key, header.Value);
}
var proxyStream = proxyResponse.GetStream();
var requestStream = response.GetStream();
proxyStream.CopyTo(requestStream);
requestStream.Close();
}
public StreamDepresser(IWebResponse response)
{
this.response = response;
}
public ImdbWrapper(IWebResponse webResponse)
{
_webResponse = webResponse;
}
private bool Is307(IWebResponse httpResponse)
{
return httpResponse.StatusCode.Equals(HttpStatusCode.TemporaryRedirect);
}
public EncodingParser(IWebResponse response)
{
this.response = response;
}
public virtual void Process (IWebResponse response)
{
throw new NotImplementedException ();
}
private static string GetResponseContent(IWebResponse response)
{
using (var stream = response.GetResponseStream())
using (var reader = new StreamReader(stream))
return reader.ReadToEnd();
}
public void Process (IWebResponse response)
{
base.ProcessRequest ();
}
