public ServiceAddress PrimaryAddress(ServiceType type)
{
return(ServiceAddresses
.Where(a => a.Service.Value == type)
.OrderBy(a => a.Precedence.Value)
.FirstOrDefault());
}
public async Task LoadAsync()
{
long startTicks = Log.Trace(String.Format("Enter"), Common.LOG_APPNAME);
var lookup = await _ServiceAddressLookupDataService.GetServiceAddressLookupAsync();
ServiceAddresses.Clear();
foreach (var item in lookup)
{
ServiceAddresses.Add(item);
}
Log.Trace(String.Format("Exit"), Common.LOG_APPNAME, startTicks);
}
private static void WriteValue(object value, BinaryWriter writer)
{
Type valueType = value == null ? typeof(DBNull) : value.GetType();
byte valueTypeCode = GetCode(valueType);
writer.Write(valueTypeCode);
if (value == null)
{
}
else if (valueType == typeof(byte))
{
writer.Write((byte)value);
}
else if (valueType == typeof(short))
{
writer.Write((short)value);
}
else if (valueType == typeof(int))
{
writer.Write((int)value);
}
else if (valueType == typeof(long))
{
writer.Write((long)value);
}
else if (valueType == typeof(float))
{
writer.Write((float)value);
}
else if (valueType == typeof(double))
{
writer.Write((double)value);
}
else if (valueType == typeof(bool))
{
writer.Write((bool)value);
}
else if (valueType == typeof(DateTime))
{
value = ((DateTime)value).ToBinary();
writer.Write((long)value);
}
else if (valueType == typeof(TimeSpan))
{
value = ((TimeSpan)value).Ticks;
writer.Write((long)value);
}
else if (valueType == typeof(string))
{
string s = (string)value;
int sz = s.Length;
writer.Write(sz);
for (int i = 0; i < sz; i++)
{
writer.Write(s[i]);
}
// Extensions ...
}
else if (typeof(IServiceAddress).IsAssignableFrom(valueType))
{
IServiceAddress address = (IServiceAddress)value;
IServiceAddressHandler handler = ServiceAddresses.GetHandler(address);
byte[] buffer = handler.ToBytes(address);
int code = handler.GetCode(address.GetType());
writer.Write(code);
writer.Write(buffer.Length);
writer.Write(buffer);
}
else if (valueType == typeof(DataAddress))
{
DataAddress dataAddr = (DataAddress)value;
writer.Write(dataAddr.DataId);
writer.Write(dataAddr.BlockId.High);
writer.Write(dataAddr.BlockId.Low);
}
else if (valueType == typeof(MessageError))
{
MessageError e = (MessageError)value;
writer.Write(e.Source);
writer.Write(e.Message);
writer.Write(e.StackTrace);
}
else if (typeof(NodeSet).IsAssignableFrom(valueType))
{
if (value is SingleNodeSet)
{
writer.Write((byte)1);
}
else if (value is CompressedNodeSet)
{
writer.Write((byte)2);
}
else
{
throw new Exception("Unknown NodeSet type: " + value.GetType());
}
NodeSet nset = (NodeSet)value;
// Write the node set,
NodeId[] nodeIds = nset.NodeIds;
int nsz = nodeIds.Length;
writer.Write(nsz);
for (int i = 0; i < nsz; i++)
{
NodeId nodeId = nodeIds[i];
writer.Write(nodeId.High);
writer.Write(nodeId.Low);
}
// Write the binary encoding,
byte[] buffer = nset.Buffer;
int bsz = buffer.Length;
writer.Write(bsz);
writer.Write(buffer, 0, bsz);
}
else if (value is Array)
{
Array array = (Array)value;
Type arrayType = array.GetType().GetElementType();
byte arrayTypeCode = GetCode(arrayType);
int sz = array.Length;
writer.Write(arrayTypeCode);
writer.Write(sz);
for (int i = 0; i < sz; i++)
{
object item = array.GetValue(i);
WriteValue(item, writer);
}
}
}
private static object ReadValue(BinaryReader reader, byte typeCode)
{
Type type = GetType(typeCode);
if (type == typeof(DBNull))
{
return(null);
}
if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
if (type == typeof(byte))
{
return(reader.ReadByte());
}
if (type == typeof(short))
{
return(reader.ReadInt16());
}
if (type == typeof(int))
{
return(reader.ReadInt32());
}
if (type == typeof(long))
{
return(reader.ReadInt64());
}
if (type == typeof(float))
{
return(reader.ReadSingle());
}
if (type == typeof(double))
{
return(reader.ReadDouble());
}
if (type == typeof(DateTime))
{
return(DateTime.FromBinary(reader.ReadInt64()));
}
if (type == typeof(char))
{
return(reader.ReadChar());
}
if (type == typeof(string))
{
int sz = reader.ReadInt32();
StringBuilder sb = new StringBuilder(sz);
for (int i = 0; i < sz; i++)
{
sb.Append(reader.ReadChar());
}
return(sb.ToString());
}
// Extensions ...
if (type == typeof(IServiceAddress))
{
int addressTypeCode = reader.ReadInt32();
Type addressType = ServiceAddresses.GetAddressType(addressTypeCode);
IServiceAddressHandler handler = ServiceAddresses.GetHandler(addressType);
int length = reader.ReadInt32();
byte[] buffer = reader.ReadBytes(length);
return(handler.FromBytes(buffer));
}
if (type == typeof(DataAddress))
{
int dataId = reader.ReadInt32();
long blockIdHigh = reader.ReadInt64();
long blockIdLow = reader.ReadInt64();
return(new DataAddress(new BlockId(blockIdHigh, blockIdLow), dataId));
}
if (type == typeof(MessageError))
{
string source = reader.ReadString();
string message = reader.ReadString();
string stackTrace = reader.ReadString();
string errorType = reader.ReadString();
return(new MessageError(source, message, stackTrace, errorType));
}
if (type == typeof(NodeSet))
{
byte nodeSetType = reader.ReadByte();
// The node_ids list,
int sz = reader.ReadInt32();
NodeId[] arr = new NodeId[sz];
for (int n = 0; n < sz; ++n)
{
long nrHigh = reader.ReadInt64();
long nrLow = reader.ReadInt64();
arr[n] = new NodeId(nrHigh, nrLow);
}
// The binary encoding,
sz = reader.ReadInt32();
byte[] buf = new byte[sz];
// Util.BinaryReader.ReadFully(din, buf, 0, sz);
reader.Read(buf, 0, sz);
// Make the node_set object type,
if (nodeSetType == 1)
{
// Uncompressed single,
return(new SingleNodeSet(arr, buf));
}
if (nodeSetType == 2)
{
// Compressed group,
return(new CompressedNodeSet(arr, buf));
}
throw new Exception("Unknown node set type: " + nodeSetType);
}
// array
if (type == typeof(Array))
{
byte arrayTypeCode = reader.ReadByte();
int sz = reader.ReadInt32();
Type arrayType = GetType(arrayTypeCode);
Array array = Array.CreateInstance(arrayType, sz);
for (int i = 0; i < sz; i++)
{
object value = ReadValue(reader);
array.SetValue(value, i);
}
return(array);
}
throw new FormatException();
}
public static ServiceAddress ResolveServer(ILogger logger, string serviceName, ServiceAddresses serviceAddrs, string[] requiredContracts)
{
var serverList = new List <RoundTripData>();
foreach (ServiceAddress serviceAddr in serviceAddrs.List)
{
Int64 roundTrip; // ticks
int maxRoundTrips = 1;
if (serviceAddrs.List.Count > 1)
{
maxRoundTrips = 3;
}
if (QueryService(logger, serviceAddr.Host, serviceAddr.Port, serviceName, requiredContracts, maxRoundTrips, out roundTrip))
{
// add addr to list
serverList.Add(new RoundTripData(serviceAddr, roundTrip));
}
} // foreach server address
// find 'nearest' server
if (serverList.Count > 0)
{
ServiceAddress address = serverList[0].Addr;
Int64 bestRoundTrip = serverList[0].Ticks;
foreach (RoundTripData item in serverList)
{
if (item.Ticks < bestRoundTrip)
{
address = item.Addr;
bestRoundTrip = item.Ticks;
}
}
return(address);
}
throw new EndpointNotFoundException(
$"No server in list '{serviceAddrs}' found!");
}
