public void ArgumentNullExceptions()
{
Assert.Throws<ArgumentNullException>(() => new Async(null as Loop));
Assert.Throws<ArgumentNullException>(() => new AsyncWatcher<int>(null as Loop));
using (var asyncWatcher = new AsyncWatcher<int>()) {
Assert.Throws<ArgumentNullException>(() => asyncWatcher.Send(null as IEnumerable<int>));
}
}
public ManosTwitter(Context context, OAuthTokens oauthtokens, TaskScheduler scheduler)
{
Context = context;
TaskScheduler = scheduler;
OAuthTokens = oauthtokens;
callbacks = new AsyncWatcher<Action>(Context, (callback) => {
callback();
});
callbacks.Start();
}
public static void ArgumentNullExceptions()
{
Assert.Throws<ArgumentNullException>(() => new Async(null as Loop));
Assert.Throws<ArgumentNullException>(() => new AsyncWatcher<int>(null as Loop));
var async = new Async();
var asyncWatcher = new AsyncWatcher<int>();
Assert.Throws<ArgumentNullException>(() => asyncWatcher.Send(null as IEnumerable<int>));
async.Close();
asyncWatcher.Close ();
}
void EioHandler(AsyncWatcher watcher, EventTypes events)
{
var count = outstanding.Count;
while (count-- > 0)
{
Action cb;
outstanding.TryDequeue(out cb);
try {
cb();
} catch (Exception e) {
Console.WriteLine("Exception in eio callback:");
Console.WriteLine(e.StackTrace);
}
}
}
public void Dispose()
{
Socket = null;
if (Stream != null)
{
Stream.Dispose();
Stream = null;
}
if (end_watcher != null)
{
end_watcher.Dispose();
end_watcher = null;
}
}
private static void HandleSynchronizationEvent(Loop loop, AsyncWatcher watcher, EventTypes revents)
{
// we don't want to empty the whole queue here, as any number of threads can enqueue
// sync blocks at will while we try to empty it. only process a fixed number of blocks
// to not starve other events.
int pendingBlocks = waitingSyncBlocks.Count;
while (pendingBlocks-- > 0)
{
SynchronizedBlock oneBlock;
// perhaps we should bail here instead, as a result of 'false' would indicate that
// somebody is stealing our events.
if (waitingSyncBlocks.TryDequeue(out oneBlock))
{
oneBlock.Run();
}
}
}
public static void Main(string[] args)
{
string configfile = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "/.config/quassel-irc.org/quasselclient.conf";
var settings = new Settings(configfile);
QuasselTypes.Init();
var acc = settings.Accounts[settings.AutoConnectAccount];
var coreConnection = new CoreConnection(acc.HostName, acc.Port, acc.User, acc.Password, false);
Application.Init();
var qc = new QuasselClient(coreConnection);
ThemeManager = new ThemeManger();
MainWindow = ThemeManager.Default.CreateMainWindow(qc);
AsyncWatcher<QVariant> listnotifier = new AsyncWatcher<QVariant>((packet) => qc.Handle(packet));
AsyncWatcher<Exception> excenotifier = new AsyncWatcher<Exception>((exce) => qc.Handle(exce));
var nt = new Thread((obj) => {
coreConnection.ReceivePacket += (packet) => {
listnotifier.Send(packet);
};
coreConnection.Exception += (exception) => {
excenotifier.Send(exception);
};
coreConnection.Connect();
coreConnection.Loop();
});
nt.Start();
Application.End += (() => {
nt.Abort();
});
Application.Run(MainWindow);
}
public void Dispose()
{
if (idle_watcher != null)
{
idle_watcher.Dispose();
idle_watcher = null;
}
if (want_poll_watcher != null)
{
want_poll_watcher.Dispose();
want_poll_watcher = null;
}
if (done_poll_watcher != null)
{
want_poll_watcher.Dispose();
done_poll_watcher = null;
}
}
public static void Start(ManosApp application)
{
if (application == null)
{
throw new ArgumentNullException("application");
}
app = application;
app.StartInternal();
started = true;
server = new HttpServer(HandleTransaction, ioloop);
server.Listen(IPAddress.ToString(), port);
syncBlockWatcher = new AsyncWatcher(IOLoop.EventLoop, HandleSynchronizationEvent);
syncBlockWatcher.Start();
ioloop.Start();
}
public SignalWatcher(Context context, Signum[] signals, Action<Signum> callback)
{
Signals = signals;
unixSignals = new UnixSignal[signals.Length];
for (int i = 0; i < signals.Length; i++) {
unixSignals[i] = new UnixSignal(signals[i]);
}
watcher = new AsyncWatcher<Signum>(context, (key) => {
if (callback != null) {
callback(key);
}
});
thread = new Thread((o) => {
while (true) {
var index = UnixSignal.WaitAny(unixSignals);
watcher.Send(Signals[index]);
}
});
}
public SignalWatcher(Loop loop, Signum[] signals, Action<Signum> callback)
{
Signals = signals;
unixSignals = new UnixSignal[signals.Length];
for (int i = 0; i < signals.Length; i++) {
unixSignals[i] = new UnixSignal((Mono.Unix.Native.Signum)signals[i]);
}
watcher = new AsyncWatcher<Signum>(loop);
watcher.Callback += (key) => {
if (callback != null) {
callback(key);
}
};
thread = new Thread((o) => {
while (true) {
var index = UnixSignal.WaitAny(unixSignals);
watcher.Send(Signals[index]);
}
});
}
public AsyncCoreConnection(Loop loop, CoreConnection coreConnection)
{
Loop = loop;
CoreConnection = coreConnection;
listnotifier = new AsyncWatcher<QVariant>((packet) => OnReceivePacket(packet));
exceptionnotifier = new AsyncWatcher<Exception>((exception) => OnException(exception));
thread = new Thread((obj) => {
coreConnection.ReceivePacket += (packet) => {
listnotifier.Send(packet);
};
coreConnection.Exception += (exception) => {
//exceptionnotifier.Send(exception);
};
coreConnection.Connect();
coreConnection.Loop();
});
}
public HttpEntity()
{
end_watcher = new AsyncWatcher(IOLoop.Instance.EventLoop, HandleEnd);
end_watcher.Start();
}
