io.hyperfoil.api.session

Interface Session

public interface Session

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	Session.Resource Just a marker interface.
static interface	Session.ResourceKey<R extends Session.Resource>
static interface	Session.Var
static class	Session.VarType

Method Summary

Modifier and Type	Method and Description
SequenceInstance	acquireSequence()
void	attach(io.netty.util.concurrent.EventExecutor executor, SharedData sharedData, HttpDestinationTable httpDestinations, SessionStatistics statistics)
SequenceInstance	currentSequence()
void	currentSequence(SequenceInstance current)
<R extends Session.Resource> void	declareResource(Session.ResourceKey<R> key, R resource)
void	enableSequence(SequenceInstance instance)
io.netty.util.concurrent.EventExecutor	executor()
void	fail(Throwable t)
<R extends Session.Resource> R	getResource(Session.ResourceKey<R> key)
HttpCache	httpCache()
HttpConnectionPool	httpConnectionPool(String authority)
HttpDestinationTable	httpDestinations()
LimitedPool<HttpRequest>	httpRequestPool()
boolean	isActive()
void	nextSequence(String name)
Phase	phase()
void	proceed() Run anything that can be executed.
void	pruneStats(Phase phase)
void	reserve(Scenario scenario)
void	reset()
SharedData	sharedData()
void	start(PhaseInstance phase)
Statistics	statistics(int stepId, String name)
void	stop()
int	uniqueId()

Method Detail

reserve

void reserve(Scenario scenario)

uniqueId

int uniqueId()

Returns:

int >= 0 that's unique across whole simulation

httpConnectionPool

HttpConnectionPool httpConnectionPool(String authority)

httpDestinations

HttpDestinationTable httpDestinations()

executor

io.netty.util.concurrent.EventExecutor executor()

sharedData

SharedData sharedData()

phase

Phase phase()

statistics

Statistics statistics(int stepId,
                      String name)

pruneStats

void pruneStats(Phase phase)

declareResource

<R extends Session.Resource> void declareResource(Session.ResourceKey<R> key,
                                                  R resource)

getResource

<R extends Session.Resource> R getResource(Session.ResourceKey<R> key)

currentSequence

void currentSequence(SequenceInstance current)

currentSequence

SequenceInstance currentSequence()

attach

void attach(io.netty.util.concurrent.EventExecutor executor,
            SharedData sharedData,
            HttpDestinationTable httpDestinations,
            SessionStatistics statistics)

start

void start(PhaseInstance phase)

proceed

void proceed()

Run anything that can be executed.

reset

void reset()

nextSequence

void nextSequence(String name)

stop

void stop()

fail

void fail(Throwable t)

isActive

boolean isActive()

httpRequestPool

LimitedPool<HttpRequest> httpRequestPool()

httpCache

HttpCache httpCache()

acquireSequence

SequenceInstance acquireSequence()

enableSequence

void enableSequence(SequenceInstance instance)