public ReplicaService(IPublisher publisher,
TFChunkDb db,
IEpochManager epochManager,
IPublisher networkSendQueue,
IAuthenticationProvider authProvider,
VNodeInfo nodeInfo,
bool useSsl,
string sslTargetHost,
bool sslValidateServer)
{
Ensure.NotNull(publisher, "publisher");
Ensure.NotNull(db, "db");
Ensure.NotNull(epochManager, "epochManager");
Ensure.NotNull(networkSendQueue, "networkSendQueue");
Ensure.NotNull(authProvider, "authProvider");
Ensure.NotNull(nodeInfo, "nodeInfo");
if (useSsl)
{
Ensure.NotNull(sslTargetHost, "sslTargetHost");
}
_publisher = publisher;
_db = db;
_epochManager = epochManager;
_networkSendQueue = networkSendQueue;
_authProvider = authProvider;
_nodeInfo = nodeInfo;
_useSsl = useSsl;
_sslTargetHost = sslTargetHost;
_sslValidateServer = sslValidateServer;
_connector = new TcpClientConnector();
}
private static bool IsOnline(string baseUrl, int millisecondsTimeout = 2000)
{
try
{
if (string.IsNullOrEmpty(baseUrl))
{
return(false);
}
var redisClientUrl = GetUrl(baseUrl);
var urlSegments = redisClientUrl.Split(':');
if (urlSegments.Length == 2)
{
var isOnline = TcpClientConnector.IsOnline(urlSegments[0], int.Parse(urlSegments[1]), millisecondsTimeout);
return(isOnline);
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
public TcpConnectionManager(string connectionName,
ITcpDispatcher dispatcher,
IPublisher publisher,
IPEndPoint remoteEndPoint,
TcpClientConnector connector)
{
Ensure.NotNull(dispatcher, "dispatcher");
Ensure.NotNull(publisher, "publisher");
Ensure.NotNull(remoteEndPoint, "remoteEndPoint");
Ensure.NotNull(connector, "connector");
_connectionName = connectionName;
_tcpEnvelope = new SendOverTcpEnvelope(this);
_publisher = publisher;
_dispatcher = dispatcher;
EndPoint = remoteEndPoint;
_framer = new LengthPrefixMessageFramer();
_framer.RegisterMessageArrivedCallback(OnMessageArrived);
_connection = connector.ConnectTo(remoteEndPoint, OnConnectionEstablished, OnConnectionFailed);
_connection.ConnectionClosed += OnConnectionClosed;
}
public TcpConnectionManager(string connectionName,
Guid connectionId,
ITcpDispatcher dispatcher,
IPublisher publisher,
string targetHost,
EndPoint remoteEndPoint,
TcpClientConnector connector,
bool useSsl,
Func <X509Certificate, X509Chain, SslPolicyErrors, ValueTuple <bool, string> > sslServerCertValidator,
Func <X509CertificateCollection> sslClientCertificatesSelector,
IPublisher networkSendQueue,
IAuthenticationProvider authProvider,
AuthorizationGateway authorization,
TimeSpan heartbeatInterval,
TimeSpan heartbeatTimeout,
Action <TcpConnectionManager> onConnectionEstablished,
Action <TcpConnectionManager, SocketError> onConnectionClosed)
{
Ensure.NotEmptyGuid(connectionId, "connectionId");
Ensure.NotNull(dispatcher, "dispatcher");
Ensure.NotNull(publisher, "publisher");
Ensure.NotNull(authProvider, "authProvider");
Ensure.NotNull(authorization, "authorization");
Ensure.NotNull(remoteEndPoint, "remoteEndPoint");
Ensure.NotNull(connector, "connector");
ConnectionId = connectionId;
ConnectionName = connectionName;
_tcpEnvelope = new SendOverTcpEnvelope(this, networkSendQueue);
_publisher = publisher;
_dispatcher = dispatcher;
_authProvider = authProvider;
_authorization = authorization;
_framer = new LengthPrefixMessageFramer();
_framer.RegisterMessageArrivedCallback(OnMessageArrived);
_weakThisEnvelope = new SendToWeakThisEnvelope(this);
_heartbeatInterval = heartbeatInterval;
_heartbeatTimeout = heartbeatTimeout;
_connectionPendingSendBytesThreshold = ESConsts.UnrestrictedPendingSendBytes;
_connectionQueueSizeThreshold = ESConsts.MaxConnectionQueueSize;
_connectionEstablished = onConnectionEstablished;
_connectionClosed = onConnectionClosed;
RemoteEndPoint = remoteEndPoint;
_connection = useSsl
? connector.ConnectSslTo(ConnectionId, targetHost, remoteEndPoint.ResolveDnsToIPAddress(), ConnectionTimeout,
sslServerCertValidator, sslClientCertificatesSelector, OnConnectionEstablished, OnConnectionFailed)
: connector.ConnectTo(ConnectionId, remoteEndPoint.ResolveDnsToIPAddress(), ConnectionTimeout, OnConnectionEstablished,
OnConnectionFailed);
_connection.ConnectionClosed += OnConnectionClosed;
if (_connection.IsClosed)
{
OnConnectionClosed(_connection, SocketError.Success);
}
}
public TcpConnectionManager(string connectionName,
Guid connectionId,
ITcpDispatcher dispatcher,
IPublisher publisher,
IPEndPoint remoteEndPoint,
TcpClientConnector connector,
bool useSsl,
string sslTargetHost,
bool sslValidateServer,
IPublisher networkSendQueue,
IAuthenticationProvider authProvider,
TimeSpan heartbeatInterval,
TimeSpan heartbeatTimeout,
Action <TcpConnectionManager> onConnectionEstablished,
Action <TcpConnectionManager, SocketError> onConnectionClosed)
{
Ensure.NotEmptyGuid(connectionId, "connectionId");
Ensure.NotNull(dispatcher, "dispatcher");
Ensure.NotNull(publisher, "publisher");
Ensure.NotNull(authProvider, "authProvider");
Ensure.NotNull(remoteEndPoint, "remoteEndPoint");
Ensure.NotNull(connector, "connector");
if (useSsl)
{
Ensure.NotNull(sslTargetHost, "sslTargetHost");
}
ConnectionId = connectionId;
ConnectionName = connectionName;
_tcpEnvelope = new SendOverTcpEnvelope(this, networkSendQueue);
_publisher = publisher;
_dispatcher = dispatcher;
_authProvider = authProvider;
_framer = new LengthPrefixMessageFramer();
_framer.RegisterMessageArrivedCallback(OnMessageArrived);
_weakThisEnvelope = new SendToWeakThisEnvelope(this);
_heartbeatInterval = heartbeatInterval;
_heartbeatTimeout = heartbeatTimeout;
_connectionPendingSendBytesThreshold = ESConsts.UnrestrictedPendingSendBytes;
_connectionQueueSizeThreshold = ESConsts.MaxConnectionQueueSize;
_connectionEstablished = onConnectionEstablished;
_connectionClosed = onConnectionClosed;
RemoteEndPoint = remoteEndPoint;
_connection = useSsl
? connector.ConnectSslTo(ConnectionId, remoteEndPoint, ConnectionTimeout,
sslTargetHost, sslValidateServer, OnConnectionEstablished, OnConnectionFailed)
: connector.ConnectTo(ConnectionId, remoteEndPoint, ConnectionTimeout, OnConnectionEstablished,
OnConnectionFailed);
_connection.ConnectionClosed += OnConnectionClosed;
if (_connection.IsClosed)
{
OnConnectionClosed(_connection, SocketError.Success);
}
}
public static MockTcpConnection CreateConnectingTcpConnection(Guid connectionId,
IPEndPoint remoteEndPoint,
TcpClientConnector connector,
TimeSpan connectionTimeout,
Action <ITcpConnection> onConnectionEstablished,
Action <ITcpConnection, SocketError> onConnectionFailed,
bool verbose)
{
_connectionId = connectionId;
_remoteEndPoint = remoteEndPoint;
return(new MockTcpConnection());
}
public ReplicaService(IPublisher publisher,
TFChunkDb db,
IEpochManager epochManager,
IPublisher networkSendQueue,
IAuthenticationProvider authProvider,
AuthorizationGateway authorizationGateway,
EndPoint internalTcp,
bool isReadOnlyReplica,
bool useSsl,
Func <X509Certificate, X509Chain, SslPolicyErrors, ValueTuple <bool, string> > sslServerCertValidator,
Func <X509Certificate> sslClientCertificateSelector,
TimeSpan heartbeatTimeout,
TimeSpan heartbeatInterval,
TimeSpan writeTimeout)
{
Ensure.NotNull(publisher, "publisher");
Ensure.NotNull(db, "db");
Ensure.NotNull(epochManager, "epochManager");
Ensure.NotNull(networkSendQueue, "networkSendQueue");
Ensure.NotNull(authProvider, "authProvider");
Ensure.NotNull(authorizationGateway, "authorizationGateway");
Ensure.NotNull(internalTcp, nameof(internalTcp));
_publisher = publisher;
_db = db;
_epochManager = epochManager;
_networkSendQueue = networkSendQueue;
_authProvider = authProvider;
_authorizationGateway = authorizationGateway;
_internalTcp = internalTcp;
_isReadOnlyReplica = isReadOnlyReplica;
_useSsl = useSsl;
_sslServerCertValidator = sslServerCertValidator;
_sslClientCertificateSelector = sslClientCertificateSelector;
_heartbeatTimeout = heartbeatTimeout;
_heartbeatInterval = heartbeatInterval;
_connector = new TcpClientConnector();
_tcpDispatcher = new InternalTcpDispatcher(writeTimeout);
}
public ReplicaService(IPublisher publisher,
TFChunkDb db,
IEpochManager epochManager,
IPublisher networkSendQueue,
IAuthenticationProvider authProvider,
AuthorizationGateway authorizationGateway,
VNodeInfo nodeInfo,
bool useSsl,
bool sslValidateServer,
X509CertificateCollection sslClientCertificates,
TimeSpan heartbeatTimeout,
TimeSpan heartbeatInterval,
TimeSpan writeTimeout)
{
Ensure.NotNull(publisher, "publisher");
Ensure.NotNull(db, "db");
Ensure.NotNull(epochManager, "epochManager");
Ensure.NotNull(networkSendQueue, "networkSendQueue");
Ensure.NotNull(authProvider, "authProvider");
Ensure.NotNull(authorizationGateway, "authorizationGateway");
Ensure.NotNull(nodeInfo, "nodeInfo");
_publisher = publisher;
_db = db;
_epochManager = epochManager;
_networkSendQueue = networkSendQueue;
_authProvider = authProvider;
_authorizationGateway = authorizationGateway;
_nodeInfo = nodeInfo;
_useSsl = useSsl;
_sslValidateServer = sslValidateServer;
_sslClientCertificates = sslClientCertificates;
_heartbeatTimeout = heartbeatTimeout;
_heartbeatInterval = heartbeatInterval;
_connector = new TcpClientConnector();
_tcpDispatcher = new InternalTcpDispatcher(writeTimeout);
}
private void Connect()
{
// TODO: implement some kind of master discovery
var endPoint = new IPEndPoint(IPAddress.Parse(_ip), _port);
var clientConnector = new TcpClientConnector();
_connectionManager = new TcpConnectionManager(
"projection",
new ClientTcpDispatcher(),
_bus,
endPoint,
clientConnector);
_connectionManager.ConnectionEstablished += manager =>
{
Console.WriteLine("Connection established: " + manager.EndPoint);
_bus.Publish(new ProjectionMessage.CoreService.Start());
_bus.Publish(new ProjectionMessage.CoreService.Connected(connection: manager));
_connectionManager.ConnectionClosed += OnConnectionClosed;
_connectionManager.StartReceiving();
};
}
private void StartSend(int port)
{
var client = new TcpClientConnector();
client.ConnectTo(new IPEndPoint(IPAddress.Loopback, port), ClientOnConnectionEstablished,
ClientOnConnectionFailed);
}
public static async Task Get_XAGL_WM3000WXGT_IndicatorDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var flag = true;
var indicatorDiagram = new IotDataOilWellIndicatorDiagram()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
double displacement = -1;
if (jo1["0"] != null)
{
double.TryParse(jo1["0"].ToString().Trim(), out displacement);
}
if (displacement > 0)
{
indicatorDiagram.Displacement = displacement;
}
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var commandParameter = par.CommandParameter.ToString();
var slot = Convert.ToInt32(jo1["1"].ToString());
var host = par.RemoteHost;
var url = "/getworkgraph/";
bool IsHostAlive = false;
if (host.StartsWith("192"))
{
$"无线功图树莓派({host})不正确，或者没有接入无线功图".Error();
}
else
{
IsHostAlive = TcpClientConnector.IsOnline(host, null, 1000);
if (IsHostAlive)
{
url = $"http://{host}{url}{slot}";
$"请求树莓派api:{url}".Info();
var indicatorDiagramJson = await url.GetJsonFromUrlAsync();
//$"树莓派api返回数据:{indicatorDiagramJson}".Info();
var oilWellIndicatorDiagram = indicatorDiagramJson.FromJson <OilWellIndicatorDiagram>();
indicatorDiagram.Stroke = oilWellIndicatorDiagram.chongCheng;
indicatorDiagram.L = oilWellIndicatorDiagram.load;
indicatorDiagram.D = oilWellIndicatorDiagram.displace;
var maxDis = indicatorDiagram.D.Max();
var minDis = indicatorDiagram.D.Min();
if (!indicatorDiagram.Displacement.HasValue)
{
indicatorDiagram.Displacement = maxDis;
}
for (var i = 0; i < indicatorDiagram.D.Count; i++)
{
if (Math.Abs(maxDis - minDis) > 0.1)
{
indicatorDiagram.D[i] = Math.Round(((indicatorDiagram.D[i] - minDis) / (maxDis - minDis) * (double)indicatorDiagram.Displacement), 2);
}
}
//补点
if (indicatorDiagram.L.Count > 0)
{
indicatorDiagram.L.Add(indicatorDiagram.L[0]);
}
if (indicatorDiagram.D.Count > 0)
{
indicatorDiagram.D.Add(indicatorDiagram.D[0]);
}
indicatorDiagram.MaxLoad = indicatorDiagram.L.Max();
indicatorDiagram.MinLoad = indicatorDiagram.L.Min();
indicatorDiagram.AvgLoad = indicatorDiagram.L.Average();
indicatorDiagram.DateTime = DateTime.Now; //树莓派时间不准确，取服务器时间
//to do 树莓派时间稳定了再换
indicatorDiagram.WellId = oilWellIndicatorDiagram.wellId;
indicatorDiagram.Count = oilWellIndicatorDiagram.count;
indicatorDiagram.Interval = oilWellIndicatorDiagram.interval;
indicatorDiagram.DeviceTypeId = par.DeviceTypeId;
indicatorDiagram.Mock = par.UseMockData;
if (displacement > 0)
{
indicatorDiagram.Displacement = displacement;
}
indicatorDiagram.NetworkNode = host;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_IndicatorDiagram", indicatorDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:IndicatorDiagram", indicatorDiagram);
redisClient.Set($"Single:OilWell:IndicatorDiagram:{par.DeviceName}-{par.DeviceId}", indicatorDiagram);
}
else
{
$"无线功图树莓派({host})网络不通!".Error();
}
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, indicatorDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
