workload

type BernoulliGenerator struct {
	Rnd         *rand.Rand
	Probability Probability
}

type BlockProfile struct {
	// Size of the block
	Size uint64 `mapstructure:"size" yaml:"size"`
}

type ByteArrayGenerator struct {
	Size uint32
	Rnd  *rand.Rand
}

type ConfigBlock struct {
	ChannelID                    string
	OrdererEndpoints             []*connection.OrdererEndpoint
	MetaNamespaceVerificationKey []byte
}

type ConflictProfile struct {
	// Probability of invalid signatures [0,1] (default: 0)
	InvalidSignatures Probability `mapstructure:"invalid-signatures" yaml:"invalid-signatures"`
	// Dependencies list of dependencies
	Dependencies []DependencyDescription `mapstructure:"dependencies" yaml:"dependencies"`
}

type ConstGenerator[T any] struct {
	Const T
}

type DependencyDescription struct {
	// Probability of the dependency type [0,1] (default: 0)
	Probability Probability `mapstructure:"probability" yaml:"probability"`
	// Gap is the distance between the dependent TXs (default: 1)
	Gap *Distribution `mapstructure:"gap" yaml:"gap"`
	// Src dependency "read", "write", or "read-write"
	Src string `mapstructure:"src" yaml:"src"`
	// Dst dependency "read", "write", or "read-write"
	Dst string `mapstructure:"dst" yaml:"dst"`
}

type DiscreteGenerator[T any] struct {
	Rnd    *rand.Rand
	Values []DiscreteValue[T]
}

type DiscreteValue[T any] struct {
	Value       T           `mapstructure:"value"`
	Probability Probability `mapstructure:"probability"`
}

type Distribution struct {
	Const     float64                  `mapstructure:"const" yaml:"const,omitempty"`
	Uniform   *UniformDist             `mapstructure:"uniform" yaml:"uniform,omitempty"`
	Normal    *NormalDist              `mapstructure:"normal" yaml:"normal,omitempty"`
	Bernoulli Probability              `mapstructure:"bernoulli" yaml:"bernoulli,omitempty"`
	Discrete  []DiscreteValue[float64] `mapstructure:"discrete" yaml:"discrete,omitempty"`
}

type FloatToBooleanGenerator struct {
	FloatGen Generator[float64]
}

type FloatToIntGenerator struct {
	FloatGen Generator[float64]
}

type FloatToPositiveIntGenerator struct {
	FloatGen Generator[float64]
}

type Generator[T any] interface {
	Next() T
}

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

type IndependentTxGenerator struct {
	TxIDGenerator            *UUIDGenerator
	ReadOnlyKeyGenerator     *MultiGenerator[Key]
	ReadWriteKeyGenerator    *MultiGenerator[Key]
	BlindWriteKeyGenerator   *MultiGenerator[Key]
	ReadWriteValueGenerator  *ByteArrayGenerator
	BlindWriteValueGenerator *ByteArrayGenerator
}

type Key = []byte

type KeyPath struct {
	SigningKey      string `mapstructure:"signing-key" yaml:"signing-key"`
	VerificationKey string `mapstructure:"verification-key" yaml:"verification-key"`
	SignCertificate string `mapstructure:"sign-certificate" yaml:"sign-certificate"`
}

type KeyProfile struct {
	// Size is the size of the key to generate.
	Size uint32 `mapstructure:"size" yaml:"size"`
}

type LimiterConfig struct {
	InitialLimit rate.Limit `mapstructure:"initial-limit"`
	// Endpoint for a simple http server to set the limiter.
	Endpoint connection.Endpoint `mapstructure:"endpoint"`
}

type Modifier interface {
	Modify(*protoblocktx.Tx) (*protoblocktx.Tx, error)
}

type MultiGenerator[T any] struct {
	Count Generator[int]
	Gen   Generator[T]
}

type NormalDist struct {
	Mean float64 `mapstructure:"mean" yaml:"mean,omitempty"`
	Std  float64 `mapstructure:"std" yaml:"std,omitempty"`
}

type NormalGenerator struct {
	Rnd       *rand.Rand
	Mean, Std float64
}

type Policy struct {
	Scheme signature.Scheme `mapstructure:"scheme" yaml:"scheme"`
	Seed   int64            `mapstructure:"seed" yaml:"seed"`
	// KeyPath describes how to find/generate the signature keys.
	// KeyPath is still not supported.
	KeyPath *KeyPath `mapstructure:"key-path" yaml:"key-path"`
}

type PolicyProfile struct {
	// NamespacePolicies specifies the namespace policies.
	NamespacePolicies map[string]*Policy `mapstructure:"namespace-policies" yaml:"namespace-policies"`

	// OrdererEndpoints may specify the endpoints to add to the config block.
	// If this field is empty, no endpoints will be configured.
	// If ConfigBlockPath is specified, this value is ignored.
	OrdererEndpoints []*connection.OrdererEndpoint `mapstructure:"orderer-endpoints" yaml:"orderer-endpoints"`

	// ConfigBlockPath may specify the config block to use.
	// If this field is empty, a default config block will be generated.
	ConfigBlockPath string `mapstructure:"config-block-path" yaml:"config-block-path"`
}

type Probability = float64

type Profile struct {
	Block       BlockProfile       `mapstructure:"block" yaml:"block"`
	Key         KeyProfile         `mapstructure:"key" yaml:"key"`
	Transaction TransactionProfile `mapstructure:"transaction" yaml:"transaction"`
	Query       QueryProfile       `mapstructure:"query" yaml:"query"`
	Conflicts   ConflictProfile    `mapstructure:"conflicts" yaml:"conflicts"`

	// The seed to generate the seeds for each worker
	Seed int64 `mapstructure:"seed" yaml:"seed"`

	// Workers is the number of independent producers.
	// Each worker uses a unique seed that is generated from the main seed.
	// To ensure responsibility of items between runs (e.g., for query)
	// the number of workers must be preserved.
	Workers uint32 `mapstructure:"workers" yaml:"workers"`
}

type QueryGenerator struct {
	ValidKeyGenerator   *ByteArrayGenerator
	InvalidKeyGenerator *ByteArrayGenerator
	Size                Generator[int]
	InvalidPortion      Generator[float64]
	ShuffleRnd          *rand.Rand
	Shuffle             bool
}

type QueryProfile struct {
	// The number of keys to query.
	QuerySize *Distribution `mapstructure:"query-size" yaml:"query-size"`
	// The minimal portion of invalid keys (1 => all keys are invalid).
	// This is a lower bound since some valid keys might have failed to commit due to conflicts.
	MinInvalidKeysPortion *Distribution `mapstructure:"min-invalid-keys-portion" yaml:"min-invalid-keys-portion"`
	// If Shuffle=false, the valid keys will be placed first.
	// Otherwise, they will be shuffled.
	Shuffle bool `mapstructure:"shuffle" yaml:"shuffle"`
}

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

type RateLimiterGenerator[T any] struct {
	Chan    <-chan []T
	Limiter *rate.Limiter
	// contains filtered or unexported fields
}

type StreamOptions struct {
	// RateLimit directly impacts the rate by limiting it.
	RateLimit *LimiterConfig `mapstructure:"rate-limit" yaml:"rate-limit"`
	// GenBatch impacts the rate by batching generated items before inserting then the channel.
	// This helps overcome the inherit rate limitation of Go channels.
	GenBatch uint32 `mapstructure:"gen-batch" yaml:"gen-batch"`
	// BuffersSize impact the rate by masking fluctuation in performance.
	BuffersSize int `mapstructure:"buffers-size" yaml:"buffers-size"`
}

type StreamWithSetup struct {
	WorkloadSetupTXs channel.Reader[*protoblocktx.Tx]
	TxStream         *TxStream
	BlockSize        uint64
}

type TransactionProfile struct {
	// The sizes of the values to generate (size=0 => value=nil)
	ReadWriteValueSize  uint32 `mapstructure:"read-write-value-size" yaml:"read-write-value-size"`
	BlindWriteValueSize uint32 `mapstructure:"blind-write-value-size" yaml:"blind-write-value-size"`
	// The number of keys to generate (read ver=nil)
	ReadOnlyCount *Distribution `mapstructure:"read-only-count" yaml:"read-only-count"`
	// The number of keys to generate (read ver=nil/write)
	ReadWriteCount *Distribution `mapstructure:"read-write-count" yaml:"read-write-count"`
	// The number of keys to generate (write)
	BlindWriteCount *Distribution  `mapstructure:"write-count" yaml:"write-count"`
	Policy          *PolicyProfile `mapstructure:"policy" yaml:"policy"`
}

type TxGeneratorWithSetup struct {
	WorkloadSetupTXs channel.Reader[*protoblocktx.Tx]
	TxGen            *RateLimiterGenerator[*protoblocktx.Tx]
}

type TxSignerVerifier struct {
	HashSigners map[string]*HashSignerVerifier
}

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

type UUIDGenerator struct {
	Rnd *rand.Rand
}

type UniformDist struct {
	Min float64 `mapstructure:"min" yaml:"min,omitempty"`
	Max float64 `mapstructure:"max" yaml:"max,omitempty"`
}

type UniformGenerator struct {
	Rnd      *rand.Rand
	Min, Max float64
}