internal MetricsSinkAdapter(string name, string description, MetricsSink sink, string context, MetricsFilter sourceFilter, MetricsFilter recordFilter, MetricsFilter metricFilter, int period, int queueCapacity, int retryDelay, float retryBackoff, int retryCount) { this.name = Preconditions.CheckNotNull(name, "name"); this.description = description; this.sink = Preconditions.CheckNotNull(sink, "sink object"); this.context = context; this.sourceFilter = sourceFilter; this.recordFilter = recordFilter; this.metricFilter = metricFilter; this.period = Contracts.CheckArg(period, period > 0, "period"); firstRetryDelay = Contracts.CheckArg(retryDelay, retryDelay > 0, "retry delay"); this.retryBackoff = Contracts.CheckArg(retryBackoff, retryBackoff > 1, "retry backoff" ); oobPutTimeout = (long)(firstRetryDelay * Math.Pow(retryBackoff, retryCount) * 1000 ); this.retryCount = retryCount; this.queue = new SinkQueue <MetricsBuffer>(Contracts.CheckArg(queueCapacity, queueCapacity > 0, "queue capacity")); latency = registry.NewRate("Sink_" + name, "Sink end to end latency", false); dropped = registry.NewCounter("Sink_" + name + "Dropped", "Dropped updates per sink" , 0); qsize = registry.NewGauge("Sink_" + name + "Qsize", "Queue size", 0); sinkThread = new _Thread_86(this); sinkThread.SetName(name); sinkThread.SetDaemon(true); }
public virtual void TestHangingConsumer() { SinkQueue <int> q = NewSleepingConsumerQueue(2, 1, 2); Assert.Equal("queue back", 2, (int)q.Back()); Assert.True("should drop", !q.Enqueue(3)); // should not block Assert.Equal("queue size", 2, q.Size()); Assert.Equal("queue head", 1, (int)q.Front()); Assert.Equal("queue back", 2, (int)q.Back()); }
public virtual void TestFull() { SinkQueue <int> q = new SinkQueue <int>(1); q.Enqueue(1); Assert.True("should drop", !q.Enqueue(2)); Assert.Equal("element", 1, (int)q.Dequeue()); q.Enqueue(3); q.Consume(new _Consumer_114()); Assert.Equal("queue size", 0, q.Size()); }
public virtual void TestClear() { SinkQueue <int> q = new SinkQueue <int>(128); for (int i = 0; i < q.Capacity() + 97; ++i) { q.Enqueue(i); } Assert.Equal("queue size", q.Capacity(), q.Size()); q.Clear(); Assert.Equal("queue size", 0, q.Size()); }
public virtual void TestCommon() { SinkQueue <int> q = new SinkQueue <int>(2); q.Enqueue(1); Assert.Equal("queue front", 1, (int)q.Front()); Assert.Equal("queue back", 1, (int)q.Back()); Assert.Equal("element", 1, (int)q.Dequeue()); Assert.True("should enqueue", q.Enqueue(2)); q.Consume(new _Consumer_50()); Assert.True("should enqueue", q.Enqueue(3)); Assert.Equal("element", 3, (int)q.Dequeue()); Assert.Equal("queue size", 0, q.Size()); Assert.Equal("queue front", null, q.Front()); Assert.Equal("queue back", null, q.Back()); }
public virtual void TestConsumeAll() { int capacity = 64; // arbitrary SinkQueue <int> q = new SinkQueue <int>(capacity); for (int i = 0; i < capacity; ++i) { Assert.True("should enqueue", q.Enqueue(i)); } Assert.True("should not enqueue", !q.Enqueue(capacity)); Runnable trigger = Org.Mockito.Mockito.Mock <Runnable>(); q.ConsumeAll(new _Consumer_136(trigger)); Org.Mockito.Mockito.Verify(trigger, Org.Mockito.Mockito.Times(capacity)).Run(); }
public virtual void TestConcurrentConsumers() { SinkQueue <int> q = NewSleepingConsumerQueue(2, 1); Assert.True("should enqueue", q.Enqueue(2)); Assert.Equal("queue back", 2, (int)q.Back()); Assert.True("should drop", !q.Enqueue(3)); // should not block ShouldThrowCME(new _Fun_206(q)); ShouldThrowCME(new _Fun_211(q)); ShouldThrowCME(new _Fun_216(q)); ShouldThrowCME(new _Fun_221(q)); // The queue should still be in consistent state after all the exceptions Assert.Equal("queue size", 2, q.Size()); Assert.Equal("queue front", 1, (int)q.Front()); Assert.Equal("queue back", 2, (int)q.Back()); }
/// <exception cref="System.Exception"/> private void TestEmptyBlocking(int awhile) { SinkQueue <int> q = new SinkQueue <int>(2); Runnable trigger = Org.Mockito.Mockito.Mock <Runnable>(); // try consuming emtpy equeue and blocking Thread t = new _Thread_75(q, trigger); t.Start(); // Should work with or without sleep if (awhile > 0) { Thread.Sleep(awhile); } q.Enqueue(1); q.Enqueue(2); t.Join(); Org.Mockito.Mockito.Verify(trigger).Run(); }
public virtual void TestConsumerException() { SinkQueue <int> q = new SinkQueue <int>(1); RuntimeException ex = new RuntimeException("expected"); q.Enqueue(1); try { q.Consume(new _Consumer_157(ex)); } catch (Exception expected) { NUnit.Framework.Assert.AreSame("consumer exception", ex, expected); } // The queue should be in consistent state after exception Assert.Equal("queue size", 1, q.Size()); Assert.Equal("element", 1, (int)q.Dequeue()); }
/// <exception cref="System.Exception"/> private SinkQueue <int> NewSleepingConsumerQueue(int capacity, params int[] values ) { SinkQueue <int> q = new SinkQueue <int>(capacity); foreach (int i in values) { q.Enqueue(i); } CountDownLatch barrier = new CountDownLatch(1); Thread t = new _Thread_251(q, barrier); // causes failure without barrier // a long time t.SetName("Sleeping consumer"); t.SetDaemon(true); // so jvm can exit t.Start(); barrier.Await(); Log.Debug("Returning new sleeping consumer queue"); return(q); }
public _Thread_75(SinkQueue <int> q, Runnable trigger) { this.q = q; this.trigger = trigger; }
public _Thread_251(SinkQueue <int> q, CountDownLatch barrier) { this.q = q; this.barrier = barrier; }
public _Fun_221(SinkQueue <int> q) { this.q = q; }