void Loop()
{
logger.Info("{0} with {1} jobs started", this, jobs.Length);
var stopWatch = new Stopwatch();
var jobsTimeMs = 0d;
while (!IsShutdown)
{
var waitFor = (int)(Period.TotalMilliseconds - jobsTimeMs);
if (waitFor > 0)
{
if (evt.WaitOne(waitFor))
{
signalsReceived++;
}
else
{
timeouts++;
}
}
jobsTimeMs = 0;
stopWatch.Restart();
RunJobs();
stopWatch.Stop();
jobsTimeMs += stopWatch.Elapsed.TotalMilliseconds;
}
RunJobs();
logger.Info("{0} stopped", this);
}
async void ConnectionLoop()
{
listener.Start(backlog);
logger.Info("Listening on {0}", listener.LocalEndpoint);
while (true)
{
try
{
var client = await listener.AcceptTcpClientAsync();
var sessionId = ++acceptedSessions;
HandleNewConnection(sessionId, client);
}
catch (SocketException e)
{
if (lifeCycleToken.IsShutdown) // triggered by listener.Stop()
{
logger.Info("Listener shutting down");
break;
}
else
{
logger.Error("Exception while accepting TcpClient - {0}", e.ToString());
}
}
}
logger.Info("Listener closed (accepted: {0})", acceptedSessions);
router.Shutdown();
}
static public void saveRegistro(String text, levels logLevel)
{
try
{
switch (logLevel)
{
case levels.debug:
logger.Debug(text);
break;
case levels.error:
logger.Error(text);
break;
case levels.info:
logger.Info(text);
break;
case levels.warning:
logger.Warn(text);
break;
default:
logger.Info(text);
break;
}
}
catch (Exception ex)
{
EventLog ev = new EventLog();
ev.WriteEntry(ex.Message, EventLogEntryType.Error);
}
}
void GetContextLoop()
{
listener.Start();
logger.Info("Listening on [{0}]", ListenOn);
while (!lifeCycleToken.IsShutdown)
{
if (getContexts.WaitOne(10))
{
listener.GetContextAsync().ContinueWith(ProcessHttpListenerContext);
}
}
listener.Stop();
listener.Close();
logger.Info("Listener closed.");
router.Shutdown();
}
public async Task <PooledResource <TResource> > GetAsync(TimeSpan poolTimeout)
{
if (await pool.WaitAsync(poolTimeout).ConfigureAwait(false))
{
TResource resource;
// 1. Try taking one from existing - if available
int current;
while ((current = currentFreeCount) > 0)
{
if (Interlocked.CompareExchange(ref currentFreeCount, current - 1, current) == current)
{
while (!bag.TryTake(out resource))
{
}
return(new PooledResource <TResource>(resource, ReturnAndRelease));
}
}
// 2. Else grow (increment) pool by one
try
{
resource = await AcquireNewResourceAsync().ConfigureAwait(false);
Interlocked.Increment(ref currentPoolSize);
logger.Info("{0}: Created new pooled resource", this);
return(new PooledResource <TResource>(resource, ReturnAndRelease));
}
catch (Exception e)
{
pool.Release();
throw new Exception($"{this}: error acquiring new resource - {e.Message}", e);
}
}
else
{
throw new TimeoutException($"{this}: timeout ({poolTimeout}) waiting to get PooledResource (pool busy)");
}
}
