public async Task <CanJoinResult> SendJoinServerInternalAsync(NodeConnectionInfo leaderNode, NodeConnectionInfo newNode)
{
var url = leaderNode.GetAbsoluteUri() + "admin/cluster/join";
using (var request = CreateRequest(leaderNode, url, HttpMethods.Post))
{
var response = await request.WriteAsync(() => new JsonContent(RavenJToken.FromObject(newNode))).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return(CanJoinResult.CanJoin);
}
switch (response.StatusCode)
{
case HttpStatusCode.Conflict:
return(CanJoinResult.IsNonEmpty);
case HttpStatusCode.NotModified:
return(CanJoinResult.AlreadyJoined);
case HttpStatusCode.NotAcceptable:
return(CanJoinResult.InAnotherCluster);
default:
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
}
public async Task <CanJoinResult> SendCanJoinAsync(NodeConnectionInfo nodeConnectionInfo)
{
var url = nodeConnectionInfo.GetAbsoluteUri() + "admin/cluster/canJoin?topologyId=" + raftEngine.CurrentTopology.TopologyId;
using (var request = CreateRequest(nodeConnectionInfo, url, HttpMethods.Get))
{
var response = await request.ExecuteAsync().ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
var voter = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (voter == "NonVoter")
{
return(CanJoinResult.CanJoinAsNonVoter);
}
return(CanJoinResult.CanJoin);
}
switch (response.StatusCode)
{
case HttpStatusCode.Conflict:
return(CanJoinResult.IsNonEmpty);
case HttpStatusCode.NotModified:
return(CanJoinResult.AlreadyJoined);
case HttpStatusCode.NotAcceptable:
return(CanJoinResult.InAnotherCluster);
default:
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
}
internal Task <Action <HttpClient> > HandleUnauthorizedResponseAsync(HttpResponseMessage unauthorizedResponse, NodeConnectionInfo nodeConnectionInfo)
{
var oauthSource = unauthorizedResponse.Headers.GetFirstValue("OAuth-Source");
if (nodeConnectionInfo.ApiKey == null)
{
AssertUnauthorizedCredentialSupportWindowsAuth(unauthorizedResponse, nodeConnectionInfo);
return(null);
}
if (string.IsNullOrEmpty(oauthSource))
{
oauthSource = nodeConnectionInfo.GetAbsoluteUri() + "/OAuth/API-Key";
}
return(GetAuthenticator(nodeConnectionInfo).DoOAuthRequestAsync(nodeConnectionInfo.GetAbsoluteUri(), oauthSource, nodeConnectionInfo.ApiKey));
}
public async Task SendInitializeNewClusterForAsync(NodeConnectionInfo node, Guid?clusterId = null)
{
var url = node.GetAbsoluteUri() + "admin/cluster/initialize-new-cluster" + (clusterId.HasValue ? "?id=" + clusterId.Value : string.Empty);
using (var request = CreateRequest(node, url, HttpMethods.Patch))
{
var response = await request.ExecuteAsync().ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return;
}
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
public async Task SendLeaveClusterInternalAsync(NodeConnectionInfo leaderNode, NodeConnectionInfo leavingNode)
{
var url = leaderNode.GetAbsoluteUri() + "admin/cluster/leave?name=" + leavingNode.Name;
using (var request = CreateRequest(leaderNode, url, HttpMethods.Get))
{
var response = await request.ExecuteAsync().ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return;
}
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
public async Task SendNodeUpdateInternalAsync(NodeConnectionInfo leaderNode, NodeConnectionInfo nodeToUpdate)
{
var url = leaderNode.GetAbsoluteUri() + "admin/cluster/update";
using (var request = CreateRequest(leaderNode, url, HttpMethods.Post))
{
var response = await request.WriteAsync(() => new JsonContent(RavenJToken.FromObject(nodeToUpdate))).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return;
}
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
private async Task PutAsync(NodeConnectionInfo node, string action, object content)
{
var url = node.GetAbsoluteUri() + action;
using (var request = CreateRequest(node, url, HttpMethods.Put))
{
var response = await request.WriteAsync(() => new JsonContent(RavenJObject.FromObject(content))).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return;
}
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
private async Task SendDatabaseDeleteInternalAsync(NodeConnectionInfo node, string databaseName, bool hardDelete)
{
var url = node.GetAbsoluteUri() + "admin/cluster/commands/database/" + Uri.EscapeDataString(databaseName) + "?hardDelete=" + hardDelete;
using (var request = CreateRequest(node, url, HttpMethods.Delete))
{
var response = await request.ExecuteAsync().ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return;
}
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
private async Task SendReplicationStateAsync(NodeConnectionInfo node, ReplicationState replicationState)
{
var url = node.GetAbsoluteUri() + "cluster/replicationState";
using (var request = CreateRequest(node, url, HttpMethods.Post))
{
var response = await request.WriteAsync(
() => new JsonContent(RavenJToken.FromObject(replicationState)))
.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return;
}
throw await CreateErrorResponseExceptionAsync(response).ConfigureAwait(false);
}
}
internal ReturnToQueue GetConnection(NodeConnectionInfo nodeConnection, out HttpClient result)
{
var connectionQueue = _httpClientsCache.GetOrAdd(nodeConnection.GetAbsoluteUri(), _ => new ConcurrentQueue <HttpClient>());
if (connectionQueue.TryDequeue(out result) == false)
{
var webRequestHandler = new WebRequestHandler
{
UseDefaultCredentials = nodeConnection.HasCredentials() == false,
Credentials = nodeConnection.ToOperationCredentials().Credentials
};
result = new HttpClient(webRequestHandler)
{
BaseAddress = nodeConnection.Uri
};
}
return(new ReturnToQueue(result, connectionQueue));
}
public async Task <ConnectivityStatus> CheckConnectivity(NodeConnectionInfo node)
{
try
{
var url = node.GetAbsoluteUri() + "stats";
using (var request = CreateRequest(node, url, HttpMethods.Get))
{
var response = await request.ExecuteAsync().ConfigureAwait(false);
return(response.IsSuccessStatusCode ? ConnectivityStatus.Online : ConnectivityStatus.Offline);
}
}
catch (ErrorResponseException e)
{
return(e.StatusCode == HttpStatusCode.Unauthorized ? ConnectivityStatus.WrongCredentials : ConnectivityStatus.Offline);
}
catch (Exception)
{
return(ConnectivityStatus.Offline);
}
}
public async Task <Tuple <ConnectivityStatus, string> > CheckConnectivity(NodeConnectionInfo node)
{
try
{
var url = node.GetAbsoluteUri() + "stats";
using (var request = CreateRequest(node, url, HttpMethods.Get))
{
var response = await request.ExecuteAsync().ConfigureAwait(false);
return(response.IsSuccessStatusCode ? Tuple.Create(ConnectivityStatus.Online, string.Empty) : Tuple.Create(ConnectivityStatus.Offline, await response.Content.ReadAsStringAsync().ConfigureAwait(false)));
}
}
catch (ErrorResponseException e)
{
return(Tuple.Create(e.StatusCode == HttpStatusCode.Unauthorized ? ConnectivityStatus.WrongCredentials : ConnectivityStatus.Offline, e.ToString()));
}
catch (Exception e)
{
return(Tuple.Create(ConnectivityStatus.Offline, e.ToString()));
}
}
internal SecuredAuthenticator GetAuthenticator(NodeConnectionInfo info)
{
return(_securedAuthenticatorCache.GetOrAdd(info.GetAbsoluteUri(), _ => new SecuredAuthenticator(autoRefreshToken: false)));
}