doppel

type Conn ¶

type Conn struct {
	essentials.Conn
	// contains filtered or unexported fields
}

func NewConn(ctx context.Context, conn essentials.Conn, stats Stats) Conn

func (c Conn) Stop()

func (c Conn) Write(p []byte) (int, error)

type Ganger ¶

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

func NewGanger(
	ctx context.Context,
	network Network,
	logger Logger,
	scoutEach time.Duration,
	scoutRepeats int,
	urls []string,
	drs bool,
) *Ganger

func (g *Ganger) NewConn(conn essentials.Conn) (Conn, error)

func (g *Ganger) NoiseParams() NoiseParams

func (g *Ganger) Run()

func (g *Ganger) Shutdown()

type Logger ¶

type Logger interface {
	Info(msg string)
	WarningError(msg string, err error)
}

type Network ¶

type Network interface {
	// Dial establishes context-free TCP connections.
	Dial(network, address string) (essentials.Conn, error)

	// DialContext dials using a context. This is a preferable way of
	// establishing TCP connections.
	DialContext(ctx context.Context, network, address string) (essentials.Conn, error)

	// MakeHTTPClient build an HTTP client with given dial function. If nothing is
	// provided, then DialContext of this interface is going to be used.
	MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client

	// NativeDialer returns a configured instance of native dialer that
	// skips proxy connections or any other irrelevant settings.
	NativeDialer() *net.Dialer
}

copypasted from mtglib

type NoiseParams ¶ added in v2.2.5

type NoiseParams struct {
	Mean   int
	Jitter int
}

NoiseParams holds the measured cert chain size for FakeTLS noise calibration. If Mean is 0, the caller should use a legacy fallback.

type Scout ¶

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

func NewScout(network Network, urls []string) Scout

func (s Scout) Learn(ctx context.Context) (ScoutResult, error)

type ScoutConn ¶

type ScoutConn struct {
	tls.Conn
	// contains filtered or unexported fields
}

func NewScoutConn(conn essentials.Conn, results *ScoutConnCollected) *ScoutConn

func (s *ScoutConn) Read(p []byte) (int, error)

func (s *ScoutConn) Write(p []byte) (int, error)

type ScoutConnCollected ¶

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

func NewScoutConnCollected() *ScoutConnCollected

func (s *ScoutConnCollected) Add(record byte, payloadLen int)

func (s *ScoutConnCollected) MarkWrite()

func (s *ScoutConnCollected) Snapshot() ([]ScoutConnResult, int)

type ScoutConnResult ¶

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

type ScoutResult ¶ added in v2.2.5

type ScoutResult struct {
	Durations []time.Duration
	CertSize  int // total ApplicationData bytes during TLS handshake; 0 if unknown
}

ScoutResult holds measurements from a single scout HTTP request.

type Stats ¶

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

Stats is responsible for generating values that are distributed according to some statistical distribution.

It follows several ideas:

1. Based on nginx and Cloudflare behaviour, even if server is eager to send a lot, they all start with small TLS packets that are approximately MTU-sized. After
2. After ~40 TLS records, server considers TCP session as somewhat solid and reliable and ramps up to 4096.
3. After ~20 TLS records more it jumps to the max 16384 bytes and keep this size as long as it can
4. If there is no any byte within a connection for a longer time period, this counter resets.

This is called Dynamic TLS Record Sizing

• https://blog.cloudflare.com/optimizing-tls-over-tcp-to-reduce-latency/
• https://community.f5.com/kb/technicalarticles/boosting-tls-performance-with-dynamic-record-sizing-on-big-ip/280798
• https://www.igvita.com/2013/10/24/optimizing-tls-record-size-and-buffering-latency/

And this optimized for the very first byte, so web browsers could start to render as early as possible, showing user some preliminary results, optimizing for perceived latency.

Since this is very typical for the website, we also aim for that.

Another important idea is how delays between TLS packets are distributed. In case of sending huge heavy content with max sized record, delays have lognormal distribution. But a nature of a typical website shows that it eagers to deliver as fast as it can in a few very first records and could possibly slow down later.

This is perfectly described by Weibull distribution:

• https://en.wikipedia.org/wiki/Weibull_distribution
• https://ieeexplore.ieee.org/document/6662948
• https://www.researchgate.net/publication/224621285_Traffic_modelling_and_cost_optimization_for_transmitting_traffic_messages_over_a_hybrid_broadcast_and_cellular_network
• https://ir.uitm.edu.my/id/eprint/105386/1/105386.pdf

In other word, a combination of Dynamic TLS Record Sizing hints us for Weibull distribution.

But we also have to keep in mind that DRS is not well spread yet. In most cases users still rely on OpenSSL or webserver defaults. OpenSSL chunks with biggest packet sizes, nginx relies on static setting that is 16k by default. Thus, dynamic sizing has to be present but we cannot oblige users to use that.

func NewStats(durations []time.Duration, drs bool) Stats

func (d *Stats) Delay() time.Duration

func (d *Stats) Size() int