public void TestReadOnlyCopyConstruct()
{
Guid id = new Guid("{53BC19DB-1D34-4995-82FE-8041C9E71EC5}");
IPolicyLanguageItem name = new NonTranslateableLanguageItem("Test routing");
RoutingTable httpRoutingTable = new RoutingTable(id, name, ChannelType.HTTP);
Assert.AreEqual(id, httpRoutingTable.Identifier);
Assert.IsFalse(httpRoutingTable.ReadOnly);
Assert.AreEqual(name.Value, httpRoutingTable.Name.Value);
Assert.IsNotNull(httpRoutingTable.DefaultDestination);
Assert.IsNotNull(httpRoutingTable.DefaultSource);
Assert.IsNotNull(httpRoutingTable[httpRoutingTable.DefaultSource, httpRoutingTable.DefaultDestination]);
RoutingTable copy = new RoutingTable(httpRoutingTable, true, false);
Assert.AreEqual(id, copy.Identifier);
Assert.IsTrue(copy.ReadOnly);
Assert.AreEqual(name.Value, copy.Name.Value);
Assert.IsNotNull(copy.DefaultSource);
Assert.IsNotNull(copy.DefaultDestination);
Assert.IsNotNull(copy[copy.DefaultSource, copy.DefaultDestination]);
Assert.IsNotNull(copy[copy.DefaultSource, copy.DefaultDestination].Name);
Assert.IsNotInstanceOf(typeof(NonTranslateableLanguageItem), copy[copy.DefaultSource, copy.DefaultDestination].Name.GetType());
Assert.AreEqual(httpRoutingTable[httpRoutingTable.DefaultSource, httpRoutingTable.DefaultDestination].Identifier, copy[copy.DefaultSource, copy.DefaultDestination].Identifier);
Assert.AreEqual(httpRoutingTable[httpRoutingTable.DefaultSource, httpRoutingTable.DefaultDestination].Name.Identifier, copy[copy.DefaultSource, copy.DefaultDestination].Name.Identifier);
Assert.AreEqual(httpRoutingTable[httpRoutingTable.DefaultSource, httpRoutingTable.DefaultDestination].Name.Value, copy[copy.DefaultSource, copy.DefaultDestination].Name.Value);
}
private void ReadRoutings(XmlNode parentNode, PolicyChannel policyChannel)
{
if (parentNode == null)
return;
IPolicyObjectCollection<IRoutingTable> routingTables = m_reader.CataloguesCache.RoutingTables;
XmlNode routingTableNode = parentNode.SelectSingleNode("RoutingTable");
if (routingTableNode == null)
return;
bool routingsReadOnly = PolicyUtilities.IsReadOnly(routingTableNode);
IAddressGroup entireAddressGroup = m_reader.CataloguesCache.AddressGroup;
string guid = routingTableNode.Attributes.GetNamedItem("id").InnerText;
Guid identifier = new Guid(guid);
bool routingTableReadOnly = PolicyUtilities.IsReadOnly(routingTableNode);
RoutingTable routingTable = new RoutingTable(routingTables[identifier] as RoutingTable, routingTableReadOnly);
XmlNodeList senderGroupNode = routingTableNode.SelectNodes("./SenderGroup/*");
if (senderGroupNode != null)
routingTable.Senders = ReadAddressGroup(senderGroupNode, entireAddressGroup, routingTableReadOnly);
XmlNodeList recipientGroupNode = routingTableNode.SelectNodes("./RecipientGroup/*");
if (recipientGroupNode != null)
routingTable.Recipients = ReadAddressGroup(recipientGroupNode, entireAddressGroup, routingTableReadOnly);
// Now build the matrix relationships... i.e. The Cells...
XmlNodeList matrixCellNodes = routingTableNode.SelectNodes("./RoutingMatrixCells/*");
if (matrixCellNodes != null)
AddMatrixCells(matrixCellNodes, routingTable);
policyChannel.Routing = routingTable;
}
public void TestReadOnlyCopyConstruct()
{
RoutingTable routingTable = new RoutingTable(Guid.Empty, new TranslateableLanguageItem("RoutingName"), ChannelType.SMTP);
RoutingItemCollection collection1 = new RoutingItemCollection(Guid.NewGuid(), "Collection1");
RoutingItemCollection collection2 = new RoutingItemCollection(Guid.NewGuid(), "Collection2");
RoutingItemCollection collection3 = new RoutingItemCollection(Guid.NewGuid(), "Collection3");
routingTable.Sources.Add(collection1);
routingTable.Sources.Add(collection2);
routingTable.Sources.Add(collection3);
RoutingItemCollection collection4 = new RoutingItemCollection(Guid.NewGuid(), "Collection4");
RoutingItemCollection collection5 = new RoutingItemCollection(Guid.NewGuid(), "Collection5");
RoutingItemCollection collection6 = new RoutingItemCollection(Guid.NewGuid(), "Collection6");
routingTable.Destinations.Add(collection4);
routingTable.Destinations.Add(collection5);
routingTable.Destinations.Add(collection6);
RoutingTable routingTable2 = new RoutingTable(routingTable, true, false);
Assert.AreEqual(routingTable.Name.Value, routingTable2.Name.Value);
Assert.AreEqual(routingTable.Sources.Count, routingTable2.Sources.Count);
Assert.AreEqual(routingTable.Destinations.Count, routingTable2.Destinations.Count);
Assert.AreEqual(routingTable.CellCount, routingTable2.CellCount);
Assert.IsTrue(routingTable2.ReadOnly);
}
public void TestConstruct()
{
Guid id = new Guid("{53BC19DB-1D34-4995-82FE-8041C9E71EC5}");
IPolicyLanguageItem name = new NonTranslateableLanguageItem("Test routing");
RoutingTable routingTable = new RoutingTable(id, name, ChannelType.Mta);
Assert.AreEqual(id, routingTable.Identifier);
Assert.IsFalse(routingTable.ReadOnly);
Assert.AreEqual(name.Value, routingTable.Name.Value);
Assert.IsNotNull(routingTable.DefaultDestination);
Assert.AreEqual(1, routingTable.Destinations.Count);
Assert.IsNotNull(routingTable.DefaultSource);
Assert.IsNotNull(routingTable[routingTable.DefaultSource, routingTable.DefaultDestination]);
Assert.AreEqual(2, routingTable.Sources.Count);
Assert.AreEqual("Mail server", routingTable.Sources[0].Name.Value);
Assert.IsTrue(System.Convert.ToBoolean(routingTable.Sources[0][RoutingTable.DefaultGroupName].Value,
System.Globalization.CultureInfo.CurrentCulture));
Assert.AreEqual("Blackberry", routingTable.Sources[1].Name.Value);
Assert.IsTrue(string.IsNullOrEmpty(routingTable.Sources[1][RoutingTable.DefaultGroupName].Value));
Assert.IsNotNull(routingTable[routingTable.Sources[0], routingTable.DefaultDestination]);
Assert.IsNotNull(routingTable[routingTable.Sources[1], routingTable.DefaultDestination]);
}
private IRoutingTable BuildSmtpRouting()
{
RoutingTable routingTable = new RoutingTable(new Guid("{AF6E5D89-0C6F-4B10-9A6C-658D13CD3EA8}"), new TranslateableLanguageItem("{8819B8B3-38AE-4D89-A05C-AB0904E979D1}"), ChannelType.SMTP);
routingTable.Sources = TestHelpers.BuildSenderGroup();
routingTable.Destinations = TestHelpers.BuildRecipientGroup();
TestHelpers.BuildMatrixCells(routingTable);
return routingTable;
}
public void MatchesDynamicUrlWithTrailingValues()
{
var target = new RoutingTable();
var expected = typeof (RoutingTableTests);
target.Add("/tests/{Id}/bar", expected);
IDictionary<string, string[]> variables;
var actual = target.Get("/tests/1/bar", out variables);
Assert.Equal(expected, actual);
}
public void MatchesStaticUrl()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/", expected);
IDictionary<string, string> _;
var actual = target.Get("/", out _);
Assert.Equal(expected, actual);
}
/// <summary>
/// Update routing table by the files that will found be requested directory.
/// Also auto loking for core routing table by "resources\routing\".
///
/// In case if tables not found then create new one to provide example.
/// </summary>
/// <param name="directories"></param>
public static void LoadRoutingTables(params string[] directories)
{
#region Load routing tables
// Load routing tables
routingTable = null;
// From system folders.
routingTable += RoutingTable.LoadRoutingTables(AppDomain.CurrentDomain.BaseDirectory + "resources\\routing\\", SearchOption.AllDirectories);
// From custrom directories.
foreach (string dir in directories)
{
routingTable += RoutingTable.LoadRoutingTables(dir, SearchOption.AllDirectories);
}
#endregion
/* TODO Deprecated unnessesary code with requesting keys and tokens.
#region Request public keys
* foreach (Instruction instruction in routingTable.intructions)
* {
* if (instruction is PartialAuthorizedInstruction pai)
* {
* Task.Run(async delegate()
* {
* // Waiting for guest token.
* await pai.TryToGetGuestTokenAsync(TerminationTokenSource.Token);
*
* // If encryption requested.
* if (instruction.encryption)
* {
* // Request public key reciving.
* _ = GetValidSecretKeysViaPPAsync(instruction);
* }
* }
* }
* }
#endregion*/
#region Validate
// If routing table not found.
if (routingTable.intructions.Count == 0)
{
//// Log error.
//Console.WriteLine("ROUTING TABLE NOT FOUND: Create default table by directory \\resources\\routing\\ROUTING.xml");
//// Set default intruction.
//routingTable.intructions.Add(Instruction.Default);
//// Save sample routing table to application files.
//RoutingTable.SaveRoutingTable(routingTable, AppDomain.CurrentDomain.BaseDirectory + "resources\\routing\\", "ROUTING");
}
else
{
// Log error.
Console.WriteLine("ROUTING TABLE: Detected {0} instructions.", routingTable.intructions.Count);
}
#endregion
}
public void MatchesVanityUrlWithTrailingSlash()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/{Name}", expected);
IDictionary<string, string> variables;
var actual = target.Get("/test/", out variables);
Assert.Equal(expected, actual);
Assert.Equal("test", variables["Name"]);
}
private HttpServer(string ipAddress, int port, IRoutingTable routingTable)
{
this.ipAddress = IPAddress.Parse(ipAddress);
this.port = port;
this.listener = new TcpListener(this.ipAddress, port);
this.routingTable = (RoutingTable)routingTable;
this.serviceCollection = new ServiceCollection();
}
/// <summary>
/// Initializes a new instance of the Network class.
/// </summary>
/// <param name="interfaces">An enumerable collection of interfaces
/// installed on the host.</param>
/// <param name="routingTable">The routing table to use.</param>
/// <param name="nodalProcessingDelay">The nodal processing delay, in
/// nanoseconds.</param>
/// <exception cref="ArgumentNullException">Thrown if the interfaces
/// parameter is null.</exception>
public Ipv4(IEnumerable <Interface> interfaces, RoutingTable routingTable,
ulong nodalProcessingDelay)
{
interfaces.ThrowIfNull("interfaces");
this.interfaces = interfaces;
this.routingTable = routingTable;
this.nodalProcessingDelay = nodalProcessingDelay;
arp = new Arp.Arp(Output);
}
public HttpServer(string ipAddress, int port, Action <IRoutingTable> routingTableConfiguration)
{
this.ipAddress = IPAddress.Parse(ipAddress);
this.port = port;
this.serverListener = new TcpListener(this.ipAddress, port);
routingTableConfiguration(this.routingTable = new RoutingTable());
ServiceCollection = new ServiceCollection();
}
public HttpServer(string _ipAddress, int _port,
Action <RoutingTable> _routingTableConfiguration)
{
ipAddress = IPAddress.Parse(_ipAddress);
port = _port;
serverListener = new TcpListener(ipAddress, port);
_routingTableConfiguration(routingTable = new RoutingTable());
}
private void AddToTable(IProtocolNode node, int count)
{
node?.Connections.ForEach(c =>
{
if (!RoutingTable.Any(t => t.Item1.Contains(c)))
{
RoutingTable.Add(new Tuple <string, string, int>(c, node.Id, count));
}
});
}
public void MatchesDynamicUrlWithOneVariable()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/tests/{Id}", expected);
IDictionary<string, string> variables;
var actual = target.Get("/tests/1", out variables);
Assert.Equal(expected, actual);
Assert.Equal("1", variables["Id"]);
}
public void Setup()
{
_id = new byte[20];
_id[1] = 128;
_node = new Node(new NodeId(_id), new IPEndPoint(IPAddress.Any, 0));
_table = new RoutingTable(_node);
_table.NodeAdded += delegate { _addedCount++; };
_table.Add(_node); //the local node is no more in routing table so add it to show test is still ok
_addedCount = 0;
}
public TcpTransport(TcpTransportConfiguration configuration, Identity identity, RoutingTable routingTable, PeerTable peerTable, InboundMessageDispatcher inboundMessageDispatcher, TcpRoutingContextContainer tcpRoutingContextContainer, PayloadUtils payloadUtils)
{
this.configuration = configuration;
this.identity = identity;
this.routingTable = routingTable;
this.peerTable = peerTable;
this.inboundMessageDispatcher = inboundMessageDispatcher;
this.tcpRoutingContextContainer = tcpRoutingContextContainer;
this.payloadUtils = payloadUtils;
}
public void Copy(RoutingTable other)
{
if (other != null)
{
for (int i = 0; i < other.Entries.Length; ++i)
{
Entries[i] = other.Entries[i];
}
}
}
public ClientCollection(IServer <TPeer> server, uint sessionId)
{
_server = server;
_sessionId = sessionId;
_playerIds = new RoutingTable();
_clientsByConnection = new Dictionary <TPeer, ClientInfo>();
_connectionsByRoom = new Dictionary <ushort, List <TPeer> >();
_connectionsByPlayerId = new Dictionary <ushort, TPeer>();
}
public IntKadNode CreateNode(int nodeId)
{
RoutingTable <int> routingTable = Mother.CreateIntRoutingTable();
var settings = new KademeliaSettings(TimeSpan.FromMilliseconds(100), 2, 5);
return
(new IntKadNode(
new MockKadCore(routingTable, settings, CreateClientFromNodeId,
new NodeIdentifier <int>("", nodeId)), this));
}
public static HttpServer WithRoutes(Action <IRoutingTable> routingTableConfiguration)
{
var routingTable = new RoutingTable();
routingTableConfiguration(routingTable);
var httpServer = new HttpServer(routingTable);
return(httpServer);
}
[InlineData(1, 2, 1, -1, true)] // expire immediately
public void ShouldBeStaleInWriteModeIfOnlyHaveOneRouter(int routerCount, int readerCount, int writerCount, long expireAfterSeconds, bool isStale)
{
var table = new RoutingTable(
CreateUriArray(routerCount),
CreateUriArray(readerCount),
CreateUriArray(writerCount),
expireAfterSeconds);
table.IsStale(AccessMode.Write).Should().Be(isStale);
}
public void MatchesDynamicUrlWithTrailingValues()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/tests/{Id}/bar", expected);
IDictionary <string, string[]> variables;
var actual = target.Get("/tests/1/bar", out variables);
Assert.Equal(expected, actual);
}
public void MatchesStaticUrl()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/", expected);
IDictionary <string, string[]> _;
var actual = target.Get("/", out _);
Assert.Equal(expected, actual);
}
public void MatchesDynamicUrlWithTwoVariables()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/tests/{Year}/{Month}", expected);
IDictionary<string, string> variables;
var actual = target.Get("/tests/2012/2", out variables);
Assert.Equal(expected, actual);
Assert.Equal("2012", variables["Year"]);
Assert.Equal("2", variables["Month"]);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="communicationLayer">Reference to the Communication Layer</param>
/// <param name="storageManager">Reference to the Storage Manager</param>
/// <param name="routingTable">Reference to the routing table</param>
/// <param name="serverGraph">Reference to server graph</param>
/// <param name="clientApplicationList">Reference to application list</param>
/// <param name="ngridManager">Reference to NGRID Manager object</param>
public OrganizationLayer(CommunicationLayer communicationLayer, IStorageManager storageManager, RoutingTable routingTable, NGRIDServerGraph serverGraph, NGRIDClientApplicationList clientApplicationList, NGRIDController ngridManager)
{
_settings = NGRIDSettings.Instance;
_communicationLayer = communicationLayer;
_storageManager = storageManager;
_routingTable = routingTable;
_serverGraph = serverGraph;
_clientApplicationList = clientApplicationList;
_ngridManager = ngridManager;
_waitingMessages = new SortedList <string, WaitingMessage>();
PrepareCommunicationLayer();
}
public void ShouldReturnExpectedValue(long elapsedMs, long expiresAfterMs, long expiredForCheckMs,
bool expected)
{
var timer = new Mock <ITimer>();
timer.Setup(x => x.ElapsedMilliseconds).Returns(elapsedMs);
var routingTable = new RoutingTable(null, new[] { new Uri("neo4j://my-router") },
new[] { new Uri("neo4j://my-reader") }, Enumerable.Empty <Uri>(), expiresAfterMs / 1000, timer.Object);
routingTable.IsExpiredFor(TimeSpan.FromMilliseconds(expiredForCheckMs)).Should().Be(expected);
}
public HttpServer(string ipAddres, int port, Action <IRoutingTable> routingTableConfiguration)
{
// local host IP address
this.ipAddress = IPAddress.Parse(ipAddres);
// port
this.port = port;
this.listener = new TcpListener(ipAddress, port);
this.routingTable = new RoutingTable();
routingTableConfiguration(this.routingTable);
}
public static PrivateKey GeneratePrivateKeyOfBucketIndex(Address tableAddress, int target)
{
var table = new RoutingTable(tableAddress);
PrivateKey privateKey;
do
{
privateKey = new PrivateKey();
}while (table.GetBucketIndexOf(privateKey.ToAddress()) != target);
return(privateKey);
}
private static RoutingTable byteArrayToRoutingTable(byte[] arrBytes)
{
MemoryStream memStream = new MemoryStream();
BinaryFormatter binForm = new BinaryFormatter();
memStream.Write(arrBytes, 0, arrBytes.Length);
memStream.Seek(0, SeekOrigin.Begin);
RoutingTable routingTable = (RoutingTable)binForm.Deserialize(memStream);
return(routingTable);
}
/// <summary>
/// Constructor.
/// </summary>
public NGRIDServer()
{
_settings = NGRIDSettings.Instance;
_serverGraph = new NGRIDServerGraph();
_clientApplicationList = new NGRIDClientApplicationList();
_ngridManager = new NGRIDController("NGRIDController");
_storageManager = StorageManagerFactory.CreateStorageManager();
_routingTable = new RoutingTable();
_communicationLayer = new CommunicationLayer();
_organizationLayer = new OrganizationLayer(_communicationLayer, _storageManager, _routingTable, _serverGraph, _clientApplicationList, _ngridManager);
_ngridManager.OrganizationLayer = _organizationLayer;
}
public void TestConstruct()
{
Guid id = new Guid("{53BC19DB-1D34-4995-82FE-8041C9E71EC5}");
IPolicyLanguageItem name = new NonTranslateableLanguageItem("Test routing");
RoutingTable httpRoutingTable = new RoutingTable(id, name, ChannelType.HTTP);
Assert.AreEqual(id, httpRoutingTable.Identifier);
Assert.IsFalse(httpRoutingTable.ReadOnly);
Assert.AreEqual(name.Value, httpRoutingTable.Name.Value);
Assert.IsNotNull(httpRoutingTable.DefaultDestination);
Assert.IsNotNull(httpRoutingTable.DefaultSource);
Assert.IsNotNull(httpRoutingTable[httpRoutingTable.DefaultSource, httpRoutingTable.DefaultDestination]);
}
public void MatchesDynamicUrlWithOneVariable()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/tests/{Id}", expected);
IDictionary <string, string[]> variables;
var actual = target.Get("/tests/1", out variables);
Assert.Equal(expected, actual);
Assert.Equal("1", variables["Id"][0]);
}
public void MatchesVanityUrlWithTrailingSlash()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/{Name}", expected);
IDictionary <string, string[]> variables;
var actual = target.Get("/test/", out variables);
Assert.Equal(expected, actual);
Assert.Equal("test", variables["Name"][0]);
}
public void returns_k_nearest_ordered()
{
RoutingTable <int> table = Mother.CreateIntRoutingTable();
table.Add(new NodeIdentifier <int>("", 1));
table.Add(new NodeIdentifier <int>("", 2));
table.Add(new NodeIdentifier <int>("", 4));
table.Add(new NodeIdentifier <int>("", 5));
CollectionAssert.IsOrdered(table.NearTo(1).Select(n => n.NodeId),
new LamdaComparer <int>((a, b) => a.CompareTo(b)));
}
public void MatchesDynamicUrlWithTwoVariables()
{
var target = new RoutingTable();
var expected = typeof(RoutingTableTests);
target.Add("/tests/{Year}/{Month}", expected);
IDictionary <string, string[]> variables;
var actual = target.Get("/tests/2012/2", out variables);
Assert.Equal(expected, actual);
Assert.Equal("2012", variables["Year"][0]);
Assert.Equal("2", variables["Month"][0]);
}
public void MatchesUrlWhenTwoRegexesHaveSameNumberOfGroups()
{
var target = new RoutingTable();
var expectedFoo = typeof(int);
var expectedBar = typeof(string);
target.Add("/tests/{Id}/foo", expectedFoo);
target.Add("/tests/{Id}/bar", expectedBar);
IDictionary <string, string[]> variables;
Assert.Equal(expectedFoo, target.Get("/tests/1/foo", out variables));
Assert.Equal(expectedBar, target.Get("/tests/1/bar", out variables));
}
public async Task ShouldAllowMultipleRoutingTables(AccessMode mode)
{
var defaultRoutingTable =
new RoutingTable(null, new[] { server01 }, new[] { server02 }, new[] { server03 }, 60);
var fooRoutingTable =
new RoutingTable("foo", new[] { server04 }, new[] { server05 }, new[] { server06 }, 80);
var barRoutingTable =
new RoutingTable("bar", new[] { server07 }, new[] { server08 }, new[] { server09 }, 100);
var discovery = new Mock <IDiscovery>();
discovery.Setup(x => x.DiscoverAsync(It.IsAny <IConnection>(), "", null, Bookmark.Empty))
.ReturnsAsync(defaultRoutingTable);
discovery.Setup(x => x.DiscoverAsync(It.IsAny <IConnection>(), "foo", null, Bookmark.Empty))
.ReturnsAsync(fooRoutingTable);
discovery.Setup(x => x.DiscoverAsync(It.IsAny <IConnection>(), "bar", null, Bookmark.Empty))
.ReturnsAsync(barRoutingTable);
var poolManager = new Mock <IClusterConnectionPoolManager>();
poolManager.Setup(x => x.CreateClusterConnectionAsync(It.IsAny <Uri>()))
.ReturnsAsync(Mock.Of <IConnection>);
var initialAddressProvider = new Mock <IInitialServerAddressProvider>();
initialAddressProvider.Setup(x => x.Get()).Returns(new HashSet <Uri> {
server01, server04, server07
});
var manager = new RoutingTableManager(initialAddressProvider.Object, discovery.Object,
poolManager.Object, Mock.Of <ILogger>(), TimeSpan.MaxValue);
// When
var routingTable1 = await manager.EnsureRoutingTableForModeAsync(mode, null, null, Bookmark.Empty);
var routingTable2 =
await manager.EnsureRoutingTableForModeAsync(mode, "foo", null, Bookmark.Empty);
var routingTable3 =
await manager.EnsureRoutingTableForModeAsync(mode, "bar", null, Bookmark.Empty);
routingTable1.Should().Be(defaultRoutingTable);
routingTable2.Should().Be(fooRoutingTable);
routingTable3.Should().Be(barRoutingTable);
manager.RoutingTableFor(null).Should().Be(defaultRoutingTable);
manager.RoutingTableFor("").Should().Be(defaultRoutingTable);
manager.RoutingTableFor("foo").Should().Be(fooRoutingTable);
manager.RoutingTableFor("bar").Should().Be(barRoutingTable);
}
public void TestRoutingTableReturnsEmptyForAbsentTopic()
{
var node = new NodeMock();
var routes = new Dictionary <string, Partition[]>
{
{ "test1p", new[] { new Partition {
Id = 0, Leader = node
} } },
};
var routingTable = new RoutingTable(routes);
Assert.Less(0, routingTable.GetPartitions("test1p").Length);
Assert.AreEqual(0, routingTable.GetPartitions("tortemoque").Length);
}
private static void OnRoleInstanceNumberChanged(int number)
{
if (number < 0)
{
List <WorkSessionServerInfo> affectedServers = new List <WorkSessionServerInfo>();
RoutingTable.ForEachWorkSessionServer((roleInstanceId, serverInfo) => {
if (serverInfo.IsProbablyShuttingDown())
{
affectedServers.Add(serverInfo);
}
});
WorkSessionMessenger.SendMessage(MessageOperation.ServerNumberDecreased, affectedServers);
}
}
public void ShouldEnsureInitialRouter()
{
var initUri = new Uri("bolt://123:456");
var routers = new HashSet <Uri> {
initUri
};
var table = new RoutingTable(null, routers);
Uri uri = table.Routers.Single();
uri.Should().Be(initUri);
table.All().Single().Should().Be(initUri);
}
private IRoutingTable BuildInternalExternalSmtpRouting()
{
RoutingTable routingTable = new RoutingTable(new Guid("{AF6E5D89-0C6F-4B10-9A6C-658D13CD3EA8}"), new TranslateableLanguageItem("{8819B8B3-38AE-4D89-A05C-AB0904E979D1}"), ChannelType.SMTP);
routingTable["resolve"] = new NonTranslateableLanguageItem("emailclient");
RoutingItemCollection interalGroup = new RoutingItemCollection(Guid.NewGuid(), "Recipients:Internal");
interalGroup.Add(new RoutingItem("Recipients:Internal", "Recipients:Internal"));
interalGroup["InternalGroup"] = new NonTranslateableLanguageItem("true");
interalGroup["assembly"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver.dll");
interalGroup["class"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver");
routingTable.Destinations.Add(interalGroup);
routingTable.Sources = TestHelpers.BuildSenderGroup();
routingTable.Destinations = TestHelpers.BuildRecipientGroup();
TestHelpers.BuildMatrixCells(routingTable);
return routingTable;
}
public void TestReadOnlyCopyConstruct()
{
Guid id = new Guid("{53BC19DB-1D34-4995-82FE-8041C9E71EC5}");
IPolicyLanguageItem name = new NonTranslateableLanguageItem("Test routing");
RoutingTable activeContentRoutingTable = new RoutingTable(id, name, ChannelType.ActiveContent);
Assert.AreEqual(id, activeContentRoutingTable.Identifier);
Assert.IsFalse(activeContentRoutingTable.ReadOnly);
Assert.AreEqual(name.Value, activeContentRoutingTable.Name.Value);
Assert.IsNotNull(activeContentRoutingTable.DefaultDestination);
Assert.IsNotNull(activeContentRoutingTable.DefaultSource);
Assert.IsNotNull(activeContentRoutingTable[activeContentRoutingTable.DefaultSource, activeContentRoutingTable.DefaultDestination]);
RoutingTable copy = new RoutingTable(activeContentRoutingTable, true, false);
Assert.AreEqual(id, copy.Identifier);
Assert.IsTrue(copy.ReadOnly);
Assert.AreEqual(name.Value, copy.Name.Value);
Assert.IsNotNull(copy.DefaultDestination);
Assert.IsNotNull(copy.DefaultSource);
Assert.IsNotNull(copy[copy.DefaultSource, copy.DefaultDestination]);
}
/// <summary>
/// Returns the 'neighbours' of an RoutingItem Collection.
/// </summary>
/// <param name="locationCollection">The location collection whose neighbours we're looking for</param>
/// <param name="routingTable">The routing table we're looking in</param>
/// <returns>If <paramref name="locationCollection"/> is on the 'row' axis of <paramref name="routingTable"/>, returns the Sources property of <paramref name="routingTable"/>. Otherwise, returns the Destinations property, or null if <paramref name="locationCollection"/> does not belong in the routing table</returns>
/// <remarks>Return value will always contain <paramref name="locationCollection"/>.
/// This method assumes that all Identifiers within the matrix are unique.</remarks>
internal static IRoutingItemCollections GetNeighbours(IRoutingItemCollection addressCollection, RoutingTable routingTable)
{
if ((null != addressCollection) && (null != routingTable))
{
foreach (IRoutingItemCollection ac in routingTable.Destinations)
{
if (0 == ac.Identifier.CompareTo(addressCollection.Identifier))
{
return routingTable.Destinations;
}
}
foreach (IRoutingItemCollection ac in routingTable.Sources)
{
if (0 == ac.Identifier.CompareTo(addressCollection.Identifier))
{
return routingTable.Sources;
}
}
}
return null;
}
public void TestGetNeighbours()
{
RoutingTable table = new RoutingTable(Guid.NewGuid(), new NonTranslateableLanguageItem("TestRoutingTable"), Workshare.Policy.ChannelType.SMTP);
table.Sources = new RoutingItemCollections();
table.Destinations = new RoutingItemCollections();
IRoutingItemCollection senderA = new RoutingItemCollection(Guid.NewGuid(), "senderA");
IRoutingItemCollection senderB = new RoutingItemCollection(Guid.NewGuid(), "senderB");
IRoutingItemCollection senderC = new RoutingItemCollection(Guid.NewGuid(), "senderC");
IRoutingItemCollection recipA = new RoutingItemCollection(Guid.NewGuid(), "recipA");
IRoutingItemCollection recipB = new RoutingItemCollection(Guid.NewGuid(), "recipB");
IRoutingItemCollection recipC = new RoutingItemCollection(Guid.NewGuid(), "recipC");
//add into the routing table
table.Sources.Add(senderA);
table.Sources.Add(senderB);
table.Sources.Add(senderC);
table.Destinations.Add(recipA);
table.Destinations.Add(recipB);
table.Destinations.Add(recipC);
IRoutingItemCollection notInMyRoutingTable = new RoutingItemCollection(Guid.NewGuid(), "notInMyRoutingTable");
Assert.IsNull(EditRoutingDetailState.GetNeighbours(null, table), "Should return null when either param is null.");
Assert.IsNull(EditRoutingDetailState.GetNeighbours(notInMyRoutingTable, null), "Should return null when either param is null.");
Assert.IsNull(EditRoutingDetailState.GetNeighbours(notInMyRoutingTable, table), "Should return null when 1st param does not exist in the table");
Assert.AreSame(table.Sources, EditRoutingDetailState.GetNeighbours(senderA, table), "Expected to return the table.Sources object for this param");
Assert.AreSame(table.Sources, EditRoutingDetailState.GetNeighbours(senderB, table), "Expected to return the table.Sources object for this param");
Assert.AreSame(table.Sources, EditRoutingDetailState.GetNeighbours(senderC, table), "Expected to return the table.Sources object for this param");
Assert.AreSame(table.Destinations, EditRoutingDetailState.GetNeighbours(recipA, table), "Expected to return the table.Destinations object for this param");
Assert.AreSame(table.Destinations, EditRoutingDetailState.GetNeighbours(recipB, table), "Expected to return the table.Destinations object for this param");
Assert.AreSame(table.Destinations, EditRoutingDetailState.GetNeighbours(recipC, table), "Expected to return the table.Destinations object for this param");
}
public void TestConstruct()
{
RoutingTable routingTable = new RoutingTable(Guid.Empty, new TranslateableLanguageItem("RoutingName"), ChannelType.SMTP);
routingTable["resolve"] = new NonTranslateableLanguageItem("emailclient");
RoutingItemCollection interalGroup = new RoutingItemCollection(Guid.NewGuid(), "Recipients:Internal");
interalGroup.Add(new RoutingItem("Recipients:Internal", "Recipients:Internal"));
interalGroup["InternalGroup"] = new NonTranslateableLanguageItem("true");
interalGroup["assembly"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver.dll");
interalGroup["class"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver");
routingTable.Destinations.Add(interalGroup);
Assert.AreEqual("RoutingName", routingTable.Name.Value);
Assert.AreEqual("Sources:Everyone", routingTable.DefaultSource.Name.Value);
Assert.AreEqual(1, routingTable.Sources.Count);
Assert.AreEqual("Sources:Everyone", routingTable.Sources[0].Name.Value);
Assert.AreEqual("Destinations:Everyone", routingTable.DefaultDestination.Name.Value);
Assert.AreEqual(2, routingTable.Destinations.Count);
Assert.AreEqual("Recipients:Internal", routingTable.Destinations[0].Name.Value);
Assert.AreEqual("Destinations:Everyone", routingTable.Destinations[1].Name.Value);
Assert.AreEqual(2, routingTable.CellCount);
}
public void TestCopyConstruct()
{
RoutingTable routingTable = new RoutingTable(Guid.Empty, new TranslateableLanguageItem("RoutingName"), ChannelType.SMTP);
routingTable["resolve"] = new NonTranslateableLanguageItem("emailclient");
RoutingItemCollection interalGroup = new RoutingItemCollection(Guid.NewGuid(), "Recipients:Internal");
interalGroup.Add(new RoutingItem("Recipients:Internal", "Recipients:Internal"));
interalGroup["InternalGroup"] = new NonTranslateableLanguageItem("true");
interalGroup["assembly"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver.dll");
interalGroup["class"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver");
routingTable.Destinations.Add(interalGroup);
RoutingItemCollection collection1 = new RoutingItemCollection(Guid.NewGuid(), "Collection1");
RoutingItemCollection collection2 = new RoutingItemCollection(Guid.NewGuid(), "Collection2");
RoutingItemCollection collection3 = new RoutingItemCollection(Guid.NewGuid(), "Collection3");
routingTable.Sources.Add(collection1);
routingTable.Sources.Add(collection2);
routingTable.Sources.Add(collection3);
RoutingItemCollection collection4 = new RoutingItemCollection(Guid.NewGuid(), "Collection4");
RoutingItemCollection collection5 = new RoutingItemCollection(Guid.NewGuid(), "Collection5");
RoutingItemCollection collection6 = new RoutingItemCollection(Guid.NewGuid(), "Collection6");
routingTable.Destinations.Add(collection4);
routingTable.Destinations.Add(collection5);
routingTable.Destinations.Add(collection6);
RoutingTable routingTable2 = new RoutingTable(routingTable);
routingTable["resolve"] = new NonTranslateableLanguageItem("emailclient");
routingTable2.Destinations.Add(interalGroup);
Assert.AreEqual(routingTable.Name.Value, routingTable2.Name.Value);
Assert.AreEqual(routingTable.Sources.Count, routingTable2.Sources.Count);
Assert.AreEqual(routingTable.Destinations.Count, routingTable2.Destinations.Count);
Assert.AreEqual(routingTable.CellCount, routingTable2.CellCount);
Assert.AreEqual(routingTable.ReadOnly, routingTable2.ReadOnly);
}
public static void BuildMatrixCells(RoutingTable routingTable)
{
PolicyCataloguesCache policyCataloguesCache = PolicyCataloguesCache.Instance();
IRoutingItemCollection senders1 = policyCataloguesCache.LocationsCollections[new Guid("{A81631A6-6AA3-45F7-AADD-4853447E5BD6}")];
Assert.IsNotNull(senders1, "Expected the sources 1 to be valid");
IRoutingItemCollection recipients1 = policyCataloguesCache.LocationsCollections[new Guid("{FA13BE82-9EB1-407E-9DD5-8005F3E840E4}")];
Assert.IsNotNull(recipients1, "Expected the destinations 1 to be valid");
IRoutingItemCollection senders2 = policyCataloguesCache.LocationsCollections[new Guid("{0DAACC5C-6167-42C7-AED0-55D1D9CC5096}")];
Assert.IsNotNull(senders2, "Expected the sources 2 to be valid");
IRoutingItemCollection recipients2 = policyCataloguesCache.LocationsCollections[new Guid("{13A8EBE5-8B1E-4919-82E2-8A860DE4043E}")];
Assert.IsNotNull(recipients2, "Expected the destinations 2 to be valid");
IRoutingMatrixCell cell = new RoutingMatrixCell(new TranslateableLanguageItem("Important"), new TranslateableLanguageItem("High Priority Scanning"), new TranslateableLanguageItem("Red"), 1, senders1, recipients1);
routingTable["{A81631A6-6AA3-45F7-AADD-4853447E5BD6}", "{FA13BE82-9EB1-407E-9DD5-8005F3E840E4}"] = cell;
IRoutingMatrixCell cell2 = new RoutingMatrixCell(new TranslateableLanguageItem("Sort of important"), new TranslateableLanguageItem("Sort of High Priority Scanning"), new TranslateableLanguageItem("Yellow"), 2, senders1, recipients2);
routingTable["{A81631A6-6AA3-45F7-AADD-4853447E5BD6}", "{13A8EBE5-8B1E-4919-82E2-8A860DE4043E}"] = cell2;
IRoutingMatrixCell cell3 = new RoutingMatrixCell(new TranslateableLanguageItem("Who cares"), new TranslateableLanguageItem("Very Low Priority Scanning"), new TranslateableLanguageItem("Brown"), 3, senders2, recipients1);
routingTable["{0DAACC5C-6167-42C7-AED0-55D1D9CC5096}", "{13A8EBE5-8B1E-4919-82E2-8A860DE4043E}"] = cell3;
IRoutingMatrixCell cell4 = new RoutingMatrixCell(new TranslateableLanguageItem("Not important at all"), new TranslateableLanguageItem("Very, very, very Low Priority Scanning"), new TranslateableLanguageItem("Black"), 4, senders2, recipients2);
routingTable["{0DAACC5C-6167-42C7-AED0-55D1D9CC5096}", "{FA13BE82-9EB1-407E-9DD5-8005F3E840E4}"] = cell4;
}
public void TestReadOnlyCopyConstructNull()
{
RoutingTable copy = new RoutingTable(null, true, false);
}
public void TestCopyConstructNull()
{
RoutingTable copy = new RoutingTable(null);
}
public void TestOfflineHttpRoutingCopyNullOffline()
{
RoutingTable routingTable = new RoutingTable(Guid.Empty, new TranslateableLanguageItem("RoutingName"), ChannelType.HTTP);
IRoutingMatrixCell offlineCell = routingTable.Offline;
Assert.IsNotNull(offlineCell, "Expected a valid offline routing cell");
offlineCell.Name.Value = "This is an offline cell";
RoutingTable copy = new RoutingTable(null, false, false);
}
public void TestOfflineHttpRoutingCopyCreateNew()
{
RoutingTable routingTable = new RoutingTable(Guid.Empty, new TranslateableLanguageItem("RoutingName"), ChannelType.HTTP);
IRoutingMatrixCell offlineCell = routingTable.Offline;
Assert.IsNotNull(offlineCell, "Expected a valid offline routing cell");
offlineCell.Name.Value = "This is an offline cell";
offlineCell.Description.Value = "This is a cell that will be used in offline mode";
Assert.IsNotNull(offlineCell, "Expected a valid offline routing cell");
RoutingTable copy = routingTable.DeepCopy(false, true) as RoutingTable;
Assert.AreEqual(offlineCell.Name.Value, copy.Offline.Name.Value);
Assert.AreNotEqual(offlineCell.Description.Identifier, copy.Offline.Description.Identifier);
Assert.AreEqual(offlineCell.Description.Value, copy.Offline.Description.Value);
copy.Offline.Description.Value = "A change was made";
Assert.AreNotEqual(offlineCell.Description.Value, copy.Offline.Description.Value);
RoutingTable copy2 = new RoutingTable(routingTable, false, true);
Assert.AreEqual(offlineCell.Name.Value, copy2.Offline.Name.Value);
Assert.AreNotEqual(offlineCell.Description.Identifier, copy2.Offline.Description.Identifier);
Assert.AreEqual(offlineCell.Description.Value, copy2.Offline.Description.Value);
copy2.Offline.Description.Value = "A change was made";
Assert.AreNotEqual(offlineCell.Description.Value, copy2.Offline.Description.Value);
}
public void TestOfflineHttpRouting()
{
RoutingTable routingTable = new RoutingTable(Guid.Empty, new TranslateableLanguageItem("RoutingName"), ChannelType.HTTP);
Assert.IsNotNull(routingTable.Offline, "Expected a valid offline routing cell");
}
private static IRoutingTable SmtpInternalExternalRoutingTableFactory(string name)
{
IRoutingTable routingTable = new RoutingTable(Guid.NewGuid(), new TranslateableLanguageItem(name), ChannelType.SMTP);
routingTable["resolve"] = new NonTranslateableLanguageItem("emailclient");
RoutingItemCollection interalGroup = new RoutingItemCollection(Guid.NewGuid(), "Recipients:Internal");
interalGroup.Add(new Workshare.Policy.ObjectModel.RoutingItem("Recipients:Internal", "Recipients:Internal"));
interalGroup["InternalGroup"] = new NonTranslateableLanguageItem("true");
interalGroup["assembly"] = new NonTranslateableLanguageItem("Workshare.InternalExternalResolver.dll");
interalGroup["class"] = new NonTranslateableLanguageItem("Workshare.Policy.Routing.InternalExternalRouter");
routingTable.Destinations.Add(interalGroup);
// creating default sources group
IRoutingItemCollection defaultSenders = routingTable.DefaultSource;
defaultSenders.Name.Value = Properties.Resources.ROUTING_EVERYONE;
// creating external destinations group
IRoutingItemCollection recipients = routingTable.DefaultDestination;
recipients.Name.Value = Properties.Resources.ROUTING_EXTERNALRECIPIENTS;
IRoutingMatrixCell cell = routingTable[defaultSenders, recipients];
cell.Name = new TranslateableLanguageItem(Properties.Resources.ROUTING_TO + recipients.Name.Value);
// creating internal destinations group
recipients = routingTable.Destinations[0];
recipients.Name.Value = Properties.Resources.ROUTING_INTERNALRECIPIENTS;
cell = routingTable[defaultSenders, recipients];
cell.Name = new TranslateableLanguageItem(Properties.Resources.ROUTING_TO + recipients.Name.Value);
RefreshRoutingMatrixTablePrecedences(routingTable);
return routingTable;
}
public void MatchesUrlWhenTwoRegexesHaveSameNumberOfGroups()
{
var target = new RoutingTable();
var expectedFoo = typeof(int);
var expectedBar = typeof(string);
target.Add("/tests/{Id}/foo", expectedFoo);
target.Add("/tests/{Id}/bar", expectedBar);
IDictionary<string, string> variables;
Assert.Equal(expectedFoo, target.Get("/tests/1/foo", out variables));
Assert.Equal(expectedBar, target.Get("/tests/1/bar", out variables));
}
public void TestCreatePolicySetChannelsMasterCataloguePrepopulateRouting()
{
string testCatalogue = m_testPath + "TestCreatePolicySetChannelsMasterCatalogue.xml";
string languageFilename = m_testPath + "TestCreatePolicySetChannelsMasterCatalogueLanguage.xml";
string policySetFilename = m_testPath + "TestCreatePolicySetChannelsMasterCataloguePolicySet.xml";
XmlPolicyLanguageStore languageStore = XmlPolicyLanguageStore.Instance;
languageStore.Reset();
Guid languageId = new Guid("{E8B22533-98EB-4D00-BDE4-406DC3E1858B}");
PolicyLanguageCache.Instance.ActiveLanguageId = languageId;
IPolicyLanguage language = new PolicyLanguage(languageId, "en");
language.DefaultLanguage = true;
languageStore.AddLanguage(language);
PolicyLanguageCache policyLanguageCache = PolicyLanguageCache.Instance;
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{B5C31A66-1B39-4CA7-BF02-AF271B5864F7}"), "New catalogue");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{9465CA41-A0A1-40BD-BE26-E83E17D83148}"), "New policy set");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{08BC5764-4879-42ED-9AD8-15040C4ADEDE}"), "New policy");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{39C06E29-074C-46C8-BE3D-F1CD92BB8D66}"), "Test channel");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{03005F4E-04FC-4287-B2A6-25F877D9C31B}"), "Test sources");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{3BF2C1D6-0F40-4A32-A311-6F65A5D271BD}"), "Test destinations");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{A8CEBEDF-92EA-4DCC-8053-08E5245ED84D}"), "Test routing table");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{86D8056D-BA38-44FA-B9BD-100CFB7113F8}"), "Test condition group");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{040C4E16-EE88-4B91-833F-8F30A536DAC6}"), "Test action group");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{F03E6CD1-98C0-4590-B789-907ECF90BEBF}"), "Test data element");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{6197CDBE-9F42-4A61-9369-238355BAB404}"), "Test data element display");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{E5C29C65-9600-42D9-8CD6-6638F40F9341}"), "Test data item");
policyLanguageCache.SetLanguageItemText(languageId, new Guid("{463295F1-A5A2-4BB1-B029-7917AC75E9E6}"), "Test action");
XMLPolicyCatalogueStore catalogueStore = XMLPolicyCatalogueStore.Instance;
catalogueStore.Reset();
PolicyCatalogue policyCatalogue = new PolicyCatalogue(new Guid("{AB5E2A43-01FB-4AA6-98FC-8F74BB0621CA}"), language.Identifier, new TranslateableLanguageItem("{B5C31A66-1B39-4CA7-BF02-AF271B5864F7}"), catalogueStore);
catalogueStore.AddPolicyCatalogue(policyCatalogue);
IPolicyStore policyStore = new XmlStore();
IPolicySet policySet = new PolicySet(new Guid("{29EC30A5-1271-4306-89C8-5811172D901A}"), new TranslateableLanguageItem("{9465CA41-A0A1-40BD-BE26-E83E17D83148}"), policyStore, policyCatalogue, false);
IPolicy newPolicy = new P5Policy(policySet, new Guid("{D257D4DC-4A12-438F-A32A-CF1CE4474441}"), new TranslateableLanguageItem("{08BC5764-4879-42ED-9AD8-15040C4ADEDE}"), PolicyStatus.Active);
policySet.Policies.Add(newPolicy);
// Create policy set channel
PolicyChannel channel = new PolicyChannel(new Guid("{0FE26539-7AAD-46DC-8D5B-9651CC00B9E4}"), new TranslateableLanguageItem("{39C06E29-074C-46C8-BE3D-F1CD92BB8D66}"), ChannelType.SMTP);
// Create routing table
RoutingTable routingTable = new RoutingTable(new Guid("{CDF0252C-3D5D-4AFB-98C2-89CF00FE2175}"), new TranslateableLanguageItem("{A8CEBEDF-92EA-4DCC-8053-08E5245ED84D}"), ChannelType.SMTP);
IRoutingItemCollection senders = new RoutingItemCollection(new Guid("{441FDCBF-B606-4325-8CD5-E829AD5303B9}"), "{03005F4E-04FC-4287-B2A6-25F877D9C31B}");
senders.Add(new RoutingItem(new Guid("{D41A47E2-CC13-46FF-BE83-829625792576}"), "James Brown", "*****@*****.**"));
senders.Add(new RoutingItem(new Guid("{B031DFE9-54E7-482B-8955-18CFB8F06A40}"), "Nat King Cole", "*****@*****.**"));
IRoutingItemCollection recipients = new RoutingItemCollection(new Guid("{29C44E5C-5405-409F-8513-A99AE246536F}"), "{3BF2C1D6-0F40-4A32-A311-6F65A5D271BD}");
recipients.Add(new RoutingItem(new Guid("{9E26C6A2-ABE2-427D-9D78-5B8547ADA8D2}"), "Jet Li", "*****@*****.**"));
routingTable.Sources.Add(senders);
routingTable.Destinations.Add(recipients);
// Assign routing table to channel
channel.Routing = routingTable;
// Create action matrix
ActionMatrix actionMatrix = new ObjectModel.ActionMatrix(false);
// Create an action matrix cell
ActionMatrixCell actionMatrixCell = new ObjectModel.ActionMatrixCell(senders, recipients);
// Populate the action matrix cell
ConditionGroup conditionGroup = new ConditionGroup(new Guid("{661EDD6F-D750-493A-9932-E56C8C22E2CF}"), new TranslateableLanguageItem("{86D8056D-BA38-44FA-B9BD-100CFB7113F8}"), ConditionLogic.AND, false);
ActionGroup actionGroup = new ObjectModel.ActionGroup(new Guid("{32D97853-2680-4B02-A391-22CAEE87B017}"), new TranslateableLanguageItem("{040C4E16-EE88-4B91-833F-8F30A536DAC6}"), 1);
IActionConditionGroup actionConditionGroup = new ObjectModel.ActionConditionGroup(conditionGroup, actionGroup, false);
ObjectModel.Action action = new ObjectModel.Action(new Guid("{5153B00E-7D30-4D37-90F9-75E55AA1B32B}"), new TranslateableLanguageItem("{463295F1-A5A2-4BB1-B029-7917AC75E9E6}"), "TestAction.dll", "Test.Action", RunAt.Client, false, 1); //TODO JE
DataItem dataItem = DataItem.CreateDataItem(new TranslateableLanguageItem("{E5C29C65-9600-42D9-8CD6-6638F40F9341}"), DataType.String, "Not again, when will it ever end!");
DataElement dataElement = new DataElement(new Guid("{39500989-0B41-4C4E-85DF-CCB4FBD5BEB8}"), new TranslateableLanguageItem("{F03E6CD1-98C0-4590-B789-907ECF90BEBF}"), new TranslateableLanguageItem("{6197CDBE-9F42-4A61-9369-238355BAB404}"), DataType.String, dataItem);
action.DataElements.Add(dataElement);
actionConditionGroup.ActionGroup.Actions.Add(action);
// Assign the action condition group to the matrix cell
actionMatrixCell.ActionConditionGroups.Add(actionConditionGroup);
// Assign the action matrix cell to the action matrix
actionMatrix[senders, recipients] = actionMatrixCell;
// Assign action matrix to channel
channel.Actions = actionMatrix;
// Assign channel to policy
newPolicy.Channels.Add(channel);
// Save everything
IPolicyCatalogueWriter catalogueWriter = catalogueStore.GetWriter(policyCatalogue.Identifier, language.Identifier);
catalogueWriter.WriteCatalogue(policyCatalogue);
catalogueWriter.Close();
policySet.Save();
TestHelpers.CompareXml(policySetFilename, policyStore.XMLRepresentation);
IRoutingMatrixCell routingMatrixCell = routingTable[senders, recipients];
string expectedCatalogueXml = System.IO.File.ReadAllText(testCatalogue);
expectedCatalogueXml = expectedCatalogueXml.Replace("{0}", routingMatrixCell.Name.Identifier.ToString("B").ToUpper());
expectedCatalogueXml = expectedCatalogueXml.Replace("{1}", routingMatrixCell.Description.Identifier.ToString("B").ToUpper());
testCatalogue += ".tmp";
System.IO.File.WriteAllText(testCatalogue, expectedCatalogueXml);
TestHelpers.CompareXml(testCatalogue, catalogueStore.GetStoreXML(policySet.MasterCatalogue.Identifier));
string expectedLanguageXml = System.IO.File.ReadAllText(languageFilename);
expectedLanguageXml = expectedLanguageXml.Replace("{0}", routingMatrixCell.Name.Identifier.ToString("B").ToUpper());
expectedLanguageXml = expectedLanguageXml.Replace("{1}", routingMatrixCell.Description.Identifier.ToString("B").ToUpper());
languageFilename += ".tmp";
System.IO.File.WriteAllText(languageFilename, expectedLanguageXml);
TestHelpers.CompareXml(languageFilename, languageStore.GetXMLRepresentation(language.Identifier, language.Name.Value));
}
public void TestAddRoutingPostAddToChannel()
{
IPolicyLanguage language = new PolicyLanguage(new Guid("{E8B22533-98EB-4D00-BDE4-406DC3E1858B}"), "en");
XMLPolicyCatalogueStore catalogueStore = XMLPolicyCatalogueStore.Instance;
catalogueStore.Reset();
PolicyCatalogue policyCatalogue = new PolicyCatalogue(new Guid("{AB5E2A43-01FB-4AA6-98FC-8F74BB0621CA}"), language.Identifier, new TranslateableLanguageItem("{B5C31A66-1B39-4CA7-BF02-AF271B5864F7}"), catalogueStore);
catalogueStore.AddPolicyCatalogue(policyCatalogue);
PolicySetObserver policySetObserver = new PolicySetObserver(policyCatalogue);
Assert.AreEqual(0, policyCatalogue.Channels.Count);
Assert.AreEqual(0, policyCatalogue.RoutingTables.Count);
Assert.AreEqual(0, policyCatalogue.LocationsCollection.Count);
Assert.AreEqual(0, policyCatalogue.Locations.Count);
PolicyChannel channel = new PolicyChannel(new Guid("{0FE26539-7AAD-46DC-8D5B-9651CC00B9E4}"), new TranslateableLanguageItem("Test channel"), ChannelType.SMTP);
policySetObserver.AddObject(channel);
IRoutingItemCollection senders = new RoutingItemCollection(new Guid("{441FDCBF-B606-4325-8CD5-E829AD5303B9}"), "Test sources");
senders.Add(new RoutingItem(new Guid("{D41A47E2-CC13-46FF-BE83-829625792576}"), "James Brown", "*****@*****.**"));
senders.Add(new RoutingItem(new Guid("{B031DFE9-54E7-482B-8955-18CFB8F06A40}"), "Nat King Cole", "*****@*****.**"));
IRoutingItemCollection recipients = new RoutingItemCollection(new Guid("{29C44E5C-5405-409F-8513-A99AE246536F}"), "Test destinations");
recipients.Add(new RoutingItem(new Guid("{9E26C6A2-ABE2-427D-9D78-5B8547ADA8D2}"), "Jet Li", "*****@*****.**"));
RoutingTable routingTable = new RoutingTable(new Guid("{CDF0252C-3D5D-4AFB-98C2-89CF00FE2175}"), new TranslateableLanguageItem("Test routing table"), ChannelType.SMTP);
routingTable.Sources.Add(senders);
routingTable.Destinations.Add(recipients);
channel.Routing = routingTable;
IRoutingItemCollection recipients2 = new RoutingItemCollection(new Guid("{4E17A792-0CBC-4362-8A82-A1A7FF3C71B0}"), "More test destinations");
recipients2.Add(new RoutingItem(new Guid("{98CE8CF9-6CF1-4F32-BE4F-C2D381E6C972}"), "why you", "*****@*****.**"));
routingTable.Destinations.Add(recipients2);
Assert.AreEqual(1, policyCatalogue.Channels.Count, "Expected one channel");
Assert.AreEqual(1, policyCatalogue.RoutingTables.Count, "Expected one routing table");
Assert.AreEqual(3, policyCatalogue.LocationsCollection.Count, "Expected two location groups");
Assert.AreEqual(4, policyCatalogue.Locations.Count, "Expected three locations");
}
public void TestWriteSmtpOfflineRouting()
{
string testCatalogue = m_testPath + "TestSmtpOfflineRouting.Catalogue.xml";
string testLanguage = m_testPath + "TestSmtpOfflineRouting.Language.xml";
Guid languageId = XmlPolicyLanguageStore.Instance.AddLanguage(System.IO.File.ReadAllText(testLanguage));
XMLPolicyCatalogueStore catalogueStore = XMLPolicyCatalogueStore.Instance;
PolicyCatalogue policyCatalogue = catalogueStore.AddPolicyCatalogue(System.IO.File.ReadAllText(testCatalogue));
XmlStore store = new XmlStore();
Store.IPolicyStoreWriter writer = store.Writer;
Assert.IsNotNull(writer, "Expected a valid [IPolicyStoreWriter] writer");
ObjectModel.PolicySet policySet = new ObjectModel.PolicySet(new Guid("{8FC9EB93-C376-4E96-B22E-71FAA848393D}"), new TranslateableLanguageItem("{D803727B-5C81-44CC-8BFC-9B68797AC6EB}"), store, policyCatalogue, false);
P5Policy policy = new P5Policy(store, policySet, new Guid("{C0F6D4BB-CBF1-41FC-8A28-616D6FC1DC73}"), new TranslateableLanguageItem("{F0DD86A0-5D21-4784-88AF-C5321B5998F6}"), PolicyStatus.Active);
IPolicyObjectCollection<IPolicyChannel> channels = new PolicyObjectCollection<IPolicyChannel>();
PolicyChannel channel = new PolicyChannel(new Guid("{390F589A-24B0-4DF0-B750-D47EDD1FF0BE}"), new TranslateableLanguageItem("{463A0FAF-CE8C-470E-8077-A093B9350719}"), ChannelType.SMTP);
IRoutingTable routings = new RoutingTable(new Guid("{AF6E5D89-0C6F-4B10-9A6C-658D13CD3EA8}"), new TranslateableLanguageItem("{8819B8B3-38AE-4D89-A05C-AB0904E979D1}"), ChannelType.SMTP);
IRoutingOfflineCell offlineCell = routings.Offline; // The offline cell will get creates the first time this is called
channel.Routing = routings;
channels.Add(channel);
policy.Channels = channels;
// Persist the changes to the catalogue.
IPolicyCatalogueWriter catalogueWriter = catalogueStore.GetWriter(policyCatalogue.Identifier, languageId);
catalogueWriter.WriteName(policyCatalogue.Name.Identifier.ToString("B").ToUpper());
catalogueWriter.WriteCatalogue(policyCatalogue);
catalogueWriter.Close();
string expectedCatalogueFile = m_testPath + "TestSmtpOfflineRouting.Catalogue.Modified.xml";
string expectedCatalogue = System.IO.File.ReadAllText(expectedCatalogueFile);
expectedCatalogue = expectedCatalogue.Replace("{91FDC9A5-CEA5-4A9C-BB58-576F57B1C329}", offlineCell.Name.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{E088C5CD-F5C9-48D5-9D3F-459A5D4BAB84}", offlineCell.Description.Identifier.ToString("B").ToUpper());
expectedCatalogueFile = expectedCatalogueFile + ".tmp";
System.IO.File.WriteAllText(expectedCatalogueFile, expectedCatalogue);
TestHelpers.CompareXml(expectedCatalogueFile, catalogueStore.GetStoreXML(policyCatalogue.Identifier));
}
public static IRoutingTable RoutingTableFactory(string name, Workshare.Policy.ChannelType channelType)
{
RoutingTable routingTable = new RoutingTable(Guid.NewGuid(), new TranslateableLanguageItem(name), channelType);
IRoutingItemCollection defaultSenders = routingTable.DefaultSource;
defaultSenders.Name.Value = (channelType == ChannelType.Mta) ?
Properties.Resources.ROUTING_MAILSERVER : Properties.Resources.ROUTING_EVERYONE;
IRoutingItemCollection defaultRecipients = routingTable.DefaultDestination;
defaultRecipients.Name.Value = Properties.Resources.ROUTING_EVERYONE;
IRoutingMatrixCell cell = routingTable[routingTable.DefaultSource, routingTable.DefaultDestination];
cell.Name = new TranslateableLanguageItem(Properties.Resources.ROUTING_TO + defaultRecipients.Name.Value);
RefreshRoutingMatrixTablePrecedences(routingTable);
return routingTable;
}
public void TestWriteHttpOfflineRouting()
{
string testCatalogue = m_testPath + "TestHttpOfflineRouting.Catalogue.xml";
string testLanguage = m_testPath + "TestHttpOfflineRouting.Language.xml";
Guid languageId = XmlPolicyLanguageStore.Instance.AddLanguage(System.IO.File.ReadAllText(testLanguage));
XMLPolicyCatalogueStore catalogueStore = XMLPolicyCatalogueStore.Instance;
PolicyCatalogue policyCatalogue = catalogueStore.AddPolicyCatalogue(System.IO.File.ReadAllText(testCatalogue));
XmlStore store = new XmlStore();
Store.IPolicyStoreWriter writer = store.Writer;
Assert.IsNotNull(writer, "Expected a valid [IPolicyStoreWriter] writer");
ObjectModel.PolicySet policySet = new ObjectModel.PolicySet(new Guid("{8FC9EB93-C376-4E96-B22E-71FAA848393D}"), new TranslateableLanguageItem("{D803727B-5C81-44CC-8BFC-9B68797AC6EB}"), store, policyCatalogue, false);
P5Policy policy = new P5Policy(store, policySet, new Guid("{C0F6D4BB-CBF1-41FC-8A28-616D6FC1DC73}"), new TranslateableLanguageItem("{F0DD86A0-5D21-4784-88AF-C5321B5998F6}"), PolicyStatus.Active);
IPolicyObjectCollection<IPolicyChannel> channels = new PolicyObjectCollection<IPolicyChannel>();
PolicyChannel channel = new PolicyChannel(new Guid("{390F589A-24B0-4DF0-B750-D47EDD1FF0BE}"), new TranslateableLanguageItem("{463A0FAF-CE8C-470E-8077-A093B9350719}"), ChannelType.HTTP);
IRoutingTable routings = new RoutingTable(new Guid("{AF6E5D89-0C6F-4B10-9A6C-658D13CD3EA8}"), new TranslateableLanguageItem("{8819B8B3-38AE-4D89-A05C-AB0904E979D1}"), ChannelType.HTTP);
IRoutingItemCollection defaultSender = routings.DefaultSource;
IRoutingItemCollection defaultRecipient = routings.DefaultDestination;
IRoutingMatrixCell routingCell = routings[defaultSender, defaultRecipient];
IRoutingOfflineCell offlineCell = routings.Offline; // The offline cell will get creates the first time this is called
channel.Routing = routings;
channels.Add(channel);
policy.Channels = channels;
// Persist the changes to the catalogue.
IPolicyCatalogueWriter catalogueWriter = catalogueStore.GetWriter(policyCatalogue.Identifier, languageId);
catalogueWriter.WriteName(policyCatalogue.Name.Identifier.ToString("B").ToUpper());
catalogueWriter.WriteCatalogue(policyCatalogue);
catalogueWriter.Close();
string expectedCatalogueFile = m_testPath + "TestHttpOfflineRouting.Catalogue.Modified.xml";
string expectedCatalogue = System.IO.File.ReadAllText(expectedCatalogueFile);
expectedCatalogue = expectedCatalogue.Replace("{91FDC9A5-CEA5-4A9C-BB58-576F57B1C329}", offlineCell.Name.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{E088C5CD-F5C9-48D5-9D3F-459A5D4BAB84}", offlineCell.Description.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{73B623E3-7D1A-470B-9C3A-BCE2B4D2B3CD}", defaultSender.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{0FC0FBD3-FC51-4D19-B7CE-04C6A5447E8C}", defaultSender.Name.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{E811E002-16F5-41B6-877E-6C7741529965}", defaultRecipient.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{3D594866-8C44-4896-91FD-A549B6481722}", defaultRecipient.Name.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{6ACC2C34-071A-445E-88A2-4C5B94452E5B}", routingCell.Name.Identifier.ToString("B").ToUpper());
expectedCatalogue = expectedCatalogue.Replace("{1BE90656-9FF3-4747-960D-176E6183C673}", routingCell.Description.Identifier.ToString("B").ToUpper());
expectedCatalogueFile = expectedCatalogueFile + ".tmp";
System.IO.File.WriteAllText(expectedCatalogueFile, expectedCatalogue);
TestHelpers.CompareXml(expectedCatalogueFile, catalogueStore.GetStoreXML(policyCatalogue.Identifier));
}
