private string addressOrAlias; // VISA identifier of the instrument
// <METHODS>
/// <summary>
/// Connects to the instrument via selected connection method (interface)
/// </summary>
/// <param name="addressOrAlias">VISA address or alias of the instrument</param>
/// <param name="connectionMode">Physical interface over which the connection is made</param>
public virtual void Connect(string addressOrAlias, ConnectionModes connectionMode)
{
if (IsConnected)
{
Disconnect();
} // disconnect first
this.addressOrAlias = addressOrAlias;
switch (connectionMode)
{
case ConnectionModes.USB:
dmm = new UsbSession(addressOrAlias);
break;
case ConnectionModes.TCPIP:
dmm = new TcpipSession(addressOrAlias);
break;
case ConnectionModes.Serial:
dmm = new SerialSession(addressOrAlias);
break;
case ConnectionModes.VXI:
dmm = new VxiSession(addressOrAlias);
break;
default:
break;
}
io = dmm.RawIO;
dmm.TimeoutMilliseconds = Global.VISATimeout;
}
/// <summary>
/// Инициализировать настройки на основе параметров канала связи
/// </summary>
public void Init(SortedList<string, string> commCnlParams, bool requireParams = true)
{
ConnMode = commCnlParams.GetEnumParam<ConnectionModes>("ConnMode", requireParams, ConnMode);
bool sharedConnMode = ConnMode == ConnectionModes.Shared;
IpAddress = commCnlParams.GetStringParam("IpAddress", requireParams && sharedConnMode, IpAddress);
TcpPort = commCnlParams.GetIntParam("TcpPort", requireParams && sharedConnMode, TcpPort);
Behavior = commCnlParams.GetEnumParam<OperatingBehaviors>("Behavior", false, Behavior);
}
private static ConnectionMode GetTargetConnectionMode(ConnectionModes connectionMode)
{
return(connectionMode switch
{
ConnectionModes.Gateway => ConnectionMode.Gateway,
ConnectionModes.Direct => ConnectionMode.Direct,
_ => throw new ArgumentException($"Unexpected connection mode: {connectionMode}"),
});
public ClientInfo(int id, IPEndPoint ep, string alias, Socket s)
{
this.id = id;
this.endPoint = ep;
this.alias = alias;
this.socket = s;
connectionMode = ConnectionModes.Accepted;
DataToSendQueue = new Queue<byte[]>();
}
/// <summary>
/// Automatically reconnect if connection gets broken
/// </summary>
/// <param name="endPoint">The endpoint to connect to.</param>
/// <returns></returns>
public void AutoConnect(IPEndPoint endPoint)
{
if (_connectionMode == ConnectionModes.fixedEndPoint)
{
return;
}
_connectionMode = ConnectionModes.fixedEndPoint;
Task.Run(() => KeepConnectedAsync(endPoint));
}
public ClientInfo(int id, IPEndPoint ep, string alias, Socket s)
{
this.id = id;
this.endPoint = ep;
this.alias = alias;
this.socket = s;
connectionMode = ConnectionModes.Accepted;
DataToSendQueue = new Queue <byte[]>();
}
/// <summary>
/// Инициализировать настройки на основе параметров канала связи
/// </summary>
public void Init(SortedList <string, string> commCnlParams, bool requireParams = true)
{
ConnMode = commCnlParams.GetEnumParam <ConnectionModes>("ConnMode", requireParams, ConnMode);
bool sharedConnMode = ConnMode == ConnectionModes.Shared;
IpAddress = commCnlParams.GetStringParam("IpAddress", requireParams && sharedConnMode, IpAddress);
TcpPort = commCnlParams.GetIntParam("TcpPort", requireParams && sharedConnMode, TcpPort);
Behavior = commCnlParams.GetEnumParam <OperatingBehaviors>("Behavior", false, Behavior);
}
/// <summary> Called to add connections </summary>
/// <param name="howMany"></param>
/// <param name="connectionMode"></param>
/// <param name="host"></param>
/// <param name="port"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="logKey"></param>
/// <param name="defaultEncoding"></param>
public void AddConnections(int howMany,
ConnectionModes connectionMode,
string host,
int port,
string userName,
string password,
string logKey,
DataCodings defaultEncoding)
{
WriteLog("ESMEManager : AddConnections : Started : HowMany[{0}] ConnectionMode[{1}] Host[{2}] Port[{3}] LogKey[{4}] DefaultEncoding[{5}]",
howMany,
connectionMode,
host,
port,
logKey,
defaultEncoding);
for (var connection = 1; connection <= howMany; ++connection)
{
if (connectionMode == ConnectionModes.Transceiver)
{
AddTransceiverConnection(connection,
host,
port,
userName,
password,
logKey,
defaultEncoding);
}
else if (connectionMode == ConnectionModes.Receiver)
{
AddReceiverConnection(connection,
host,
port,
userName,
password,
logKey,
defaultEncoding);
}
else
{
AddTransmitterConnection(connection,
host,
port,
userName,
password,
logKey,
defaultEncoding);
}
}
}
/// <summary> Constructor For ESMS mode </summary>
/// <param name="connectionId"></param>
/// <param name="shortLongCode"></param>
/// <param name="connectionMode"></param>
/// <param name="host"></param>
/// <param name="port"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="logKey"></param>
/// <param name="defaultEncoding"></param>
/// <param name="connectionEventHandler"></param>
/// <param name="receivedMessageHandler"></param>
/// <param name="receivedGenericNackHandler"></param>
/// <param name="submitMessageHandler"></param>
/// <param name="queryMessageHandler"></param>
/// <param name="logEventHandler"></param>
/// <param name="pduDetailsEventHandler"></param>
public ESMEConnection(int connectionId, string shortLongCode, ConnectionModes connectionMode,
string host, int port, string userName, string password, string logKey,
DataCodings defaultEncoding,
CONNECTION_EVENT_HANDLER connectionEventHandler,
RECEIVED_MESSAGE_HANDLER receivedMessageHandler,
RECEIVED_GENERICNACK_HANDLER receivedGenericNackHandler,
SUBMIT_MESSAGE_HANDLER submitMessageHandler,
QUERY_MESSAGE_HANDLER queryMessageHandler,
LOG_EVENT_HANDLER logEventHandler,
PDU_DETAILS_EVENT_HANDLER pduDetailsEventHandler)
{
// Properties
ConnectionId = connectionId;
ShortLongCode = shortLongCode;
ConnectionMode = connectionMode;
Host = host;
Port = port;
UserName = userName;
Password = password;
LogKey = string.Format("{0}-{1}-{2}", logKey, ConnectionMode, ConnectionId);
// Bind user events
ConnectionEventHandler = connectionEventHandler;
ReceivedMessageHandler = receivedMessageHandler;
ReceivedGenericNackHandler = receivedGenericNackHandler;
SubmitMessageHandler = submitMessageHandler;
QueryMessageHandler = queryMessageHandler;
LogEventHandler = logEventHandler;
PduDetailsEventHandler = pduDetailsEventHandler;
// Create the connection to the server
Client = new SmppClient(defaultEncoding);
// Bind Internal ESME required events
Client.ConnectEvent += new SmppClient.ConnectedEventHandler(ClientEventConnect);
Client.DeliverSmEvent += new SmppClient.DeliverSmEventHandler(ClientEventDeliverSm);
Client.DisconnectEvent += new SmppClient.DisconnectEventHandler(ClientEventDisconnect);
Client.EnquireLinkSmEvent += new SmppClient.EnquireLinkSmEventHandler(ClientEventEnquireLinkSm);
Client.EnquireLinkSmRespEvent += new SmppClient.EnquireLinkSmRespEventHandler(ClientEventEnquireLinkSmResp);
Client.ErrorEvent += new SmppClient.ErrorEventHandler(ClientEventError);
Client.GenericNackSmEvent += new SmppClient.GenericNackSmEventHandler(ClientEventGenericNackSm);
Client.QuerySmRespEvent += new SmppClient.QuerySmRespEventHandler(ClientEventQuerySmResp);
Client.SubmitSmRespEvent += new SmppClient.SubmitSmRespEventHandler(ClientEventSubmitSmResp);
Client.UnBindSmEvent += new SmppClient.UnBindSmEventHandler(ClientEventUnBindSm);
Client.PduDetailsEvent += new SmppClient.PduDetailsEventHandler(ClientEventPduDetails);
// Start a thread to get this connection
ConnectionThread = new Thread(new ThreadStart(PerformConnectClient));
ConnectionThread.Start();
}
/// <summary>
/// Инициализировать настройки на основе параметров канала связи
/// </summary>
public void Init(SortedList <string, string> commCnlParams, bool requireParams = true)
{
ConnMode = commCnlParams.GetEnumParam("ConnMode", requireParams, ConnMode);
bool sharedConnMode = ConnMode == ConnectionModes.Shared;
Host = commCnlParams.GetStringParam("IpAddress", false, Host); // для обратной совместимости
if (Host == "")
{
Host = commCnlParams.GetStringParam("Host", requireParams && sharedConnMode, Host);
}
TcpPort = commCnlParams.GetIntParam("TcpPort", requireParams && sharedConnMode, TcpPort);
ReconnectAfter = commCnlParams.GetIntParam("ReconnectAfter", false, ReconnectAfter);
StayConnected = commCnlParams.GetBoolParam("StayConnected", false, StayConnected);
Behavior = commCnlParams.GetEnumParam("Behavior", false, Behavior);
}
/// <summary>
/// Discover sever and automatically reconnect if connection gets broken
/// </summary>
/// <param name="serverName">The endpoint to connect to.</param>
/// <returns></returns>
public void AutoConnect(string serverName = "SimplSocketServer")
{
if (_connectionMode == ConnectionModes.Discovery)
{
return;
}
_connectionMode = ConnectionModes.Discovery;
_probe = new Probe(serverName);
_probe.BeaconsUpdated += beacons => {
lock (_beaconsLock)
{
_beacons = beacons.ToList();
}
};
_probe.Start();
Task.Run(() => KeepConnectedAsync(serverName));
}
internal Task CreateIngestQueryDeleteAsync <T>(
ConnectionModes connectionModes,
CollectionTypes collectionTypes,
IEnumerable <string> documents,
Query <T> query,
T testArgs,
string partitionKey = "/id",
Cosmos.IndexingPolicy indexingPolicy = null,
CosmosClientFactory cosmosClientFactory = null)
{
return(this.CreateIngestQueryDeleteAsync(
connectionModes,
collectionTypes,
documents,
query,
cosmosClientFactory ?? this.CreateDefaultCosmosClient,
testArgs,
partitionKey,
indexingPolicy));
}
static ConnectionMode GetTargetConnectionMode(ConnectionModes connectionMode)
{
ConnectionMode targetConnectionMode;
switch (connectionMode)
{
case ConnectionModes.Gateway:
targetConnectionMode = ConnectionMode.Gateway;
break;
case ConnectionModes.Direct:
targetConnectionMode = ConnectionMode.Direct;
break;
default:
throw new ArgumentException($"Unexpected connection mode: {connectionMode}");
}
return(targetConnectionMode);
}
private static BasicConnector CreateConnectorByMode(ConnectionModes mode, CommunicationInfoStruct info)
{
BasicConnector res;
//TODO: add more modes
switch (mode)
{
case ConnectionModes.Usb:
case ConnectionModes.Bluetooth:
res = new SerialConnector(info.SerialInfo.RxPort, info.SerialInfo.TxPort, info.SerialInfo.Baudrate);
break;
case ConnectionModes.WiFi:
res = new TcpConnector(info.TcpInfo.Ip, info.TcpInfo.Port);
break;
default:
res = null;
break;
}
return(res);
}
public static DeviceMessage BuildRequest(string message, ConnectionModes settings)
{
var buffer = new List <byte>();
byte[] lrc;
switch (settings)
{
case ConnectionModes.SERIAL:
case ConnectionModes.PAY_AT_TABLE:
buffer.Add((byte)ControlCodes.STX);
foreach (char c in message)
{
buffer.Add((byte)c);
}
buffer.Add((byte)ControlCodes.ETX);
lrc = CalculateLRC(message);
buffer.Add(lrc[0]);
break;
case ConnectionModes.TCP_IP_SERVER:
var _msg = CalculateHeader(Encoding.UTF8.GetBytes(message)) + message;
foreach (char c in _msg)
{
buffer.Add((byte)c);
}
break;
default:
throw new BuilderException("Failed to build request message. Unknown Connection mode.");
}
return(new DeviceMessage(buffer.ToArray()));
}
internal Task CreateIngestQueryDeleteAsync(
ConnectionModes connectionModes,
CollectionTypes collectionTypes,
IEnumerable <string> documents,
Query query,
string partitionKey = "/id",
Cosmos.IndexingPolicy indexingPolicy = null,
CosmosClientFactory cosmosClientFactory = null)
{
Task queryWrapper(Container container, IReadOnlyList <CosmosObject> inputDocuments, object throwaway)
{
return(query(container, inputDocuments));
}
return(this.CreateIngestQueryDeleteAsync <object>(
connectionModes,
collectionTypes,
documents,
queryWrapper,
null,
partitionKey,
indexingPolicy,
cosmosClientFactory));
}
/// <summary>
/// Task that wraps boiler plate code for query tests (container create -> ingest documents -> query documents -> delete collections).
/// Note that this function will take the cross product connectionModes
/// </summary>
/// <param name="connectionModes">The connection modes to use.</param>
/// <param name="documents">The documents to ingest</param>
/// <param name="query">
/// The callback for the queries.
/// All the standard arguments will be passed in.
/// Please make sure that this function is idempotent, since a container will be reused for each connection mode.
/// </param>
/// <param name="cosmosClientFactory">
/// The callback for the create CosmosClient. This is invoked for the different ConnectionModes that the query is targeting.
/// If CosmosClient instantiated by this does not apply the expected ConnectionMode, an assert is thrown.
/// </param>
/// <param name="partitionKey">The partition key for the partition container.</param>
/// <param name="testArgs">The optional args that you want passed in to the query.</param>
/// <returns>A task to await on.</returns>
internal async Task CreateIngestQueryDeleteAsync <T>(
ConnectionModes connectionModes,
CollectionTypes collectionTypes,
IEnumerable <string> documents,
Query <T> query,
CosmosClientFactory cosmosClientFactory,
T testArgs,
string partitionKey = "/id",
Cosmos.IndexingPolicy indexingPolicy = null)
{
try
{
IList <(Container, IReadOnlyList <CosmosObject>)> collectionsAndDocuments = new List <(Container, IReadOnlyList <CosmosObject>)>();
foreach (CollectionTypes collectionType in Enum.GetValues(collectionTypes.GetType()).Cast <Enum>().Where(collectionTypes.HasFlag))
{
if (collectionType == CollectionTypes.None)
{
continue;
}
Task <(Container, IReadOnlyList <CosmosObject>)> createContainerTask = collectionType switch
{
CollectionTypes.NonPartitioned => this.CreateNonPartitionedContainerAndIngestDocumentsAsync(
documents,
indexingPolicy),
CollectionTypes.SinglePartition => this.CreateSinglePartitionContainerAndIngestDocumentsAsync(
documents,
partitionKey,
indexingPolicy),
CollectionTypes.MultiPartition => this.CreateMultiPartitionContainerAndIngestDocumentsAsync(
documents,
partitionKey,
indexingPolicy),
_ => throw new ArgumentException($"Unknown {nameof(CollectionTypes)} : {collectionType}"),
};
collectionsAndDocuments.Add(await createContainerTask);
}
List <CosmosClient> cosmosClients = new List <CosmosClient>();
foreach (ConnectionModes connectionMode in Enum.GetValues(connectionModes.GetType()).Cast <Enum>().Where(connectionModes.HasFlag))
{
if (connectionMode == ConnectionModes.None)
{
continue;
}
ConnectionMode targetConnectionMode = GetTargetConnectionMode(connectionMode);
CosmosClient cosmosClient = cosmosClientFactory(targetConnectionMode);
Assert.AreEqual(
targetConnectionMode,
cosmosClient.ClientOptions.ConnectionMode,
"Test setup: Invalid connection policy applied to CosmosClient");
cosmosClients.Add(cosmosClient);
}
List <Task> queryTasks = new List <Task>();
foreach (CosmosClient cosmosClient in cosmosClients)
{
foreach ((Container container, IReadOnlyList <CosmosObject> insertedDocuments) in collectionsAndDocuments)
{
Task queryTask = Task.Run(() => query(container, insertedDocuments, testArgs));
queryTasks.Add(queryTask);
}
}
await Task.WhenAll(queryTasks);
List <Task <ContainerResponse> > deleteContainerTasks = new List <Task <ContainerResponse> >();
foreach (Container container in collectionsAndDocuments.Select(tuple => tuple.Item1))
{
deleteContainerTasks.Add(container.DeleteContainerAsync());
}
await Task.WhenAll(deleteContainerTasks);
}
catch (Exception ex) when(ex.GetType() != typeof(AssertFailedException))
{
while (ex.InnerException != null)
{
ex = ex.InnerException;
}
ExceptionDispatchInfo.Capture(ex).Throw();
}
}
public static string Name(this ConnectionModes connectionMode)
{
string[] connectionModesNames = new string[] { "USB", "TCP/IP", "Serial port", "VXI" };
return(connectionModesNames[(int)connectionMode]);
}
public void ManualConnect()
{
_connectionMode = ConnectionModes.Manual;
}
private void inputWorker()
{
int length = -1;
byte[] lenBytes = new byte[4];
List <byte[]> dataToSend = new List <byte[]>();
while (ShouldBeRunning)
{
if (length == -1 && socket.Available >= 4)
{
int count = socket.Receive(lenBytes);
length = BitConverter.ToInt32(lenBytes, 0);
if (length > 10000)
{
throw new FormatException("packet length is unreasonably long");
}
}
else if (length > 0 && socket.Available >= length)
{
byte[] data = new byte[length];
int datacount = socket.Receive(data);
Packet p = Packet.Read(data);
if (p != null)
{
CallPacketReceived(p);
}
length = -1;
}
dataToSend.Clear();
lock (DataToSendQueue)
{
while (DataToSendQueue.Count > 0)
{
dataToSend.Add(DataToSendQueue.Dequeue());
}
}
if (!socket.Connected)
{
continue;
}
try
{
foreach (byte[] b in dataToSend)
{
socket.Send(b);
}
}
catch (SocketException E)
{
ShouldBeRunning = false;
connectionMode = ConnectionModes.Disconnected;
System.Diagnostics.Debug.WriteLine(E.StackTrace);
// no longer connected.
}
Thread.Sleep(10);
}
if (connectionMode == ConnectionModes.Disconnected)
{
CallClientDisconnected();
}
}
public Manager(ConnectionModes mode, CommunicationInfoStruct info) : base(CreateConnectorByMode(mode, info))
{
}
/// <summary>
/// 解析update
/// </summary>
/// <param name = "tableName">物理表名</param>
/// <param name = "updateFields">更新字段</param>
/// <param name = "queryGroup">查询集合</param>
/// <returns>解析后的sql</returns>
public static string __ParseUpdateSQL(string tableName, UpdateFieldConditionCollections updateFields,
QueryGroupConditionCollections queryGroup, ConnectionModes cnnmode)
{
var sqlBuilder = new StringBuilder();
if (string.IsNullOrEmpty(tableName))
throw new Exception("无效的表名称！");
sqlBuilder.AppendFormat("Update {0} ", tableName);
if (updateFields == null || updateFields.Count < 1)
throw new Exception("无效的更新字段参数!");
sqlBuilder.Append(" set ");
for (var n = 0; n < updateFields.Count; n++)
{
var upField = updateFields[n];
sqlBuilder.AppendFormat(" {0}{1}{2} ", upField.FieldName, GetOperatorType(upField.Operator),
FormatSQLValue(upField.Value, cnnmode));
if (n < updateFields.Count - 1)
sqlBuilder.AppendFormat(" , ");
}
if (queryGroup != null && queryGroup.Count > 0)
{
sqlBuilder.AppendFormat(" where ");
for (var i = 0; i < queryGroup.Count; i++)
{
var qry = queryGroup[i];
sqlBuilder.AppendFormat(" (");
for (var j = 0; j < qry.FieldConditions.Count; j++)
{
var field = qry.FieldConditions[j];
sqlBuilder.AppendFormat("( {0} {1} {2} )", field.FieldName, GetOperatorType(field.Operator),
FormatSQLValue(field.Value, cnnmode));
if (j < qry.FieldConditions.Count - 1)
sqlBuilder.AppendFormat(" {0} ", GetWhereUnionType(field.NextUnionType));
}
sqlBuilder.AppendFormat(") ");
if (i < (queryGroup.Count - 1))
sqlBuilder.AppendFormat(" {0} ", GetWhereUnionType(qry.NextUnionType));
}
}
Console.WriteLine("create sql:" + sqlBuilder);
return sqlBuilder.ToString();
}
/// <summary>
/// 解析insert
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="updateFields">更新字段结构集合</param>
/// <returns>返回解析后的sql</returns>
public static string __ParseInsertSQL(string tableName, UpdateFieldConditionCollections updateFields, ConnectionModes cnnmode)
{
var sqlBuilder = new StringBuilder();
if (string.IsNullOrEmpty(tableName))
throw new Exception("无效的表名称！");
sqlBuilder.AppendFormat("Insert Into {0} ", tableName);
if (updateFields == null || updateFields.Count < 1)
throw new Exception("无效的更新字段参数!");
sqlBuilder.Append("(");
for (var n = 0; n < updateFields.Count; n++)
{
var upField = updateFields[n];
sqlBuilder.AppendFormat(" {0} ", upField.FieldName);
if (n < updateFields.Count - 1)
sqlBuilder.Append(" , ");
}
sqlBuilder.Append(")values(");
for (var n = 0; n < updateFields.Count; n++)
{
var upField = updateFields[n];
sqlBuilder.AppendFormat(" {0} ", FormatSQLValue(upField.Value, cnnmode));
if (n < updateFields.Count - 1)
sqlBuilder.Append(" , ");
}
sqlBuilder.Append(")");
Console.WriteLine("create sql:" + sqlBuilder);
return sqlBuilder.ToString();
}
/// <summary>
/// 解析Sql
/// </summary>
/// <param name = "tableName">物理表名称</param>
/// <param name = "queryGroup">查询组</param>
/// <param name = "orderBy">排序组</param>
/// <returns>返回解析后的sql</returns>
public static string __ParseSelectSQL(string tableName, QueryGroupConditionCollections queryGroup,
OrderCollections orderBy, ConnectionModes cnnmode)
{
var sqlBuilder = new StringBuilder();
if (string.IsNullOrEmpty(tableName))
throw new Exception("无效的表名称！");
sqlBuilder.AppendFormat("select * from {0} ", tableName);
if (queryGroup != null && queryGroup.Count > 0)
{
var queryCount = queryGroup.Sum(qry => qry.FieldConditions.Count);
if (queryCount > 0)
{
sqlBuilder.AppendFormat(" where ");
for (var i = 0; i < queryGroup.Count; i++)
{
var qry = queryGroup[i];
sqlBuilder.AppendFormat(" (");
for (var j = 0; j < qry.FieldConditions.Count; j++)
{
var field = qry.FieldConditions[j];
//支持sql 拼接
if (field.Operator == OperatorType.SqlText)
sqlBuilder.AppendFormat(" {0} ", field.Value);
else
sqlBuilder.AppendFormat(" {0} {1} {2} ", field.FieldName,
GetOperatorType(field.Operator),
FormatSQLValue(field.Value, cnnmode));
if (j < qry.FieldConditions.Count - 1)
sqlBuilder.AppendFormat(" {0} ", GetWhereUnionType(field.NextUnionType));
}
sqlBuilder.AppendFormat(") ");
if (i < (queryGroup.Count - 1))
sqlBuilder.AppendFormat(" {0} ", GetWhereUnionType(qry.NextUnionType));
}
}
}
if (orderBy != null && orderBy.Count > 0)
{
sqlBuilder.Append(" order by ");
for (var n = 0; n < orderBy.FieldNames.Length; n++)
{
var fieldName = orderBy.FieldNames[n];
sqlBuilder.AppendFormat(" {0} {1} ", fieldName, GetOrderByType(orderBy[fieldName]));
if (n < (orderBy.FieldNames.Length - 1))
sqlBuilder.Append(",");
}
}
Console.WriteLine("create sql:" + sqlBuilder);
return sqlBuilder.ToString();
}
/// <summary>
/// 获取分页用的SQL(直接包装带where等条件的SQL语句)
/// </summary>
/// <param name = "sqls">可以带where等条件的SQL语句</param>
/// <param name = "minRowNum">最小行号</param>
/// <param name = "maxRowNum">最大行号</param>
/// <returns>分页用的SQL语句</returns>
protected static string GetPageSql(string sqls, int minRowNum, int maxRowNum, ConnectionModes ConnectionMode)
{
if (ConnectionMode == ConnectionModes.MICROSOFT_ORACLE || ConnectionMode == ConnectionModes.MICROSOFT_ORACLE9 ||
ConnectionMode == ConnectionModes.ORACLE || ConnectionMode == ConnectionModes.ORACLE9)
{
if (sqls == "")
return sqls;
string sqlstpl =
"SELECT Ttt.*\n" +
" FROM (SELECT Tt.*, Rownum rowno FROM (" + sqls + ") Tt) Ttt\n" +
" WHERE rowno > " + minRowNum + "\n" +
" AND rowno <= " + maxRowNum;
return sqlstpl;
}
else
{
if (sqls == "")
return sqls;
string sqlstpl = @" select t3.*
from (select row_number() over(order by t2.rowno_def) rowno,t2.* " +
"from (select null rowno_def,t1.* from (" + sqls + ") t1) t2) t3 " +
"where rowno>" + minRowNum + " and rowno<=" + maxRowNum;
return sqlstpl;
}
}
/// <summary>
/// 格式化sql值
/// </summary>
/// <param name = "someValue">原始值</param>
/// <returns>字符串形式</returns>
public static string FormatSQLValue(object someValue, ConnectionModes cnnmode)
{
string formattedValue;
if (someValue == null)
{
formattedValue = "NULL";
}
else
{
if (someValue is Array)
{
formattedValue = (someValue as Array).Cast<object>().Aggregate(" (",
(current, sv) =>
current + (FormatSQLValue(sv, cnnmode) + ","));
return formattedValue.TrimEnd(',') + ") ";
}
switch (someValue.GetType().Name)
{
case "String":
formattedValue = "'" + ((string)someValue).Replace("'", "''") + "'";
break;
case "DateTime":
if (cnnmode == ConnectionModes.MICROSOFT_ORACLE || cnnmode == ConnectionModes.MICROSOFT_ORACLE9 ||
cnnmode == ConnectionModes.ORACLE || cnnmode == ConnectionModes.ORACLE9)
{
if (((DateTime)someValue).ToString("HH:mm:ss").Equals("00:00:00"))
formattedValue = "to_date('" + ((DateTime)someValue).ToString("yyyy-MM-dd") +
"','yyyy-MM-dd')";
else
formattedValue = "to_date('" + ((DateTime)someValue).ToString("yyyy-MM-dd HH:mm:ss") +
"','yyyy-MM-dd hh24:mi:ss')";
}
else
{
// for sql server
if (((DateTime)someValue).ToString("HH:mm:ss").Equals("00:00:00"))
formattedValue = "cast('" + ((DateTime)someValue).ToString("yyyy-MM-dd") +
"' as Date)";
else
formattedValue = "cast('" + ((DateTime)someValue).ToString("yyyy-MM-dd HH:mm:ss") +
"' as datetime)";
}
break;
case "DBNull":
formattedValue = "NULL";
break;
case "Boolean":
formattedValue = (bool)someValue ? "1" : "0";
break;
default:
formattedValue = someValue.ToString();
break;
}
}
return formattedValue;
}
/// <summary>
/// Connects to an endpoint. Once this is called, you must call Close before calling Connect again.
/// </summary>
/// <param name="endPoint">The endpoint.</param>
/// <returns>true if connection is successful, false otherwise.</returns>
public bool Connect(EndPoint endPoint)
{
// Sanitize
if (endPoint == null)
{
throw new ArgumentNullException(nameof(endPoint));
}
_connectionMode = ConnectionModes.Manual;
lock (_isConnectedLock)
{
if (_isConnected)
{
Disconnect();
}
if (_isConnected)
{
throw new InvalidOperationException("socket is already in use");
}
// Create socket
_socket = _socketFunc();
// Turn on or off Nagle algorithm
_socket.NoDelay = !_useNagleAlgorithm;
// Set the linger state
_socket.LingerState = _lingerOption;
// Post a connect to the socket synchronously
try
{
_socket.Connect(endPoint);
}
catch (SocketException ex)
{
HandleCommunicationError(_socket, ex);
return(false);
}
// Post a receive to the socket as the client will be continuously receiving messages to be pushed to the queue
if (!TryUnsafeSocketOperation(_socket, SocketAsyncOperation.Receive, _socketAsyncEventArgsReceivePool.Pop()))
{
return(false);
}
// Spin up the keep-alive
Task.Run(() => SendKeepAlive(_socket));
// Process all queued sends on a separate thread
Task.Run(() => ProcessSendQueue(_socket));
// Process all incoming messages on a separate thread
Task.Run(() => ProcessReceivedMessage(_socket));
_isConnected = true;
_lastStateConnected = true;
Connected?.Invoke(this, new ServerEndpointArgs(_socket.RemoteEndPoint as IPEndPoint));
}
return(true);
}
private void inputWorker()
{
int length = -1;
byte[] lenBytes = new byte[4];
List<byte[]> dataToSend = new List<byte[]>();
while (ShouldBeRunning)
{
if (length == -1 && socket.Available>=4)
{
int count = socket.Receive(lenBytes);
length = BitConverter.ToInt32(lenBytes, 0);
if (length > 10000)
throw new FormatException("packet length is unreasonably long");
}
else if (length>0 && socket.Available>=length)
{
byte[] data = new byte[length];
int datacount = socket.Receive(data);
Packet p = Packet.Read(data);
if (p != null)
CallPacketReceived(p);
length = -1;
}
dataToSend.Clear();
lock (DataToSendQueue)
{
while (DataToSendQueue.Count > 0)
dataToSend.Add(DataToSendQueue.Dequeue());
}
if (!socket.Connected)
continue;
try
{
foreach (byte[] b in dataToSend)
socket.Send(b);
}
catch(SocketException E)
{
ShouldBeRunning = false;
connectionMode = ConnectionModes.Disconnected;
System.Diagnostics.Debug.WriteLine(E.StackTrace);
// no longer connected.
}
Thread.Sleep(10);
}
if (connectionMode == ConnectionModes.Disconnected)
{
CallClientDisconnected();
}
}
/// <summary> Called to add connections </summary>
/// <param name="howMany"></param>
/// <param name="connectionMode"></param>
/// <param name="host"></param>
/// <param name="port"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="logKey"></param>
/// <param name="defaultEncoding"></param>
public void AddConnections(int howMany, ConnectionModes connectionMode, string host, int port,
string userName, string password, string logKey, DataCodings defaultEncoding)
{
WriteLog("ESMEManager : AddConnections : Started : HowMany[{0}] ConnectionMode[{1}] Host[{2}] Port[{3}] LogKey[{4}] DefaultEncoding[{5}]", howMany, connectionMode, host, port, logKey, defaultEncoding);
for (int connection = 1; connection <= howMany; ++connection)
{
if (connectionMode == ConnectionModes.Transceiver)
{
AddTransceiverConnection(connection, host, port, userName, password, logKey, defaultEncoding);
}
else if (connectionMode == ConnectionModes.Receiver)
{
AddReceiverConnection(connection, host, port, userName, password, logKey, defaultEncoding);
}
else
{
AddTransmitterConnection(connection, host, port, userName, password, logKey, defaultEncoding);
}
}
}
/// <summary> Register client with the SMSC system and request an SMPP session </summary>
/// <param name="SystemId"></param>
/// <param name="Password"></param>
/// <param name="mode"></param>
/// <returns> BindSmResp </returns>
public BindSmResp Bind(string SystemId, string Password, ConnectionModes mode)
{
if (SystemId == null || SystemId.Length == 0)
{
throw new ArgumentException("SystemId");
}
if (Password == null || Password.Length == 0)
{
throw new ArgumentException("Password");
}
// Set the connection mode
_ConnectionMode = mode;
BindSmResp bindSmResp = BindSmResp.Create(DefaultEncoding);
try
{
BindSm bindSm = BindSm.Create(DefaultEncoding);
switch (mode)
{
case ConnectionModes.Receiver:
bindSm.Command = CommandSet.BindReceiver;
bindSmResp.Command = CommandSet.BindReceiverResp;
break;
case ConnectionModes.Transmitter:
bindSm.Command = CommandSet.BindTransmitter;
bindSmResp.Command = CommandSet.BindTransmitterResp;
break;
default:
bindSm.Command = CommandSet.BindTransceiver;
bindSmResp.Command = CommandSet.BindTransceiverResp;
break;
}
if (!_SocketClient.IsAvailable)
{
bindSmResp.Status = CommandStatus.SMPPCLIENT_NOCONN;
return bindSmResp;
}
bindSm.SystemId = SystemId;
bindSm.Password = Password;
bindSm.SystemType = SystemType;
bindSm.AddrNpi = AddrNpi;
bindSm.AddrTon = AddrTon;
bindSm.AddressRange = AddressRange;
BindDone.Reset();
GenericDone.Reset();
WaitHandle[] handles = new WaitHandle[2] { BindDone, GenericDone };
SendPacket(bindSm);
int res = WaitHandle.WaitAny(handles, Timeout, false);
if (res == 0)
{
// Set the response we received
bindSmResp = BindSmResp;
if (bindSmResp.Status == CommandStatus.ESME_ROK)
{
_Status = ConnectionStatus.Bound;
OnConnect(true);
}
else
{
OnConnect(false);
}
}
else if (res == 1)
{
bindSmResp.Status = CommandStatus.SMPPCLIENT_GENERIC_NACK;
OnConnect(false);
}
else
{
bindSmResp.Status = CommandStatus.SMPPCLIENT_RCVTIMEOUT;
OnConnect(false);
}
}
catch (Exception exception)
{
OnError("Bind error : ", exception);
bindSmResp.Status = CommandStatus.SMPPCLIENT_UNKNOWNERROR;
}
return bindSmResp;
}
/// <summary>
/// 解析Update命令定义集合
/// </summary>
/// <param name="upcmd">更新命令结构</param>
/// <returns>返回解析后的sql集合</returns>
public static List<string> __ParseUpdateDataTable(UpdateCommandCondition upcmd, ConnectionModes cnnmode)
{
var sqlText = new List<string>();
var upFields = new UpdateFieldConditionCollections();
switch (upcmd.UpdateCommandType)
{
case UpdateCommandType.Insert:
//组合insert sql
var insertData = upcmd.DataSource.GetChanges(DataRowState.Added);
if (insertData != null)
foreach (DataRow dr in insertData.Rows)
{
upFields.Clear();
foreach (var tbCol in tabColumns[upcmd.DataSource.TableName.ToUpper()])
upFields.Add(tbCol.ColumnName, dr[tbCol.ColumnName]);
sqlText.Add(__ParseInsertSQL(upcmd.DataSource.TableName.ToUpper(), upFields, cnnmode));
}
break;
case UpdateCommandType.Update:
//组合update sql
var updateData = upcmd.DataSource.GetChanges(DataRowState.Modified);
if (updateData != null)
foreach (DataRow dr in updateData.Rows)
{
upFields.Clear();
foreach (var tbCol in tabColumns[upcmd.DataSource.TableName.ToUpper()])
upFields.Add(tbCol.ColumnName, dr[tbCol.ColumnName]);
//获取主键
sqlText.Add(
__ParseUpdateSQL(upcmd.DataSource.TableName.ToUpper(), upFields,
GetKeyColumnToQueryGroup(upcmd.DataSource, dr), cnnmode));
}
break;
case UpdateCommandType.Delete:
//组合delete sql
var deleteData = upcmd.DataSource.GetChanges(DataRowState.Deleted);
if (deleteData != null)
{
deleteData.RejectChanges();
sqlText.AddRange(from DataRow dr in deleteData.Rows
select
__ParseDeleteSQL(upcmd.DataSource.TableName,
GetKeyColumnToQueryGroup(upcmd.DataSource, dr), cnnmode));
}
break;
default:
sqlText.Clear();
var allData = upcmd.DataSource.GetChanges();
if (allData != null)
foreach (DataRow dr in allData.Rows)
{
switch (dr.RowState)
{
case DataRowState.Added:
upFields.Clear();
foreach (var tbCol in tabColumns[upcmd.DataSource.TableName.ToUpper()])
upFields.Add(tbCol.ColumnName, dr[tbCol.ColumnName]);
sqlText.Add(__ParseInsertSQL(upcmd.DataSource.TableName.ToUpper(), upFields, cnnmode));
break;
case DataRowState.Deleted:
sqlText.Add(__ParseDeleteSQL(upcmd.DataSource.TableName,
GetKeyColumnToQueryGroup(upcmd.DataSource, dr), cnnmode));
break;
case DataRowState.Modified:
upFields.Clear();
foreach (var tbCol in tabColumns[upcmd.DataSource.TableName.ToUpper()])
upFields.Add(tbCol.ColumnName, dr[tbCol.ColumnName]);
//获取主键
sqlText.Add(
__ParseUpdateSQL(upcmd.DataSource.TableName.ToUpper(), upFields,
GetKeyColumnToQueryGroup(upcmd.DataSource, dr), cnnmode));
break;
}
}
break;
}
return sqlText;
}
/// <summary>
/// Overrides default connection method and augments it with setting a bus trigger
/// </summary>
/// <param name="addressOrAlias">See base method</param>
/// <param name="connectionMode">See base method</param>
public override void Connect(string addressOrAlias, ConnectionModes connectionMode)
{
base.Connect(addressOrAlias, connectionMode);
Setup();
}
/// <summary> Constructor For ESMS mode </summary>
/// <param name="connectionId"></param>
/// <param name="shortLongCode"></param>
/// <param name="connectionMode"></param>
/// <param name="host"></param>
/// <param name="port"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="logKey"></param>
/// <param name="defaultEncoding"></param>
/// <param name="connectionEventHandler"></param>
/// <param name="receivedMessageHandler"></param>
/// <param name="receivedGenericNackHandler"></param>
/// <param name="submitMessageHandler"></param>
/// <param name="queryMessageHandler"></param>
/// <param name="logEventHandler"></param>
/// <param name="pduDetailsEventHandler"></param>
public ESMEConnection(int connectionId, string shortLongCode, ConnectionModes connectionMode,
string host, int port, string userName, string password, string logKey,
DataCodings defaultEncoding,
CONNECTION_EVENT_HANDLER connectionEventHandler,
RECEIVED_MESSAGE_HANDLER receivedMessageHandler,
RECEIVED_GENERICNACK_HANDLER receivedGenericNackHandler,
SUBMIT_MESSAGE_HANDLER submitMessageHandler,
QUERY_MESSAGE_HANDLER queryMessageHandler,
LOG_EVENT_HANDLER logEventHandler,
PDU_DETAILS_EVENT_HANDLER pduDetailsEventHandler)
{
// Properties
ConnectionId = connectionId;
ShortLongCode = shortLongCode;
ConnectionMode = connectionMode;
Host = host;
Port = port;
UserName = userName;
Password = password;
LogKey = string.Format("{0}-{1}-{2}", logKey, ConnectionMode, ConnectionId);
// Bind user events
ConnectionEventHandler = connectionEventHandler;
ReceivedMessageHandler = receivedMessageHandler;
ReceivedGenericNackHandler = receivedGenericNackHandler;
SubmitMessageHandler = submitMessageHandler;
QueryMessageHandler = queryMessageHandler;
LogEventHandler = logEventHandler;
PduDetailsEventHandler = pduDetailsEventHandler;
// Create the connection to the server
Client = new SmppClient(defaultEncoding);
// Bind Internal ESME required events
Client.ConnectEvent += new SmppClient.ConnectedEventHandler(ClientEventConnect);
Client.DeliverSmEvent += new SmppClient.DeliverSmEventHandler(ClientEventDeliverSm);
Client.DisconnectEvent += new SmppClient.DisconnectEventHandler(ClientEventDisconnect);
Client.EnquireLinkSmEvent += new SmppClient.EnquireLinkSmEventHandler(ClientEventEnquireLinkSm);
Client.EnquireLinkSmRespEvent += new SmppClient.EnquireLinkSmRespEventHandler(ClientEventEnquireLinkSmResp);
Client.ErrorEvent += new SmppClient.ErrorEventHandler(ClientEventError);
Client.GenericNackSmEvent += new SmppClient.GenericNackSmEventHandler(ClientEventGenericNackSm);
Client.QuerySmRespEvent += new SmppClient.QuerySmRespEventHandler(ClientEventQuerySmResp);
Client.SubmitSmRespEvent += new SmppClient.SubmitSmRespEventHandler(ClientEventSubmitSmResp);
Client.UnBindSmEvent += new SmppClient.UnBindSmEventHandler(ClientEventUnBindSm);
Client.PduDetailsEvent += new SmppClient.PduDetailsEventHandler(ClientEventPduDetails);
// Start a thread to get this connection
ConnectionThread = new Thread(new ThreadStart(PerformConnectClient));
ConnectionThread.Start();
}
