public void Should_serialize_null()
{
var serialized = EnvironmentNodeDataSerializer.Serialize(null);
var deserialized = EnvironmentNodeDataSerializer.Deserialize(envName, serialized);
deserialized.Should().BeEquivalentTo(new EnvironmentInfo(envName, null, null));
}
public static byte[] SetEnvironmentProperties(string environment, Func <IEnvironmentInfoProperties, IEnvironmentInfoProperties> update, byte[] bytes)
{
var environmentInfo = EnvironmentNodeDataSerializer.Deserialize(environment, bytes);
var newProperties = update(environmentInfo.Properties);
return(EnvironmentNodeDataSerializer.Serialize(new EnvironmentInfo(environment, environmentInfo.ParentEnvironment, newProperties)));
}
public async Task <bool> TryCreateEnvironmentAsync(IEnvironmentInfo environmentInfo)
{
var createRequest = new CreateRequest(pathHelper.BuildEnvironmentPath(environmentInfo.Environment), CreateMode.Persistent)
{
Data = EnvironmentNodeDataSerializer.Serialize(environmentInfo)
};
return((await zooKeeperClient.CreateAsync(createRequest).ConfigureAwait(false)).IsSuccessful);
}
protected void CreateEnvironmentNode(string environment, string parent = null, IReadOnlyDictionary <string, string> properties = null)
{
var info = new EnvironmentInfo(environment, parent, properties);
var data = EnvironmentNodeDataSerializer.Serialize(info);
var path = PathHelper.BuildEnvironmentPath(environment);
CreateOrUpdate(path, data);
}
public void Should_serialize_and_deserialize(string parent)
{
foreach (var properties in TestProperties())
{
var info = new EnvironmentInfo(envName, parent, properties);
var serialized = EnvironmentNodeDataSerializer.Serialize(info);
var deserialized = EnvironmentNodeDataSerializer.Deserialize(envName, serialized);
deserialized.Should().BeEquivalentTo(info);
}
}
private void Update(string name, VersionedContainer <EnvironmentInfo> container)
{
if (isDisposed)
{
return;
}
try
{
var environmentPath = pathHelper.BuildEnvironmentPath(name);
var environmentExists = zooKeeperClient.Exists(new ExistsRequest(environmentPath)
{
Watcher = nodeWatcher
});
if (!environmentExists.IsSuccessful)
{
return;
}
if (environmentExists.Stat == null)
{
container.Clear();
}
else
{
if (!container.NeedUpdate(environmentExists.Stat.ModifiedZxId))
{
return;
}
var environmentData = zooKeeperClient.GetData(new GetDataRequest(environmentPath)
{
Watcher = nodeWatcher
});
if (environmentData.Status == ZooKeeperStatus.NodeNotFound)
{
container.Clear();
}
if (!environmentData.IsSuccessful)
{
return;
}
var info = EnvironmentNodeDataSerializer.Deserialize(name, environmentData.Data);
container.Update(environmentData.Stat.ModifiedZxId, info);
}
}
catch (Exception error)
{
log.Error(error, "Failed to update '{Environment}' environment.", name);
}
}
public async Task <IEnvironmentInfo> GetEnvironmentAsync(string environment)
{
var data = await zooKeeperClient.GetDataAsync(new GetDataRequest(pathHelper.BuildEnvironmentPath(environment))).ConfigureAwait(false);
if (data.Status == ZooKeeperStatus.NodeNotFound)
{
return(null);
}
data.EnsureSuccess();
var envData = EnvironmentNodeDataSerializer.Deserialize(environment, data.Data);
return(envData);
}
public void Should_deserialize_empty()
{
EnvironmentNodeDataSerializer.Deserialize(envName, new byte[0]).Should().BeEquivalentTo(new EnvironmentInfo(envName, null, null));
}
public static byte[] SetEnvironmentParent(string environment, string newParent, byte[] bytes)
{
var environmentInfo = EnvironmentNodeDataSerializer.Deserialize(environment, bytes);
return(EnvironmentNodeDataSerializer.Serialize(new EnvironmentInfo(environment, newParent, environmentInfo.Properties)));
}
