kafka_schema

type Alias string

type AliasDTO struct {
	Alias Alias     `json:"alias"`
	UUID  uuid.UUID `json:"uuid"`
}

type AliasListDTO struct {
	Aliases []Alias `json:"aliases"`
	Count   int     `json:"count"`
}

type AliasMap struct {
	catchall.ConcurrentObservable
	Map aliasMapType
}

type AliasRepo interface {
	// WhoIs looks up an alias and returns the associated schema's uuid
	WhoIs(alias Alias) (uuid.UUID, bool)
	// WaitAliasReady returns a channel that can be used to wait for an alias and the associated schema to become ready.
	// This works analogous to func Repo.WaitSchemaReady.
	WaitAliasReady(alias Alias) chan bool
	// ListAliases returns a slice of all aliases that are currently available.
	// Note that this may not represent the actual state stored in Kafka, since there
	// is some lag between the time when an alias change arrives in Kafka and the
	// time the Repo implementation has consumed the change.
	ListAliases() []Alias
}

type AliasRequest struct {
	UUID  uuid.UUID `json:"UUID"`
	Alias string    `json:"alias"`
}

type AliasesDTO struct {
	Aliases []AliasDTO `json:"aliases"`
}

type Commander struct {
	*core.Producer
}

type LocalRepo struct {
	Schemata SchemaMap
	Aliases  AliasMap
	core.TopicRouter
}

type NameVersion struct {
	// Name is the plain text address of the thing.
	Name string
	// Version is the version number of the thing.
	// The version number starts at 0 and increases linearly by 1.
	Version uint
}

type Repo interface {
	// Decode decodes a datum with the given avro schema
	Decode(schema uuid.UUID, datum []byte) (interface{}, error)
	// Encode encodes a datum with the given avro schema
	Encode(schema uuid.UUID, datum interface{}) ([]byte, error)
	// WaitSchemaReady returns a channel that can be used to wait for a schema to become available.
	// Since the schemata are stored in Kafka, it might take the underlying implementation
	// a while until it has consumed all schema changes.
	WaitSchemaReady(schema uuid.UUID) chan bool
	// ListSchemata returns a slice of all uuids that are currently available.
	// Note that this may not represent the actual state stored in Kafka, since there
	// is some lag between the time when a schema change arrives in Kafka and the
	// time the Repo implementation has consumed the change.
	ListSchemata() []uuid.UUID
	// GetSpecification returns the avro specification for the given uuid in plain text.
	GetSpecification(schema uuid.UUID) (specification string, ok bool)
	// Count returns the number of schemata currently available
	Count() int
}

type SchemaDTO struct {
	UUID          uuid.UUID `json:"uuid"`
	Specification string    `json:"spec"`
}

type SchemaListDTO struct {
	Count    int         `json:"count"`
	Schemata []uuid.UUID `json:"schemata"`
}

type SchemaMap struct {
	catchall.ConcurrentObservable
	Map schemaMapType
}

type SchemataDTO struct {
	Schemata []SchemaDTO `json:"schemata"`
}

type UpdateRequest struct {
	UUID uuid.UUID `json:"UUID"`
	Spec string    `json:"spec"`
}

type Updater interface {
	// UpdateSchema sets the given UUID to equal the given plain-text Avro spec.
	UpdateSchema(schemaUUID uuid.UUID, specification string) error
	// UpdateAlias sets the given Alias to equal the given UUID.
	UpdateAlias(alias string, schemaUUID uuid.UUID) error
}

type Version interface {
	// IsOrigin indicates whether this is the first version of the thing.
	IsOrigin() bool
	// GetVersion returns the version number of the thing.
	GetVersion() uint
	// GetName returns the name i.e. the plain text address of the thing.
	GetName() string
	// GetPrevious returns the Version preceding this Version.
	// If this is the origin, it returns the origin unchanged.
	// The ok flag indicates whether the returned Version differs from the passed Version.
	GetPrevious() (v Version, ok bool)
	// GetNext returns the Version succeeding this Version.
	// If this is the most recent Version, it returns the Version unchanged.
	// The ok flag indicates whether the returned Version differs from the passed Version.
	GetNext() (v Version, ok bool)
	// String marshals the Version into a string.
	String() string
	// Alias marshals the Version into an Alias.
	Alias() Alias
}

type VersionedRepo interface {
	// DecodeVersion decodes a datum using the specified schema at the specified version.
	DecodeVersion(schema NameVersion, datum []byte) (interface{}, error)
	// EncodeVersion encodes a datum using the specified schema at the specified version.
	EncodeVersion(schema NameVersion, datum interface{}) ([]byte, error)
	// WaitVersionReady returns a channel that can be used to wait for a schema to become available in the specified version.
	// This works analogous to func Repo.WaitSchemaReady.
	WaitVersionReady(schema NameVersion) chan bool
}