server

package
v0.0.0-...-f1c747c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 11, 2017 License: Apache-2.0 Imports: 32 Imported by: 0

Documentation

Overview

Package server holds code for core Trillian servers.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AnnounceSelf 

func AnnounceSelf(ctx context.Context, etcdServers, etcdService, endpoint string) func()

AnnounceSelf announces this binary's presence to etcd. Returns a function that should be called on process exit.

Types

type LogOperation 

type LogOperation interface {
	// Name returns the name of the task.
	Name() string
	// ExecutePass performs a single pass of processing on a single log.  It returns
	// a count of items processed (for logging) and an error.
	ExecutePass(ctx context.Context, logID int64, info *LogOperationInfo) (int, error)
}

LogOperation defines a task that operates on a log. Examples are scheduling, signing, consistency checking or cleanup.

type LogOperationInfo 

type LogOperationInfo struct {
	// Registry provides access to Trillian storage.
	Registry extension.Registry

	// BatchSize is the processing batch size to be passed to tasks run by this manager
	BatchSize int
	// TimeSource should be used by the LogOperation to allow mocking for tests.
	TimeSource util.TimeSource

	// RunInterval is the time between starting batches of processing.  If a
	// batch takes longer than this interval to complete, the next batch
	// will start immediately.
	RunInterval time.Duration
	// PreElectionPause is the maximum interval to wait before starting a
	// mastership election for a particular log.
	PreElectionPause time.Duration
	// MasterCheckInterval is the interval between checks that we still
	// hold mastership for a log.
	MasterCheckInterval time.Duration
	// MasterHoldInterval is the minimum interval to hold mastership for.
	MasterHoldInterval time.Duration
	// ResignOdds gives the chance of resigning mastership after each
	// check interval, as the N for 1-in-N.
	ResignOdds int
	// NumWorkers is the number of worker goroutines to run in parallel.
	NumWorkers int
}

LogOperationInfo bundles up information needed for running a set of LogOperations.

type LogOperationManager 

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

LogOperationManager controls scheduling activities for logs.

func NewLogOperationManager 

func NewLogOperationManager(info LogOperationInfo, logOperation LogOperation) *LogOperationManager

NewLogOperationManager creates a new LogOperationManager instance.

func (*LogOperationManager) OperationLoop 

func (l *LogOperationManager) OperationLoop(ctx context.Context)

OperationLoop starts the manager working. It continues until told to exit. TODO(Martin2112): No mechanism for error reporting etc., this is OK for v1 but needs work

func (*LogOperationManager) OperationSingle 

func (l *LogOperationManager) OperationSingle(ctx context.Context)

OperationSingle performs a single pass of the manager.

type Main 

type Main struct {
	// Endpoints for RPC and HTTP/REST servers.
	// HTTP/REST is optional, if empty it'll not be bound.
	RPCEndpoint, HTTPEndpoint string
	Registry                  extension.Registry
	Server                    *grpc.Server
	// RegisterHandlerFn is called to register REST-proxy handlers.
	RegisterHandlerFn func(context.Context, *runtime.ServeMux, string, []grpc.DialOption) error
	// RegisterServerFn is called to register RPC servers.
	RegisterServerFn func(*grpc.Server, extension.Registry) error
}

Main encapsulates the data and logic to start a Trillian server (Log or Map).

func (*Main) Run 

func (m *Main) Run(ctx context.Context) error

Run starts the configured server. Blocks until the server exits.

type MockLogOperation 

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

Mock of LogOperation interface

func NewMockLogOperation 

func NewMockLogOperation(ctrl *gomock.Controller) *MockLogOperation

func (*MockLogOperation) EXPECT 

func (_m *MockLogOperation) EXPECT() *_MockLogOperationRecorder

func (*MockLogOperation) ExecutePass 

func (_m *MockLogOperation) ExecutePass(_param0 context.Context, _param1 int64, _param2 *LogOperationInfo) (int, error)

func (*MockLogOperation) Name 

func (_m *MockLogOperation) Name() string

type SequencerManager 

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

SequencerManager provides sequencing operations for a collection of Logs.

func NewSequencerManager 

func NewSequencerManager(registry extension.Registry, gw time.Duration) *SequencerManager

NewSequencerManager creates a new SequencerManager instance based on the provided KeyManager instance and guard window.

func (*SequencerManager) ExecutePass 

func (s *SequencerManager) ExecutePass(ctx context.Context, logID int64, info *LogOperationInfo) (int, error)

ExecutePass performs sequencing for the specified Log.

func (*SequencerManager) Name 

func (s *SequencerManager) Name() string

Name returns the name of the object.

type TrillianLogRPCServer 

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

TrillianLogRPCServer implements the RPC API defined in the proto

func NewTrillianLogRPCServer 

func NewTrillianLogRPCServer(registry extension.Registry, timeSource util.TimeSource) *TrillianLogRPCServer

NewTrillianLogRPCServer creates a new RPC server backed by a LogStorageProvider.

func (*TrillianLogRPCServer) GetConsistencyProof 

func (t *TrillianLogRPCServer) GetConsistencyProof(ctx context.Context, req *trillian.GetConsistencyProofRequest) (*trillian.GetConsistencyProofResponse, error)

GetConsistencyProof obtains a proof that two versions of the tree are consistent with each other and that the later tree includes all the entries of the prior one. For more details see the example trees in RFC 6962.

func (*TrillianLogRPCServer) GetEntryAndProof 

func (t *TrillianLogRPCServer) GetEntryAndProof(ctx context.Context, req *trillian.GetEntryAndProofRequest) (*trillian.GetEntryAndProofResponse, error)

GetEntryAndProof returns both a Merkle Leaf entry and an inclusion proof for a given index and tree size.

func (*TrillianLogRPCServer) GetInclusionProof 

func (t *TrillianLogRPCServer) GetInclusionProof(ctx context.Context, req *trillian.GetInclusionProofRequest) (*trillian.GetInclusionProofResponse, error)

GetInclusionProof obtains the proof of inclusion in the tree for a leaf that has been sequenced. Similar to the get proof by hash handler but one less step as we don't need to look up the index

func (*TrillianLogRPCServer) GetInclusionProofByHash 

func (t *TrillianLogRPCServer) GetInclusionProofByHash(ctx context.Context, req *trillian.GetInclusionProofByHashRequest) (*trillian.GetInclusionProofByHashResponse, error)

GetInclusionProofByHash obtains proofs of inclusion by leaf hash. Because some logs can contain duplicate hashes it is possible for multiple proofs to be returned.

func (*TrillianLogRPCServer) GetLatestSignedLogRoot 

func (t *TrillianLogRPCServer) GetLatestSignedLogRoot(ctx context.Context, req *trillian.GetLatestSignedLogRootRequest) (*trillian.GetLatestSignedLogRootResponse, error)

GetLatestSignedLogRoot obtains the latest published tree root for the Merkle Tree that underlies the log.

func (*TrillianLogRPCServer) GetLeavesByHash 

func (t *TrillianLogRPCServer) GetLeavesByHash(ctx context.Context, req *trillian.GetLeavesByHashRequest) (*trillian.GetLeavesByHashResponse, error)

GetLeavesByHash obtains one or more leaves based on their tree hash. It is not possible to fetch leaves that have been queued but not yet integrated. Logs may accept duplicate entries so this may return more results than the number of hashes in the request.

func (*TrillianLogRPCServer) GetLeavesByIndex 

func (t *TrillianLogRPCServer) GetLeavesByIndex(ctx context.Context, req *trillian.GetLeavesByIndexRequest) (*trillian.GetLeavesByIndexResponse, error)

GetLeavesByIndex obtains one or more leaves based on their sequence number within the tree. It is not possible to fetch leaves that have been queued but not yet integrated. TODO: Validate indices against published tree size in case we implement write sharding that can get ahead of this point. Not currently clear what component should own this state.

func (*TrillianLogRPCServer) GetSequencedLeafCount 

func (t *TrillianLogRPCServer) GetSequencedLeafCount(ctx context.Context, req *trillian.GetSequencedLeafCountRequest) (*trillian.GetSequencedLeafCountResponse, error)

GetSequencedLeafCount returns the number of leaves that have been integrated into the Merkle Tree. This can be zero for a log containing no entries.

func (*TrillianLogRPCServer) IsHealthy 

func (t *TrillianLogRPCServer) IsHealthy() error

IsHealthy returns nil if the server is healthy, error otherwise.

func (*TrillianLogRPCServer) QueueLeaf 

func (t *TrillianLogRPCServer) QueueLeaf(ctx context.Context, req *trillian.QueueLeafRequest) (*trillian.QueueLeafResponse, error)

QueueLeaf submits one leaf to the queue.

func (*TrillianLogRPCServer) QueueLeaves 

func (t *TrillianLogRPCServer) QueueLeaves(ctx context.Context, req *trillian.QueueLeavesRequest) (*trillian.QueueLeavesResponse, error)

QueueLeaves submits a batch of leaves to the log for later integration into the underlying tree.

type TrillianMapServer 

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

TrillianMapServer implements the RPC API defined in the proto

func NewTrillianMapServer 

func NewTrillianMapServer(registry extension.Registry) *TrillianMapServer

NewTrillianMapServer creates a new RPC server backed by registry

func (*TrillianMapServer) GetLeaves 

func (t *TrillianMapServer) GetLeaves(ctx context.Context, req *trillian.GetMapLeavesRequest) (*trillian.GetMapLeavesResponse, error)

GetLeaves implements the GetLeaves RPC method. Each requested index will return an inclusion proof to either the leaf, or nil if the leaf does not exist.

func (*TrillianMapServer) GetSignedMapRoot 

func (t *TrillianMapServer) GetSignedMapRoot(ctx context.Context, req *trillian.GetSignedMapRootRequest) (*trillian.GetSignedMapRootResponse, error)

GetSignedMapRoot implements the GetSignedMapRoot RPC method.

func (*TrillianMapServer) GetSignedMapRootByRevision 

func (t *TrillianMapServer) GetSignedMapRootByRevision(ctx context.Context, req *trillian.GetSignedMapRootByRevisionRequest) (*trillian.GetSignedMapRootResponse, error)

GetSignedMapRootByRevision implements the GetSignedMapRootByRevision RPC method.

func (*TrillianMapServer) IsHealthy 

func (t *TrillianMapServer) IsHealthy() error

IsHealthy returns nil if the server is healthy, error otherwise.

func (*TrillianMapServer) SetLeaves 

func (t *TrillianMapServer) SetLeaves(ctx context.Context, req *trillian.SetMapLeavesRequest) (*trillian.SetMapLeavesResponse, error)

SetLeaves implements the SetLeaves RPC method.

Source Files

View all Source files

Directories

Path Synopsis
Package admin contains the TrillianAdminServer implementation.
 Package admin contains the TrillianAdminServer implementation.
Package errors contains utilities to translate TrillianErrors to gRPC errors.
 Package errors contains utilities to translate TrillianErrors to gRPC errors.
Package interceptor defines gRPC interceptors for Trillian.
 Package interceptor defines gRPC interceptors for Trillian.
The trillian_log_server binary runs the Trillian log server, and also provides an admin server.
 The trillian_log_server binary runs the Trillian log server, and also provides an admin server.
The trillian_log_signer binary runs the log signing code.
 The trillian_log_signer binary runs the log signing code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.