public void TestPlacementPolicyDefaultCBF()
{
var p = new PlacementPolicy(
0,
new Replica[] {
new Replica(1, "EU"),
},
new Selector[] {
new Selector("EU", "Location", Clause.Same, 1, "*"),
},
null
);
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("Location", "Europe"), ("Country", "RU"), ("City", "St.Petersburg")),
Helper.GenerateTestNode(1, ("Location", "Europe"), ("Country", "RU"), ("City", "Moscow")),
Helper.GenerateTestNode(2, ("Location", "Europe"), ("Country", "DE"), ("City", "Berlin")),
Helper.GenerateTestNode(3, ("Location", "Europe"), ("Country", "FR"), ("City", "Paris")),
};
var nm = new NetMap(nodes);
var v = nm.GetContainerNodes(p, null);
Assert.AreEqual((int)Context.DefaultCBF, v.Flatten().Count);
//with pivot
v = nm.GetContainerNodes(p, "59e01b6e64d586a02b8a3fea60749a89f6cef96d8a189bb492c719aa2957223f".HexToBytes());
var r = v.Flatten();
Assert.AreEqual((int)Context.DefaultCBF, r.Count);
Assert.AreEqual(0, r[0].Index);
Assert.AreEqual(1, r[1].Index);
Assert.AreEqual(2, r[2].Index);
}
public void TestFilterOps()
{
string q = @"REP 1
SELECT 2 IN City FROM Good
FILTER A GT 1 AND B GE 2 AND C LT 3 AND D LE 4
AND E EQ 5 AND F NE 6 AS Good";
var expected = new PlacementPolicy(0,
new Replica[] { new Replica(1, "") },
new Selector[] { new Selector("", "City", Clause.Unspecified, 2, "Good") },
new Filter[]
{
new Filter("Good", "", "", Operation.And,
new Filter("", "A", "1", Operation.Gt),
new Filter("", "B", "2", Operation.Ge),
new Filter("", "C", "3", Operation.Lt),
new Filter("", "D", "4", Operation.Le),
new Filter("", "E", "5", Operation.Eq),
new Filter("", "F", "6", Operation.Ne)
)
});
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
}
public void TestPutContainerOnlyOne()
{
using var client = new Client.Client(key, host);
var replica1 = new Replica(1, "loc1");
var replica2 = new Replica(1, "loc2");
var selector1 = new Selector("loc1", "Location", Clause.Same, 1, "loc1");
var selector2 = new Selector("loc2", "Location", Clause.Same, 1, "loc2");
var filter1 = new Filter("loc1", "Location", "Shanghai", Netmap.Operation.Eq);
var filter2 = new Filter("loc2", "Location", "Shanghai", Netmap.Operation.Ne);
var policy = new PlacementPolicy(1, new Replica[] { replica1, replica2 }, new Selector[] { selector1, selector2 }, new Filter[] { filter1, filter2 });
var container = new Container.Container
{
Version = Refs.Version.SDKVersion(),
OwnerId = OwnerID.FromScriptHash(key.PublicKey().PublicKeyToScriptHash()),
Nonce = Guid.NewGuid().ToByteString(),
BasicAcl = BasicAcl.PublicBasicRule,
PlacementPolicy = policy,
};
container.Attributes.Add(new Container.Container.Types.Attribute
{
Key = "CreatedAt",
Value = DateTime.UtcNow.ToString(),
});
using var source = new CancellationTokenSource();
source.CancelAfter(TimeSpan.FromMinutes(1));
var cid = client.PutContainer(container, context: source.Token).Result;
Console.WriteLine(cid.String());
Assert.AreEqual(container.CalCulateAndGetId, cid);
}
public void TestFilterReference()
{
string q = @"REP 1
SELECT 2 IN City FROM Good
FILTER Country EQ RU AS FromRU
FILTER @FromRU AND Rating GT 7 AS Good";
var expected = new PlacementPolicy(0,
new Replica[] { new Replica(1, "") },
new Selector[] { new Selector("", "City", Clause.Unspecified, 2, "Good") },
new Filter[]
{
new Filter("FromRU", "Country", "RU", Operation.Eq),
new Filter("Good", "", "", Operation.And,
new Filter()
{
Name = "FromRU"
},
new Filter("", "Rating", "7", Operation.Gt)
)
});
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
}
public static string[] EncodePlacementPolicy(PlacementPolicy p)
{
if (p is null)
{
return(null);
}
var replicas = new Replica[p.Replicas.Count];
p.Replicas.CopyTo(replicas, 0);
var selectors = new Selector[p.Selectors.Count];
p.Selectors.CopyTo(selectors, 0);
var filters = new Filter[p.Filters.Count];
p.Filters.CopyTo(filters, 0);
List <string> res = new List <string>();
// print replicas
res.AddRange(EncodeReplicas(replicas));
// backup factor
var cbf = p.ContainerBackupFactor;
if (cbf != 0)
{
res.Add("CBF " + cbf.ToString());
}
// selectors
res.AddRange(EncodeSelectors(selectors));
// filters
res.AddRange(EncodeFilters(filters));
return(res.ToArray());
}
public void TestProcessSelectorsHRW()
{
var p = new PlacementPolicy(1, null,
new Selector[] {
new Selector("Main", "Country", Clause.Distinct, 3, "*"),
},
null
);
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("Country", "Germany"), (Node.AttributePrice, "2"), (Node.AttributeCapacity, "10000")),
Helper.GenerateTestNode(1, ("Country", "Germany"), (Node.AttributePrice, "4"), (Node.AttributeCapacity, "1")),
Helper.GenerateTestNode(2, ("Country", "France"), (Node.AttributePrice, "3"), (Node.AttributeCapacity, "10")),
Helper.GenerateTestNode(3, ("Country", "Russia"), (Node.AttributePrice, "2"), (Node.AttributeCapacity, "10000")),
Helper.GenerateTestNode(4, ("Country", "Russia"), (Node.AttributePrice, "1"), (Node.AttributeCapacity, "10000")),
Helper.GenerateTestNode(5, ("Country", "Russia"), (Node.AttributeCapacity, "10000")),
Helper.GenerateTestNode(6, ("Country", "France"), (Node.AttributePrice, "100"), (Node.AttributeCapacity, "1")),
Helper.GenerateTestNode(7, ("Country", "France"), (Node.AttributePrice, "7"), (Node.AttributeCapacity, "10000")),
Helper.GenerateTestNode(8, ("Country", "Russia"), (Node.AttributePrice, "2"), (Node.AttributeCapacity, "1")),
};
var nm = new NetMap(nodes);
var c = new Context(nm);
c.SetPivot(Encoding.ASCII.GetBytes("containerID"));
c.SetCBF(p.ContainerBackupFactor);
c.SetWeightFunc(Netmap.Helper.WeightFunc(new MaxNorm(10000), new ReverseMinNorm(1)));
c.SetAggregator(() => new MaxAgg());
c.ProcessFilters(p);
c.ProcessSelectors(p);
var result = c.Selections["Main"];
var expected = new Dictionary <int, (int, ulong, ulong)>
{
{ 0, (4, 10000u, 1u) },
public void TestPutContainerSelect()
{
using var client = new Client.Client(key, host);
// var replica = new Replica(2, ""); //not in policy
var replica = new Replica(2, ""); // in policy with others
// var replica = new Replica(1, ""); // test only one node put container size
var policy = new PlacementPolicy(1, new Replica[] { replica }, null, null);
var container = new Container.Container
{
Version = Refs.Version.SDKVersion(),
OwnerId = OwnerID.FromScriptHash(key.PublicKey().PublicKeyToScriptHash()),
Nonce = Guid.NewGuid().ToByteString(),
BasicAcl = BasicAcl.PublicBasicRule,
PlacementPolicy = policy,
};
container.Attributes.Add(new Container.Container.Types.Attribute
{
Key = "CreatedAt",
Value = DateTime.UtcNow.ToString(),
});
using var source = new CancellationTokenSource();
source.CancelAfter(TimeSpan.FromMinutes(1));
var cid = client.PutContainer(container, context: source.Token).Result;
Console.WriteLine(cid.String());
Assert.AreEqual(container.CalCulateAndGetId, cid);
}
public void TestFilterWithPrecedence()
{
string q = @"REP 7 IN SPB
SELECT 1 IN City FROM SPBSSD AS SPB
FILTER City EQ SPB AND SSD EQ true OR City EQ SPB AND Rating GE 5 AS SPBSSD";
var expected = new PlacementPolicy(0,
new Replica[] { new Replica(7, "SPB") },
new Selector[] { new Selector("SPB", "City", Clause.Unspecified, 1, "SPBSSD") },
new Filter[]
{
new Filter("SPBSSD", "", "", Operation.Or,
new Filter("", "", "", Operation.And,
new Filter("", "City", "SPB", Operation.Eq),
new Filter("", "SSD", "true", Operation.Eq)
),
new Filter("", "", "", Operation.And,
new Filter("", "City", "SPB", Operation.Eq),
new Filter("", "Rating", "5", Operation.Ge)
)
)
});
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
}
public void TestIssue213()
{
var p = new PlacementPolicy(
1,
new Replica[] {
new Replica(4, ""),
},
new Selector[] {
new Selector("", "", Clause.Distinct, 4, "LOC_EU"),
},
new Filter[] {
new Filter("LOC_EU", "Location", "Europe", Operation.Eq),
}
);
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("Location", "Europe"), ("Country", "Russia"), ("City", "Moscow")),
Helper.GenerateTestNode(1, ("Location", "Europe"), ("Country", "Russia"), ("City", "Saint-Petersburg")),
Helper.GenerateTestNode(2, ("Location", "Europe"), ("Country", "Sweden"), ("City", "Stockholm")),
Helper.GenerateTestNode(3, ("Location", "Europe"), ("Country", "Finalnd"), ("City", "Helsinki")),
};
var nm = new NetMap(nodes);
var v = nm.GetContainerNodes(p, null);
Assert.AreEqual(4, v.Flatten().Count);
//with pivot
var r = nm.GetContainerNodes(p, "752cf3d93e6c6b87952d942012ece22e15ac821d0597dcdadd923e77a44de74a".HexToBytes()).Flatten();
Assert.AreEqual(4, r.Count);
}
public void TestSelectFromClause()
{
string q = @"REP 4
SELECT 3 IN Country FROM *
SELECT 2 IN SAME City FROM *
SELECT 1 IN DISTINCT Continent FROM *";
var expected = new PlacementPolicy(0,
new Replica[] { new Replica(4, "") },
new Selector[]
{
new Selector("", "Country", Clause.Unspecified, 3, "*"),
new Selector("", "City", Clause.Same, 2, "*"),
new Selector("", "Continent", Clause.Distinct, 1, "*")
},
new Filter[0]);
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
//Assert.AreEqual(expected.Selectors[0].Count, actual.Selectors[0].Count);
//Assert.AreEqual(expected.Selectors[0].Clause, actual.Selectors[0].Clause); // Unspecified
//Assert.AreEqual(expected.Selectors[1].Clause, actual.Selectors[1].Clause); // Same
//Assert.AreEqual(expected.Selectors[1].Attribute, actual.Selectors[1].Attribute);
//Assert.AreEqual(expected.Selectors[2].Clause, actual.Selectors[2].Clause); // Distinct
//Assert.AreEqual(expected.Selectors[2].Filter, actual.Selectors[2].Filter);
//Assert.AreEqual(expected.Selectors[2].Name, actual.Selectors[2].Name);
}
public void TestPutContainer()
{
var host = "localhost:8080";
var key = "KxDgvEKzgSBPPfuVfw67oPQBSjidEiqTHURKSDL1R7yGaGYAeYnr".LoadWif();
var client = new Client.Client(key, host);
var replica = new Replica(1, "*");
var policy = new PlacementPolicy(2, new Replica[] { replica }, null, null);
var container = new Container.Container
{
// Version = Refs.Version.SDKVersion(),
// OwnerId = key.ToOwnerID(),
Nonce = new Guid().ToByteString(),
BasicAcl = (uint)BasicAcl.PublicBasicRule,
PlacementPolicy = policy,
};
container.Attributes.Add(new Container.Container.Types.Attribute
{
Key = "CreatedAt",
Value = DateTime.UtcNow.ToString(),
});
var source = new CancellationTokenSource();
source.CancelAfter(TimeSpan.FromMinutes(1));
var cid = client.PutContainer(source.Token, container);
Console.WriteLine(cid.ToBase58String());
Assert.AreEqual(container.CalCulateAndGetID, cid);
}
public void TestSimpleWithCBF()
{
string q = "REP 3 CBF 4";
var expected = new PlacementPolicy(4, new Replica[] { new Replica(3, "") }, new Selector[0], new Filter[0]);
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
}
public void TestUnspecifiedClause()
{
var p = new PlacementPolicy(1, new Replica[] { new Replica(1, "X") }, new Selector[] { new Selector("X", "", Clause.Distinct, 4, "*") }, null);
var nodes = new Node[]
{
Helper.GenerateTestNode(0, ("ID", "1"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "0")),
Helper.GenerateTestNode(1, ("ID", "2"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "1")),
Helper.GenerateTestNode(2, ("ID", "3"), ("Country", "RU"), ("City", "Moscow"), ("SSD", "1")),
Helper.GenerateTestNode(3, ("ID", "4"), ("Country", "RU"), ("City", "Moscow"), ("SSD", "1")),
};
public JObject ToJson()
{
var json = new JObject();
json["version"] = Version?.ToJson();
json["ownerID"] = OwnerId?.ToJson();
json["nonce"] = Nonce.ToBase64();
json["basicACL"] = BasicAcl;
json["attributes"] = new JArray(Attributes.Select(p => p.ToJson()));
json["placementPolicy"] = PlacementPolicy?.ToJson();
return(json);
}
public static TestCase FromJson(string name, JObject json)
{
return(new()
{
Name = name,
Policy = PlacementPolicy.Parser.ParseJson(json["policy"].ToString()),
Pivot = json["pivot"] is not null?Convert.FromBase64String(json["pivot"].GetString()) : null,
Result = ((JArray)json["result"])?.Select(p => ((JArray)p).Select(q => int.Parse(q.AsString())).ToArray()).ToArray(),
Error = json["error"]?.GetString() ?? "",
Placement = Placement.FromJson(json["placement"])
});
}
public void TestSelectFrom2()
{
string q = @"REP 1 IN SPB
SELECT 1 IN DISTINCT City FROM * AS SPB";
var expected = new PlacementPolicy(0,
new Replica[] { new Replica(1, "SPB") },
new Selector[] { new Selector("SPB", "City", Clause.Distinct, 1, "*") },
new Filter[0]);
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
}
public void TestProcessSelectors()
{
var p = new PlacementPolicy(2, null,
new Selector[] {
new Selector("SameRU", "City", Clause.Same, 2, "FromRU"),
new Selector("DistinctRU", "City", Clause.Distinct, 2, "FromRU"),
new Selector("Good", "Country", Clause.Distinct, 2, "Good"),
new Selector("Main", "Country", Clause.Distinct, 3, "*"),
},
new Filter[] {
new Filter("FromRU", "Country", "Russia", Operation.Eq),
new Filter("Good", "Rating", "4", Operation.Ge),
}
);
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("Country", "Russia"), ("Rating", "1"), ("City", "SPB")),
Helper.GenerateTestNode(1, ("Country", "Germany"), ("Rating", "5"), ("City", "Berlin")),
Helper.GenerateTestNode(2, ("Country", "Russia"), ("Rating", "6"), ("City", "Moscow")),
Helper.GenerateTestNode(3, ("Country", "France"), ("Rating", "4"), ("City", "Paris")),
Helper.GenerateTestNode(4, ("Country", "France"), ("Rating", "1"), ("City", "Lyon")),
Helper.GenerateTestNode(5, ("Country", "Russia"), ("Rating", "5"), ("City", "SPB")),
Helper.GenerateTestNode(6, ("Country", "Russia"), ("Rating", "7"), ("City", "Moscow")),
Helper.GenerateTestNode(7, ("Country", "Germany"), ("Rating", "3"), ("City", "Darmstadt")),
Helper.GenerateTestNode(8, ("Country", "Germany"), ("Rating", "7"), ("City", "Frankfurt")),
Helper.GenerateTestNode(9, ("Country", "Russia"), ("Rating", "9"), ("City", "SPB")),
Helper.GenerateTestNode(10, ("Country", "Russia"), ("Rating", "9"), ("City", "SPB")),
};
var nm = new NetMap(nodes);
var c = new Context(nm);
c.SetCBF(p.ContainerBackupFactor);
c.ProcessFilters(p);
c.ProcessSelectors(p);
foreach (var s in p.Selectors)
{
var ns = c.Selections[s.Name];
var sel = c.Selectors[s.Name];
var bc = sel.GetBucketCount();
var nib = sel.GetNodesInBucket();
nib *= (int)c.Cbf;
Assert.AreEqual(bc, ns.Count);
foreach (var res in ns)
{
Assert.AreEqual(nib, res.Count);
foreach (var j in res)
{
Assert.IsTrue(c.ApplyFilter(sel.Filter, j));
}
}
}
}
public void TestMatch()
{
var filters = new Filter[]
{
new Filter
{
Name = "StorageSSD",
Key = "Storage",
Value = "SSD",
Op = Operation.Eq,
},
new Filter
{
Name = "GoodRating",
Key = "Rating",
Value = "4",
Op = Operation.Ge,
},
new Filter("Main", "", "", Operation.And,
new Filter("StorageSSD", "", "", 0),
new Filter("", "IntField", "123", Operation.Lt),
new Filter("GoodRating", "", "", 0),
new Filter("", "", "", Operation.Or,
new Filter("", "Param", "Value1", Operation.Eq),
new Filter("", "Param", "Value2", Operation.Eq)
)
)
};
var c = new Context(new NetMap(new()));
var p = new PlacementPolicy(1, null, null, filters);
c.ProcessFilters(p);
var n = Helper.GenerateTestNode(0, ("Storage", "SSD"), ("Rating", "10"), ("IntField", "100"), ("Param", "Value1"));
Assert.IsTrue(c.ApplyFilter("Main", n));
n = Helper.GenerateTestNode(0, ("Storage", "HDD"), ("Rating", "10"), ("IntField", "100"), ("Param", "Value1"));
Assert.IsFalse(c.ApplyFilter("Main", n));
n = Helper.GenerateTestNode(0, ("Storage", "SSD"), ("Rating", "3"), ("IntField", "100"), ("Param", "Value1"));
Assert.IsFalse(c.ApplyFilter("Main", n));
n = Helper.GenerateTestNode(0, ("Storage", "HDD"), ("Rating", "3"), ("IntField", "str"), ("Param", "Value1"));
Assert.IsFalse(c.ApplyFilter("Main", n));
n = Helper.GenerateTestNode(0, ("Storage", "HDD"), ("Rating", "3"), ("IntField", "100"), ("Param", "NotValue"));
Assert.IsFalse(c.ApplyFilter("Main", n));
}
public void TestSimpleFilter()
{
string q = @"REP 1
SELECT 1 IN City FROM Good
FILTER Rating GT 7 AS Good";
var expected = new PlacementPolicy(0,
new Replica[] { new Replica(1, "") },
new Selector[] { new Selector("", "City", Clause.Unspecified, 1, "Good") },
new Filter[] { new Filter("Good", "Rating", "7", Operation.Gt) });
var actual = ParsePlacementPolicy(q);
Assert.IsTrue(expected.Equals(actual));
//Assert.AreEqual(expected.Filters[0].Name, actual.Filters[0].Name);
//Assert.AreEqual(expected.Filters[0].Key, actual.Filters[0].Key);
//Assert.AreEqual(expected.Filters[0].Value, actual.Filters[0].Value);
//Assert.AreEqual(expected.Filters[0].Op, actual.Filters[0].Op);
}
public void TestPlacementPolicyMinimal()
{
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("City", "Saint-Petersburg")),
Helper.GenerateTestNode(1, ("City", "Moscow")),
Helper.GenerateTestNode(2, ("City", "Berlin")),
Helper.GenerateTestNode(3, ("City", "Paris")),
};
var nm = new NetMap(nodes);
void RunTest(uint rep, bool error)
{
var p = new PlacementPolicy(0, new Replica[] { new Replica(rep, "") }, null, null);
try
{
var v = nm.GetContainerNodes(p, null);
var count = (int)(rep * Context.DefaultCBF);
if (nodes.Count < count)
{
count = nodes.Count;
}
Assert.AreEqual(count, v.Flatten().Count);
}
catch (Exception e)
{
if (error)
{
return;
}
Console.WriteLine(e.Message);
Assert.Fail();
}
}
Console.WriteLine("REP 1");
RunTest(1, false);
Console.WriteLine("REP 3");
RunTest(3, false);
Console.WriteLine("REP 5");
RunTest(5, true);
}
public void TestUnspecifiedClause()
{
var p = new PlacementPolicy(1, new Replica[] { new Replica(1, "X") }, new Selector[] { new Selector("X", "", Clause.Distinct, 4, "*") }, null);
var nodes = new List <Node>
{
Helper.GenerateTestNode(0, ("ID", "1"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "0")),
Helper.GenerateTestNode(1, ("ID", "2"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "1")),
Helper.GenerateTestNode(2, ("ID", "3"), ("Country", "RU"), ("City", "Moscow"), ("SSD", "1")),
Helper.GenerateTestNode(3, ("ID", "4"), ("Country", "RU"), ("City", "Moscow"), ("SSD", "1")),
};
var nm = new NetMap(nodes);
var result = nm.GetContainerNodes(p, null);
Assert.AreEqual(4, result.Flatten().Count);
//with pivot
result = nm.GetContainerNodes(p, "bda4d48fe60f077d127bebccdc318901af555308bbf6826f725b7ef5400b5c2c".HexToBytes());
var r = result.Flatten();
Assert.AreEqual(4, r.Count);
}
public void TestPlacementPolicyMutipleREP()
{
var p = new PlacementPolicy(
1,
new Replica[] {
new Replica(1, "LOC_SPB_PLACE"),
new Replica(1, "LOC_MSK_PLACE")
},
new Selector[] {
new Selector("LOC_SPB_PLACE", "", Clause.Unspecified, 1, "LOC_SPB"),
new Selector("LOC_MSK_PLACE", "", Clause.Unspecified, 1, "LOC_MSK"),
},
new Filter[] {
new Filter("LOC_SPB", "City", "Saint-Petersburg", Operation.Eq),
new Filter("LOC_MSK", "City", "Moscow", Operation.Eq),
}
);
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("City", "Saint-Petersburg")),
Helper.GenerateTestNode(1, ("City", "Moscow")),
Helper.GenerateTestNode(2, ("City", "Berlin")),
Helper.GenerateTestNode(3, ("City", "Paris")),
};
var nm = new NetMap(nodes);
var v = nm.GetContainerNodes(p, null);
Assert.AreEqual(2, v.Count);
Assert.AreEqual(1, v[0].Count);
Assert.AreEqual("Saint-Petersburg", v[0][0].Attributes["City"]);
Assert.AreEqual(1, v[1].Count);
Assert.AreEqual("Moscow", v[1][0].Attributes["City"]);
//with pivot
v = nm.GetContainerNodes(p, "d611c46ef7b2adbcffb9959159d1b8657ddc34582c34a8204cc22fe9468fb663".HexToBytes());
var r = v.Flatten();
Assert.AreEqual(2, r.Count);
Assert.AreEqual(0, r[0].Index);
Assert.AreEqual(1, r[1].Index);
}
public void TestPlacementPolicyLowerBound()
{
var p = new PlacementPolicy(
2,
new Replica[] {
new Replica(1, "X"),
},
new Selector[] {
new Selector("X", "Country", Clause.Same, 2, "*"),
},
null
);
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("ID", "1"), ("Country", "DE")),
Helper.GenerateTestNode(1, ("ID", "2"), ("Country", "DE")),
Helper.GenerateTestNode(2, ("ID", "3"), ("Country", "DE")),
};
var nm = new NetMap(nodes);
var v = nm.GetContainerNodes(p, null);
Assert.AreEqual(3, v.Flatten().Count);
}
/// <summary>
/// Create or update a placement policy in a private cloud cluster
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group. The name is case insensitive.
/// </param>
/// <param name='privateCloudName'>
/// Name of the private cloud
/// </param>
/// <param name='clusterName'>
/// Name of the cluster in the private cloud
/// </param>
/// <param name='placementPolicyName'>
/// Name of the VMware vSphere Distributed Resource Scheduler (DRS) placement
/// policy
/// </param>
/// <param name='placementPolicy'>
/// A placement policy in the private cloud cluster
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <PlacementPolicy> BeginCreateOrUpdateAsync(this IPlacementPoliciesOperations operations, string resourceGroupName, string privateCloudName, string clusterName, string placementPolicyName, PlacementPolicy placementPolicy, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, privateCloudName, clusterName, placementPolicyName, placementPolicy, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Create or update a placement policy in a private cloud cluster
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group. The name is case insensitive.
/// </param>
/// <param name='privateCloudName'>
/// Name of the private cloud
/// </param>
/// <param name='clusterName'>
/// Name of the cluster in the private cloud
/// </param>
/// <param name='placementPolicyName'>
/// Name of the VMware vSphere Distributed Resource Scheduler (DRS) placement
/// policy
/// </param>
/// <param name='placementPolicy'>
/// A placement policy in the private cloud cluster
/// </param>
public static PlacementPolicy BeginCreateOrUpdate(this IPlacementPoliciesOperations operations, string resourceGroupName, string privateCloudName, string clusterName, string placementPolicyName, PlacementPolicy placementPolicy)
{
return(operations.BeginCreateOrUpdateAsync(resourceGroupName, privateCloudName, clusterName, placementPolicyName, placementPolicy).GetAwaiter().GetResult());
}
public void TestProcessFiltersInvalid()
{
var fs = new Filter[]
{
new Filter
{
Name = "",
Key = "Storage",
Value = "SSD",
Op = Operation.Eq,
},
new Filter
{
Name = "Main",
Key = "",
Value = "",
Op = Operation.And,
},
new Filter
{
Name = "Main",
Key = "Storage",
Value = "SSD",
Op = Operation.Eq,
},
new Filter
{
Name = "Main",
Key = "Rating",
Value = "three",
Op = Operation.Ge,
},
new Filter
{
Name = "Main",
Key = "Rating",
Value = "3",
Op = 0,
},
new Filter
{
Name = "*",
Key = "Rating",
Value = "3",
Op = Operation.Ge,
}
};
fs[1].Filters.Add(new Filter
{
Name = "StorageSSD",
Key = "",
Value = "",
Op = 0,
});
fs[2].Filters.Add(new Filter
{
Name = "StorageSSD",
Key = "",
Value = "",
Op = 0,
});
for (int i = 0; i < fs.Length; i++)
{
var c = new Context(new NetMap(new()));
var p = new PlacementPolicy
{
ContainerBackupFactor = 1,
};
p.Filters.Add(fs[i]);
if (i == 4)
{
Assert.ThrowsException <InvalidOperationException>(() => c.ProcessFilters(p));
}
else if (i == 6)
{
Assert.ThrowsException <ArgumentNullException>(() => c.ProcessFilters(p));
}
else
{
Assert.ThrowsException <ArgumentException>(() => c.ProcessFilters(p));
}
}
}
public void TestProcessFilter()
{
var filters = new Filter[] {
new Filter
{
Name = "StorageSSD",
Key = "Storage",
Value = "SSD",
Op = Operation.Eq
},
new Filter
{
Name = "GoodRating",
Key = "Rating",
Value = "4",
Op = Operation.Ge
},
new Filter
{
Name = "Main",
Key = "",
Value = "",
Op = Operation.And,
},
};
filters[2].Filters.AddRange(new Filter[] {
new Filter
{
Name = "StorageSSD",
Key = "",
Value = "",
Op = 0
},
new Filter
{
Name = "",
Key = "IntField",
Value = "123",
Op = Operation.Lt
},
new Filter
{
Name = "GoodRating",
Key = "",
Value = "",
Op = 0
}
});
var nm = new NetMap(new());
var context = new Context(nm);
var policy = new PlacementPolicy
{
ContainerBackupFactor = 1,
};
policy.Filters.AddRange(filters);
context.ProcessFilters(policy);
Assert.AreEqual(3, context.Filters.Count);
foreach (var it in filters)
{
Assert.AreEqual(it, context.Filters[it.Name]);
}
Assert.AreEqual((UInt64)4, context.NumCache[filters[1]]);
Assert.AreEqual((UInt64)123, context.NumCache[filters[2].Filters[1]]);
}
public void TestMatchSimple()
{
var ni = new NodeInfo();
ni.Attributes.Add(new NodeInfo.Types.Attribute
{
Key = "Rating",
Value = "4",
});
ni.Attributes.Add(new NodeInfo.Types.Attribute
{
Key = "Country",
Value = "Germany",
});
var n = new Node(0, ni);
var test_cases = new FilterCase[]
{
//#1
new FilterCase
{
Name = "GE_true",
Expect = true,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "4",
Op = Operation.Ge,
}
},
//#2
new FilterCase
{
Name = "GE_false",
Expect = false,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "5",
Op = Operation.Ge,
}
},
//#3
new FilterCase
{
Name = "GT_true",
Expect = true,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "3",
Op = Operation.Gt,
}
},
//#4
new FilterCase
{
Name = "GT_false",
Expect = false,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "4",
Op = Operation.Gt,
}
},
//#5
new FilterCase
{
Name = "LE_true",
Expect = true,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "4",
Op = Operation.Le,
}
},
//#6
new FilterCase
{
Name = "LE_false",
Expect = false,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "3",
Op = Operation.Le,
}
},
//#7
new FilterCase
{
Name = "LT_true",
Expect = true,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "5",
Op = Operation.Lt,
}
},
//#8
new FilterCase
{
Name = "LT_false",
Expect = false,
F = new Filter
{
Name = "Main",
Key = "Rating",
Value = "4",
Op = Operation.Lt,
}
},
//#9
new FilterCase
{
Name = "EQ_true",
Expect = true,
F = new Filter
{
Name = "Main",
Key = "Country",
Value = "Germany",
Op = Operation.Eq,
}
},
//#10
new FilterCase
{
Name = "EQ_false",
Expect = false,
F = new Filter
{
Name = "Main",
Key = "Country",
Value = "China",
Op = Operation.Eq,
}
},
//#11
new FilterCase
{
Name = "NE_true",
Expect = true,
F = new Filter
{
Name = "Main",
Key = "Country",
Value = "France",
Op = Operation.Ne,
}
},
//#12
new FilterCase
{
Name = "NE_false",
Expect = false,
F = new Filter
{
Name = "Main",
Key = "Country",
Value = "Germany",
Op = Operation.Ne,
}
},
};
foreach (var t in test_cases)
{
var c = new Context(new NetMap(new()));
var p = new PlacementPolicy()
{
ContainerBackupFactor = 1
};
p.Filters.Add(t.F);
c.ProcessFilters(p);
Assert.AreEqual(t.Expect, c.Match(t.F, n));
}
}
public void TestGetPlacementVectors()
{
var p = new PlacementPolicy(2,
new Replica[] {
new Replica(1, "SPB"),
new Replica(2, "Americas"),
},
new Selector[] {
new Selector("SPB", "City", Clause.Same, 1, "SPBSSD"),
new Selector("Americas", "City", Clause.Distinct, 2, "Americas"),
},
new Filter[] {
new Filter("SPBSSD", "", "", Operation.And,
new Filter("", "Country", "RU", Operation.Eq),
new Filter("", "City", "St.Petersburg", Operation.Eq),
new Filter("", "SSD", "1", Operation.Eq)),
new Filter("Americas", "", "", Operation.Or,
new Filter("", "Continent", "NA", Operation.Eq),
new Filter("", "Continent", "SA", Operation.Eq)),
});
var nodes = new List <Node> {
Helper.GenerateTestNode(0, ("ID", "1"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "0")),
Helper.GenerateTestNode(1, ("ID", "2"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "1")),
Helper.GenerateTestNode(2, ("ID", "3"), ("Country", "RU"), ("City", "Moscow"), ("SSD", "1")),
Helper.GenerateTestNode(3, ("ID", "4"), ("Country", "RU"), ("City", "Moscow"), ("SSD", "1")),
Helper.GenerateTestNode(4, ("ID", "5"), ("Country", "RU"), ("City", "St.Petersburg"), ("SSD", "1")),
Helper.GenerateTestNode(5, ("ID", "6"), ("Continent", "NA"), ("City", "NewYork")),
Helper.GenerateTestNode(6, ("ID", "7"), ("Continent", "AF"), ("City", "Cairo")),
Helper.GenerateTestNode(7, ("ID", "8"), ("Continent", "AF"), ("City", "Cairo")),
Helper.GenerateTestNode(8, ("ID", "9"), ("Continent", "SA"), ("City", "Lima")),
Helper.GenerateTestNode(9, ("ID", "10"), ("Continent", "AF"), ("City", "Cairo")),
Helper.GenerateTestNode(10, ("ID", "11"), ("Continent", "NA"), ("City", "NewYork")),
Helper.GenerateTestNode(11, ("ID", "12"), ("Continent", "NA"), ("City", "LosAngeles")),
Helper.GenerateTestNode(12, ("ID", "13"), ("Continent", "SA"), ("City", "Lima")),
};
var nm = new NetMap(nodes);
var result = nm.GetContainerNodes(p, null);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(6, result.Flatten().Count);
Assert.AreEqual(2, result[0].Count);
foreach (var ni in result[0])
{
Assert.AreEqual("RU", ni.Attributes["Country"]);
Assert.AreEqual("St.Petersburg", ni.Attributes["City"]);
Assert.AreEqual("1", ni.Attributes["SSD"]);
}
Assert.AreEqual(4, result[1].Count);
foreach (var ni in result[1])
{
ni.Attributes["Continent"].Should().BeOneOf("NA", "SA");
}
//with pivot
var pivot = "ec63f5b498cb62a9ba2f9c925317fc953e196d5d5cf33028557c8892ff5cbc2f".HexToBytes();
var v = nm.GetPlacementVectors(result, pivot);
var r = v.Flatten();
Assert.AreEqual(1, r[0].Index);
Assert.AreEqual(4, r[1].Index);
Assert.AreEqual(8, r[2].Index);
Assert.AreEqual(12, r[3].Index);
Assert.AreEqual(5, r[4].Index);
Assert.AreEqual(10, r[5].Index);
v = nm.GetContainerNodes(p, pivot);
r = v.Flatten();
Assert.AreEqual(6, r.Count);
Assert.AreEqual(1, r[0].Index);
Assert.AreEqual(4, r[1].Index);
Assert.AreEqual(5, r[2].Index);
Assert.AreEqual(10, r[3].Index);
Assert.AreEqual(8, r[4].Index);
Assert.AreEqual(12, r[5].Index);
}
