ctrl

Documentation

Index

• Variables
• type BootstrapController
  • func NewBootstrapController(wg WireGuardClient, config *config.Config, devices DeviceRepository, ...) *BootstrapController
  • func (ctrl *BootstrapController) Execute(ctx context.Context)
• type DeviceRepository
• type EndpointDecryptRequest
• type EndpointDecryptResponse
• type EndpointDecryptor
• type EndpointEncryptRequest
• type EndpointEncryptResponse
• type EndpointEncryptor
• type EstablishController
  • func NewEstablishController(ctrl *wgctrl.Client, devices DeviceRepository, peers PeerRepository, ...) *EstablishController
  • func (c *EstablishController) Execute(ctx context.Context, peerId entity.PeerId)
• type PeerRepository
• type PublishController
  • func NewPublishController(devices DeviceRepository, peers PeerRepository, store plugin.Store, ...) *PublishController
  • func (c *PublishController) Execute(ctx context.Context)
• type RefreshController
  • func NewRefreshController(peers PeerRepository, queue RefreshQueue, logger *zerolog.Logger) *RefreshController
  • func (c *RefreshController) Execute(ctx context.Context)
• type RefreshQueue
• type StunResolver
• type WireGuardClient

Variables

var DefaultSet = wire.NewSet(
	NewBootstrapController,
	NewPublishController,
	NewEstablishController,
	NewRefreshController,
)

Types

type BootstrapController

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

func NewBootstrapController

func NewBootstrapController(wg WireGuardClient, config *config.Config, devices DeviceRepository, peers PeerRepository, logger *zerolog.Logger, filterService *entity.FilterPeerService) *BootstrapController

func (*BootstrapController) Execute

func (ctrl *BootstrapController) Execute(ctx context.Context)

type DeviceRepository

type DeviceRepository interface {
	List(ctx context.Context) ([]*entity.Device, error)
	Find(ctx context.Context, name entity.DeviceId) (*entity.Device, error)
	Save(ctx context.Context, device *entity.Device)
}

type EndpointDecryptRequest

type EndpointDecryptRequest struct {
	PeerPublicKey [32]byte
	PrivateKey    [32]byte
	Data          string
}

type EndpointDecryptResponse

type EndpointDecryptResponse struct {
	Host string
	Port int
}

type EndpointDecryptor

type EndpointDecryptor interface {
	Decrypt(ctx context.Context, input *EndpointDecryptRequest) (*EndpointDecryptResponse, error)
}

type EndpointEncryptRequest

type EndpointEncryptRequest struct {
	PeerPublicKey [32]byte
	PrivateKey    [32]byte
	Host          string
	Port          int
}

type EndpointEncryptResponse

type EndpointEncryptResponse struct {
	Data string
}

type EndpointEncryptor

type EndpointEncryptor interface {
	Encrypt(ctx context.Context, input *EndpointEncryptRequest) (*EndpointEncryptResponse, error)
}

type EstablishController

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

func NewEstablishController

func NewEstablishController(ctrl *wgctrl.Client, devices DeviceRepository, peers PeerRepository, store plugin.Store, decryptor EndpointDecryptor, logger *zerolog.Logger) *EstablishController

func (*EstablishController) Execute

func (c *EstablishController) Execute(ctx context.Context, peerId entity.PeerId)

type PeerRepository

type PeerRepository interface {
	List(ctx context.Context) ([]*entity.Peer, error)
	ListByDevice(ctx context.Context, deviceName entity.DeviceId) ([]*entity.Peer, error)
	Find(ctx context.Context, id entity.PeerId) (*entity.Peer, error)
	Save(ctx context.Context, peer *entity.Peer)
}

type PublishController

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

func NewPublishController

func NewPublishController(devices DeviceRepository, peers PeerRepository, store plugin.Store, resolver StunResolver, encryptor EndpointEncryptor, logger *zerolog.Logger) *PublishController

func (*PublishController) Execute

func (c *PublishController) Execute(ctx context.Context)

type RefreshController

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

func NewRefreshController

func NewRefreshController(peers PeerRepository, queue RefreshQueue, logger *zerolog.Logger) *RefreshController

func (*RefreshController) Execute

func (c *RefreshController) Execute(ctx context.Context)

type RefreshQueue

type RefreshQueue interface {
	Enqueue(entity entity.PeerId)
}

type StunResolver

type StunResolver interface {
	Resolve(ctx context.Context, port uint16) (string, int, error)
}

type WireGuardClient

type WireGuardClient interface {
	Device(deviceName string) (*wgtypes.Device, error)
}