cabridss

type ACLEntry struct {
	// on unix-like fsy DSS: x-uid:<uid> or x-gid:<gid> will be honored
	User   string `json:"user"` // on encrypted DSS, any alias for an IdentityConfig whose secret is owned by the user will be honored
	Rights Rights `json:"rights"`
}

type AuditIndexInfo struct {
	Error string // "IndexInternal", "IndexMissing", "StorageMissing", "Inconsistent"
	Err   error  // origin error
	Time  int64  // the time of the entry in the DSS
	Bytes []byte // the metadata
}

type Client struct {
	http.Client
	// contains filtered or unexported fields
}

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

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

type CreateNewParams struct {
	ConfigPassword string                                                      // if not "" master password used to encrypt client configuration
	ConfigDir      string                                                      // if not "" path to the user's configuration directory
	Create         bool                                                        // perform CreateXxx or NewXxx?
	DssType        string                                                      // fsy, olf, obs, smf
	Root           string                                                      // fsy, olf, smf
	Size           string                                                      // if olf: s,m,l
	LocalPath      string                                                      // fsy, obs, smf (Root assumed if olf or smf)
	Encrypted      bool                                                        // all but fsy: enable repository encryption
	GetIndex       func(config DssBaseConfig, localPath string) (Index, error) // see DssBaseConfig
	Lsttime        int64                                                       // all but fsy: if not zero is the upper time of entries retrieved in it
	Aclusers       []string                                                    // all but fsy: if not nil is a List of ACL users for access check
	Endpoint       string                                                      // obs: AWS S3 or Openstack Swift endpoint, eg "https://s3.gra.cloud.ovh.net"
	Region         string                                                      // obs: AWS S3  or Openstack Swift region, eg "GRA"
	AccessKey      string                                                      // obs: AWS S3 access key (Openstack Swift must generate it)
	SecretKey      string                                                      // obs: AWS S3 secret key (Openstack Swift must generate it)
	Container      string                                                      // obs: AWS S3 bucket or Openstack Swift container
	RedLimit       int                                                         // all: reducer limit or 0
}

type Dss interface {
	// Mkns creates a namespace in the Dss, return an error if any happens
	//
	// npath is the full namespace without leading or trailing slash
	// mtime is the last modification POSIX time
	// children are the children names, a trailing slash denotes a namespace, else regular content
	// acl is the access control List to the namespace
	Mkns(npath string, mtime int64, children []string, acl []ACLEntry) error

	// Updatens updates a namespace in the Dss, return an error if any happens
	//
	// npath is the full namespace without leading or trailing slash
	// mtime is the last modification POSIX time
	// children are the children names, a trailing slash denotes a namespace, else regular content
	// acl is the access control List to the namespace
	Updatens(npath string, mtime int64, children []string, acl []ACLEntry) error

	// Lsns lists a namespace's content, return it or an error if any happens
	//
	// npath is the full namespace without leading or trailing slash
	//
	// returns:
	// - children names, a trailing slash denotes a namespace, else regular content
	// - err error if any happens
	Lsns(npath string) (children []string, err error)

	// IsDuplicate checks if content's checksum ch already exists in DSS
	//
	// returns duplicate status and an error if any happens
	IsDuplicate(ch string) (bool, error)

	// GetContentWriter creates content for writing
	//
	// npath is the full namespace + name without leading slash
	// mtime is the last modification POSIX time
	// acl is the access control List to the content
	// cb if not nil is a callback called when writer is closed
	//
	// returns:
	// - a writer to provide the content
	// - err error if any happens
	GetContentWriter(npath string, mtime int64, acl []ACLEntry, cb WriteCloserCb) (io.WriteCloser, error)

	// GetContentReader opens content for reading
	//
	// npath is the full namespace + name without leading slash
	//
	// returns:
	// - a reader to retrieve the content
	// - err error if any happens
	GetContentReader(npath string) (io.ReadCloser, error)

	// Symlink makes a symlink from npath to target path
	//
	// npath is the full namespace + name without leading slash
	// tpath is the target as a relative path following underlying OS conventions
	// mtime is the last modification POSIX time
	// acl is the access control List to the content
	//
	// returns:
	// - err error if any happens
	Symlink(npath string, tpath string, mtime int64, acl []ACLEntry) error

	// Remove removes a namespace (and recursively its children) or some content
	//
	// npath is the full namespace + name without leading slash, trailing slash indicates it is a namespace
	//
	// returns:
	// - err error if any happens
	Remove(npath string) error

	// GetMeta gets a namespace or some content metadata
	//
	// npath is the full namespace + name without leading slash, trailing slash indicates it is a namespace
	//
	// returns:
	// - the metadata
	// - err error if any happens
	GetMeta(npath string, getCh bool) (IMeta, error)

	// SetCurrentTime injects arbitrary current time for tests
	// does nothing on fsy DSS
	SetCurrentTime(time int64)

	// SetMetaMockCbs injects arbitrary json [un]marshal for tests if build tag constraint enables
	SetMetaMockCbs(cbs *MetaMockCbs)

	// SetAfs injects abstract FS for tests if build tag constraint enables
	SetAfs(tfs afero.Fs)

	// GetAfs retrieves it
	GetAfs() afero.Fs

	// Close can be necessary to perform final cleanup or index synchronization
	Close() error

	// SetSu enables superuser access for synchro
	SetSu()

	// SuEnableWrite enables physical write access for fsy: DSS in case SetSu is active
	//
	// npath is the full namespace + name without leading slash, trailing slash indicates it is a namespace
	//
	// returns:
	// - err error if any happens
	SuEnableWrite(npath string) error
}

type DssBaseConfig struct {
	ConfigDir         string                                                      `json:"-"`          // if not "" path to the user's configuration directory
	ConfigPassword    string                                                      `json:"-"`          // if master password is used to encrypt client configuration
	LocalPath         string                                                      `json:"-"`          // local path for configuration and index, or "" if unused (index will be memory based)
	RepoId            string                                                      `json:"repoId"`     // uuid of the repository
	Unlock            bool                                                        `json:"-"`          // unlocks index concurrent updates lock
	AutoRepair        bool                                                        `json:"autoRepair"` // if unlock required, automatically repairs the index
	ReIndex           bool                                                        `json:"-"`          // forces full content reindexation
	GetIndex          func(config DssBaseConfig, localPath string) (Index, error) `json:"-"`          // non-default function to instantiate an index
	XImpl             string                                                      `json:"xImpl"`      // index implementation code: bdb, memory, no
	LibApi            bool                                                        `json:"-"`          // prevents using a web API server for local DSS access
	WebProtocol       string                                                      `json:"-"`          // web API server protocol
	WebHost           string                                                      `json:"-"`          // web API server host
	WebPort           string                                                      `json:"-"`          // web API server port
	WebClientTimeout  time.Duration                                               `json:"-"`          // client timeout in seconds, a Timeout of zero means no timeout
	TlsCert           string                                                      `json:"-"`          // certificate file on https server or untrusted CA on https client
	TlsKey            string                                                      `json:"-"`          // certificate key file on https server
	TlsNoCheck        bool                                                        `json:"-"`          // no check of certificate by https client
	BasicAuthUser     string                                                      `json:"-"`          // adds basic authentication
	BasicAuthPassword string                                                      `json:"-"`          // basic authentication password
	WebRoot           string                                                      `json:"-"`          // web API server root
	Encrypted         bool                                                        `json:"encrypted"`  // repository is encrypted
	ReducerLimit      int                                                         `json:"-"`          // if not 0 max number of parallel I/O
}

type EDssConfig struct {
	WebDssConfig
}

type ErrBadParameter struct {
	Key   string
	Value fmt.Stringer
	Err   error
}

type ErrorCollector []error

type FsyConfig struct {
	DssBaseConfig
}

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

type HDss interface {
	Dss

	// GetHistory gets the history of the npath entry as a map of entry state sorted by time
	//
	// npath is the full namespace + name without leading slash, trailing slash indicates it is a namespace
	// recursive requests the service to recursively get the history of all namespace children
	// resolution "s" for seconds, "m" for minutes, "h" for hours, "d" for days summarizes the history with given resolution
	//
	// returns:
	// - the history (inclusive times when the entry is visible) for all entries
	// - err error if any happens
	GetHistory(npath string, recursive bool, resolution string) (map[string][]HistoryInfo, error)

	// RemoveHistory removes history entries for a given time period
	//
	// it must be noted that removing a parent history may cause children to be removed for a larger period of time
	//
	// npath is the full namespace + name without leading slash, trailing slash indicates it is a namespace
	// recursive requests the service to recursively remove the history of all namespace children,
	// evaluate don't remove, just report work to be done
	// start is the inclusive index time above which entries must be removed, zero meanning all past entries
	// end is the inclusive index time below which entries must be removed, zero meaning all future entries
	//
	// returns:
	// - the history (inclusive times when the entry is removed) for all entries
	// - err error if any happens
	RemoveHistory(npath string, recursive, evaluate bool, start, end int64) (map[string][]HistoryInfo, error)

	// GetIndex provides the DSS index or nil
	GetIndex() Index

	// DumpIndex for debug
	DumpIndex() string

	// GetRepoId provides the DSS repoId or ""
	GetRepoId() string

	// IsEncrypted tells if repository is encrypted
	IsEncrypted() bool

	// IsRepoEncrypted tells if repository configuration is set to encrypted
	IsRepoEncrypted() bool

	// AuditIndex compares the DSS index with meta and content actually stored
	AuditIndex() (map[string][]AuditIndexInfo, error)

	// ScanStorage scans the DSS storage and loads meta and content sha256 sum
	//
	// checksum checks content checksums
	// purge removes unreferenced content from the repository
	// purgeHidden removes hidden meta and content from the repository
	ScanStorage(checksum, purge, purgeHidden bool) (StorageInfo, *ErrorCollector)

	// GetHistoryChunks returns history chunks loaded from local index
	//
	// resolution s, m, h, d from seconds to days
	//
	// returns:
	// - the DSS activity periods sorted by time
	// - err error if any happens
	GetHistoryChunks(resolution string) ([]HistoryChunk, error)

	// Reindex scans the DSS storage and loads meta and content sha256 sum into the index
	Reindex() (StorageInfo, *ErrorCollector)
}

type HistoryChunk struct {
	Start int64 `json:"start"` // period start time POSIX aligned to resolution
	End   int64 `json:"end"`   // period end time POSIX aligned to resolution
	Count int   `json:"count"` // number of history updates in the time period
}

type HistoryInfo struct {
	Start int64 // start time POSIX of the history entry
	End   int64 // end time POSIX of the history entry
	HMeta Meta  // the  metadata
}

type IMeta interface {
	GetPath() string                     // path in the DSS
	GetMtime() int64                     // last modification POSIX time
	GetSize() int64                      // content size
	GetCh() string                       // content truncated SHA256 checksum (panic if DSS does not enable)
	GetChUnsafe() string                 // content truncated SHA256 checksum or empty if DSS does not enable
	GetIsNs() bool                       // is it a namespace, if true has children
	GetChildren() []string               // namespace children, sorted by name
	GetIsSymLink() bool                  // is it a symbolic link, if true has SymLinkTarget
	GetSymLinkTarget() string            // target of the symbolic link
	GetAcl() []ACLEntry                  // access control List, sorted by user
	GetItime() int64                     // index time
	Equals(other IMeta, chacl bool) bool // checks equality (does not compare Ch if one end is unavailable) compare ACL if chacl true
}

type IS3Session interface {
	Initialize() error
	Check() error
	List(prefix string) ([]string, error)
	Meta(key string) (S3Meta, error)
	Put(key string, content []byte) error
	Get(key string) ([]byte, error)
	Upload(key string, r io.Reader) error
	Download(key string) (io.ReadCloser, error)
	Delete(key string) error
	DeleteAll(prefix string) error
}

type IdentityConfig struct {
	Alias  string `json:"alias"`
	PKey   string `json:"pKey"`
	Secret string `json:"secret"`
}

type Index interface {
	IsPersistent() bool

	Close() error
	Repair(readOnly bool) ([]string, error)
	Dump() string
	// contains filtered or unexported methods
}

type LibApiDssConfig struct {
	IsOlf  bool
	OlfCfg OlfConfig
	IsObs  bool
	IsSmf  bool
	ObsCfg ObsConfig
}

type Meta struct {
	Path          string     `json:"path"`                    // full path for data content
	Mtime         int64      `json:"mtime"`                   // last modification POSIX time
	Size          int64      `json:"size"`                    // content size
	Ch            string     `json:"ch"`                      // truncated SHA256 checksum of the content
	IsNs          bool       `json:"isNs"`                    // is it a namespace, if true has children
	Children      []string   `json:"children"`                // namespace children, sorted by name
	IsSymLink     bool       `json:"isSymLink,omitempty"`     // is it a symbolic link, if true has SymLinkTarget
	SymLinkTarget string     `json:"symLinkTarget,omitempty"` // target of the symbolic link
	ACL           []ACLEntry `json:"acl"`                     // access control List, sorted by user
	Itime         int64      `json:"itime"`                   // index time
	ECh           string     `json:"ech"`                     // truncated SHA256 checksum of the encrypted content if encrypted else empty
	EMId          string     `json:"emid"`                    // encrypted meta-data unique identifier if encrypted else empty
}

type MetaMockCbs struct {
	MockMarshal   func(v interface{}) ([]byte, error)
	MockUnmarshal func(data []byte, v interface{}) error
}

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

type ObsConfig struct {
	DssBaseConfig
	Endpoint     string            `json:"endpoint"`  // AWS S3 or Openstack Swift endpoint, eg "https://s3.gra.cloud.ovh.net"
	Region       string            `json:"region"`    // AWS S3  or Openstack Swift region, eg "GRA"
	AccessKey    string            `json:"accessKey"` // AWS S3 access key (Openstack Swift must generate it)
	SecretKey    string            `json:"secretKey"` // AWS S3 secret key (Openstack Swift must generate it)
	Container    string            `json:"container"` // AWS S3 bucket or Openstack Swift container
	GetS3Session func() IS3Session `json:"-"`         // if not nil enables to set a mock S3 implementation
}

type OlfConfig struct {
	DssBaseConfig
	Root string // filesystem root for the OLF DSS
	Size string // DSS size may be small, medium or large ("s", "m" or "l")

}

type PixClient struct {
	InternalId int `json:"internalId"` // client internal id (key prefix to client entries in DB)
	TxId       int `json:"txCounter"`  // current client transaction id (key prefix to client new transactions in DB)
}

type PixClients struct {
	IdCounter int                   `json:"counter"` // next internal id to be used
	Clients   map[string]*PixClient `json:"clients"` // mapping external client id to internal id
}

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

type Rights struct {
	Read    bool `json:"read"`
	Write   bool `json:"write"`
	Execute bool `json:"execute"`
}

type S3Meta struct {
	Length int64
}

type SIHnIt struct {
	Hn string `json:"hn"`
	It int64  `json:"it"`
}

type StorageInfo struct {
	Path2Meta     map[string][]byte           `json:"path2Meta"`
	Path2CMeta    map[string][]byte           `json:"path2CMeta"`
	Path2HnIt     map[string]SIHnIt           `json:"path2HnIt"`
	ExistingCs    map[string]bool             `json:"existingCs"`
	ExistingEcs   map[string]bool             `json:"existingEcs"`
	Path2Content  map[string]string           `json:"path2Content"`
	Path2CContent map[string]string           `json:"path2CContent"`
	Path2Error    map[string]error            `json:"path2Error"`
	XLMetas       map[string]map[int64][]byte `json:"xlmetas"` // Local meta data
	XRMetas       map[string]map[int64][]byte `json:"xrmetas"` // Remote meta data
}

type TempFileWriteCloserWithCb struct {
	WriteCloserWithCb
	// contains filtered or unexported fields
}

type TimeResolution string

type TimedMeta struct {
	Time  int64  `json:"time,string"`
	Bytes string `json:"bytes"`
}

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

type UnixNanoUTC int64

type UnixUTC int64

type UpdatedData struct {
	Changed map[string][]TimedMeta `json:"changed"`
	Deleted map[string]bool        `json:"deleted"`
}

type UserConfig struct {
	ClientId   string `json:"clientId"`
	Identities []IdentityConfig
	Internal   IdentityConfig
}

type WebApiClient interface {
	Url() string
	DoAsJson(request *http.Request, outBody any) (*http.Response, error)
	SimpleDoAsJson(method, url string, inBody any, outBody any) (*http.Response, error)
	GetConfig() interface{}
	SetCabriHeader(h string)
}

type WebDssConfig struct {
	DssBaseConfig
	LibApiDssConfig
	ClId string
}

type WebDssServerConfig struct {
	WebServerConfig
	UserConfig
	Dss HDss
}

type WebServer interface {
	Serve() error
	Shutdown() error
	ConfigureApi(
		root string, customConfig interface{},
		shutdownCallback func(root string, customConfigs map[string]interface{}) error,
		ctor func(e *echo.Echo, root string, customConfigs map[string]interface{}) error,
	) error
	// contains filtered or unexported methods
}

type WebServerConfig struct {
	Addr              string // host[:port]
	HasLog            bool
	IsTls             bool   // https
	TlsCert           string // certificate file on https server or untrusted CA on https client
	TlsKey            string // certificate key file on https server
	TlsNoCheck        bool   // no check of certificate by https client
	BasicAuthUser     string
	BasicAuthPassword string
}

type WfsDssConfig struct {
	DssBaseConfig
}

type WfsDssServerConfig struct {
	WebServerConfig
	Dss Dss
}

type WriteCloserCb func(err error, size int64, ch string)

type WriteCloserErrCb func(err error, size int64, ch string, me *WriteCloserWithCb) error

type WriteCloserWithCb struct {
	Underlying io.WriteCloser
	// contains filtered or unexported fields
}