/// <remarks>Throws <see cref="InvalidDiscoveryException"/> if the discovery result is invalid.</remarks>
public void Rediscovery()
{
using (var session = new Session(_conn, _logger))
{
var result = session.Run($"CALL {ProcedureName}");
var record = result.Single();
// TODO require an IT to make sure List or IList, Dictionary or IDictionary
foreach (var servers in record["servers"].As <List <Dictionary <string, object> > >())
{
var addresses = servers["addresses"].As <List <string> >();
var role = servers["role"].As <string>();
switch (role)
{
case "READ":
Readers = addresses.Select(BoltRoutingUri).ToArray();
break;
case "WRITE":
Writers = addresses.Select(BoltRoutingUri).ToArray();
break;
case "ROUTE":
Routers = addresses.Select(BoltRoutingUri).ToArray();
break;
}
}
ExpireAfterSeconds = record["ttl"].As <long>();
}
if (!Readers.Any() || !Writers.Any() || !Routers.Any())
{
throw new InvalidDiscoveryException(
$"Invalid discovery result: discovered {Routers.Count()} routers, " +
$"{Writers.Count()} writers and {Readers.Count()} readers. A Redisvoery is required.");
}
}
public void TriggerEvent(string eventType)
{
Delegate @delegate;
if (Routers.TryGetValue(eventType, out @delegate))
{
Delegate[] invocationList = @delegate.GetInvocationList();
for (int i = 0; i < invocationList.Length; i++)
{
Action action = invocationList [i] as Action;
if (action == null)
{
throw new EventException(string.Format("TriggerEvent {0} error: types of parameters are not match.", eventType));
}
try
{
action();
}
catch (Exception ex)
{
UnuLogger.LogError(ex.StackTrace);
}
}
}
}
public void Cleanup()
{
List <string> list = new List <string> ();
foreach (KeyValuePair <string, Delegate> current in Routers)
{
bool flag = false;
foreach (string current2 in PermanentEvents)
{
if (current.Key == current2)
{
flag = true;
break;
}
}
if (!flag)
{
list.Add(current.Key);
}
}
foreach (string current2 in list)
{
Routers.Remove(current2);
}
}
/// <summary>
/// <para>
/// Creates a snapshot of the current state of the <see cref="RouteData"/> before appending
/// <paramref name="router"/> to <see cref="Routers"/>, merging <paramref name="values"/> into
/// <see cref="Values"/>, and merging <paramref name="dataTokens"/> into <see cref="DataTokens"/>.
/// </para>
/// <para>
/// Call <see cref="RouteDataSnapshot.Restore"/> to restore the state of this <see cref="RouteData"/>
/// to the state at the time of calling
/// <see cref="PushState(IRouter, RouteValueDictionary, RouteValueDictionary)"/>.
/// </para>
/// </summary>
/// <param name="router">
/// An <see cref="IRouter"/> to append to <see cref="Routers"/>. If <c>null</c>, then <see cref="Routers"/>
/// will not be changed.
/// </param>
/// <param name="values">
/// A <see cref="RouteValueDictionary"/> to merge into <see cref="Values"/>. If <c>null</c>, then
/// <see cref="Values"/> will not be changed.
/// </param>
/// <param name="dataTokens">
/// A <see cref="RouteValueDictionary"/> to merge into <see cref="DataTokens"/>. If <c>null</c>, then
/// <see cref="DataTokens"/> will not be changed.
/// </param>
/// <returns>A <see cref="RouteDataSnapshot"/> that captures the current state.</returns>
public RouteDataSnapshot PushState(IRouter router, RouteValueDictionary values, RouteValueDictionary dataTokens)
{
var snapshot = new RouteDataSnapshot(
this,
_dataTokens?.Count > 0 ? new RouteValueDictionary(_dataTokens) : null,
_routers?.Count > 0 ? new List <IRouter>(_routers) : null,
_values?.Count > 0 ? new RouteValueDictionary(_values) : null);
if (router != null)
{
Routers.Add(router);
}
if (values != null)
{
foreach (var kvp in values)
{
if (kvp.Value != null)
{
Values[kvp.Key] = kvp.Value;
}
}
}
if (dataTokens != null)
{
foreach (var kvp in dataTokens)
{
DataTokens[kvp.Key] = kvp.Value;
}
}
return(snapshot);
}
public void OnListenerRemoved(string eventType)
{
if (Routers[eventType] == null)
{
Routers.Remove(eventType);
}
}
public bool OnListenerRemoving(string eventType, Delegate listenerBeingRemoved)
{
#if LOG_ALL_MESSAGES
Debug.Log("MESSENGER OnListenerRemoving \t\"" + eventType + "\"\t{" + listenerBeingRemoved.Target + " -> " + listenerBeingRemoved.Method + "}");
#endif
bool success = true;
if (Routers.ContainsKey(eventType))
{
Delegate d = Routers[eventType];
if (d == null)
{
success = false;
throw new ListenerException(string.Format("Attempting to remove listener with for event type \"{0}\" but current listener is null.", eventType));
}
else if (d.GetType() != listenerBeingRemoved.GetType())
{
success = false;
throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being removed has type {2}", eventType, d.GetType().Name, listenerBeingRemoved.GetType().Name));
}
}
else
{
success = false;
throw new ListenerException(string.Format("Attempting to remove listener for type \"{0}\" but Messenger doesn't know about this event type.", eventType));
}
return(success);
}
public void Register(Func <object, IScope, RouteKey> retriever)
{
Routers.Add(new Router(retriever)
{
Key = "agg" + kid++
});
}
private void btnCompute_Click(object sender, EventArgs e)
{
if (listRouter.SelectedItem == null)
{
MessageBox.Show("Not selected router", "Error", MessageBoxButtons.OK);
return;
}
int routerId = Int32.Parse(listRouter.SelectedItem.ToString().Split('_')[0]);
int turn = Int32.Parse(listRouter.SelectedItem.ToString().Split('_')[1]);
DijkstraFinding dijkstra = new DijkstraFinding(BusManager.Inst());
Router router = null;
if (!Routers.ContainsKey(routerId))
{
MessageBox.Show("Invalid router", "Error", MessageBoxButtons.OK);
return;
}
router = Routers[routerId];
List <int> stationIds = null;
if (turn == 0)
{
stationIds = router.Stations1;
}
else if (turn == 1)
{
stationIds = router.Stations2;
}
if (stationIds == null)
{
MessageBox.Show("Invalid turn", "Error", MessageBoxButtons.OK);
return;
}
for (int i = 0; i < stationIds.Count - 1; i++)
{
dijkstra.addPath(stationIds[i], stationIds[i + 1]);
}
Vertex dest = dijkstra.computePath(stationIds[0], stationIds[stationIds.Count - 20]);
if (dest == null)
{
MessageBox.Show("Cannot find shortest path");
return;
}
List <int> listStation = new List <int>();
while (dest.PreviewVertex != null)
{
listStation.Add(dest.StationId);
dest = dest.PreviewVertex;
}
listStation.Reverse();
clearMap();
drawStationPath(listStation, Color.Red, sortedPathOverlay);
}
public void Register(IRouter router)
{
if (string.IsNullOrWhiteSpace(router.Key))
{
router.Key = "agg" + kid++;
}
Routers.Add(router);
}
/// <summary>
/// 映射 解决与指定谓词所定义的条件相匹配的类型 到特定类型 【TResult】 的转换。
/// </summary>
/// <typeparam name="TResult">目标类型。</typeparam>
/// <param name="router">映射路由。</param>
public void Map <TResult>(MapRouter <TResult> router)
{
if (router is null)
{
throw new ArgumentNullException(nameof(router));
}
Routers.Add(router);
}
/// <summary>
/// Initializes a new instance of the <see cref="Configuration"/> class from the given, possibly encrypted
/// bytes.
/// </summary>
/// <param name="bytes">The bytes to read the settings from.</param>
public ConfigFile(byte[] bytes)
{
// Detect if the bytes represent encrypted content.
bool isEncrypted = false;
foreach (byte b in bytes)
{
// Any byte with a value under 32 which is not a line break is not valid in.
// decrypted files.
if (b < 32 && b != '\r' && b != '\n')
{
isEncrypted = true;
break;
}
}
// Get the decrypted content.
string text;
if (isEncrypted)
{
text = Decrypt(bytes);
}
else
{
text = Encoding.ASCII.GetString(bytes);
}
string[] lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
// Detect if the configuration has user settings.
int numberInLine3 = Int32.Parse(lines[2]);
bool hasUserConfiguration = numberInLine3 < 17;
// Parse the possibly existing user configuration.
int line = 0;
if (hasUserConfiguration)
{
Username = lines[0];
Password = lines[1];
Routers = new List <Router>(numberInLine3);
RouterName = lines[3];
line = 4;
}
else
{
Routers = new List <Router>();
}
// Parse the router list.
for (int i = line; i < lines.Length; i += 3)
{
string name = lines[i];
IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse(lines[i + 1]), Int16.Parse(lines[i + 2]));
Routers.Add(new Router(name, ipEndPoint));
}
}
/// <remarks>Throws <see cref="ProtocolException"/> if the discovery result is invalid.</remarks>
/// <remarks>Throws <see cref="ServiceUnavailableException"/> if the no discovery procedure could be found in the server.</remarks>
public void Rediscovery()
{
try
{
using (var provider = new SingleConnectionBasedConnectionProvider(_conn))
using (var session = new Session(provider, _logger))
{
var result = session.Run(DiscoveryProcedure);
var record = result.Single();
foreach (var servers in record["servers"].As <List <Dictionary <string, object> > >())
{
var addresses = servers["addresses"].As <List <string> >();
var role = servers["role"].As <string>();
switch (role)
{
case "READ":
Readers = addresses.Select(BoltRoutingUri).ToArray();
break;
case "WRITE":
Writers = addresses.Select(BoltRoutingUri).ToArray();
break;
case "ROUTE":
Routers = addresses.Select(BoltRoutingUri).ToArray();
break;
}
}
ExpireAfterSeconds = record["ttl"].As <long>();
}
}
catch (ClientException e)
{
throw new ServiceUnavailableException(
$"Error when calling `getServers` procedure: {e.Message}. " +
"Please make sure that there is a Neo4j 3.1+ causal cluster up running.", e);
}
catch (Exception e)
{
// for any reason we failed to do a discovery
throw new ProtocolException(
$"Error when parsing `getServers` result: {e.Message}.");
}
if (!Readers.Any() || !Routers.Any())
{
throw new ProtocolException(
$"Invalid discovery result: discovered {Routers.Count()} routers, " +
$"{Writers.Count()} writers and {Readers.Count()} readers.");
}
}
static void Initialize()
{
Computer c1 = new Computer {
Id = 1, Model = "PC", Manufactured = DateTime.Now, HardwareAddress = "90-1F-12-22-33-55", LogicAddress = 2,
};
Computer c2 = new Computer {
Id = 2, Model = "PC2", Manufactured = DateTime.Now.AddDays(-1), HardwareAddress = "90-1F-12-22-33-54", LogicAddress = 22
};
Router r1 = new Router {
Id = 1, Model = "R1", Manufactured = DateTime.Now, HardwareAddress = "90-1F-12-22-33-53", LogicAddress = 33, Mask = 4294967040, Computers = new List <Computer> {
c1, c2
}
};
Room rm1 = new Room {
Id = 1, Number = 521, Routers = new List <Router> {
r1
}, Computers = new List <Computer> {
c1, c2
}
};
Building b1 = new Building {
Id = 1, Name = "MyBuilding", Rooms = new List <Room> {
rm1
}
};
c1.Router = r1;
c1.RouterId = r1.Id;
c1.Room = rm1;
c1.RoomId = rm1.Id;
c2.Router = r1;
c2.RouterId = r1.Id;
c2.Room = rm1;
c2.RoomId = rm1.Id;
r1.Room = rm1;
r1.RoomId = rm1.Id;
rm1.Building = b1;
rm1.BuildingId = b1.Id;
Computers.Add(c1);
Computers.Add(c2);
Routers.Add(r1);
Rooms.Add(rm1);
Buildings.Add(b1);
}
public RouteDataSnapshot PushState(IRouter?router, RouteValueDictionary?values, RouteValueDictionary?dataTokens)
{
// Perf: this is optimized for small list sizes, in particular to avoid overhead of a native call in
// Array.CopyTo inside the List(IEnumerable<T>) constructor.
List <IRouter>?routers = null;
var count = _routers?.Count;
if (count > 0)
{
Debug.Assert(_routers != null);
routers = new List <IRouter>(count.Value);
for (var i = 0; i < count.Value; i++)
{
routers.Add(_routers[i]);
}
}
var snapshot = new RouteDataSnapshot(
this,
_dataTokens?.Count > 0 ? new RouteValueDictionary(_dataTokens) : null,
routers,
_values?.Count > 0 ? new RouteValueDictionary(_values) : null);
if (router != null)
{
Routers.Add(router);
}
if (values != null)
{
foreach (var kvp in values)
{
if (kvp.Value != null)
{
Values[kvp.Key] = kvp.Value;
}
}
}
if (dataTokens != null)
{
foreach (var kvp in dataTokens)
{
DataTokens[kvp.Key] = kvp.Value;
}
}
return(snapshot);
}
private bool disposedValue = false; // 要检测冗余调用
/// <summary>
/// 释放资源。
/// </summary>
/// <param name="disposing">全部释放。</param>
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
Routers.Clear();
Invokers.Clear();
if (disposing)
{
GC.SuppressFinalize(this);
}
disposedValue = true;
}
}
public void OnListenerAdding(string eventType, Delegate listenerBeingAdded)
{
#if LOG_ALL_MESSAGES || LOG_ADD_LISTENER
Debug.Log("MESSENGER OnListenerAdding \t\"" + eventType + "\"\t{" + listenerBeingAdded.Target + " -> " + listenerBeingAdded.Method + "}");
#endif
if (!Routers.ContainsKey(eventType))
{
Routers.Add(eventType, null);
}
Delegate d = Routers[eventType];
if (d != null && d.GetType() != listenerBeingAdded.GetType())
{
throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", eventType, d.GetType().Name, listenerBeingAdded.GetType().Name));
}
}
public static List <T> Set <T>() where T : class
{
if (typeof(T) == typeof(Building))
{
return((List <T>)Buildings.Cast <T>());
}
if (typeof(T) == typeof(Room))
{
return((List <T>)Rooms.Cast <T>());
}
if (typeof(T) == typeof(Router))
{
return((List <T>)Routers.Cast <T>());
}
if (typeof(T) == typeof(Computer))
{
return((List <T>)Computers.Cast <T>());
}
return(null);
}
public async Task RediscoveryAsync()
{
var provider = new SingleConnectionBasedConnectionProvider(_conn);
var session = new Session(provider, _logger);
try
{
var result = await session.RunAsync(DiscoveryProcedure).ConfigureAwait(false);
var record = await result.SingleAsync().ConfigureAwait(false);
ParseDiscoveryResult(record);
}
catch (Exception e)
{
HandleDiscoveryException(e);
}
finally
{
try
{
await session.CloseAsync().ConfigureAwait(false);
}
catch (Exception)
{
// ignore any exception
}
await provider.CloseAsync().ConfigureAwait(false);
}
if (!Readers.Any() || !Routers.Any())
{
throw new ProtocolException(
$"Invalid discovery result: discovered {Routers.Count()} routers, " +
$"{Writers.Count()} writers and {Readers.Count()} readers.");
}
}
/// <remarks>Throws <see cref="ProtocolException"/> if the discovery result is invalid.</remarks>
/// <remarks>Throws <see cref="ServiceUnavailableException"/> if the no discovery procedure could be found in the server.</remarks>
public void Rediscovery()
{
try
{
using (var provider = new SingleConnectionBasedConnectionProvider(_conn))
using (var session = new Session(provider, _logger))
{
var result = session.Run(DiscoveryProcedure);
var record = result.Single();
ParseDiscoveryResult(record);
}
}
catch (Exception e)
{
HandleDiscoveryException(e);
}
if (!Readers.Any() || !Routers.Any())
{
throw new ProtocolException(
$"Invalid discovery result: discovered {Routers.Count()} routers, " +
$"{Writers.Count()} writers and {Readers.Count()} readers.");
}
}
public bool ContainsEvent(string eventType)
{
return(Routers.ContainsKey(eventType));
}
private void AddTestRoutes()
{
Routers routers = new Routers();
//------------------------------------------------------------------------------------------------------------------
{
Route route = new Route()
{
Name = "NetworkDLS",
ListenPort = 80,
TrafficType = TrafficType.Http,
MaxBufferSize = 1021 * 1024,
ListenOnAllAddresses = false,
AutoStart = true,
Description = "Default example route."
};
route.Bindings.Add(new Binding {
Enabled = true, Address = "127.0.0.1"
});
route.Endpoints.ConnectionPattern = ConnectionPattern.FailOver;
route.Endpoints.Add(new Endpoint("www.NetworkDLS.com", 80));
route.HttpHeaderRules.Add(new HttpHeaderRule(HttpHeaderType.Request, HttpVerb.Any, "Host", HttpHeaderAction.Upsert, "www.NetworkDLS.com"));
routers.Add(new Router(route));
}
//------------------------------------------------------------------------------------------------------------------
{
Route route = new Route()
{
Name = "Ingenuity",
ListenPort = 81,
TrafficType = TrafficType.Http,
MaxBufferSize = 1021 * 1024,
ListenOnAllAddresses = true,
AutoStart = true
};
//route.Bindings.Add(new Binding { Enabled = true, Address = "127.0.0.1" });
route.Endpoints.ConnectionPattern = ConnectionPattern.FailOver;
route.Endpoints.Add(new Endpoint("www.IngenuitySC.com", 80));
route.HttpHeaderRules.Add(new HttpHeaderRule(HttpHeaderType.Request, HttpVerb.Any, "Host", HttpHeaderAction.Upsert, "www.IngenuitySC.com"));
routers.Add(new Router(route));
}
//------------------------------------------------------------------------------------------------------------------
{
Route route = new Route()
{
Name = "Microsoft LIVE!",
ListenPort = 82,
TrafficType = TrafficType.Https,
MaxBufferSize = 1021 * 1024,
ListenOnAllAddresses = true,
AutoStart = true
};
//route.Bindings.Add(new Binding { Enabled = true, Address = "127.0.0.1" });
route.Endpoints.ConnectionPattern = ConnectionPattern.FailOver;
route.Endpoints.Add(new Endpoint("login.live.com", 443));
route.HttpHeaderRules.Add(new HttpHeaderRule(HttpHeaderType.Request, HttpVerb.Any, "Host", HttpHeaderAction.Upsert, "login.live.com"));
routers.Add(new Router(route));
}
//------------------------------------------------------------------------------------------------------------------
string routesText = JsonConvert.SerializeObject(routers.Routes());
string configPath = RegistryHelper.GetString(Registry.LocalMachine, Constants.RegsitryKey, "", "ConfigPath");
File.WriteAllText(Path.Combine(configPath, Constants.RoutesConfigFileName), routesText);
}
