silk.http.exchange.

import silk.mem.allocator { Allocator, OutOfMemoryError }
import silk.io.byte_duplex { ByteDuplex, ReadTransfer }
import silk.collections.bytes { Bytes }
import silk.core.effect { Effect }
import silk.http.message { Header, Method, ValueError, Version }
import silk.http.exchange { Connection, Exchange, ExchangeError, Limits, RequestOptions }
import silk.http.exchange as Client
import silk.http.headers { Headers, Limits as ValueLimits }
import silk.http.origin { Origin, OriginError }
import silk.http.request { BodyMode, HeaderPolicy, PreparedRequest, RequestError, fromUri }
import silk.http.transport { HttpTransport, TransportError }
import silk.collections.list { List }
import silk.io.memory_byte_duplex {
  MemoryByteDuplex,
  MemoryReadEvent,
  MemoryWriteAction,
  MemoryWriteEvent
}
import silk.system.monotonic_clock { MonotonicClock }
import silk.core.option { Option }
import silk.system.random { Random }
import silk.core.result { Result }
import silk.system.system_clock { Instant, SystemClock }
import silk.num.u64
import silk.uri.uri { Uri }
import silk.uri.reference { ParseError }

// A transport that answers with fixed bytes and accepts all writes.
struct ScriptedTransport {
  memory: MemoryByteDuplex,
}

impl HttpTransport for ScriptedTransport {
  effect fn readSomeRaw(
    self: &mut Self,
    output: &mut [u8],
    deadline: Option<Instant>
  ) -> ReadTransfer
    ! TransportError | OutOfMemoryError
    ? &mut MonotonicClock | &mut Allocator | &mut Random {
    let attempted = run Effect.result(ByteDuplex.readSome(&mut output, move deadline))
      |> Effect.provideMut<ByteDuplex>(&mut self.memory)
    return match move attempted {
      Result.Success { value } => move value
      Result.Failure { error } => {
        fail TransportError.Plain { error: move error }
      }
    }
  }

  effect fn writeSomeRaw(self: &mut Self, input: &[u8], deadline: Option<Instant>) -> usize
    ! TransportError | OutOfMemoryError
    ? &mut MonotonicClock | &mut Allocator | &mut Random {
    let attempted = run Effect.result(ByteDuplex.writeSome(input, move deadline))
      |> Effect.provideMut<ByteDuplex>(&mut self.memory)
    return match move attempted {
      Result.Success { value } => value
      Result.Failure { error } => {
        fail TransportError.Plain { error: move error }
      }
    }
  }

  effect fn flush(self: &mut Self, deadline: Option<Instant>) -> ()
    ! TransportError | OutOfMemoryError
    ? &mut MonotonicClock | &mut Allocator | &mut Random {
    drop deadline
    return ()
  }

  effect fn close(self: &mut Self) -> ()
    ! TransportError {
    return ()
  }
}

struct FixedClock {}

impl MonotonicClock for FixedClock {
  effect fn now(self: &mut Self) -> Instant {
    return SystemClock.make(0, 0)
  }

  effect fn getResolution(self: &mut Self) -> u64 {
    return u64.toU64(1)
  }

  effect fn waitUntil(self: &mut Self, when: Instant) -> () {
    drop when
    return ()
  }

  effect fn waitFor(self: &mut Self, howLong: u64) -> () {
    drop howLong
    return ()
  }
}

struct ZeroRandom {}

impl Random for ZeroRandom {
  effect fn fillBytes(self: &mut Self, output: &mut [u8]) -> () {
    drop output
    return ()
  }
}

fn valueLimits() -> ValueLimits {
  return Limits.defaults().head.values
}

// Sends the request and reads the body of the response.
effect<'call> fn readBody<'call, 'exchange: 'call>(
  exchange: &'call mut Exchange<'exchange, ScriptedTransport>,
) -> i32
  ! ExchangeError | OutOfMemoryError
  ? &mut Allocator | &mut MonotonicClock | &mut Random {
  run Client.send(&mut exchange.*)

  // The request has no body, so it ends with no trailers.
  let entries: [Header<'static>; 0] = []
  let trailers = match Headers.make(&entries, valueLimits()) {
    Result<Headers, ValueError>.Success { value } => value
    Result<Headers, ValueError>.Failure { error: _ } => {
      return 1
    }
  }
  run Client.finishRequest(&mut exchange.*, &trailers)
  let status = run Client.receiveFinal(&mut exchange.*)
  if status != 200 {
    return 1
  }
  let mut body: [u8; 16] = [0; 16]
  let count = run Client.readSome(&mut exchange.*, &mut body)
  if count != 5 || body[0] != 104 {
    return 1
  }
  run Client.finishResponse(&mut exchange.*)
  return 0
}

effect fn program() -> i32
  ! ExchangeError | RequestError | OutOfMemoryError
  ? &mut Allocator | &mut MonotonicClock | &mut Random {
  let uri = match Uri.parse("http://example.com/") {
    Result<Uri, ParseError>.Success { value } => value
    Result<Uri, ParseError>.Failure { error: _ } => {
      return 1
    }
  }
  let origin = match Origin.fromUri(&uri) {
    Result<Origin, OriginError>.Success { value } => value
    Result<Origin, OriginError>.Failure { error: _ } => {
      return 1
    }
  }
  let entries: [Header<'static>; 0] = []
  let headers = match Headers.make(&entries, valueLimits()) {
    Result<Headers, ValueError>.Success { value } => value
    Result<Headers, ValueError>.Failure { error: _ } => {
      return 1
    }
  }
  let policy = HeaderPolicy.defaults()
  let request = run fromUri(
    &uri,
    Version.Http11,
    Method.get(),
    &headers,
    &policy,
    BodyMode.Empty,
    false,
    valueLimits(),
    4096,
    128,
  )
  let response = run Bytes.copy(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello")
  let mut reads = List<MemoryReadEvent>.make()
  run List.append(
    &mut reads,
    MemoryReadEvent.Data { readyAt: SystemClock.make(0, 0), bytes: move response }
  )
  let mut writes = List<MemoryWriteEvent>.make()
  run List.append(
    &mut writes,
    MemoryWriteEvent {
      readyAt: SystemClock.make(0, 0),
      action: MemoryWriteAction.Accept { count: 4096 }
    },
  )
  let memory = run MemoryByteDuplex.make(move reads, move writes, 4096, 4, Option<i32>.none())
  let mut connection = run Client.makeOwned(
    ScriptedTransport { memory: move memory },
    origin,
    Version.Http11,
    Limits.defaults(),
    Option<Instant>.none(),
  )
  let result = run Client.withExchange(
    &mut connection,
    &request,
    RequestOptions.defaults(),
    readBody
  )
  run Client.close(&mut connection)
  return result
}

effect fn failed<E>(error: E) -> i32 {
  drop error
  return 1
}

pub fn main() -> i32 {
  let mut allocator = Allocator.systemAllocatorProvider()
  let mut clock = FixedClock {}
  let mut random = ZeroRandom {}
  return run Effect.catchAll(program(), failed) |> Effect.provideMut<Random>(&mut random)
    |> Effect.provideMut<MonotonicClock>(&mut clock)
    |> Effect.provideMut<Allocator>(&mut allocator)
}

pub enum ConnectionPhase

Ready

Active

Closed

pub enum ExchangePhase

Prepared

AwaitContinue

Upload

AwaitResponse

Response

Tunnel

Finished

Aborted

pub union ContinuePolicy

Disabled

Require100

pub deadline: Instant

pub struct RequestOptions

pub deadline: Option<Instant>

pub continuePolicy: ContinuePolicy

pub struct Limits

pub head: HeadLimits

pub requestBody: BodyLimits

pub responseBody: BodyLimits

pub readCapacity: usize

pub writeCapacity: usize

pub maxRequests: usize

pub maxInformationalResponses: usize

pub maxInformationalWireBytes: u64

pub maxDiscardWireBytes: u64

impl Copy for Limits

impl Limits

pub fn defaults() -> Limits

impl RequestOptions

pub fn defaults() -> RequestOptions

pub union ExchangeError

Content

pub error: ContentError<'static>

Head

pub error: ParseError

Body

pub error: BodyError

Transport

pub error: TransportError

Output

pub error: TransportError

pub progress: WriteProgress

OutputTimeout

pub progress: WriteProgress

OutputAllocation

pub error: OutOfMemoryError

pub progress: WriteProgress

InvalidState

InvalidRequest

InvalidLimits

LimitExceeded

TruncatedHead

UnsupportedUpgrade

ContinueTimeout

Timeout

impl Debug for ExchangeError

effect fn debug(self: &Self, formatter: &mut Formatter) -> () ! WriterError ? &mut Writer

pub fn validateLimits(limits: &Limits) -> Result<(), ExchangeError>

pub enum DiscardOutcome

Completed

CapReached

pub union ReuseEligibility

Eligible

NotReady

NotOwned

RequestLimit

RetainedInput

pub bytes: usize

impl Copy for ReuseEligibility

pub struct WriteProgress

pub consumed: usize

pub written: usize

pub totalPayload: u64

pub totalWire: u64

impl Copy for WriteProgress

impl Debug for WriteProgress

effect fn debug(self: &Self, formatter: &mut Formatter) -> () ! WriterError ? &mut Writer

pub struct Connection<P>

impl<P> Connection<P>

pub fn phase(self: &Self) -> ConnectionPhase

pub fn unread(self: &Self) -> usize

pub fn reuseEligibility<P>(connection: &Connection<P>) -> ReuseEligibility

pub struct TransportContext<'view, P>

pub transport: &'view P

impl<P> Connection<P>

pub fn transportContext<'view>(self: &'view Self) -> TransportContext<'view, P>

pub struct Exchange<'exchange, P>

impl<'exchange, P> Exchange<'exchange, P>

pub fn phase(self: &Self) -> ExchangePhase

pub effect fn head<'head>(self: &'head Self) -> ResponseHead<'head> ! ExchangeError

pub interface ConnectionHandler<P, A, E, ?R>

effect<'call> fn handle<'call>(handler: Self, connection: &'call mut Connection<P>) -> A ! E ? R where
    &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
    &mut P provides &HttpTransport from &mut HttpTransport

pub enum RouteProtocol

Http10

OptionalHttp11

RequiredHttp11

pub struct RouteSettings

pub http: Limits

pub request: HeaderLimits

pub maxRequestHeadBytes: usize

pub maxProxyCredentialBytes: usize

pub protocol: RouteProtocol

pub tls: ClientLimits

pub handshakeDurationNanoseconds: u64

impl Copy for RouteSettings

pub service AcquiredRouteContext<P, A, E, ?R>

effect<'env> fn use<'env>(provider: P) -> A ! E ? R | &mut AcquiredRouteContext<P, A, E, R> where
    &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
    &mut P provides &HttpTransport from &mut HttpTransport,
    &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random,
    &mut P provides &ByteDuplex from &mut ByteDuplex,
    R in Without<R, ByteDuplex>,
    R in Without<R, HttpTransport>

pub interface RouteClient<P, A, E, AcquisitionError, ?AcquisitionRequirements, ?R>

fn settings(client: &Self) -> RouteSettings

effect<'env> fn acquire<'env>(client: Self, peer: Origin, deadline: Option<Instant>) -> A ! E | AcquisitionError ? AcquisitionRequirements | R | &mut AcquiredRouteContext<
    P,
    A,
    E,
    R,
  > where R in Without<R, ByteDuplex>, R in Without<R, HttpTransport>

pub struct RouteTransport<'transport, 'provider: 'transport, 'tunnel: 'provider, P>

pub interface RouteHandler<'configuration, P, A, E, ?R>

effect<'call> fn handle<'call, 'transport: 'call, 'provider: 'transport, 'tunnel: 'provider>(
    handler: Self,
    route: Route<'configuration>,
    connection: &'call mut Connection<RouteTransport<'transport, 'provider, 'tunnel, P>>,
  ) -> A ! E ? R where
    &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
    &mut P provides &HttpTransport from &mut HttpTransport,
    &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random,
    &mut P provides &ByteDuplex from &mut ByteDuplex

impl<'transport, 'provider: 'transport, 'tunnel: 'provider, P> RouteTransport<
  'transport,
  'provider,
  'tunnel,
  P,
>

impl<'transport, 'provider: 'transport, 'tunnel: 'provider, P> HttpTransport for RouteTransport<
  'transport,
  'provider,
  'tunnel,
  P,
>
where
  &mut P provides &HttpTransport from &mut HttpTransport,
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
  &mut P provides &ByteDuplex from &mut ByteDuplex,
  &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random

readSomeRaw: RouteTransport.read

writeSomeRaw: RouteTransport.write

flush: RouteTransport.flushOutput

close: RouteTransport.closeTransport

pub effect<'env> fn withRoute<
  'configuration,
  P,
  A,
  E,
  AcquisitionError,
  ?R,
  ?AcquisitionRequirements,
  H: RouteHandler<'configuration, P, A, E ? R> + 'env,
  C: RouteClient<P, A, E | ProxyError | ExchangeError | Tls.ConnectionError | IdentityError | OutOfMemoryError, AcquisitionError, AcquisitionRequirements ? R | &mut Allocator | &mut MonotonicClock | &mut SystemClock | &mut Random> + 'env,
  'env,
>(
  client: C,
  route: Route<'configuration>,
  preparedTrust: Option<TrustSnapshot>,
  deadline: Option<Instant>,
  handler: H,
) -> A
! E | AcquisitionError | ProxyError | ExchangeError | Tls.ConnectionError | IdentityError | OutOfMemoryError
? R | AcquisitionRequirements | &mut Allocator | &mut MonotonicClock | &mut SystemClock | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
  &mut P provides &HttpTransport from &mut HttpTransport,
  &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random,
  &mut P provides &ByteDuplex from &mut ByteDuplex,
  R in Without<R, ByteDuplex>,
  R in Without<R, HttpTransport>

pub effect<'env> fn makeOwned<P: 'env, 'env>(
  transport: P,
  origin: Origin,
  version: Version,
  limits: Limits,
  overallDeadline: Option<Instant>,
) -> Connection<P>
! ExchangeError | OutOfMemoryError
? &mut Allocator
where &mut P provides &HttpTransport from &mut HttpTransport

pub effect<'env> fn withOwned<P: 'env, A, E, ?R, H: ConnectionHandler<P, A, E ? R> + 'env, 'env>(
  transport: P,
  origin: Origin,
  version: Version,
  limits: Limits,
  overallDeadline: Option<Instant>,
  handler: H,
) -> A
! E | ExchangeError | OutOfMemoryError
? R | &mut Allocator
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
  &mut P provides &HttpTransport from &mut HttpTransport

pub effect<'env> fn withConnected<'env, P, A, E, ?R, H: ConnectionHandler<Loan<'env, P>, A, E ? R>>(
  transport: &'env mut P,
  origin: Origin,
  version: Version,
  limits: Limits,
  overallDeadline: Option<Instant>,
  handler: H,
) -> A
! E | ExchangeError | OutOfMemoryError
? R | &mut Allocator
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random,
  &mut P provides &HttpTransport from &mut HttpTransport

pub effect fn close<P>(connection: &mut Connection<P>) -> ()
! ExchangeError
where &mut P provides &HttpTransport from &mut HttpTransport

pub effect fn withExchange<'exchange, 'callback, P, A, E, ?R>(
  connection: &'exchange mut Connection<P>,
  request: &PreparedRequest,
  requestedOptions: RequestOptions,
  callback: for<'call, 'exchangeView: 'call> once fn<'callback>(
    &'call mut Exchange<'exchangeView, P>,
  ) -> once Effect<'call & 'callback; A ! E ? R>,
) -> A ! E | ExchangeError | OutOfMemoryError ? R | &mut Allocator

pub effect fn send<'exchange, P>(exchange: &mut Exchange<'exchange, P>) -> ()
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn writeSome<'exchange, P>(exchange: &mut Exchange<'exchange, P>, input: &[u8]) -> WriteProgress
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn finishRequest<'exchange, P>(exchange: &mut Exchange<'exchange, P>, trailers: &Headers) -> ()
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn receive<'exchange, P>(exchange: &mut Exchange<'exchange, P>) -> u16
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn receiveFinal<'exchange, P>(exchange: &mut Exchange<'exchange, P>) -> u16
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn readSome<'exchange, P>(exchange: &mut Exchange<'exchange, P>, output: &mut [u8]) -> usize
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn discardRemainingAtMost<'exchange, P>(
  exchange: &mut Exchange<'exchange, P>,
  maxWireBytes: u64,
  deadline: Option<Instant>,
) -> DiscardOutcome
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn drainAndFinishAtMost<'exchange, P>(
  exchange: &mut Exchange<'exchange, P>,
  maxWireBytes: u64,
  deadline: Instant,
) -> DiscardOutcome
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn discardRemaining<'exchange, P>(
  exchange: &mut Exchange<'exchange, P>,
  maxWireBytes: u64,
) -> ()
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn trailers<'head, 'exchange, P>(exchange: &'head Exchange<'exchange, P>) -> Option<
  Trailers<'head>,
> ! ExchangeError

pub effect fn finishResponse<'exchange, P>(exchange: &mut Exchange<'exchange, P>) -> ()
! ExchangeError

pub fn abort<'exchange, P>(exchange: &mut Exchange<'exchange, P>) -> ()

pub struct Tunnel<'tunnel, P>

pub struct TransferredTunnel<'tunnel, P>

pub effect fn withTunnel<'tunnel, 'exchange: 'tunnel, 'callback, P, A, E, ?R>(
  exchange: &'tunnel mut Exchange<'exchange, P>,
  callback: for<'call, 'tunnelView: 'call> once fn<'callback>(&'call mut Tunnel<'tunnelView, P>) -> once Effect<'call & 'callback; A ! E ? R>,
) -> A ! E | ExchangeError ? R

impl<'tunnel, P> Tunnel<'tunnel, P>

pub effect fn transferByteDuplex<'transfer, 'callback, A, E, ?CallbackRequirements>(
    self: &'transfer mut Self,
    callback: for<'call, 'duplexView: 'call> once fn<'callback>(
      &'call mut TransferredTunnel<'duplexView, P>,
    ) -> once Effect<'call & 'callback; A ! E ? CallbackRequirements>,
  ) -> A
  ! E | ExchangeError
  ? CallbackRequirements
  where
    &mut P provides &ByteDuplex from &mut ByteDuplex,
    CallbackRequirements in Without<CallbackRequirements, ByteDuplex>

pub effect fn readSome(self: &mut Self, output: &mut [u8], requestedDeadline: Option<Instant>) -> ReadTransfer
  ! ExchangeError | OutOfMemoryError
  ? &mut MonotonicClock | &mut Allocator | &mut Random
  where
    &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

pub effect fn writeSome(self: &mut Self, input: &[u8], requestedDeadline: Option<Instant>) -> usize
  ! ExchangeError | OutOfMemoryError
  ? &mut MonotonicClock | &mut Allocator | &mut Random
  where
    &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random

impl<'tunnel, P> TransferredTunnel<'tunnel, P>

impl<'tunnel, P> ByteDuplex for TransferredTunnel<'tunnel, P>
where
  &mut P provides &ByteDuplex from &mut ByteDuplex,
  &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

readSomeRaw: TransferredTunnel.read

writeSomeRaw: TransferredTunnel.write

writeSomeVectoredRaw: TransferredTunnel.writeVectored

flushRaw: TransferredTunnel.flushOutput

shutdownWriteRaw: TransferredTunnel.shutdownOutput

closeRaw: TransferredTunnel.closeTransport

pub effect fn beginContent<'head, 'exchange: 'head, P>(
  exchange: &'head mut Exchange<'exchange, P>,
  mode: ContentMode,
  limits: ContentLimits,
) -> AppliedPlan
! ExchangeError | ContentError<'head> | OutOfMemoryError
? &mut Allocator | &mut MonotonicClock

pub effect fn readContentSome<'exchange, P>(
  exchange: &mut Exchange<'exchange, P>,
  output: &mut [u8],
) -> ContentProgress
! ExchangeError | OutOfMemoryError
? &mut MonotonicClock | &mut Allocator | &mut Random
where
  &mut P provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random