storage

type Change struct {
	ID        uint `gorm:"primary_key" sql:"not null" json:",string"`
	CreatedAt time.Time
	GUN       string `gorm:"column:gun" sql:"type:varchar(255);not null"`
	Version   int    `sql:"not null"`
	SHA256    string `gorm:"column:sha256" sql:"type:varchar(64);"`
	Category  string `sql:"type:varchar(20);not null;"`
}

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

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

type ErrNotFound struct{}

type ErrOldVersion struct{}

type KeyStore interface {
	// GetKey returns the algorithm and public key for the given GUN and role.
	// If the GUN+role don't exist, returns an error.
	GetKey(gun, role string) (algorithm string, public []byte, err error)

	// SetKey sets the algorithm and public key for the given GUN and role if
	// it doesn't already exist.  Otherwise an error is returned.
	SetKey(gun, role, algorithm string, public []byte) error
}

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

type MetaStore interface {
	// UpdateCurrent adds new metadata version for the given GUN if and only
	// if it's a new role, or the version is greater than the current version
	// for the role. Otherwise an error is returned.
	UpdateCurrent(gun string, update MetaUpdate) error

	// UpdateMany adds multiple new metadata for the given GUN.  It can even
	// add multiple versions for the same role, so long as those versions are
	// all unique and greater than any current versions.  Otherwise,
	// none of the metadata is added, and an error is be returned.
	UpdateMany(gun string, updates []MetaUpdate) error

	// GetCurrent returns the modification date and data part of the metadata for
	// the latest version of the given GUN and role.  If there is no data for
	// the given GUN and role, an error is returned.
	GetCurrent(gun, tufRole string) (created *time.Time, data []byte, err error)

	// GetChecksum returns the given TUF role file and creation date for the
	// GUN with the provided checksum. If the given (gun, role, checksum) are
	// not found, it returns storage.ErrNotFound
	GetChecksum(gun, tufRole, checksum string) (created *time.Time, data []byte, err error)

	// Delete removes all metadata for a given GUN.  It does not return an
	// error if no metadata exists for the given GUN.
	Delete(gun string) error

	// GetChanges returns an ordered slice of changes. It starts from
	// the change matching changeID, but excludes this change from the results
	// on the assumption that if a user provides an ID, they've seen that change.
	// If changeID is 0, it starts from the
	// beginning, and if changeID is -1, it starts from the most recent
	// change. The number of results returned is limited by records.
	// If records is negative, we will return that number of changes preceding
	// the given changeID.
	// The returned []Change should always be ordered oldest to newest.
	GetChanges(changeID string, records int, filterName string) ([]Change, error)
}

type MetaUpdate struct {
	Role    string
	Version int
	Data    []byte
}

type RDBTUFFile struct {
	rethinkdb.Timing
	GunRoleVersion []interface{} `gorethink:"gun_role_version"`
	Gun            string        `gorethink:"gun"`
	Role           string        `gorethink:"role"`
	Version        int           `gorethink:"version"`
	Sha256         string        `gorethink:"sha256"`
	Data           []byte        `gorethink:"data"`
	TSchecksum     string        `gorethink:"timestamp_checksum"`
}

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

type SQLStorage struct {
	gorm.DB
}

type TUFFile struct {
	gorm.Model
	Gun     string `sql:"type:varchar(255);not null"`
	Role    string `sql:"type:varchar(255);not null"`
	Version int    `sql:"not null"`
	Sha256  string `sql:"type:varchar(64);"`
	Data    []byte `sql:"type:longblob;not null"`
}

type TUFMetaStorage struct {
	MetaStore
	// contains filtered or unexported fields
}