public void When_Storing_A_New_Key_Observe_Will_Fail_With_Replication_More_Than_Available_Nodes()
{
var availableNodesCount = getWorkingNodes().Count();
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2);
switch (availableNodesCount)
{
case 1:
{
var observeResult = Client.Observe(kv.Item2, storeResult.Cas, PersistTo.Zero, ReplicateTo.Two);
Assert.That(observeResult.Success, Is.False);
break;
}
case 2:
{
var observeResult = Client.Observe(kv.Item2, storeResult.Cas, PersistTo.Zero, ReplicateTo.Three);
Assert.That(observeResult.Success, Is.False);
break;
}
default:
{
Assert.Fail("The test is applicable only when the number of nodes in cluster is either one or two.");
break;
}
}
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Multi_Node_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.One);
StoreAssertPass(storeResult);
}
public void When_Storing_A_New_Key_Observe_Will_Pass_With_Replication_More_Than_Available_Nodes()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
IStoreOperationResult storeResult = null;
var availableNodesCount = getWorkingNodes().Count();
switch (availableNodesCount)
{
case 1:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Two);
break;
}
case 2:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
break;
}
default:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
break;
}
}
StoreAssertPass(storeResult);
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Master_Persistence_And_Single_Node_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.One, ReplicateTo.One);
TestUtils.StoreAssertPass(storeResult);
}
public void When_Getting_Key_With_Lock_And_Expiry_Set_Fails_Until_Lock_Expires()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var casResult = Client.GetWithLock(kv.Item1, TimeSpan.FromSeconds(2));
Assert.That(casResult.Result, Is.EqualTo(kv.Item2));
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
Thread.Sleep(3000);
var newValue = KeyValueUtils.GenerateValue();
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, newValue);
Assert.That(storeResult.Success, Is.True);
var getResult = Client.ExecuteGet(kv.Item1);
TestUtils.GetAssertPass(getResult, newValue);
}
public void When_Execute_Getting_Key_With_Lock_And_Expiry_Second_Lock_Attempt_Does_Not_Change_Expiry()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult = Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(6));
Assert.That(getlResult.Value, Is.EqualTo(kv.Item2));
var otherGetlResult = Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(2));
Assert.That(otherGetlResult.Cas, Is.Not.EqualTo(getlResult.Cas));
Assert.That(otherGetlResult.StatusCode, Is.EqualTo((int)CouchbaseStatusCodeEnums.LockError));
Thread.Sleep(3000);
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
Assert.That(storeResult.StatusCode.Value, Is.EqualTo((int)StatusCodeEnums.DataExistsForKey));
Thread.Sleep(4000);
var newValue = KeyValueUtils.GenerateValue();
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, newValue);
Assert.That(storeResult.Success, Is.True, "Failed to update item");
var getResult = Client.ExecuteGet(kv.Item1);
TestUtils.GetAssertPass(getResult, newValue);
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Zero_Persistence_And_Zero_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Zero, ReplicateTo.Zero);
StoreAssertPass(storeResult);
}
public override bool KeyValue(string key, string value)
{
if (key == "style")
{
int.TryParse(value, out _style);
return(true);
}
else if (key == "pitch")
{
var angles = Angles;
angles.X = KeyValueUtils.ParseFloat(value);
Angles = angles;
return(true);
}
else if (key == "pattern")
{
_pattern = value;
return(true);
}
return(base.KeyValue(key, value));
}
public void When_Persisting_Json_Id_Is_Not_Serialized_But_Is_Returned_In_View()
{
var key = KeyValueUtils.GenerateKey("json");
var thing = new Thing {
Id = key, SomeProperty = "Foo", SomeOtherProperty = 17
};
var result = Client.ExecuteStoreJson(StoreMode.Set, key, thing, PersistTo.One);
Assert.That(result.Success, Is.True);
var obj = Client.ExecuteGet <string>(key);
Assert.That(obj.Value, Is.Not.StringContaining("\"id\""));
var savedThing = Client.ExecuteGetJson <Thing>(key);
Assert.That(savedThing.Value.Id, Is.StringContaining(key));
var view = Client.GetView <Thing>("things", "all", true);
foreach (var item in view)
{
if (item.Id == key)
{
return;
}
}
Assert.Fail("Id was not returned in view");
}
public void When_Storing_A_New_Key_Observe_Will_Fail_When_Cluster_Has_Too_Few_Nodes_For_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
Assert.That(storeResult.Success, Is.False);
}
public void When_Storing_A_New_Key_Observe_Will_Fail_With_Persistence_More_Than_Available_Nodes()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
IStoreOperationResult storeResult = null;
var availableNodesCount = getWorkingNodes().Count();
switch (availableNodesCount)
{
case 1:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Two);
break;
}
case 2:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Three);
break;
}
case 3:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Four);
break;
}
default:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Four);
break;
}
}
Assert.That(storeResult.Success, Is.False);
}
public void When_Execute_Unlocking_A_Key_With_Invalid_Cas_Key_Is_Unlocked()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult1 = Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult1.Value, Is.EqualTo(kv.Item2));
Assert.That(getlResult1.Success, Is.True);
var getlResult2 = Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult2.Success, Is.False);
var unlockResult = Client.ExecuteUnlock(kv.Item1, getlResult1.Cas - 1);
Assert.That(unlockResult.Success, Is.False);
storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertFail(storeResult);
var getlResult3 = Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult3.Success, Is.False);
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Master_Only_Persistence()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.One);
StoreAssertPass(storeResult);
}
static void Main(string[] args)
{
var data = KeyValueUtils.Load(@"root-folder",
recursive: true,
showProcess: true);
KeyValueUtils.ImportToEtcd(data);
}
public void When_Storing_A_New_Key_Observe_Will_Fail_With_Master_Persistence_And_Cas_Value_Has_Changed()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2);
var observeResult = _Client.Observe(kv.Item2, storeResult.Cas - 1, PersistTo.One, ReplicateTo.Zero);
Assert.That(observeResult.Success, Is.False);
Assert.That(observeResult.Message, Is.StringMatching(ObserveOperationConstants.MESSAGE_MODIFIED));
}
public override bool KeyValue(string key, string value)
{
if (key == "framerate")
{
FrameRate = KeyValueUtils.ParseFloat(value);
return(true);
}
return(base.KeyValue(key, value));
}
public void When_Timeout_Is_Set_To_Greater_Than_30_Seconds_Exception_Is_Thrown()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult = Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(31));
}
public void When_Timeout_Is_Less_Than_Or_Equal_To_30_Seconds_Exception_Is_Not_Thrown()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(30));
Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(29));
Assert.Pass();
}
public void When_Storing_A_New_Key_Observe_Will_Fail_When_Cluster_Has_Too_Few_Nodes_For_Replication()
{
var availableNodesCount = getWorkingNodes().Count();
if (availableNodesCount > 1)
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
Assert.That(storeResult.Success, Is.False);
}
else
{
Assert.Ignore("This test requires more than one node in the cluster");
}
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Multi_Node_Persistence_And_Single_Node_Replication()
{
var availableNodesCount = getWorkingNodes().Count();
if (availableNodesCount > 1)
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Two, ReplicateTo.One);
TestUtils.StoreAssertPass(storeResult);
}
else
{
Assert.Ignore("This test requires more than one node in the cluster");
}
}
public void When_Execute_Getting_Key_With_Lock_Set_Fails_While_Locked()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult = Client.ExecuteGetWithLock(kv.Item1);
Assert.That(getlResult.Value, Is.EqualTo(kv.Item2));
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
Assert.That(storeResult.StatusCode.Value, Is.EqualTo((int)StatusCodeEnums.DataExistsForKey));
}
public void When_Generic_Execute_Getting_Key_With_Lock_And_Expiry_Set_Succeeds_With_Valid_Cas()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = Store(StoreMode.Set, kv.Item1, kv.Item2);
StoreAssertPass(storeResult);
var getlResult = _Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult.Value, Is.EqualTo(kv.Item2));
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
storeResult = _Client.ExecuteCas(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue(), getlResult.Cas);
Assert.That(storeResult.Success, Is.True);
}
public void When_Getting_Key_With_Lock_And_Expiry_Set_Succeeds_With_Valid_Cas()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var casResult = Client.GetWithLock(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(casResult.Result, Is.EqualTo(kv.Item2));
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
storeResult = Client.ExecuteCas(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue(), casResult.Cas);
Assert.That(storeResult.Success, Is.True);
}
public void When_Using_App_Config_And_HttpClient_Factory_Is_Not_Set_Operations_Succeed()
{
var config = ConfigurationManager.GetSection("min-config") as CouchbaseClientSection;
Assert.That(config, Is.Not.Null, "min-config section missing from app.config");
Assert.That(config.HttpClientFactory, Is.InstanceOf <ProviderElement <IHttpClientFactory> >());
var client = new CouchbaseClient(config);
var kv = KeyValueUtils.GenerateKeyAndValue("default_config");
var result = client.ExecuteStore(StoreMode.Add, kv.Item1, kv.Item2);
Assert.That(result.Success, Is.True, "Store failed: " + result.Message);
var value = client.Get(kv.Item1);
Assert.That(value, Is.StringMatching(kv.Item2));
}
public void When_StoringJson_For_A_Class_With_Id_Property_Id_Is_Not_Stored_In_Json()
{
var key = KeyValueUtils.GenerateKey("json");
var thing = new Thing {
Id = key, SomeProperty = "Foo", SomeOtherProperty = 17
};
var result = Client.StoreJson(StoreMode.Set, key, thing);
Assert.That(result, Is.True);
var obj = Client.Get <string>(key);
Assert.That(obj, Is.Not.StringContaining("\"id\""));
var savedThing = Client.GetJson <Thing>(key);
Assert.That(savedThing.Id, Is.StringContaining(key));
}
public void When_Using_Code_Config_And_HttpClient_Factory_Is_Not_Set_Operations_Succeed()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
Assert.That(config.HttpClientFactory, Is.InstanceOf <DefaultHttpClientFactory>());
Assert.That(config, Is.Not.Null, "min-config section missing from app.config");
Assert.That(config.HttpClientFactory, Is.InstanceOf <DefaultHttpClientFactory>());
var client = new CouchbaseClient(config);
var kv = KeyValueUtils.GenerateKeyAndValue("default_config");
var result = client.ExecuteStore(StoreMode.Add, kv.Item1, kv.Item2);
Assert.That(result.Success, Is.True, "Store failed: " + result.Message);
var value = client.Get(kv.Item1);
Assert.That(value, Is.StringMatching(kv.Item2));
}
static int Main(string[] args)
{
// https://github.com/natemcmaster/CommandLineUtils
var app = new CommandLineApplication();
app.Name = "kvutil";
app.HelpOption();
var optionVersion = app.Option("-v|--version", "Show version", CommandOptionType.NoValue);
var optionFolder = app.Option("-f|--folder <FOLDER>", "The root folder for kv import", CommandOptionType.SingleValue);
//var optionRepeat = app.Option<int>("-n|--count <N>", "Repeat", CommandOptionType.SingleValue);
app.OnExecute(() =>
{
if (optionVersion.HasValue())
{
"version 0.01a".OutYellow();
return(0);
}
var dir = optionFolder.HasValue() ? optionFolder.Value() : Directory.GetCurrentDirectory();
if (!Directory.Exists(dir))
{
$"Directory {dir} not exists".OutRed();
return(-1);
}
var data = KeyValueUtils.Load(dir, recursive: true, showProcess: true);
"Data loaded".OutYellow();
KeyValueUtils.ImportToEtcd(data);
"Data imported".OutYellow();
return(0);
});
return(app.Execute(args));
}
/// <summary>
/// Initializes a component's keyvalues from a list of keyvalues
/// </summary>
/// <param name="component"></param>
/// <param name="keyValues"></param>
public bool InitializeComponent(Component component, IReadOnlyList <KeyValuePair <string, string> > keyValues)
{
if (component == null)
{
throw new ArgumentNullException(nameof(component));
}
if (keyValues == null)
{
throw new ArgumentNullException(nameof(keyValues));
}
foreach (var keyValue in keyValues)
{
if (component.MetaData.KeyValues.TryGetValue(keyValue.Key, out var member))
{
component.MetaData.Accessor[component, member.Member.Name] = member.Converter.FromString(member.MemberType, keyValue.Key, keyValue.Value);
}
//Special handling for spawnflags to remap them to booleans
if (keyValue.Key == "spawnflags")
{
var spawnFlags = KeyValueUtils.ParseInt(keyValue.Value);
foreach (var flag in component.MetaData.SpawnFlags)
{
//All flags are assumed to default to false, so only set to true here
if ((flag.Flag & spawnFlags) != 0)
{
component.MetaData.Accessor[component, flag.Member.Name] = true;
}
}
}
}
return(true);
}
private void LoadEntity(List <KeyValuePair <string, string> > block, int index)
{
var className = GetClassName(block, index);
var info = EntityRegistry.FindEntityByMapName(className);
if (info == null)
{
throw new ArgumentException($"No entity class of name {className} exists");
}
BaseEntity entity = null;
//The world always has edict 0, but alloc calls can never get that edict directly.
if (index == 0)
{
entity = EntityRegistry.CreateInstance(info, EntityDictionary.Allocate(0));
}
else
{
entity = EntityRegistry.CreateInstance(info);
}
if (entity == null)
{
throw new ArgumentException($"Couldn't create instance of entity {className}");
}
//The entity can remove itself in Spawn, so keep the edict here to properly free it in case of problems
var edict = entity.Edict();
try
{
foreach (var kv in block)
{
var key = kv.Key;
var value = kv.Value;
//Don't do this multiple times
if (key != "classname")
{
//The engine does not allow values with the same content as the classname to be passed
//No reason to impose this restriction here
CheckKeyValue(entity, ref key, ref value);
if (!KeyValueUtils.TrySetKeyValue(entity, info, key, value))
{
entity.KeyValue(key, value);
}
}
}
Log.Message($"Spawning entity {entity.ClassName} ({entity.GetType().FullName})");
Spawn(entity.Edict());
//TODO: can check if the entity is a template and do stuff here
}
catch (Exception)
{
//On failure always free the edict
//This will also free the entity instance if it has been assigned
EntityDictionary.Free(edict);
throw;
}
}
