/// <summary>
/// Write exception to output message
/// </summary>
public async Task WriteExceptionAsync(HttpResponse httpResponse, Exception ex)
{
// Check if it's an unknown error, not managed (yet)
if (!(ex is SyncException syncException))
{
syncException = new SyncException(ex);
}
var webException = new WebSyncException
{
Message = syncException.Message,
SyncStage = syncException.SyncStage,
TypeName = syncException.TypeName,
DataSource = syncException.DataSource,
InitialCatalog = syncException.InitialCatalog,
Number = syncException.Number,
Side = syncException.Side
};
var webXMessage = JsonConvert.SerializeObject(webException);
httpResponse.StatusCode = StatusCodes.Status400BadRequest;
httpResponse.ContentLength = webXMessage.Length;
await httpResponse.WriteAsync(webXMessage);
}
/// <summary>
/// Write exception to output message
/// </summary>
public async Task WriteExceptionAsync(HttpResponse httpResponse, Exception ex)
{
// Check if it's an unknwon error, not managed (yet)
if (!(ex is SyncException syncException))
{
syncException = new SyncException(ex.Message, SyncStage.None, this.LocalProvider.ProviderTypeName, SyncExceptionType.Unknown);
}
var webXMessage = JsonConvert.SerializeObject(syncException);
httpResponse.StatusCode = StatusCodes.Status400BadRequest;
httpResponse.ContentLength = webXMessage.Length;
await httpResponse.WriteAsync(webXMessage);
}
/// <summary>
/// Write exception to output message
/// </summary>
public Task <HttpResponseMessage> WriteExceptionAsync(Exception ex)
{
// Check if it's an unknwon error, not managed (yet)
if (!(ex is SyncException syncException))
{
syncException = new SyncException(ex.Message, SyncStage.None, this.LocalProvider.ProviderTypeName, SyncExceptionType.Unknown);
}
var webXMessage = JsonConvert.SerializeObject(syncException);
var response = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(webXMessage)
};
return(Task.FromResult(response));
}
/// <summary>
/// Handle a request error
/// </summary>
/// <returns></returns>
private async Task HandleSyncError(HttpResponseMessage response, ISerializerFactory serializerFactory)
{
try
{
if (TryGetHeaderValue(response.Headers, "dotmim-sync-error", out string syncErrorTypeName))
{
using (var streamResponse = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
if (streamResponse.CanRead && streamResponse.Length > 0)
{
// Error are always json formatted
var webSyncErrorSerializer = new Serialization.JsonConverter <WebSyncException>();
var webError = await webSyncErrorSerializer.DeserializeAsync(streamResponse);
if (webError != null)
{
var syncException = new SyncException(webError.Message);
syncException.DataSource = webError.DataSource;
syncException.InitialCatalog = webError.InitialCatalog;
syncException.Number = webError.Number;
syncException.Side = webError.Side;
syncException.SyncStage = webError.SyncStage;
syncException.TypeName = webError.TypeName;
throw syncException;
}
}
}
}
else
{
throw new UnknownException(await response.Content.ReadAsStringAsync());
}
}
catch (SyncException sexc)
{
throw sexc;
}
catch (Exception ex)
{
throw new SyncException(ex);
}
}
public override void EnsureSyncException(SyncException syncException)
{
if (!string.IsNullOrEmpty(this.ConnectionString))
{
var builder = new MySqlConnectionStringBuilder(this.ConnectionString);
syncException.DataSource = builder.Server;
syncException.InitialCatalog = builder.Database;
}
var mySqlException = syncException.InnerException as MySqlException;
if (mySqlException == null)
{
return;
}
syncException.Number = mySqlException.Number;
return;
}
public override void EnsureSyncException(SyncException syncException)
{
if (!string.IsNullOrEmpty(this.ConnectionString))
{
var builder = new SqliteConnectionStringBuilder(this.ConnectionString);
syncException.DataSource = builder.DataSource;
}
var sqliteException = syncException.InnerException as SqliteException;
if (sqliteException == null)
{
return;
}
syncException.Number = sqliteException.SqliteErrorCode;
return;
}
public override void EnsureSyncException(SyncException syncException)
{
if (!string.IsNullOrEmpty(this.ConnectionString))
{
var builder = new SqlConnectionStringBuilder(this.ConnectionString);
syncException.DataSource = builder.DataSource;
syncException.InitialCatalog = builder.InitialCatalog;
}
// Can add more info from SqlException
var sqlException = syncException.InnerException as SqlException;
if (sqlException == null)
{
return;
}
syncException.Number = sqlException.Number;
return;
}
/// <summary>
/// Process a request message with HttpClient object.
/// </summary>
public async Task <T> ProcessRequest <T>(T content, Guid sessionId, SerializationFormat serializationFormat, CancellationToken cancellationToken)
{
if (this.BaseUri == null)
{
throw new ArgumentException("BaseUri is not defined");
}
HttpResponseMessage response = null;
T responseMessage = default(T);
try
{
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
var requestUri = new StringBuilder();
requestUri.Append(this.BaseUri.ToString());
requestUri.Append(this.BaseUri.ToString().EndsWith("/", StringComparison.CurrentCultureIgnoreCase) ? string.Empty : "/");
// Add params if any
if (ScopeParameters != null && ScopeParameters.Count > 0)
{
string prefix = "?";
foreach (var kvp in ScopeParameters)
{
requestUri.AppendFormat("{0}{1}={2}", prefix, Uri.EscapeUriString(kvp.Key),
Uri.EscapeUriString(kvp.Value));
if (prefix.Equals("?"))
{
prefix = "&";
}
}
}
// default handler if no one specified
HttpClientHandler httpClientHandler = this.Handler ?? new HttpClientHandler();
// serialize dmSet content to bytearraycontent
var serializer = BaseConverter <T> .GetConverter(serializationFormat);
var binaryData = serializer.Serialize(content);
ByteArrayContent arrayContent = new ByteArrayContent(binaryData);
// do not dispose HttpClient for performance issue
if (client == null)
{
client = new HttpClient(httpClientHandler);
}
// reinit client
client.DefaultRequestHeaders.Clear();
// add it to the default header
if (this.Cookie != null)
{
client.DefaultRequestHeaders.Add("Cookie", this.Cookie.ToString());
}
var requestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri.ToString())
{
Content = arrayContent
};
// Adding the serialization format used and session id
requestMessage.Headers.Add("dotmim-sync-session-id", sessionId.ToString());
requestMessage.Headers.Add("dotmim-sync-serialization-format", serializationFormat.ToString());
// Adding others headers
if (this.CustomHeaders != null && this.CustomHeaders.Count > 0)
{
foreach (var kvp in this.CustomHeaders)
{
if (!requestMessage.Headers.Contains(kvp.Key))
{
requestMessage.Headers.Add(kvp.Key, kvp.Value);
}
}
}
//request.AddHeader("content-type", "application/json");
if (serializationFormat == SerializationFormat.Json && !requestMessage.Content.Headers.Contains("content-type"))
{
requestMessage.Content.Headers.Add("content-type", "application/json");
}
response = await client.SendAsync(requestMessage, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
// get response from server
if (!response.IsSuccessStatusCode && response.Content != null)
{
var exrror = await response.Content.ReadAsStringAsync();
SyncException syncException = JsonConvert.DeserializeObject <SyncException>(exrror);
if (syncException != null)
{
throw syncException;
}
}
// try to set the cookie for http session
var headers = response?.Headers;
if (headers != null)
{
if (headers.TryGetValues("Set-Cookie", out IEnumerable <string> tmpList))
{
var cookieList = tmpList.ToList();
// var cookieList = response.Headers.GetValues("Set-Cookie").ToList();
if (cookieList != null && cookieList.Count > 0)
{
#if NETSTANDARD
// Get the first cookie
this.Cookie = CookieHeaderValue.ParseList(cookieList).FirstOrDefault();
#else
//try to parse the very first cookie
if (CookieHeaderValue.TryParse(cookieList[0], out var cookie))
{
this.Cookie = cookie;
}
#endif
}
}
}
using (var streamResponse = await response.Content.ReadAsStreamAsync())
if (streamResponse.CanRead && streamResponse.Length > 0)
{
responseMessage = serializer.Deserialize(streamResponse);
}
return(responseMessage);
}
catch (TaskCanceledException)
{
throw;
}
catch (SyncException)
{
throw;
}
catch (Exception e)
{
if (response == null || response.Content == null)
{
throw e;
}
var exrror = await response.Content.ReadAsStringAsync();
throw new SyncException(exrror);
}
}
