408 lines
14 KiB
C#
408 lines
14 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Web;
|
|
using log4net;
|
|
|
|
using OpenSim.Framework.ServiceAuth;
|
|
|
|
namespace OpenSim.Framework
|
|
{
|
|
/// <summary>
|
|
/// Implementation of a generic REST client
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This class is a generic implementation of a REST (Representational State Transfer) web service. This
|
|
/// </remarks>
|
|
public class RestClient : IDisposable
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
// private string realuri;
|
|
|
|
#region member variables
|
|
|
|
/// <summary>
|
|
/// The base Uri of the web-service e.g. http://www.google.com
|
|
/// </summary>
|
|
private readonly string _url;
|
|
|
|
/// <summary>
|
|
/// Path elements of the query
|
|
/// </summary>
|
|
private readonly List<string> _pathElements = new();
|
|
|
|
/// <summary>
|
|
/// Parameter elements of the query, e.g. min=34
|
|
/// </summary>
|
|
private readonly Dictionary<string, string> _parameterElements = new();
|
|
|
|
/// <summary>
|
|
/// Request method. E.g. GET, POST, PUT or DELETE
|
|
/// </summary>
|
|
private string _method;
|
|
|
|
/// <summary>
|
|
/// Temporary buffer used to store bytes temporarily as they come in from the server
|
|
/// </summary>
|
|
private readonly byte[] _readbuf;
|
|
|
|
/// <summary>
|
|
/// MemoryStream representing the resulting resource
|
|
/// </summary>
|
|
private readonly MemoryStream _resource;
|
|
|
|
/// <summary>
|
|
/// Default time out period
|
|
/// </summary>
|
|
private const int DefaultTimeout = 90000; // 90 seconds timeout
|
|
|
|
/// <summary>
|
|
/// Default Buffer size of a block requested from the web-server
|
|
/// </summary>
|
|
private const int BufferSize = 4 * 4096; // Read blocks of 4 * 4 KB.
|
|
|
|
#endregion member variables
|
|
|
|
#region constructors
|
|
|
|
/// <summary>
|
|
/// Instantiate a new RestClient
|
|
/// </summary>
|
|
/// <param name="url">Web-service to query, e.g. http://osgrid.org:8003</param>
|
|
public RestClient(string url)
|
|
{
|
|
_url = url;
|
|
_readbuf = new byte[BufferSize];
|
|
_resource = new MemoryStream();
|
|
_lock = new object();
|
|
}
|
|
|
|
private readonly object _lock;
|
|
|
|
#endregion constructors
|
|
|
|
|
|
#region Dispose
|
|
|
|
private bool disposed = false;
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (disposed)
|
|
return;
|
|
|
|
if (disposing)
|
|
{
|
|
_resource.Dispose();
|
|
}
|
|
|
|
disposed = true;
|
|
}
|
|
|
|
#endregion Dispose
|
|
|
|
|
|
/// <summary>
|
|
/// Add a path element to the query, e.g. assets
|
|
/// </summary>
|
|
/// <param name="element">path entry</param>
|
|
public void AddResourcePath(string element)
|
|
{
|
|
_pathElements.Add(Util.TrimEndSlash(element));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a query parameter to the Url
|
|
/// </summary>
|
|
/// <param name="name">Name of the parameter, e.g. min</param>
|
|
/// <param name="value">Value of the parameter, e.g. 42</param>
|
|
public void AddQueryParameter(string name, string value)
|
|
{
|
|
try
|
|
{
|
|
_parameterElements.Add(HttpUtility.UrlEncode(name), HttpUtility.UrlEncode(value));
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
m_log.Error("[REST]: Query parameter " + name + " is already added.");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[REST]: An exception was raised adding query parameter to dictionary. Exception: {0}",e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a query parameter to the Url
|
|
/// </summary>
|
|
/// <param name="name">Name of the parameter, e.g. min</param>
|
|
public void AddQueryParameter(string name)
|
|
{
|
|
try
|
|
{
|
|
_parameterElements.Add(HttpUtility.UrlEncode(name), null);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
m_log.Error("[REST]: Query parameter " + name + " is already added.");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[REST]: An exception was raised adding query parameter to dictionary. Exception: {0}",e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Web-Request method, e.g. GET, PUT, POST, DELETE
|
|
/// </summary>
|
|
public string RequestMethod
|
|
{
|
|
get { return _method; }
|
|
set { _method = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Build a Uri based on the initial Url, path elements and parameters
|
|
/// </summary>
|
|
/// <returns>fully constructed Uri</returns>
|
|
private Uri buildUri()
|
|
{
|
|
StringBuilder sb = new();
|
|
sb.Append(_url);
|
|
|
|
foreach (string e in _pathElements)
|
|
{
|
|
sb.Append('/');
|
|
sb.Append(e);
|
|
}
|
|
|
|
bool firstElement = true;
|
|
foreach (KeyValuePair<string, string> kv in _parameterElements)
|
|
{
|
|
if (firstElement)
|
|
{
|
|
sb.Append('?');
|
|
firstElement = false;
|
|
}
|
|
else
|
|
sb.Append('&');
|
|
|
|
sb.Append(kv.Key);
|
|
if (!string.IsNullOrEmpty(kv.Value))
|
|
{
|
|
sb.Append('=');
|
|
sb.Append(kv.Value);
|
|
}
|
|
}
|
|
// realuri = sb.ToString();
|
|
//m_log.InfoFormat("[REST CLIENT]: RestURL: {0}", realuri);
|
|
return new Uri(sb.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform a synchronous request
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MemoryStream Request()
|
|
{
|
|
return Request(null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform a synchronous request
|
|
/// </summary>
|
|
public MemoryStream Request(IServiceAuth auth)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
Uri uri = null;
|
|
HttpResponseMessage responseMessage = null;
|
|
HttpRequestMessage request = null;
|
|
HttpClient client = null;
|
|
try
|
|
{
|
|
client = WebUtil.GetNewGlobalHttpClient(DefaultTimeout);
|
|
uri = buildUri();
|
|
request = new(new HttpMethod(RequestMethod), uri);
|
|
|
|
auth?.AddAuthorization(request.Headers);
|
|
request.Headers.ExpectContinue = false;
|
|
request.Headers.TransferEncodingChunked = false;
|
|
|
|
//if (keepalive)
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Keep-Alive", "timeout=30, max=10");
|
|
request.Headers.TryAddWithoutValidation("Connection", "Keep-Alive");
|
|
request.Headers.ConnectionClose = false;
|
|
}
|
|
//else
|
|
// request.Headers.TryAddWithoutValidation("Connection", "close");
|
|
|
|
|
|
if (WebUtil.DebugLevel >= 3)
|
|
m_log.DebugFormat("[REST CLIENT] {0} to {1}", RequestMethod, uri);
|
|
|
|
//_request.ContentType = "application/xml";
|
|
responseMessage = client.Send(request, HttpCompletionOption.ResponseHeadersRead);
|
|
responseMessage.EnsureSuccessStatusCode();
|
|
|
|
using CancellationTokenSource cts = new(30000);
|
|
using Stream respStream = responseMessage.Content.ReadAsStream(cts.Token);
|
|
int length = respStream.Read(_readbuf, 0, BufferSize);
|
|
while (length > 0)
|
|
{
|
|
_resource.Write(_readbuf, 0, length);
|
|
length = respStream.Read(_readbuf, 0, BufferSize);
|
|
}
|
|
}
|
|
catch (HttpRequestException e)
|
|
{
|
|
if(uri is not null)
|
|
{
|
|
if (e.StatusCode is HttpStatusCode status)
|
|
{
|
|
if (status == HttpStatusCode.NotFound)
|
|
{
|
|
// This is often benign. E.g., requesting a missing asset will return 404.
|
|
m_log.DebugFormat("[REST CLIENT] Resource not found (404): {0}", uri.ToString());
|
|
}
|
|
else
|
|
{
|
|
m_log.Error($"[REST CLIENT] Error fetching resource from server: {uri} status: {status} {e.Message}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Error($"[REST CLIENT] Error fetching resource from server: {uri} {e.Message}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Error($"[REST CLIENT] Error fetching null resource from server: {e.Message}");
|
|
}
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
request?.Dispose();
|
|
responseMessage?.Dispose();
|
|
client?.Dispose();
|
|
}
|
|
|
|
if (_resource != null)
|
|
{
|
|
_resource.Flush();
|
|
_resource.Seek(0, SeekOrigin.Begin);
|
|
}
|
|
|
|
if (WebUtil.DebugLevel >= 5)
|
|
WebUtil.LogOutgoingDetail("[REST CLIENT]", _resource);
|
|
|
|
return _resource;
|
|
}
|
|
}
|
|
|
|
// just sync post data, ignoring result
|
|
public void POSTRequest(byte[] src, IServiceAuth auth)
|
|
{
|
|
Uri uri = null;
|
|
HttpResponseMessage responseMessage = null;
|
|
HttpRequestMessage request = null;
|
|
HttpClient client = null;
|
|
try
|
|
{
|
|
client = WebUtil.GetNewGlobalHttpClient(DefaultTimeout);
|
|
uri = buildUri();
|
|
request = new(HttpMethod.Post, uri);
|
|
|
|
auth?.AddAuthorization(request.Headers);
|
|
request.Headers.ExpectContinue = false;
|
|
request.Headers.TransferEncodingChunked = false;
|
|
|
|
//if (keepalive)
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Keep-Alive", "timeout=30, max=10");
|
|
request.Headers.TryAddWithoutValidation("Connection", "Keep-Alive");
|
|
request.Headers.ConnectionClose = false;
|
|
}
|
|
//else
|
|
// request.Headers.TryAddWithoutValidation("Connection", "close");
|
|
|
|
request.Content = new ByteArrayContent(src);
|
|
request.Content.Headers.TryAddWithoutValidation("Content-Type", "application/xml");
|
|
request.Content.Headers.TryAddWithoutValidation("Content-Length", src.Length.ToString());
|
|
|
|
responseMessage = client.Send(request, HttpCompletionOption.ResponseContentRead);
|
|
responseMessage.EnsureSuccessStatusCode();
|
|
}
|
|
catch (HttpRequestException e)
|
|
{
|
|
if(uri is not null)
|
|
{
|
|
if (e.StatusCode is HttpStatusCode status)
|
|
m_log.Warn($"[REST]: POST {uri} failed with status {status} and message {e.Message}");
|
|
else
|
|
m_log.Warn($"[REST]: POST {uri} failed with message {e.Message}");
|
|
}
|
|
else
|
|
m_log.Warn($"[REST]: POST failed {e.Message}");
|
|
return;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (uri is not null)
|
|
m_log.Warn($"[REST]: POST {uri} failed with message {e.Message}");
|
|
else
|
|
m_log.Warn($"[REST]: POST failed {e.Message}");
|
|
return;
|
|
}
|
|
finally
|
|
{
|
|
request?.Dispose();
|
|
responseMessage?.Dispose();
|
|
client?.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|