public void TestConnectedServer()
{
IConnection c = new ConnectionFactory().CreateConnection();
string u = c.ConnectedUrl;
if (string.IsNullOrWhiteSpace(u))
{
Assert.Fail("Invalid connected url {0}.", u);
}
if (!Defaults.Url.Equals(u))
{
Assert.Fail("Invalid connected url {0}.", u);
}
c.Close();
u = c.ConnectedUrl;
if (u != null)
{
Assert.Fail("Url is not null after connection is closed.");
}
}
public void TestCloseDisconnectedHandler()
{
using (new NATSServer())
{
bool disconnected = false;
Object mu = new Object();
Options o = utils.DefaultTestOptions;
o.AllowReconnect = false;
o.DisconnectedEventHandler += (sender, args) =>
{
lock (mu)
{
disconnected = true;
Monitor.Pulse(mu);
}
};
IConnection c = new ConnectionFactory().CreateConnection(o);
lock (mu)
{
c.Close();
Monitor.Wait(mu, 20000);
}
Assert.True(disconnected);
// now test using.
disconnected = false;
lock (mu)
{
using (c = new ConnectionFactory().CreateConnection(o)) { };
Monitor.Wait(mu, 20000);
}
Assert.True(disconnected);
}
}
private void BtnPesquisa_Click(object sender, EventArgs e)
{
MySqlConnection conn = new ConnectionFactory().GetConnection();
DAOProduto daoproduto = new DAOProduto();
DtaGridProduto.DataSource = daoproduto.Pesquisa_Geral();
//daofornecedor.PesquisarPorID(id_fornecedor);
if (tbxnomepesquisa.Text != string.Empty)
{
DtaGridProduto.DataSource = daoproduto.PesquisarPorNome(tbxnomepesquisa.Text);
alterarnomesDtagridview();
}
else
{
DtaGridProduto.DataSource = daoproduto.Pesquisa_Geral();
alterarnomesDtagridview();
}
if (ComBoxTipoProcura.Text == "Valor")
{
DtaGridProduto.DataSource = daoproduto.Pesquisa_Geral();
alterarnomesDtagridview();
}
else
{
DtaGridProduto.DataSource = daoproduto.Pesquisa_Geral();
alterarnomesDtagridview();
}
conn.Close();
}
//[Fact]
// This test works locally, but fails in AppVeyor some of the time
// TODO: Work to identify why this happens...
private void TestCallbacksOrder()
{
bool firstDisconnect = true;
long orig = DateTime.Now.Ticks;
long dtime1 = orig;
long dtime2 = orig;
long rtime = orig;
long atime1 = orig;
long atime2 = orig;
long ctime = orig;
AutoResetEvent reconnected = new AutoResetEvent(false);
AutoResetEvent closed = new AutoResetEvent(false);
AutoResetEvent asyncErr1 = new AutoResetEvent(false);
AutoResetEvent asyncErr2 = new AutoResetEvent(false);
AutoResetEvent recvCh = new AutoResetEvent(false);
AutoResetEvent recvCh1 = new AutoResetEvent(false);
AutoResetEvent recvCh2 = new AutoResetEvent(false);
using (NATSServer s = utils.CreateServerWithConfig("auth_1222.conf"),
def = new NATSServer())
{
Options o = utils.DefaultTestOptions;
o.DisconnectedEventHandler += (sender, args) =>
{
Thread.Sleep(100);
if (firstDisconnect)
{
firstDisconnect = false;
dtime1 = DateTime.Now.Ticks;
}
else
{
dtime2 = DateTime.Now.Ticks;
}
};
o.ReconnectedEventHandler += (sender, args) =>
{
Thread.Sleep(100);
rtime = DateTime.Now.Ticks;
reconnected.Set();
};
o.AsyncErrorEventHandler += (sender, args) =>
{
Thread.Sleep(100);
if (args.Subscription.Subject.Equals("foo"))
{
atime1 = DateTime.Now.Ticks;
asyncErr1.Set();
}
else
{
atime2 = DateTime.Now.Ticks;
asyncErr2.Set();
}
};
o.ClosedEventHandler += (sender, args) =>
{
ctime = DateTime.Now.Ticks;
closed.Set();
};
o.ReconnectWait = 500;
o.NoRandomize = true;
o.Servers = new string[] { "nats://localhost:4222", "nats://localhost:1222" };
o.SubChannelLength = 1;
using (IConnection nc = new ConnectionFactory().CreateConnection(o),
ncp = utils.DefaultTestConnection)
{
// On hosted environments, some threads/tasks can start before others
// due to resource constraints. Allow time to start.
Thread.Sleep(1000);
def.Bounce(1000);
Thread.Sleep(1000);
Assert.True(reconnected.WaitOne(3000));
object asyncLock = new object();
EventHandler <MsgHandlerEventArgs> eh = (sender, args) =>
{
lock (asyncLock)
{
recvCh.Set();
if (args.Message.Subject.Equals("foo"))
{
recvCh1.Set();
}
else
{
recvCh2.Set();
}
}
};
IAsyncSubscription sub1 = nc.SubscribeAsync("foo", eh);
IAsyncSubscription sub2 = nc.SubscribeAsync("bar", eh);
nc.Flush();
ncp.Publish("foo", System.Text.Encoding.UTF8.GetBytes("hello"));
ncp.Publish("bar", System.Text.Encoding.UTF8.GetBytes("hello"));
ncp.Flush();
recvCh.WaitOne(3000);
for (int i = 0; i < 3; i++)
{
ncp.Publish("foo", System.Text.Encoding.UTF8.GetBytes("hello"));
ncp.Publish("bar", System.Text.Encoding.UTF8.GetBytes("hello"));
}
ncp.Flush();
Assert.True(asyncErr1.WaitOne(3000));
Assert.True(asyncErr2.WaitOne(3000));
def.Shutdown();
Thread.Sleep(1000);
closed.Reset();
nc.Close();
Assert.True(closed.WaitOne(3000));
}
if (dtime1 == orig || dtime2 == orig || rtime == orig ||
atime1 == orig || atime2 == orig || ctime == orig)
{
Console.WriteLine("Error = callback didn't fire: {0}\n{1}\n{2}\n{3}\n{4}\n{5}\n",
dtime1, dtime2, rtime, atime1, atime2, ctime);
throw new Exception("Callback didn't fire.");
}
if (rtime < dtime1 || dtime2 < rtime || ctime < atime2)
{
Console.WriteLine("Wrong callback order:\n" +
"dtime1: {0}\n" +
"rtime: {1}\n" +
"atime1: {2}\n" +
"atime2: {3}\n" +
"dtime2: {4}\n" +
"ctime: {5}\n",
dtime1, rtime, atime1, atime2, dtime2, ctime);
throw new Exception("Invalid callback order.");
}
}
}
public void TestIsReconnectingAndStatus()
{
bool disconnected = false;
object disconnectedLock = new object();
bool reconnected = false;
object reconnectedLock = new object();
IConnection c = null;
Options opts = utils.DefaultTestOptions;
opts.Url = "nats://localhost:22222";
opts.AllowReconnect = true;
opts.MaxReconnect = 10000;
opts.ReconnectWait = 100;
opts.DisconnectedEventHandler += (sender, args) =>
{
lock (disconnectedLock)
{
disconnected = true;
Monitor.Pulse(disconnectedLock);
}
};
opts.ReconnectedEventHandler += (sender, args) =>
{
lock (reconnectedLock)
{
reconnected = true;
Monitor.Pulse(reconnectedLock);
}
};
using (NATSServer s = utils.CreateServerOnPort(22222))
{
c = new ConnectionFactory().CreateConnection(opts);
Assert.True(c.State == ConnState.CONNECTED);
Assert.True(c.IsReconnecting() == false);
}
// server stops here...
lock (disconnectedLock)
{
if (!disconnected)
{
Assert.True(Monitor.Wait(disconnectedLock, 10000));
}
}
Assert.True(c.State == ConnState.RECONNECTING);
Assert.True(c.IsReconnecting() == true);
// restart the server
using (NATSServer s = utils.CreateServerOnPort(22222))
{
lock (reconnectedLock)
{
// may have reconnected, if not, wait
if (!reconnected)
{
Assert.True(Monitor.Wait(reconnectedLock, 10000));
}
}
Assert.True(c.IsReconnecting() == false);
Assert.True(c.State == ConnState.CONNECTED);
c.Close();
}
Assert.True(c.IsReconnecting() == false);
Assert.True(c.State == ConnState.CLOSED);
}
public void TestAsyncInfoProtocolConnect()
{
using (NATSServer s1 = new NATSServer("-a localhost -p 4221 --cluster nats://127.0.0.1:4551 --routes nats://127.0.0.1:4552"),
s2 = new NATSServer("-a localhost -p 4222 --cluster nats://127.0.0.1:4552 --routes nats://127.0.0.1:4551"),
s3 = new NATSServer("-a localhost -p 4223 --cluster nats://127.0.0.1:4553 --routes nats://127.0.0.1:4551"),
s4 = new NATSServer("-a localhost -p 4224 --cluster nats://127.0.0.1:4554 --routes nats://127.0.0.1:4551"),
s5 = new NATSServer("-a localhost -p 4225 --cluster nats://127.0.0.1:4555 --routes nats://127.0.0.1:4551"),
s6 = new NATSServer("-a localhost -p 4226 --cluster nats://127.0.0.1:4556 --routes nats://127.0.0.1:4551"),
s7 = new NATSServer("-a localhost -p 4227 --cluster nats://127.0.0.1:4557 --routes nats://127.0.0.1:4551"))
{
var opts = utils.DefaultTestOptions;
opts.NoRandomize = false;
opts.Url = "nats://127.0.0.1:4223";
var c = new ConnectionFactory().CreateConnection(opts);
Assert.True(assureClusterFormed(c, 7),
"Incomplete cluster with server count: " + c.Servers.Length);
c.Close();
// Create a new connection to start from scratch, and recieve
// the entire server list at once.
c = new ConnectionFactory().CreateConnection(opts);
Assert.True(assureClusterFormed(c, 7),
"Incomplete cluster with server count: " + c.Servers.Length);
// Sufficiently test to ensure we don't hit a random false positive
// - avoid flappers.
bool different = false;
for (int i = 0; i < 50; i++)
{
var c2 = new ConnectionFactory().CreateConnection(opts);
Assert.True(assureClusterFormed(c, 7),
"Incomplete cluster with server count: " + c.Servers.Length);
// The first urls should be the same.
Assert.True(c.Servers[0].Equals(c2.Servers[0]));
// now check the others are different (randomized)
for (int j = 1; j < c.Servers.Length; j++)
{
if (!c.Servers[j].Equals(c2.Servers[j]))
{
different = true;
break;
}
}
c2.Close();
// ensure the two connections are different - that randomization
// occurred.
if (different)
{
break;
}
}
Assert.True(different, "Connection urls may not be randomized");
c.Close();
}
}
public void TestCallbacksOrder()
{
bool firstDisconnect = true;
long orig = DateTime.Now.Ticks;
long dtime1 = orig;
long dtime2 = orig;
long rtime = orig;
long atime1 = orig;
long atime2 = orig;
long ctime = orig;
ConditionalObj reconnected = new ConditionalObj();
ConditionalObj closed = new ConditionalObj();
ConditionalObj asyncErr1 = new ConditionalObj();
ConditionalObj asyncErr2 = new ConditionalObj();
ConditionalObj recvCh = new ConditionalObj();
ConditionalObj recvCh1 = new ConditionalObj();
ConditionalObj recvCh2 = new ConditionalObj();
using (NATSServer s = utils.CreateServerWithConfig(TestContext, "auth_1222.conf"))
{
Options o = ConnectionFactory.GetDefaultOptions();
o.DisconnectedEventHandler += (sender, args) =>
{
Thread.Sleep(100);
if (firstDisconnect)
{
System.Console.WriteLine("First disconnect.");
firstDisconnect = false;
dtime1 = DateTime.Now.Ticks;
}
else
{
System.Console.WriteLine("Second disconnect.");
dtime2 = DateTime.Now.Ticks;
}
};
o.ReconnectedEventHandler += (sender, args) =>
{
System.Console.WriteLine("Reconnected.");
Thread.Sleep(50);
rtime = DateTime.Now.Ticks;
reconnected.notify();
};
o.AsyncErrorEventHandler += (sender, args) =>
{
if (args.Subscription.Subject.Equals("foo"))
{
System.Console.WriteLine("Error handler foo.");
Thread.Sleep(200);
atime1 = DateTime.Now.Ticks;
asyncErr1.notify();
}
else
{
System.Console.WriteLine("Error handler bar.");
atime2 = DateTime.Now.Ticks;
asyncErr2.notify();
}
};
o.ClosedEventHandler += (sender, args) =>
{
System.Console.WriteLine("Closed handler.");
ctime = DateTime.Now.Ticks;
closed.notify();
};
o.ReconnectWait = 50;
o.NoRandomize = true;
o.Servers = new string[] { "nats://localhost:4222", "nats:localhost:1222" };
o.SubChannelLength = 1;
using (IConnection nc = new ConnectionFactory().CreateConnection(o),
ncp = new ConnectionFactory().CreateConnection())
{
utils.StopDefaultServer();
Thread.Sleep(1000);
utils.StartDefaultServer();
reconnected.wait(3000);
EventHandler <MsgHandlerEventArgs> eh = (sender, args) =>
{
System.Console.WriteLine("Received message on subject: " + args.Message.Subject);
recvCh.notify();
if (args.Message.Subject.Equals("foo"))
{
recvCh1.notify();
}
else
{
recvCh2.notify();
}
};
IAsyncSubscription sub1 = nc.SubscribeAsync("foo", eh);
IAsyncSubscription sub2 = nc.SubscribeAsync("bar", eh);
nc.Flush();
ncp.Publish("foo", System.Text.Encoding.UTF8.GetBytes("hello"));
ncp.Publish("bar", System.Text.Encoding.UTF8.GetBytes("hello"));
ncp.Flush();
recvCh.wait(3000);
for (int i = 0; i < 3; i++)
{
ncp.Publish("foo", System.Text.Encoding.UTF8.GetBytes("hello"));
ncp.Publish("bar", System.Text.Encoding.UTF8.GetBytes("hello"));
}
ncp.Flush();
asyncErr1.wait(3000);
asyncErr2.wait(3000);
utils.StopDefaultServer();
Thread.Sleep(1000);
closed.reset();
nc.Close();
closed.wait(3000);
}
if (dtime1 == orig || dtime2 == orig || rtime == orig ||
atime1 == orig || atime2 == orig || ctime == orig)
{
System.Console.WriteLine("Error = callback didn't fire: {0}\n{1}\n{2}\n{3}\n{4}\n{5}\n",
dtime1, dtime2, rtime, atime1, atime2, ctime);
throw new Exception("Callback didn't fire.");
}
if (rtime < dtime1 || dtime2 < rtime || atime2 < atime1 || ctime < atime2)
{
System.Console.WriteLine("Wrong callback order:{0}\n{1}\n{2}\n{3}\n{4}\n{5}\n",
dtime1, rtime, atime1, atime2, dtime2, ctime);
throw new Exception("Invalid callback order.");
}
}
}
