public void GetConnectedClient_should_reconnect_to_new_ensemble_after_timeout()
{
using (var ensemble1 = ZooKeeperEnsemble.DeployNew(10, 1, Log))
{
var connectionString = ensemble1.ConnectionString;
// ReSharper disable once AccessToModifiedClosure
var settings = new ZooKeeperClientSettings(() => connectionString)
{
Timeout = DefaultTimeout
};
var holder = new ClientHolder(settings, Log);
WaitForNewConnectedClient(holder);
ensemble1.Dispose();
WaitForDisconnectedState(holder);
using (var ensemble2 = ZooKeeperEnsemble.DeployNew(11, 1, Log))
{
ensemble2.ConnectionString.Should().NotBe(connectionString);
connectionString = ensemble2.ConnectionString;
Thread.Sleep(DefaultTimeout);
WaitForNewConnectedClient(holder);
}
}
}
protected TestObserver <ConnectionState> GetObserver(ClientHolder holder)
{
var observer = new TestObserver <ConnectionState>();
holder.OnConnectionStateChanged.Subscribe(observer);
return(observer);
}
private static async Task <bool> ConsumeApi(ClientHolder holder)
{
using (var client = getClient())
using (var responce = await MakeResponce(client, holder))
{
return(responce.IsSuccessStatusCode);
}
}
private static async Task <T> ConsumeApi <T>(ClientHolder holder)
{
using (var client = getClient())
using (var responce = await MakeResponce(client, holder))
{
return(JsonConvert.DeserializeObject <T>(await responce.Content.ReadAsStringAsync()));
}
}
public static void Register(ClientHolder client, ILog log)
{
if (Interlocked.CompareExchange(ref owner, client, null) != null)
{
return;
}
InjectLogging(log);
}
private void Awake()
{
if (instance != null)
{
Debug.LogWarning("More than one instance found");
return;
}
instance = this;
}
/// <summary>
/// Creates a new instance of <see cref="ZooKeeperClient"/> using given <paramref name="settings" /> and <paramref name="log"/>.
/// </summary>
public ZooKeeperClient([NotNull] ZooKeeperClientSettings settings, [CanBeNull] ILog log)
{
this.settings = settings ?? throw new ArgumentNullException(nameof(settings));
this.log = log = (log ?? LogProvider.Get())
.ForContext <ZooKeeperClient>()
.WithMinimumLevel(settings.LoggingLevel);
clientHolder = new ClientHolder(settings, log);
watcherWrapper = new WatcherWrapper(settings.WatchersCacheCapacity, log);
}
public static async Task <List <Pooper> > GetAllPoopersAsync()
{
var holder = new ClientHolder()
{
Uri = $"{ApiUri.AbsoluteUri}/Poopers",
OperationType = OperationType.Get,
Content = null
};
return(await ConsumeApi <List <Pooper> >(holder));
}
public static async Task <bool> AddFeedItemAsync(FeedItemRequest item)
{
var holder = new ClientHolder()
{
Uri = $"{ApiUri.AbsoluteUri}/FeedItems",
OperationType = OperationType.Post,
Content = MakeContent(item)
};
return(await ConsumeApi(holder));
}
public static async Task <IEnumerable <FeedItem> > GetFeedForPooperAsync(int id, int pageNum = 1)
{
var holder = new ClientHolder()
{
Uri = $"{ApiUri.AbsoluteUri}/FeedItems/pooper/{id}?pageNum={pageNum}",
OperationType = OperationType.Post,
Content = null
};
return(await ConsumeApi <IEnumerable <FeedItem> >(holder));
}
public static async Task <Pooper> DeletePooperAsync(int id)
{
var holder = new ClientHolder()
{
Uri = $"{ApiUri.AbsoluteUri}/Poopers/{id}",
OperationType = OperationType.Delete,
Content = null
};
return(await ConsumeApi <Pooper>(holder));
}
public static async Task <List <Pooper> > CreatePooper(PooperRequest request)
{
var holder = new ClientHolder()
{
Uri = $"{ApiUri.AbsoluteUri}/Poopers",
OperationType = OperationType.Post,
Content = MakeContent(request)
};
return(await ConsumeApi <List <Pooper> >(holder));
}
public void Should_work_with_uri_provider()
{
var settings = new ZooKeeperClientSettings(() => Ensemble.Topology)
{
Timeout = DefaultTimeout
};
var holder = new ClientHolder(settings, Log);
WaitForNewConnectedClient(holder);
holder.ConnectionState.Should().Be(ConnectionState.Connected);
holder.SessionId.Should().NotBe(0);
}
public void GetConnectedClient_should_reconnect_to_new_ensemble_after_connection_string_change(bool useUri)
{
using (var ensemble1 = ZooKeeperEnsemble.DeployNew(10, 1, Log))
{
var currentEnsemble = ensemble1;
var settings = useUri
? new ZooKeeperClientSettings(() => currentEnsemble.Topology)
{
Timeout = DefaultTimeout
}
: new ZooKeeperClientSettings(() => currentEnsemble.ConnectionString)
{
Timeout = DefaultTimeout
};
var holder = new ClientHolder(settings, Log);
var observer = GetObserver(holder);
WaitForNewConnectedClient(holder);
var sid1 = holder.SessionId;
using (var ensemble2 = ZooKeeperEnsemble.DeployNew(11, 1, Log))
{
currentEnsemble = ensemble2;
WaitForNewConnectedClient(holder);
ensemble1.Stop();
WaitForNewConnectedClient(holder);
var sid2 = holder.SessionId;
sid2.Should().NotBe(sid1);
}
VerifyObserverMessages(observer, ConnectionState.Disconnected, ConnectionState.Connected, ConnectionState.Disconnected, ConnectionState.Connected);
}
}
protected static void WaitForNewConnectedClient(ClientHolder holder)
{
holder.GetConnectedClient().ShouldCompleteIn(DefaultTimeout).Should().NotBe(null);
holder.ConnectionState.Should().Be(ConnectionState.Connected);
}
private static async Task <HttpResponseMessage> MakeResponce(K_AkicaClient client, ClientHolder holder)
{
switch (holder.OperationType)
{
case OperationType.Get:
return(await client.GetAsync(holder.Uri));
case OperationType.Post:
return(await client.PostAsync(holder.Uri, holder.Content));
case OperationType.Put:
return(await client.PutAsync(holder.Uri, holder.Content));
case OperationType.Delete:
return(await client.DeleteAsync(holder.Uri));
}
return(null);
}
protected static void WaitForDiedState(ClientHolder holder)
{
Action assertion = () => { holder.ConnectionState.Should().Be(ConnectionState.Died); };
assertion.ShouldPassIn(5.Seconds());
}
protected static Task KillSession(ClientHolder holder, string connectionString) => ZooKeeperClientTestsHelper.KillSession(holder.SessionId, holder.SessionPassword, holder.OnConnectionStateChanged, connectionString, DefaultTimeout);
public static void Unregister(ClientHolder client) => Interlocked.CompareExchange(ref owner, null, client);
