se.l4.vibe.internal.builder.SamplerBuilderImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vibe-api Show documentation
There is a newer version: 0.4.0
package se.l4.vibe.internal.builder;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import se.l4.vibe.backend.VibeBackend;
import se.l4.vibe.builder.SamplerBuilder;
import se.l4.vibe.builder.TriggerBuilder;
import se.l4.vibe.event.EventSeverity;
import se.l4.vibe.event.Events;
import se.l4.vibe.internal.EventsImpl;
import se.l4.vibe.internal.time.TimeSampler;
import se.l4.vibe.probes.SampleListener;
import se.l4.vibe.probes.SampledProbe;
import se.l4.vibe.probes.Sampler;
import se.l4.vibe.probes.Sampler.Entry;
import se.l4.vibe.trigger.Condition;
import se.l4.vibe.trigger.On;
import se.l4.vibe.trigger.Trigger;
import se.l4.vibe.trigger.TriggerEvent;

/**
 * Builder for time series.
 * 
 * @author Andreas Holstenson
 *
 * @param 
 */
public class SamplerBuilderImpl
	extends AbstractBuilder>
	implements SamplerBuilder
{
	private final VibeBackend backend;
	private final TimeSampler sampler;
	private final SampledProbe probe;
	
	final List triggers;
	private Events triggerEvents;
	
	private long sampleInterval;
	
	public SamplerBuilderImpl(VibeBackend backend, 
			TimeSampler sampler,
			SampledProbe probe)
	{
		this.backend = backend;
		this.sampler = sampler;
		this.probe = probe;
		
		triggers = new ArrayList();
		
		sampleInterval = sampler.getDefaultTime();
	}
	
	@Override
	public Sampler build()
	{
		// Find or create a suitable sampler
		Sampler instance = sampler.sampleTimeSeries(sampleInterval, probe);
		
		// Create the triggers
		List builtTriggers = new ArrayList(); 
		for(TriggerHolder th : triggers)
		{
			Runnable r = th.create(instance, triggerEvents);
			builtTriggers.add(r);
		}
		
		// Create listener for triggers
		final Runnable[] triggers = builtTriggers.toArray(new Runnable[builtTriggers.size()]);
		instance.addListener(new SampleListener()
		{
			@Override
			public void sampleAcquired(SampledProbe probe, Entry value)
			{
				for(Runnable r : triggers)
				{
					r.run();
				}
			}
		});
		
		return instance;
	}
	
	@Override
	public Sampler export()
	{
		verify();
		
		Sampler instance = build();
		backend.export(path, instance);
		return instance;
	}
	
	@Override
	public  TriggerBuilder> when(
			Trigger trigger, 
			Condition condition)
	{
		verify();
		
		if(triggerEvents == null)
		{
			triggerEvents = new EventsImpl(EventSeverity.WARN);
			backend.export(path + ':' + triggers.size(), triggerEvents);
		}
		
		return new SamplerTriggerBuilder(this, trigger, condition, triggerEvents);
	}
	
	@Override
	public  TriggerBuilder> when(
			Trigger trigger, 
			On on,
			Condition condition)
	{
		Trigger newTrigger = on.build(trigger);
		
		return when(newTrigger, condition);
	}
	
	@Override
	public SamplerBuilder withInterval(long time, TimeUnit unit)
	{
		sampleInterval = unit.toMillis(time);
		return this;
	}
}