commands

package
v0.0.1 Latest Latest
Warning

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

 Go to latest Published: Mar 2, 2023 License: MIT Imports: 31 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrBanListMappingNotFound = errors.New("ban list mapping not found")
View Source 
var ErrRoomAliasAlreadyTaken = errors.New("alias is already taken")

Functions

This section is empty.

Types

type AcceptNewPeerHandler 

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

func NewAcceptNewPeerHandler 

func NewAcceptNewPeerHandler(
	peerManager PeerManager,
	messageReplicator MessageReplicator,
	blobReplicator BlobReplicator,
	roomScanner RoomScanner,
	logger logging.Logger,
) *AcceptNewPeerHandler

func (*AcceptNewPeerHandler) Handle 

func (h *AcceptNewPeerHandler) Handle(ctx context.Context, peer transport.Peer)

type AcceptTunnelConnect 

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

func NewAcceptTunnelConnect 

func NewAcceptTunnelConnect(origin refs.Identity, target refs.Identity, portal refs.Identity, rwc io.ReadWriteCloser) (AcceptTunnelConnect, error)

func (AcceptTunnelConnect) IsZero 

func (a AcceptTunnelConnect) IsZero() bool

func (AcceptTunnelConnect) Origin 

func (a AcceptTunnelConnect) Origin() refs.Identity

func (AcceptTunnelConnect) Portal 

func (a AcceptTunnelConnect) Portal() refs.Identity

func (AcceptTunnelConnect) Rwc 

func (a AcceptTunnelConnect) Rwc() io.ReadWriteCloser

func (AcceptTunnelConnect) Target 

func (a AcceptTunnelConnect) Target() refs.Identity

type AcceptTunnelConnectHandler 

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

func NewAcceptTunnelConnectHandler 

func NewAcceptTunnelConnectHandler(
	local identity.Public,
	initializer ServerPeerInitializer,
) *AcceptTunnelConnectHandler

func (*AcceptTunnelConnectHandler) Handle 

func (h *AcceptTunnelConnectHandler) Handle(ctx context.Context, cmd AcceptTunnelConnect) error

type Adapters 

type Adapters struct {
	Feed         FeedRepository
	ReceiveLog   ReceiveLogRepository
	SocialGraph  SocialGraphRepository
	BlobWantList BlobWantListRepository
	FeedWantList FeedWantListRepository
	BanList      BanListRepository
}

type AddToBanList 

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

func NewAddToBanList 

func NewAddToBanList(hash bans.Hash) (AddToBanList, error)

func (AddToBanList) IsZero 

func (c AddToBanList) IsZero() bool

type AddToBanListHandler 

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

func NewAddToBanListHandler 

func NewAddToBanListHandler(
	transaction TransactionProvider,
) *AddToBanListHandler

func (*AddToBanListHandler) Handle 

func (h *AddToBanListHandler) Handle(cmd AddToBanList) error

type BanListRepository 

type BanListRepository interface {
	// Add adds a hash to the ban list.
	Add(hash bans.Hash) error

	// Remove removes a hash from the ban list. If a hash isn't in the ban list
	// no errors are returned.
	Remove(hash bans.Hash) error

	// Clear removes all entries from the ban list.
	Clear() error

	// ContainsFeed checks if the particular feed is banned.
	ContainsFeed(feed refs.Feed) (bool, error)

	// LookupMapping returns ErrBanListMappingNotFound error if a ref can not be
	// found.
	LookupMapping(hash bans.Hash) (BannableRef, error)
}

type BannableRef 

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

BannableRef wraps a feed ref.

func NewBannableRef 

func NewBannableRef(v any) (BannableRef, error)

func (*BannableRef) Value 

func (b *BannableRef) Value() any

type BlobCreator 

type BlobCreator interface {
	Create(r io.Reader) (refs.Blob, error)
}

type BlobReplicationManager 

type BlobReplicationManager interface {
	HandleIncomingCreateWantsRequest(ctx context.Context) (<-chan messages.BlobWithSizeOrWantDistance, error)
}

type BlobReplicator 

type BlobReplicator interface {
	Replicate(ctx context.Context, peer transport.Peer) error
}

type BlobWantListRepository 

type BlobWantListRepository interface {
	// Add puts the blob in the want list. If the blob can't be retrieved before
	// the specified point of time it will be removed from the want list.
	Add(id refs.Blob, until time.Time) error
}

type Connect 

type Connect struct {
	// Remote is the identity of the remote node.
	Remote identity.Public

	// Address is the address of the remote node.
	Address network.Address
}

Connect tries to initiate the connection to the specified node. This is most likely useful when you want to explicitly stimulate the program to talk to a specific node. Normally connections are initiated and managed automatically. Executing this command doesn't necessarily mean that a new connection will be established, for example the underlying implementation may decide not to do this if the connection with the specified identity already exists.

type ConnectHandler 

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

func NewConnectHandler 

func NewConnectHandler(
	peerManager PeerManager,
	logger logging.Logger,
) *ConnectHandler

func (*ConnectHandler) Handle 

func (h *ConnectHandler) Handle(ctx context.Context, cmd Connect) error

type ContentParser 

type ContentParser interface {
	Parse(raw message.RawContent) (message.Content, error)
}

type CreateBlob 

type CreateBlob struct {
	Reader io.Reader
}

type CreateBlobHandler 

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

func NewCreateBlobHandler 

func NewCreateBlobHandler(
	creator BlobCreator,
) *CreateBlobHandler

func (*CreateBlobHandler) Handle 

func (h *CreateBlobHandler) Handle(cmd CreateBlob) (refs.Blob, error)

type CreateWants 

type CreateWants struct {
}

type CreateWantsHandler 

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

func NewCreateWantsHandler 

func NewCreateWantsHandler(manager BlobReplicationManager) *CreateWantsHandler

func (*CreateWantsHandler) Handle 

func (h *CreateWantsHandler) Handle(ctx context.Context, cmd CreateWants) (<-chan messages.BlobWithSizeOrWantDistance, error)

type CurrentTimeProvider 

type CurrentTimeProvider interface {
	Get() time.Time
}

type DeleteGoSSBRepositoryInOldFormat 

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

func NewDeleteGoSSBRepositoryInOldFormat 

func NewDeleteGoSSBRepositoryInOldFormat(
	directory string,
) (DeleteGoSSBRepositoryInOldFormat, error)

func (DeleteGoSSBRepositoryInOldFormat) IsZero 

func (cmd DeleteGoSSBRepositoryInOldFormat) IsZero() bool

type Dialer 

type Dialer interface {
	DialWithInitializer(ctx context.Context, initializer network.ClientPeerInitializer, remote identity.Public, addr network.Address) (transport.Peer, error)
	Dial(ctx context.Context, remote identity.Public, address network.Address) (transport.Peer, error)
}

type DisconnectAllHandler 

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

func NewDisconnectAllHandler 

func NewDisconnectAllHandler(peerManager PeerManager) *DisconnectAllHandler

func (*DisconnectAllHandler) Handle 

func (h *DisconnectAllHandler) Handle() error

type DownloadBlob 

type DownloadBlob struct {
	Id refs.Blob
}

type DownloadBlobHandler 

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

func NewDownloadBlobHandler 

func NewDownloadBlobHandler(
	transaction TransactionProvider,
	currentTimeProvider CurrentTimeProvider,
) *DownloadBlobHandler

func (*DownloadBlobHandler) Handle 

func (h *DownloadBlobHandler) Handle(cmd DownloadBlob) error

type DownloadFeed 

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

func NewDownloadFeed 

func NewDownloadFeed(id refs.Feed) (DownloadFeed, error)

func (DownloadFeed) Id 

func (d DownloadFeed) Id() refs.Feed

func (DownloadFeed) IsZero 

func (d DownloadFeed) IsZero() bool

type DownloadFeedHandler 

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

func NewDownloadFeedHandler 

func NewDownloadFeedHandler(
	transaction TransactionProvider,
	currentTimeProvider CurrentTimeProvider,
) *DownloadFeedHandler

func (*DownloadFeedHandler) Handle 

func (h *DownloadFeedHandler) Handle(cmd DownloadFeed) error

type EstablishNewConnectionsHandler 

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

func NewEstablishNewConnectionsHandler 

func NewEstablishNewConnectionsHandler(
	peerManager PeerManager,
) *EstablishNewConnectionsHandler

func (*EstablishNewConnectionsHandler) Handle 

func (h *EstablishNewConnectionsHandler) Handle(ctx context.Context) error

type FeedRepository 

type FeedRepository interface {
	// UpdateFeed updates the specified feed by calling the provided function on
	// it. Feed is never nil.
	UpdateFeed(ref refs.Feed, f UpdateFeedFn) error

	// UpdateFeedIgnoringReceiveLog works like UpdateFeed but doesn't put
	// messages in receive log.
	UpdateFeedIgnoringReceiveLog(ref refs.Feed, f UpdateFeedFn) error

	// DeleteFeed removes the feed with all associated data.
	DeleteFeed(ref refs.Feed) error

	// GetMessage returns a message with a given sequence from the specified
	// feed.
	GetMessage(ref refs.Feed, sequence message.Sequence) (message.Message, error)

	// RemoveMessagesAtOrAboveSequence removes all feed messages with sequence
	// greater or equal to the given one.
	RemoveMessagesAtOrAboveSequence(ref refs.Feed, sequence message.Sequence) error
}

type FeedWantListRepository 

type FeedWantListRepository interface {
	// Add puts the feed in the want list. The entry is removed after the
	// specified amount of time.
	Add(id refs.Feed, until time.Time) error

	List() ([]refs.Feed, error)

	Contains(id refs.Feed) (bool, error)
}

FeedWantListRepository adds a way to temporarily add feeds to the list of replicated feeds. Those feeds will be replicated even if they are not in the social graph.

type Follow 

type Follow struct {
	Target refs.Identity
}

type FollowHandler 

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

func NewFollowHandler 

func NewFollowHandler(
	transaction TransactionProvider,
	local identity.Private,
	marshaler content.Marshaler,
	logger logging.Logger,
) *FollowHandler

func (*FollowHandler) Handle 

func (h *FollowHandler) Handle(cmd Follow) error

type ForkedFeedTracker 

type ForkedFeedTracker interface {
	AddForkedFeed(replicatedFrom identity.Public, feed refs.Feed)
}

type GoSSBMessage 

type GoSSBMessage struct {
	ReceiveLogSequence common.ReceiveLogSequence
	Message            gossbrefs.Message
}

type GoSSBMessageOrError 

type GoSSBMessageOrError struct {
	Value GoSSBMessage
	Err   error
}

type GoSSBRepoReader 

type GoSSBRepoReader interface {
	// GetMessages returns a channel on which receive log messages will be sent
	// ordered by their receive log sequence. Some messages may be missing. If
	// the provided value is not nil it will resume from the provided sequence.
	GetMessages(ctx context.Context, directory string, resumeFromSequence *common.ReceiveLogSequence) (<-chan GoSSBMessageOrError, error)
}

type HandleIncomingEbtReplicate 

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

func NewHandleIncomingEbtReplicate 

func NewHandleIncomingEbtReplicate(version int, format messages.EbtReplicateFormat, stream ebt.Stream) (HandleIncomingEbtReplicate, error)

func (HandleIncomingEbtReplicate) Format 

func (cmd HandleIncomingEbtReplicate) Format() messages.EbtReplicateFormat

func (HandleIncomingEbtReplicate) IsZero 

func (cmd HandleIncomingEbtReplicate) IsZero() bool

func (HandleIncomingEbtReplicate) Stream 

func (cmd HandleIncomingEbtReplicate) Stream() ebt.Stream

func (HandleIncomingEbtReplicate) Version 

func (cmd HandleIncomingEbtReplicate) Version() int

type HandleIncomingEbtReplicateHandler 

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

func NewHandleIncomingEbtReplicateHandler 

func NewHandleIncomingEbtReplicateHandler(replicator ebt.Replicator) *HandleIncomingEbtReplicateHandler

func (*HandleIncomingEbtReplicateHandler) Handle 

func (h *HandleIncomingEbtReplicateHandler) Handle(ctx context.Context, cmd HandleIncomingEbtReplicate) error

type ImportDataFromGoSSB 

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

func NewImportDataFromGoSSB 

func NewImportDataFromGoSSB(
	directory string,
	resumeFromSequence *common.ReceiveLogSequence,
	saveResumeFromSequenceFn SaveResumeFromSequenceFn,
) (ImportDataFromGoSSB, error)

func (ImportDataFromGoSSB) IsZero 

func (cmd ImportDataFromGoSSB) IsZero() bool

type ImportDataFromGoSSBResult 

type ImportDataFromGoSSBResult struct {
	Successes int
	Errors    int
}

type InviteRedeemer 

type InviteRedeemer interface {
	RedeemInvite(ctx context.Context, invite invites.Invite, target identity.Public) error
}

type MessageBuffer 

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

func NewMessageBuffer 

func NewMessageBuffer(
	transaction TransactionProvider,
	identifier RawMessageIdentifier,
	forkedFeedTracker ForkedFeedTracker,
	logger logging.Logger,
) *MessageBuffer

func (*MessageBuffer) Handle 

func (m *MessageBuffer) Handle(replicatedFrom identity.Public, rawMsg message.RawMessage) error

func (*MessageBuffer) Run 

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

type MessageReplicator 

type MessageReplicator interface {
	Replicate(ctx context.Context, peer transport.Peer) error
}

type MigrationHandlerDeleteGoSSBRepositoryInOldFormat 

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

func NewMigrationHandlerDeleteGoSSBRepositoryInOldFormat 

func NewMigrationHandlerDeleteGoSSBRepositoryInOldFormat(
	repoReader GoSSBRepoReader,
	logger logging.Logger,
) *MigrationHandlerDeleteGoSSBRepositoryInOldFormat

func (MigrationHandlerDeleteGoSSBRepositoryInOldFormat) Handle 

func (h MigrationHandlerDeleteGoSSBRepositoryInOldFormat) Handle(ctx context.Context, cmd DeleteGoSSBRepositoryInOldFormat) error

type MigrationHandlerImportDataFromGoSSB 

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

func NewMigrationHandlerImportDataFromGoSSB 

func NewMigrationHandlerImportDataFromGoSSB(
	repoReader GoSSBRepoReader,
	transaction TransactionProvider,
	contentParser ContentParser,
	logger logging.Logger,
) *MigrationHandlerImportDataFromGoSSB

func (MigrationHandlerImportDataFromGoSSB) Handle 

func (h MigrationHandlerImportDataFromGoSSB) Handle(ctx context.Context, cmd ImportDataFromGoSSB) (ImportDataFromGoSSBResult, error)

type Migrations 

type Migrations struct {
	MigrationDeleteGoSSBRepositoryInOldFormat *MigrationHandlerDeleteGoSSBRepositoryInOldFormat
	MigrationImportDataFromGoSSB              *MigrationHandlerImportDataFromGoSSB
}

type MigrationsRunner 

type MigrationsRunner interface {
	Run(ctx context.Context, migrations migrations.Migrations, progressCallback migrations.ProgressCallback) error
}

type PeerManager 

type PeerManager interface {
	// Connect instructs the peer manager that it should establish
	// communications with the specified node. The peer manager may ignore this
	// request under specific circumstances e.g. it may avoid establishing
	// duplicate connections to a single identity.
	Connect(ctx context.Context, remote identity.Public, address network.Address) error

	// ConnectViaRoom instructs the peer manager that it should establish
	// communications with the specified node using a room as a relay. Behaves
	// like Connect.
	ConnectViaRoom(ctx context.Context, portal transport.Peer, target identity.Public) error

	// EstablishNewConnections instructs the peer manager that it is time to
	// establish new connections so that the specific connections quotas are
	// met.
	EstablishNewConnections(ctx context.Context) error

	// ProcessNewLocalDiscovery informs the peer manager about a new local
	// discovery.
	ProcessNewLocalDiscovery(ctx context.Context, remote identity.Public, address network.Address) error

	// DisconnectAll disconnects all peers.
	DisconnectAll() error

	TrackPeer(ctx context.Context, peer transport.Peer)
}

type ProcessNewLocalDiscovery 

type ProcessNewLocalDiscovery struct {
	Remote  identity.Public
	Address network.Address
}

type ProcessNewLocalDiscoveryHandler 

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

func NewProcessNewLocalDiscoveryHandler 

func NewProcessNewLocalDiscoveryHandler(peerManager PeerManager) *ProcessNewLocalDiscoveryHandler

func (*ProcessNewLocalDiscoveryHandler) Handle 

func (h *ProcessNewLocalDiscoveryHandler) Handle(ctx context.Context, cmd ProcessNewLocalDiscovery) error

type ProcessRoomAttendantEvent 

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

func NewProcessRoomAttendantEvent 

func NewProcessRoomAttendantEvent(
	portal transport.Peer,
	event rooms.RoomAttendantsEvent,
) (ProcessRoomAttendantEvent, error)

func (ProcessRoomAttendantEvent) Event 

func (e ProcessRoomAttendantEvent) Event() rooms.RoomAttendantsEvent

func (ProcessRoomAttendantEvent) IsZero 

func (e ProcessRoomAttendantEvent) IsZero() bool

func (ProcessRoomAttendantEvent) Portal 

func (e ProcessRoomAttendantEvent) Portal() transport.Peer

type ProcessRoomAttendantEventHandler 

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

func NewProcessRoomAttendantEventHandler 

func NewProcessRoomAttendantEventHandler(peerManager PeerManager) *ProcessRoomAttendantEventHandler

func (*ProcessRoomAttendantEventHandler) Handle 

func (h *ProcessRoomAttendantEventHandler) Handle(ctx context.Context, cmd ProcessRoomAttendantEvent) error

type PublishRaw 

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

func NewPublishRaw 

func NewPublishRaw(content []byte) (PublishRaw, error)

func (PublishRaw) IsZero 

func (cmd PublishRaw) IsZero() bool

type PublishRawAsIdentity 

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

func NewPublishRawAsIdentity 

func NewPublishRawAsIdentity(content []byte, identity identity.Private) (PublishRawAsIdentity, error)

func (PublishRawAsIdentity) IsZero 

func (cmd PublishRawAsIdentity) IsZero() bool

type PublishRawAsIdentityHandler 

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

func NewPublishRawAsIdentityHandler 

func NewPublishRawAsIdentityHandler(
	publisher RawMessagePublisher,
) *PublishRawAsIdentityHandler

func (*PublishRawAsIdentityHandler) Handle 

func (h *PublishRawAsIdentityHandler) Handle(cmd PublishRawAsIdentity) (refs.Message, error)

type PublishRawHandler 

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

func NewPublishRawHandler 

func NewPublishRawHandler(
	publisher RawMessagePublisher,
	local identity.Private,
) *PublishRawHandler

func (*PublishRawHandler) Handle 

func (h *PublishRawHandler) Handle(cmd PublishRaw) (refs.Message, error)

type RawMessageHandler 

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

func NewRawMessageHandler 

func NewRawMessageHandler(
	identifier RawMessageIdentifier,
	buffer *MessageBuffer,
	logger logging.Logger,
) *RawMessageHandler

func (*RawMessageHandler) Handle 

func (h *RawMessageHandler) Handle(replicatedFrom identity.Public, rawMsg message.RawMessage) error

type RawMessageIdentifier 

type RawMessageIdentifier interface {
	PeekRawMessage(raw message.RawMessage) (feeds.PeekedMessage, error)
	VerifyRawMessage(raw message.RawMessage) (message.Message, error)
}

type RawMessagePublisher 

type RawMessagePublisher interface {
	Publish(identity identity.Private, content message.RawContent) (refs.Message, error)
}

type ReceiveLogRepository 

type ReceiveLogRepository interface {
	PutUnderSpecificSequence(id refs.Message, sequence common.ReceiveLogSequence) error

	// ReserveSequencesUpTo ensures that sequences all the way to and including
	// the provided sequence will not be used for automatic sequence generation.
	ReserveSequencesUpTo(sequence common.ReceiveLogSequence) error

	// GetMessage returns the message that the provided receive log sequence
	// points to. Returns common.ErrReceiveLogEntryNotFound if not found.
	GetMessage(seq common.ReceiveLogSequence) (message.Message, error)
}

type RedeemInvite 

type RedeemInvite struct {
	Invite invites.Invite
}

type RedeemInviteHandler 

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

func NewRedeemInviteHandler 

func NewRedeemInviteHandler(
	redeemer InviteRedeemer,
	local identity.Private,
	logger logging.Logger,
) *RedeemInviteHandler

func (*RedeemInviteHandler) Handle 

func (h *RedeemInviteHandler) Handle(ctx context.Context, cmd RedeemInvite) error

type RemoveFromBanList 

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

func NewRemoveFromBanList 

func NewRemoveFromBanList(hash bans.Hash) (RemoveFromBanList, error)

func (RemoveFromBanList) IsZero 

func (c RemoveFromBanList) IsZero() bool

type RemoveFromBanListHandler 

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

func NewRemoveFromBanListHandler 

func NewRemoveFromBanListHandler(transaction TransactionProvider) *RemoveFromBanListHandler

func (*RemoveFromBanListHandler) Handle 

func (h *RemoveFromBanListHandler) Handle(cmd RemoveFromBanList) error

type RoomScanner 

type RoomScanner interface {
	Run(ctx context.Context, peer transport.Peer) error
}

type RoomsAliasRegister 

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

func NewRoomsAliasRegister 

func NewRoomsAliasRegister(
	room refs.Identity,
	address network.Address,
	alias aliases.Alias,
) (RoomsAliasRegister, error)

func (RoomsAliasRegister) Address 

func (r RoomsAliasRegister) Address() network.Address

func (RoomsAliasRegister) Alias 

func (r RoomsAliasRegister) Alias() aliases.Alias

func (RoomsAliasRegister) IsZero 

func (r RoomsAliasRegister) IsZero() bool

func (RoomsAliasRegister) Room 

func (r RoomsAliasRegister) Room() refs.Identity

type RoomsAliasRegisterHandler 

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

func NewRoomsAliasRegisterHandler 

func NewRoomsAliasRegisterHandler(
	dialer Dialer,
	local identity.Private,
) *RoomsAliasRegisterHandler

func (*RoomsAliasRegisterHandler) Handle 

func (h *RoomsAliasRegisterHandler) Handle(ctx context.Context, cmd RoomsAliasRegister) (aliases.AliasEndpointURL, error)

type RoomsAliasRevoke 

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

func NewRoomsAliasRevoke 

func NewRoomsAliasRevoke(
	room refs.Identity,
	address network.Address,
	alias aliases.Alias,
) (RoomsAliasRevoke, error)

func (RoomsAliasRevoke) Address 

func (r RoomsAliasRevoke) Address() network.Address

func (RoomsAliasRevoke) Alias 

func (r RoomsAliasRevoke) Alias() aliases.Alias

func (RoomsAliasRevoke) IsZero 

func (r RoomsAliasRevoke) IsZero() bool

func (RoomsAliasRevoke) Room 

func (r RoomsAliasRevoke) Room() refs.Identity

type RoomsAliasRevokeHandler 

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

func NewRoomsAliasRevokeHandler 

func NewRoomsAliasRevokeHandler(
	dialer Dialer,
) *RoomsAliasRevokeHandler

func (*RoomsAliasRevokeHandler) Handle 

func (h *RoomsAliasRevokeHandler) Handle(ctx context.Context, cmd RoomsAliasRevoke) error

type RunMigrations 

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

func NewRunMigrations 

func NewRunMigrations(progressCallback migrations.ProgressCallback) (RunMigrations, error)

func (RunMigrations) IsZero 

func (cmd RunMigrations) IsZero() bool

type RunMigrationsHandler 

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

func NewRunMigrationsHandler 

func NewRunMigrationsHandler(
	runner MigrationsRunner,
	migrations migrations.Migrations,
) *RunMigrationsHandler

func (RunMigrationsHandler) Run 

func (h RunMigrationsHandler) Run(ctx context.Context, cmd RunMigrations) error

type SaveResumeFromSequenceFn 

type SaveResumeFromSequenceFn func(common.ReceiveLogSequence) error

type ServerPeerInitializer 

type ServerPeerInitializer interface {
	InitializeServerPeer(ctx context.Context, rwc io.ReadWriteCloser) (transport.Peer, error)
}

type SetBanList 

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

func NewSetBanList 

func NewSetBanList(hashes []bans.Hash) (SetBanList, error)

type SetBanListHandler 

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

func NewSetBanListHandler 

func NewSetBanListHandler(transaction TransactionProvider) *SetBanListHandler

func (*SetBanListHandler) Handle 

func (h *SetBanListHandler) Handle(cmd SetBanList) error

type SocialGraphRepository 

type SocialGraphRepository interface {
	GetSocialGraphBuilder() (*graph.SocialGraphBuilder, error)
}

type TransactionProvider 

type TransactionProvider interface {
	Transact(func(adapters Adapters) error) error
}

type TransactionRawMessagePublisher 

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

func NewTransactionRawMessagePublisher 

func NewTransactionRawMessagePublisher(transaction TransactionProvider) *TransactionRawMessagePublisher

func (*TransactionRawMessagePublisher) Publish 

func (h *TransactionRawMessagePublisher) Publish(identity identity.Private, content message.RawContent) (refs.Message, error)

type UpdateFeedFn 

type UpdateFeedFn func(feed *feeds.Feed) error

Source Files

View all Source files

Directories

Path Synopsis

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.