public static void SendItem(bool isAsync)
{
var host = QueueHost.Parse("tcp:127.0.0.1:15000?NC_Bulk");
QueueApi q = QueueClient.GetApi(host);
var item = QueueClient.CreateQueueItem("Hello world " + DateTime.Now.ToString("s"), "test");
item.Host = "NC_Bulk";
//IQueueAck ack = null;
QueueClient.EnqueueItem(q, item, 0, (IQueueAck ack) =>
{
Console.WriteLine("State:{0},Creation:{1},Host:{2},Label:{3}, Identifier:{4}, Duration:{5}, item:{6}", ack.MessageState, ack.Creation, ack.Host, ack.Label, ack.Identifier, ack.Duration, item.Id);
});
//if (q.IsAsync)
//{
// IQueueAck ack = QueueClient.SendItemAsync(q, item, 0);
// Console.WriteLine("State:{0},Creation:{1},Host:{2},Label:{3}, Identifier:{4}, Duration:{5}, item:{6}", ack.MessageState, ack.Creation, ack.Host, ack.Label, ack.Identifier, ack.Duration, item.Id);
//}
//else
//{
// QueueClient.SendItemAsync(q, item, 0, (IQueueAck ack) =>
// {
// Console.WriteLine("State:{0},Creation:{1},Host:{2},Label:{3}, Identifier:{4}, Duration:{5}, item:{6}", ack.MessageState, ack.Creation, ack.Host, ack.Label, ack.Identifier, ack.Duration, item.Id);
// });
//}
//var duration = DateTime.Now.Subtract(start);
//var milliseconds = duration.TotalMilliseconds;
//Console.WriteLine("duration: {0}, item: {1}", milliseconds, item);
}
public static QueueHost GetHost(string protocol, string host_address, string queueName)
{
//127.0.0.1:15000
var host = QueueHost.Parse(protocol + ":" + host_address + "?" + queueName);
return(host);
}
public static void DoQuery(QueueHost host)
{
QueueApi q = new QueueApi(host);
var req = new QueueRequest()
{
QCommand = QueueCmd.ReportQueueItems, DuplexType = DuplexTypes.NoWaite, Host = "NC_Quick"
};
var ts = q.SendDuplexStream(req, 1000000);
if (ts != null)
{
//var stream = ts.ReadStream(null);
//Nistec.Serialization.BinaryStreamer bs = new Nistec.Serialization.BinaryStreamer(stream);
//var olist= bs.Decode();
//var olist = ts.ReadValue();
var list = ts.ReadValue <IEnumerable <PersistItem> >();
Console.WriteLine(list);
}
else
{
Console.WriteLine("Get nothing!");
}
}
public static QueueHost GetHost(string host_address, string queueName)
{
//"tcp:127.0.0.1:15000?NC_Quick"
var host = QueueHost.Parse("tcp:127.0.0.1:15000?" + queueName);
return(host);
}
IQueueAck ExecRout(QueueItem item, QueueHost qh)
{
if (qh == null)
{
throw new MessageException(MessageState.InvalidMessageHost, "Invalid QueueHost for Routing " + item.Host);
}
IQueueAck ack = null;
if (qh.IsLocal)
{
item.Host = qh.HostName;
MQueue Q = Get(item.Host);
if (Q == null)
{
throw new MessageException(MessageState.InvalidMessageHost, "message.RoutHostName not found " + item.Host);
}
ack = Q.Enqueue(item);
return(ack);// ptr.MessageState;
}
var api = new QueueApi(qh.NetProtocol);
ack = api.SendAsync(item, 0);
return(ack);
}
protected override void OnAsyncExecutingWorker(AsyncCallEventArgs e)
{
base.OnAsyncExecutingWorker(e);
try
{
DataSet ds = new DataSet("RemoteQueue");
ds.ReadXml(filename);
dt = ds.Tables[0];
int count = dt.Rows.Count;
this.ProgressBar1.Maximum = count;
var hostPipe = QueueHost.Parse("ipc:.:nistec_queue_manager?" + queueName);
QueueApi Client = new QueueApi(hostPipe);
foreach (DataRow dr in dt.Rows)
{
Client.Enqueue(QueueItem.Create(dr));
this.ProgressBar1.Increment(1);
}
}
catch (Exception ex)
{
MsgBox.ShowError(ex.Message);
}
finally
{
//Closewindow();
}
}
internal SessionListener(QueueAdapter adapter, int interval)
{
if (adapter == null)
{
throw new ArgumentNullException("adapter");
}
if (adapter.Source == null)
{
throw new ArgumentNullException("adapter.Source");
}
Adapter = adapter;
//_Owner = owner;
_Source = adapter.Source;
//_TransferTo = adapter.TransferTo;
//_ServerName = channel.ServerName;
//_QueueName = channel.Source;
//IntervalWait = interval < MinWait ? MinWait : interval;// 1000;
Interval = interval;
_ConnectTimeout = adapter.ConnectTimeout;
_ReadTimeout = adapter.ReadTimeout;
_WorkerCount = adapter.WorkerCount;
_IsAsync = adapter.IsAsync;
//_Action = adapter.QueueAction;
EnableResetEvent = adapter.EnableResetEvent;
EnableDynamicWait = adapter.EnableDynamicWait;
//_ActionTransfer = adapter.AckAction;
//_AdapterOperation = adapter.OperationType;
//_api = new QueueApi(adapter.Source);
}
public void Http401_If_No_Token_specified()
{
var tokenValidator = Substitute.For <IApiTokenValidator>();
string tokenValue = "token_123422";
tokenValidator.IsValidToken(tokenValue).Returns(true);
_host = new QueueHost(_defaultPort, tokenValidator);
new Thread(_host.Start).Start();
Thread.Sleep(2000);
var request = WebRequest.Create($"http://127.0.0.1:{_defaultPort}/api/Queue/AreYouAlive") as HttpWebRequest;
request.Method = "GET";
request.Timeout = 3000;
request.ContentType = "application/json";
request.Accept = "application/json";
HttpStatusCode responseCode = HttpStatusCode.Accepted;
try
{
request.GetResponse();
}
catch (WebException ex)
{
responseCode = (ex.Response as HttpWebResponse).StatusCode;
}
Assert.AreEqual(HttpStatusCode.Unauthorized, responseCode);
}
public static void DoSbscriberListener()
{
var settings = new TcpSettings()
{
Address = "127.0.0.1",
ConnectTimeout = 5000,
HostName = "Netcell",
Port = 15002,
IsAsync = false
};
var host = QueueHost.Parse(string.Format("file:{0}:Queues?{1}", Assists.EXECPATH, settings.HostName));
host.CoverMode = CoverMode.FileStream;
host.CommitMode = PersistCommitMode.OnMemory;
host.ReloadOnStart = true;
var listener = new TopicSbscriberListener(host, true)
{
OnItemReceived = (IQueueItem message) =>
{
Console.WriteLine("State:{0},Arrived:{1},Host:{2},Label:{3}, Identifier:{4}", message.MessageState, message.ArrivedTime, message.Host, message.Label, message.Identifier);
return(new QueueAck(Nistec.Messaging.MessageState.Received, message).ToTransStream());
},
OnError = (string message) => {
Console.WriteLine("OnError:{0}", message);
}
};
string logpath = NetlogSettings.GetDefaultPath("topicSubs");
listener.Logger = new Logger(logpath, LoggerMode.Console | LoggerMode.File);
listener.InitServerQueue(settings, true);
//listener.PausePersistQueue(true);
}
public void Token_Is_required_If_TokenValidation_specified()
{
var tokenValidator = Substitute.For <IApiTokenValidator>();
string tokenValue = "token_123422";
tokenValidator.IsValidToken(tokenValue).Returns(true);
_host = new QueueHost(_defaultPort, tokenValidator);
new Thread(_host.Start).Start();
Thread.Sleep(2000);
var request = WebRequest.Create($"http://127.0.0.1:{_defaultPort}/api/Queue/AreYouAlive") as HttpWebRequest;
request.Method = "GET";
request.Timeout = 3000;
request.ContentType = "application/json";
request.Accept = "application/json";
request.Headers.Add("Api-Token", tokenValue);
string responseFromServer = "";
using (WebResponse response = request.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
StreamReader reader = new StreamReader(stream);
responseFromServer = reader.ReadToEnd();
}
}
Assert.AreEqual(responseFromServer, "\"YES\"");
}
public static QueueApi GetApi(QueueHost host)
{
QueueApi q = new QueueApi(host);
q.IsAsync = false;
return(q);
}
public void LoadTcpSettings(QueueHost host)
{
IPBindInfo bindinfo = new IPBindInfo(host.HostAddress, NetworkProtocol.Tcp, IPAddress.Any, host.Port);
MaxConnections = 0;
MaxConnectionsPerIP = 0;
TaskIdleTimeout = 0;
}
static void Main(string[] args)
{
var httpPort = 8083;
var queue = new QueueHost(httpPort);
queue.Start();
Console.WriteLine($"DotQueue listener is listening on port {httpPort}");
Console.ReadLine();
}
public QueueApi(QueueHost host)
: this()
{
_QueueName = host.HostName;
_HostProtocol = host.Protocol;
RemoteHostAddress = host.Endpoint;
RemoteHostPort = host.Port;
Protocol = host.NetProtocol;
}
public void TokenProvider_Is_Initialized_If_tokenValidation_specified()
{
var tokenValidator = Substitute.For <IApiTokenValidator>();
_host = new QueueHost(_defaultPort, tokenValidator);
Thread.Sleep(1000);
Assert.IsTrue(TokenValidationProvider.CheckAuthorization);
Assert.AreEqual(tokenValidator, TokenValidationProvider.Validator);
}
//public QueueApi(string queueName) : this()
//{
// _QueueName = queueName;
// _HostProtocol = HostProtocol.ipc;
// RemoteHostAddress = null;
// Protocol = NetProtocol.Pipe;
//}
public QueueApi(string queueName, string hostAddress)
: this()
{
var qh = QueueHost.Parse(hostAddress);
_QueueName = queueName;
_HostProtocol = qh.Protocol;
RemoteHostAddress = qh.Endpoint;
RemoteHostPort = qh.Port;
Protocol = qh.Protocol.GetProtocol();
}
public QueueHost GetRoutHost()
{
if (Mode == CoverMode.Rout)
{
if (TargetPath == null || TargetPath == "")
{
return(null);
}
return(QueueHost.Parse(TargetPath));
}
return(null);
}
public static void DoListnning(QueueHost host)
{
var adapter = new QueueAdapter()
{
Source = host,
IsAsync = true,
//Interval = 100,
ConnectTimeout = 5000,
ReadTimeout = 180000,
WorkerCount = 1,
EnableDynamicWait = true,
QueueAction = (message) =>
{
Console.WriteLine("State:{0},Arrived:{1},Host:{2},Label:{3}, Identifier:{4}, Duration:{5}", message.MessageState, message.ArrivedTime.ToString("yyyy-MM-dd HH:mm:ss.fff"), message.Host, message.Label, message.Identifier, message.Duration);
var body = message.GetBody();
string sbody = body == null ? "null" : body.ToString();
Console.WriteLine("body: " + sbody);
},
FaultAction = (message) =>
{
Console.WriteLine(message);
}
};
QueueListener listener = new QueueListener(adapter, 100);
string logpath = NetlogSettings.GetDefaultPath("qlistener");
listener.Logger = new Logger(logpath);
//listener.ErrorOcurred += Listener_ErrorOcurred;
//listener.MessageReceived += Listener_MessageReceived;
listener.Start();
//QueueApi api = new QueueApi(host);
//api.ReceiveCompleted += api_ReceiveCompleted;
////api.Listener(10000, message_ReceiveCompleted);
//bool KeepAlive = true;
//int connectTimeout=10000;
// while (KeepAlive)
// {
// api.Receive(connectTimeout,message_ReceiveCompleted);
// Thread.Sleep(100);
// }
//Console.WriteLine("QueueListener finished...");
//Console.ReadLine();
}
/// <summary>
/// Ensure that lister is exists.
/// </summary>
/// <param name="host"></param>
/// <returns></returns>
public virtual Listener EnsureListener(QueueHost host)
{
if (host == null)
{
throw new ArgumentNullException("Find.ack");
}
var listener = Find(host.HostId);
if (listener == null)
{
throw new Exception("Listener not found " + host.HostId);
}
return(listener);
}
public static void PublishItem()
{
var host = QueueHost.Parse("tcp:127.0.0.1:15000?Netcell");
QueueApi q = QueueClient.GetApi(host);
var item = QueueClient.CreateQueueItem("Hello world " + DateTime.Now.ToString("s"), "test");
item.Host = "Netcell";
item.QCommand = QueueCmd.Enqueue;
//IQueueAck ack = null;
QueueClient.PublishItem(q, item, 0, (IQueueAck ack) =>
{
Console.WriteLine("State:{0},Creation:{1},Host:{2},Label:{3}, Identifier:{4}, Duration:{5}, item:{6}", ack.MessageState, ack.Creation, ack.Host, ack.Label, ack.Identifier, ack.Duration, item.Id);
});
}
/// <summary>
/// Initialize a new instance of folder queue.
/// </summary>
/// <param name="host"></param>
public FolderQueue(QueueHost host)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
m_fileMessage = new FileMessage(host);
//m_host = host;
//OperationType = AdapterOperations.Recieve;
FileOrderType = FileOrderTypes.ByName;
IsCoverable = false;
MaxItemsPerSession = 1;
ConnectTimeout = FileMessage.DefaultConnectTimeout;
}
public static void DoGet(QueueHost host)
{
QueueApi q = new QueueApi(host);
q.Timeout = 500000000;
var item = q.Receive(DuplexTypes.WaitOne);
if (item != null)
{
Console.WriteLine(item.Print());
}
else
{
Console.WriteLine("Get nothing!");
}
}
public TopicSbscriberListener(QueueHost qhost, bool enablePersistQueue = false)
{
SbscriberHost = qhost.HostName;
HostProtocol = qhost.Protocol;
HostInfo = string.Format("HostName:{0},Protocol:{1}, HostAddress:{2}", qhost.HostName, qhost.Protocol, qhost.HostAddress);
EnablePersistQueue = enablePersistQueue;
if (enablePersistQueue)
{
Queue = new PriorityFsQueue(qhost);
}
//if (autoStart)
//{
// InitServerQueue(settings, autoStart);
//}
}
public void Start_starts_all_the_queue_consumers()
{
var kernel = new StandardKernel();
var queueConsumerTestMessage1 = new Mock<IQueueConsumer<TestMessage1>>();
var queueConsumerTestMessage2 = new Mock<IQueueConsumer<TestMessage2>>();
kernel.Bind<IQueueConsumer<TestMessage1>>().ToConstant(queueConsumerTestMessage1.Object);
kernel.Bind<IQueueConsumer<TestMessage2>>().ToConstant(queueConsumerTestMessage2.Object);
var host = new QueueHost(kernel, new QueueHostConfiguration(new Type[] { typeof(TestMessage1), typeof(TestMessage2) }));
host.Start();
queueConsumerTestMessage1.Verify(x => x.Start());
queueConsumerTestMessage2.Verify(x => x.Start());
host.Dispose();
}
public static void DoGet(QueueHost host)
{
QueueApi q = new QueueApi(host);
q.ConnectTimeout = 500000000;
//q.ReadTimeout = -1;
var item = q.Dequeue();// DuplexTypes.WaitOne);
if (item != null)
{
Console.WriteLine(item.Print());
}
else
{
Console.WriteLine("Get nothing!");
}
}
//public static FolderQueue CreateSync(
// QueueHost host,
// int connectTimeout,
// int maxItemsPersession,
// FileOrderTypes orderType,
// bool isCoverable)
//{
// return new FolderQueue(host)
// {
// FileOrderType = orderType,
// MaxItemsPerSession = maxItemsPersession,
// ConnectTimeout = connectTimeout,
// IsCoverable = isCoverable,
// OperationType = AdapterOperations.Async,
// };
//}
public static FolderQueue CreateAsync(
QueueHost host,
int connectTimeout,
int maxItemsPersession,
FileOrderTypes orderType,
Action <QueueItem> targetAction,
bool isCoverable)
{
return(new FolderQueue(host)
{
FileOrderType = orderType,
MaxItemsPerSession = maxItemsPersession,
QueueAction = targetAction,
ConnectTimeout = connectTimeout,
IsCoverable = isCoverable
//OperationType = AdapterOperations.Recieve,
});
}
public static FolderQueue CreateAsyncTransfer(
QueueHost host,
int connectTimeout,
int maxItemsPersession,
FileOrderTypes orderType,
Action <IQueueAck> ackAction,
QueueHost hostDestination,
bool isCoverable)
{
return(new FolderQueue(host)
{
FileOrderType = orderType,
MaxItemsPerSession = maxItemsPersession,
AckAction = ackAction,
ConnectTimeout = connectTimeout,
IsCoverable = isCoverable,
//OperationType = AdapterOperations.Transfer,
Destination = hostDestination
});
}
static void Main(string[] args)
{
Console.WriteLine("QueueTasker started...");
var host = QueueHost.Parse("ipc:.:nistec_queue_channel?NC_Quick");
QueueApi q = new QueueApi(host);
while (true)
{
var msg = q.Report(QueueCmdReport.ReportQueueStatistic, "NC_Quick");
Console.WriteLine("State:{0},Creation:{1},Host:{2},Label:{3}", msg.MessageState, msg.Creation, msg.Host, msg.Label);
Thread.Sleep(10000);
}
Console.WriteLine("QueueTasker finished...");
Console.ReadLine();
}
public void Messages_Are_Persisted()
{
int port = 8083;
var host = new QueueHost(port, persistenceAdapter: new SQLitePersistenceAdapter());
//start host with SQLite persistence adapter
new Thread(() => host.Start()).Start();
//Wait for listener to be ready
Thread.Sleep(1000);
//send messages
var client = new MessageQueue <DummyMessage>(new DotQueueAddress
{
IpAddress = IPAddress.Parse("127.0.0.1"),
Port = port
});
var msg1 = CreateRandomMessage();
var msg2 = CreateRandomMessage();
client.Add(msg1);
client.Add(msg2);
//stop the host
host.Stop();
//start the queue again
new Thread(() => host.Start()).Start();
//Wait for listener to be ready
Thread.Sleep(1000);
//pull messages and assert results are matching
var actual1 = client.Pull();
var actual2 = client.Pull();
Assert.That(actual1, Is.EqualTo(msg1));
Assert.That(actual2, Is.EqualTo(msg2));
}
internal Listener(IListenerHandler owner, AdapterProperties channel)
{
if (channel == null)
{
throw new ArgumentNullException("channel");
}
if (channel.Source == null)
{
throw new ArgumentNullException("channel.Source");
}
_Owner = owner;
_Source = channel.Source;
_TransferTo = channel.TransferTo;
//_ServerName = channel.ServerName;
//_QueueName = channel.Source;
_Interval = channel.Interval;
_ConnectTimeout = channel.ConnectTimeout;
_WorkerCount = channel.WorkerCount;
_Action = channel.TargetAction;
_AdapterOperation = channel.OperationType;
}
static void Main(string[] args)
{
var httpPort = 8083; //Can be any other port#
#region RavenDb example
/*
* IDocumentStore address = new DocumentStore {
* Url = "http://localhost:8080",
* DefaultDatabase = "Customers",
* };
* var host = new QueueHost(httpPort, persistenceAdapter:new RavenDbPersistenceAdapter(address));
*/
#endregion
#region Sqlite example
var host = new QueueHost(httpPort, persistenceAdapter: new SQLitePersistenceAdapter());
#endregion
host.Start();
Console.ReadLine();
}
