castorev1

type BlobChunk struct {
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

type BlobServiceClient interface {
	// Stat can be used to check for the existence of a blob, as well as
	// gathering more data about it, like more granular chunking information
	// or baos.
	// Server implementations are not required to provide more granular chunking
	// information, especially if the digest specified in `StatBlobRequest` is
	// already a chunk of a blob.
	Stat(ctx context.Context, in *StatBlobRequest, opts ...grpc.CallOption) (*StatBlobResponse, error)
	// Read allows reading (all) data of a blob/chunk by the BLAKE3 digest of
	// its contents.
	// If the backend communicated more granular chunks in the `Stat` request,
	// this can also be used to read chunks.
	// This request returns a stream of BlobChunk, which is just a container for
	// a stream of bytes.
	// The server may decide on whatever chunking it may seem fit as a size for
	// the individual BlobChunk sent in the response stream, this is mostly to
	// keep individual messages at a manageable size.
	Read(ctx context.Context, in *ReadBlobRequest, opts ...grpc.CallOption) (BlobService_ReadClient, error)
	// Put uploads a Blob, by reading a stream of bytes.
	//
	// The way the data is chunked up in individual BlobChunk messages sent in
	// the stream has no effect on how the server ends up chunking blobs up, if
	// it does at all.
	Put(ctx context.Context, opts ...grpc.CallOption) (BlobService_PutClient, error)
}

type BlobServiceServer interface {
	// Stat can be used to check for the existence of a blob, as well as
	// gathering more data about it, like more granular chunking information
	// or baos.
	// Server implementations are not required to provide more granular chunking
	// information, especially if the digest specified in `StatBlobRequest` is
	// already a chunk of a blob.
	Stat(context.Context, *StatBlobRequest) (*StatBlobResponse, error)
	// Read allows reading (all) data of a blob/chunk by the BLAKE3 digest of
	// its contents.
	// If the backend communicated more granular chunks in the `Stat` request,
	// this can also be used to read chunks.
	// This request returns a stream of BlobChunk, which is just a container for
	// a stream of bytes.
	// The server may decide on whatever chunking it may seem fit as a size for
	// the individual BlobChunk sent in the response stream, this is mostly to
	// keep individual messages at a manageable size.
	Read(*ReadBlobRequest, BlobService_ReadServer) error
	// Put uploads a Blob, by reading a stream of bytes.
	//
	// The way the data is chunked up in individual BlobChunk messages sent in
	// the stream has no effect on how the server ends up chunking blobs up, if
	// it does at all.
	Put(BlobService_PutServer) error
	// contains filtered or unexported methods
}

type BlobService_PutClient interface {
	Send(*BlobChunk) error
	CloseAndRecv() (*PutBlobResponse, error)
	grpc.ClientStream
}

type BlobService_PutServer interface {
	SendAndClose(*PutBlobResponse) error
	Recv() (*BlobChunk, error)
	grpc.ServerStream
}

type BlobService_ReadClient interface {
	Recv() (*BlobChunk, error)
	grpc.ClientStream
}

type BlobService_ReadServer interface {
	Send(*BlobChunk) error
	grpc.ServerStream
}

type Directory struct {
	Directories []*DirectoryNode `protobuf:"bytes,1,rep,name=directories,proto3" json:"directories,omitempty"`
	Files       []*FileNode      `protobuf:"bytes,2,rep,name=files,proto3" json:"files,omitempty"`
	Symlinks    []*SymlinkNode   `protobuf:"bytes,3,rep,name=symlinks,proto3" json:"symlinks,omitempty"`
	// contains filtered or unexported fields
}

type DirectoryNode struct {

	// The (base)name of the directory
	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The blake3 hash of a Directory message, serialized in protobuf canonical form.
	Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	// Number of child elements in the Directory referred to by `digest`.
	// Calculated by summing up the numbers of `directories`, `files` and
	// `symlinks`, and for each directory, its size field. Used for inode number
	// calculation.
	// This field is precisely as verifiable as any other Merkle tree edge.
	// Resolve `digest`, and you can compute it incrementally. Resolve the entire
	// tree, and you can fully compute it from scratch.
	// A credulous implementation won't reject an excessive size, but this is
	// harmless: you'll have some ordinals without nodes. Undersizing is obvious
	// and easy to reject: you won't have an ordinal for some nodes.
	Size uint64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	// contains filtered or unexported fields
}

type DirectoryServiceClient interface {
	// Get retrieves a stream of Directory messages, by using the lookup
	// parameters in GetDirectoryRequest.
	// Keep in mind multiple DirectoryNodes in different parts of the graph might
	// have the same digest if they have the same underlying contents,
	// so sending subsequent ones can be omitted.
	//
	// It is okay for certain implementations to only allow retrieval of
	// Directory digests that are at the "root", aka the last element that's
	// sent in a Put. This makes sense for implementations bundling closures of
	// directories together in batches.
	Get(ctx context.Context, in *GetDirectoryRequest, opts ...grpc.CallOption) (DirectoryService_GetClient, error)
	// Put uploads a graph of Directory messages.
	// Individual Directory messages need to be send in an order walking up
	// from the leaves to the root - a Directory message can only refer to
	// Directory messages previously sent in the same stream.
	// Keep in mind multiple DirectoryNodes in different parts of the graph might
	// have the same digest if they have the same underlying contents,
	// so sending subsequent ones can be omitted.
	// We might add a separate method, allowing to send partial graphs at a later
	// time, if requiring to send the full graph turns out to be a problem.
	Put(ctx context.Context, opts ...grpc.CallOption) (DirectoryService_PutClient, error)
}

type DirectoryServiceServer interface {
	// Get retrieves a stream of Directory messages, by using the lookup
	// parameters in GetDirectoryRequest.
	// Keep in mind multiple DirectoryNodes in different parts of the graph might
	// have the same digest if they have the same underlying contents,
	// so sending subsequent ones can be omitted.
	//
	// It is okay for certain implementations to only allow retrieval of
	// Directory digests that are at the "root", aka the last element that's
	// sent in a Put. This makes sense for implementations bundling closures of
	// directories together in batches.
	Get(*GetDirectoryRequest, DirectoryService_GetServer) error
	// Put uploads a graph of Directory messages.
	// Individual Directory messages need to be send in an order walking up
	// from the leaves to the root - a Directory message can only refer to
	// Directory messages previously sent in the same stream.
	// Keep in mind multiple DirectoryNodes in different parts of the graph might
	// have the same digest if they have the same underlying contents,
	// so sending subsequent ones can be omitted.
	// We might add a separate method, allowing to send partial graphs at a later
	// time, if requiring to send the full graph turns out to be a problem.
	Put(DirectoryService_PutServer) error
	// contains filtered or unexported methods
}

type DirectoryService_GetClient interface {
	Recv() (*Directory, error)
	grpc.ClientStream
}

type DirectoryService_GetServer interface {
	Send(*Directory) error
	grpc.ServerStream
}

type DirectoryService_PutClient interface {
	Send(*Directory) error
	CloseAndRecv() (*PutDirectoryResponse, error)
	grpc.ClientStream
}

type DirectoryService_PutServer interface {
	SendAndClose(*PutDirectoryResponse) error
	Recv() (*Directory, error)
	grpc.ServerStream
}

type FileNode struct {

	// The (base)name of the file
	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The blake3 digest of the file contents
	Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	// The file content size
	Size uint64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	// Whether the file is executable
	Executable bool `protobuf:"varint,4,opt,name=executable,proto3" json:"executable,omitempty"`
	// contains filtered or unexported fields
}

type GetDirectoryRequest struct {

	// Types that are assignable to ByWhat:
	//
	//	*GetDirectoryRequest_Digest
	ByWhat isGetDirectoryRequest_ByWhat `protobuf_oneof:"by_what"`
	// If set to true, recursively resolve all child Directory messages.
	// Directory messages SHOULD be streamed in a recursive breadth-first walk,
	// but other orders are also fine, as long as Directory messages are only
	// sent after they are referred to from previously sent Directory messages.
	Recursive bool `protobuf:"varint,2,opt,name=recursive,proto3" json:"recursive,omitempty"`
	// contains filtered or unexported fields
}

type GetDirectoryRequest_Digest struct {
	// The blake3 hash of the (root) Directory message, serialized in
	// protobuf canonical form.
	// Keep in mind this can be a subtree of another root.
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3,oneof"`
}

type Node struct {

	// Types that are assignable to Node:
	//
	//	*Node_Directory
	//	*Node_File
	//	*Node_Symlink
	Node isNode_Node `protobuf_oneof:"node"`
	// contains filtered or unexported fields
}

type Node_Directory struct {
	Directory *DirectoryNode `protobuf:"bytes,1,opt,name=directory,proto3,oneof"`
}

type Node_File struct {
	File *FileNode `protobuf:"bytes,2,opt,name=file,proto3,oneof"`
}

type Node_Symlink struct {
	Symlink *SymlinkNode `protobuf:"bytes,3,opt,name=symlink,proto3,oneof"`
}

type PutBlobResponse struct {

	// The blake3 digest of the data that was sent.
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// contains filtered or unexported fields
}

type PutDirectoryResponse struct {
	RootDigest []byte `protobuf:"bytes,1,opt,name=root_digest,json=rootDigest,proto3" json:"root_digest,omitempty"`
	// contains filtered or unexported fields
}

type ReadBlobRequest struct {

	// The blake3 digest of the blob or chunk requested
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// contains filtered or unexported fields
}

type StatBlobRequest struct {

	// The blake3 digest of the blob requested
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// Whether the server should reply with a list of more granular chunks.
	SendChunks bool `protobuf:"varint,2,opt,name=send_chunks,json=sendChunks,proto3" json:"send_chunks,omitempty"`
	// Whether the server should reply with a bao.
	SendBao bool `protobuf:"varint,3,opt,name=send_bao,json=sendBao,proto3" json:"send_bao,omitempty"`
	// contains filtered or unexported fields
}

type StatBlobResponse struct {

	// If `send_chunks` was set to true, this MAY contain a list of more
	// granular chunks, which then may be read individually via the `Read`
	// method.
	Chunks []*StatBlobResponse_ChunkMeta `protobuf:"bytes,2,rep,name=chunks,proto3" json:"chunks,omitempty"`
	// If `send_bao` was set to true, this MAY contain a outboard bao.
	// The exact format and message types here will still be fleshed out.
	Bao []byte `protobuf:"bytes,3,opt,name=bao,proto3" json:"bao,omitempty"`
	// contains filtered or unexported fields
}

type StatBlobResponse_ChunkMeta struct {

	// Digest of that specific chunk
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	// Length of that chunk, in bytes.
	Size uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// contains filtered or unexported fields
}

type SymlinkNode struct {

	// The (base)name of the symlink
	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The target of the symlink.
	Target []byte `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedBlobServiceServer struct {
}

type UnimplementedDirectoryServiceServer struct {
}

type UnsafeBlobServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeDirectoryServiceServer interface {
	// contains filtered or unexported methods
}