loadtest

type ClientOpts ¶

type ClientOpts struct {
	BearerToken      string
	BearerTokenWrite string

	Client *http.Client
}

type Hammer ¶

type Hammer struct {
	// contains filtered or unexported fields
}

Hammer is responsible for coordinating the operations against the log in the form of write and read operations. The work of analysing the results of hammering should live outside of this class.

func NewHammer(tracker *client.LogStateTracker, f client.EntryBundleFetcherFunc, w LeafWriter, gen func() []byte, seqLeafChan chan<- LeafTime, errChan chan<- error, opts HammerOpts) *Hammer

func (h *Hammer) Run(ctx context.Context)

type HammerAnalyser ¶

type HammerAnalyser struct {
	SeqLeafChan chan LeafTime
	ErrChan     chan error

	QueueTime       *movingaverage.ConcurrentMovingAverage
	IntegrationTime *movingaverage.ConcurrentMovingAverage
	// contains filtered or unexported fields
}

HammerAnalyser is responsible for measuring and interpreting the result of hammering.

func NewHammerAnalyser(treeSizeFn func() uint64) *HammerAnalyser

func (a *HammerAnalyser) Run(ctx context.Context)

type HammerOpts ¶

type HammerOpts struct {
	MaxReadOpsPerSecond  int
	MaxWriteOpsPerSecond int

	NumReadersRandom int
	NumReadersFull   int
	NumWriters       int
	NumMMDVerifiers  int
	MMDDuration      time.Duration
}

type LeafMMD ¶

type LeafMMD struct {
	// contains filtered or unexported fields
}

LeafMMD records the generated leaf in the request and the timestamp in the response.

This is used to verify the MMD violation by the performing the inclusion proof.

type LeafReader ¶

type LeafReader struct {
	// contains filtered or unexported fields
}

LeafReader reads leaves from the tree. This class is not thread safe.

func NewLeafReader(tracker *client.LogStateTracker, f client.EntryBundleFetcherFunc, next func(uint64) uint64, throttle <-chan bool, errChan chan<- error) *LeafReader

func (r *LeafReader) Kill()

func (r *LeafReader) Run(ctx context.Context)

type LeafTime ¶

type LeafTime struct {
	Index      uint64
	QueuedAt   time.Time
	AssignedAt time.Time
}

LeafTime records the time at which a leaf was assigned the given index.

This is used when sampling leaves which are added in order to later calculate how long it took to for them to become integrated.

type LeafWriter ¶

type LeafWriter func(ctx context.Context, data []byte) (index uint64, timestamp uint64, err error)

LeafWriter is the signature of a function which can write arbitrary data to a log. The data to be written is provided, and the implementation must return the sequence number at which this data will be found in the log and the timestamp of the SCT issued for the data, or an error.

type LogReader ¶

type LogReader interface {
	ReadCheckpoint(ctx context.Context) ([]byte, error)

	ReadTile(ctx context.Context, l, i uint64, p uint8) ([]byte, error)

	ReadEntryBundle(ctx context.Context, i uint64, p uint8) ([]byte, error)
}

type LogWriter ¶

type LogWriter struct {
	// contains filtered or unexported fields
}

LogWriter writes new leaves to the log that are generated by `gen`.

func NewLogWriter(writer LeafWriter, gen func() []byte, throttle <-chan bool, errChan chan<- error, leafSampleChan chan<- LeafTime, leafMMDChan chan<- LeafMMD) *LogWriter

func (w *LogWriter) Kill()

func (w *LogWriter) Run(ctx context.Context)

type MMDVerifier ¶

type MMDVerifier struct {
	// contains filtered or unexported fields
}

MMDVerifier verifies the signed timestamp against the MMD policy for newly added entries by performing inclusion proof.

func NewMMDVerifier(tracker *client.LogStateTracker, mmdDuration time.Duration, errChan chan<- error, leafMMDChan <-chan LeafMMD) *MMDVerifier

func (v *MMDVerifier) Kill()

func (v *MMDVerifier) Run(ctx context.Context)

type Throttle ¶

type Throttle struct {
	TokenChan chan bool
	// contains filtered or unexported fields
}

func NewThrottle(opsPerSecond int) *Throttle

func (t *Throttle) Decrease()

func (t *Throttle) Increase()

func (t *Throttle) Run(ctx context.Context)

func (t *Throttle) String() string

type Worker ¶

type Worker interface {
	Run(ctx context.Context)
	Kill()
}

type WorkerPool ¶

type WorkerPool struct {
	// contains filtered or unexported fields
}

WorkerPool contains a collection of _running_ workers.

func NewWorkerPool(factory func() Worker) WorkerPool

func (p *WorkerPool) Grow(ctx context.Context)

func (p *WorkerPool) Shrink(ctx context.Context)

func (p *WorkerPool) Size() int