virtnet

type Accept struct {
	Addr *Addr // accepting with this local address
	Ack  chan error
}

type Addr struct {
	Net  string // full network name, e.g. "pipeα" or "lonetβ"
	Host string // name of host access point on the network
	Port int    // port on host
}

type Engine interface {
	// VNetNewHost creates resources for host and announces it to registry.
	//
	// VNetNewHost should create resources for new host and announce
	// hostname to provided registry. When announcing it should encode in
	// hostdata a way for VNetDial - potentially run on another subnetwork
	// - to find out where to connect to when dialing to this host.
	//
	// On error the returned error will be wrapped by virtnet with "new
	// host" operation and hostname.
	VNetNewHost(ctx context.Context, hostname string, registry Registry) error

	// VNetDial creates outbound virtnet connection.
	//
	// VNetDial, given destination virtnet address and destination
	// hostdata, should establish connection to destination. It should let
	// remote side know that its peer virtnet address is src.
	//
	// On success net.Conn that will be handling data exchange via its
	// Read/Write should be returned. This net.Conn will be wrapped by
	// virtnet with overwritten LocalAddr and RemoteAddr to be src and
	// addrAccept correspondingly.
	//
	// On error the returned error will be wrapped by virtnet with
	// corresponding net.OpError{"dial", src, dst}.
	//
	// Virtnet always passes to VNetDial src and dst with the same network
	// name that was used when creating corresponding SubNetwork.
	VNetDial(ctx context.Context, src, dst *Addr, dsthostdata string) (_ net.Conn, addrAccept *Addr, _ error)

	// Close shuts down subnetwork engine.
	//
	// Close should close engine resources and return corresponding error.
	//
	// There is no need to explicitly interrupt other engine operations -
	// to those virtnet always passes ctx that is canceled before
	// engine.Close is called.
	Close() error
}

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

type Notifier interface {
	// VNetAccept notifies virtnet about incoming connection.
	//
	// VNetAccept, given destination virtnet address, should make decision
	// to either accept or reject provided connection.
	//
	// On success the connection is pre-accepted and corresponding Accept
	// is returned to virtnet network implementation.
	//
	// On error an error is returned without any "accept" prefix, e.g.
	// ErrConnRefused. Such accept prefix should be provided by network
	// implementation that is using VNetAccept.
	VNetAccept(ctx context.Context, src, dst *Addr, netconn net.Conn) (*Accept, error)

	// VNetDown notifies virtnet that underlying network is down.
	//
	// Provided err describes the cause of why the network is down.
	VNetDown(err error)
}

type Registry interface {
	// Announce announces host to registry.
	//
	// Returned error, if !nil, is *RegistryError with .Err describing the
	// error cause:
	//
	//	- ErrRegistryDown  if registry cannot be accessed,
	//	- ErrHostDup       if hostname was already announced,
	//	- some other error indicating e.g. IO problem.
	Announce(ctx context.Context, hostname, hostdata string) error

	// Query queries registry for host.
	//
	// Returned error, if !nil, is *RegistryError with .Err describing the
	// error cause:
	//
	//	- ErrRegistryDown  if registry cannot be accessed,
	//	- ErrNoHost        if hostname was not announced to registry,
	//	- some other error indicating e.g. IO problem.
	Query(ctx context.Context, hostname string) (hostdata string, _ error)

	// Close closes access to registry.
	//
	// Close should close registry resources and return corresponding error.
	//
	// There is no need to explicitly interrupt other registry operations -
	// to those virtnet always passes ctx that is canceled before
	// registry.Close is called.
	Close() error
}

type RegistryError struct {
	Registry string      // name of the registry
	Op       string      // operation that failed
	Args     interface{} // operation arguments, if any
	Err      error       // actual error that occurred during the operation
}

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