The raxx from crowdhailer

Location header to warn if set on invalid response status

Location header should only be set on response status 201 | 3XX

Adding Cowboy to a supervision tree

The cowboy adapter currently cannot be started under a project applications supervision tree.

Cowboy, by design, starts a server under its application supervision tree when using :cowboy.start_http/4.

It is possible to start it under a project supervisor. and we would like to add that functionality to the cowboy adapter.

See:

Add middleware Raxx.Logger

This should be started in a new repo and linked from the extensions section of this repo.
The hex project should be raxx_logger

Logger should write a single line if response is sent in a complete state. i.e. when body is false or binary()
Logger should write a line for first part of response and details of each chunk when response is streamed.
Logger could use common logger format.
- it could be customised using: https://www.ibm.com/support/knowledgecenter/en/ssw_i5_54/rzaie/rzaielogformat.htm
- similar to old implementation here. https://github.com/CrowdHailer/Tokumei/blob/raxx-0.11.1/app/lib/tokumei/common_logger.ex

Implement `X-forwarded-for`

Resources

rails discusses how this updates looking up client ip
https://github.com/rails/rails/blob/4-2-stable/actionpack/lib/action_dispatch/middleware/remote_ip.rb

maybe this? https://tools.ietf.org/html/draft-petersson-forwarded-for-02

Add documentation to raxx_cowboy

Add documentation to README
Ensue Docs available on hex
Improve hello_cowboy example, ideally add to supervision tree #31
Link from top level README

Raise error for incomplete response without new server state

If any callback returns a response with body set to true an error should be raised. This is because the response is incomplete.

e.g.

defmodule MyServer do
use Raxx.Server

def handle_request(request, state) do
  response = Raxx.response(:ok)
  |> Raxx.set_body(true)
end
end

This example should raise an error
the correct return value is {response, new_state}

Suggestion: upgrade to https://github.com/elli-lib/elli

https://github.com/elli-lib/elli seems to be in active development.

Should we upgrade?

Add @impl

All examples should have @impl Raxx.Server used correctly through out the project

create URI::NestedQuery module

Add middleware Raxx.Session

This should be started in a new repo and linked from the extensions section of this repo.
The hex project should be raxx_session

A previous implementation exists in the Tokumei project but the new independent implementation must also handle streaming.

https://github.com/CrowdHailer/Tokumei/tree/master/app/lib/tokumei/session

The session method should be pluggable but always decode the session into a raxx.session header

debug care because of this

Note that calls inside try/1 are not tail recursive since the VM
needs to keep the stacktrace in case an exception happens.

https://github.com/elixir-lang/elixir/blob/22bd10a8170af0b187029d115abe4cc8edcf2ae6/lib/elixir/lib/kernel/special_forms.ex#L1622

rename helper functions

Raxx.ServerSentEvents -> Rack.ServerSentEvents.Handler

Raxx.Handler -> Raxx.{Basic/Core/Request}.Handler

need to handle reusing connections.

Before this is done applications can just ask for each connection to be closed.

Headers cannot be a map as it is valid to specify HTTP headers more than once

Error Handlers

Have an extensible method for handling errors within the main callbacks.

Do we need different error handlers for different call backs. Or can we just have a return value of resolved/not_resolved

URI query decoding.

I am unclear why elixirs URL library does not support lists when encoding and decoding query strings

URI.decode_query("foo[]=1&foo[]=2")
# %{"foo[]" => "2"}
# But I would expect %{"foo" => ["1", "2"]}

This is obviously a deliberate choice as in the docs is this quote

Keys and values can be any term that implements the String.Chars protocol, except lists which are explicitly forbidden.

elixir-lang/elixir#2876 Suggests just using plug but I will be instead copy and pasting as raxx cannot depend on plug.

setting up raxx for ssl

Thanks for this simple web server library.

Please can you give an example of how to setup raxx as a secure server, i.e. with ssl.
I have looked at your Elli and Cowboy adaptors, I cannot find where you handle https.

Server Sent Event

add protocol field to request

destructing of the Host field gives host and port but also protocol and possibly authority. Though I think that authority is not part of the updated rfc.

enforce keys in request struct, builder to include valid hosts

Support for sending cookies.

Raxx does not yet support cookies. Can follow Rack closely on this respect

Use logger

Use logger not IO.inspect on adapter.

MochiWeb adapter

https://github.com/mochi/mochiweb

separate projects for hex

so far

core (raxx)
server_sent_events (SSE)
chunked (possibly core)
test (might just be methods eg Raxx.get
error handler and debug page
static
session
validate to check server implementations
ace_http (maybe move ace itself as part of the project)

have some master test file for integrations

create responses in same way as raxx test

def ok(body, headers)
def ok(headers)
def ok(%{body: body, headers: headers}, headers)
def ok(json(%{content})

be able to make a stack of middleware

I think there must be some great macro stuff possible here to reduce runtime lookups

defmodule MyApp do
  use Raxx.Stack

  stack Raxx.Csrf
  stack Raxx.Session, secret: "top secret"
  stack Raxx.GZip
  stack Raxx.Time
  stack Raxx.WhoAmI, server_name: "my name"
  stack Raxx.ContentLength
  stack Raxx.Head
  stack Raxx.Scrub, (redirect or rewrite)
  
  mount "/assets", AssetsController
  service "/accounts", "accounts.app.consul"
end

Static file serving middleware.

Needs to incorporate mime information. Elixir has a mime library.

https://github.com/elixir-lang/mime

Respond with blobs or file descriptors.
Stream large files automatically.

link to tokumei docker documentation for contributing

Streaming

long poll

Long poll should just await within function

chunked responses
chunked requests

https://24ways.org/2016/http2-server-push-and-service-workers/
https://github.com/phoenixframework/phoenix/blob/v1.2.3/lib/phoenix/transports/long_poll.ex#L1

[state, [{target, message]

%Response{state: :completed, promises: []}
middleware to fetch promises from response links

(server-process) -> (handler-process)
kill handler process after replying.
Good for HTTP2

@expect-continue true
def handle_request(r, c) do
   body = body(r) # memoised
   
   {{__MODULE__, c}, [%Response{body: nil}] # chunked
   {{__MODULE__, c}, []} # longpoll
   {nil, [%Response{body: nil}, promise("/favicon.ico")] # with server push
end

with mailbox monad

def handle_request(r, c) do
  reply(response)
  promise("favicon.ico")
end

def handle_request(r, c) do
  upgrade(__MODULE__, :awaiting)
end

def handle_info(message) do
  reply(response)
end

defmodule Ping.Ready do
  receive config do
    Request(path: ["event", id]) ->
      send(MyApp.PubSub, {self, id})
      send(:timer, 10_000)
      Ping.Awaiting, config
  end
end
defmodule Ping.Awaiting do
  receive config do
    PubSub.update(contents) ->
      send(MyApp.PubSub, {self, id})
      reply(ok("content"))
      Raxx.Completed # could call a close state here
  end
end

Add type specs and dialyzer

Add dialyxir to this project and typespecs to all public functions. The benefits of this are improved documentation as well as an extra layer of checks.

Running dialyzer should become part of the travis test action.

Add middleware that closes connections on responses to `Connection: close` header

If we respond to a request with Connection: close, we should send a response with Connection: close and then close it ourselves.

This works around buggy clients that send Connection: close and never close the connection themselves.

Document testing approach for raxx apps

Hey!

Could you document the recommended approach of testing raxx apps please? Are there some handy helper functions we can use? :)

Cheers,
Louis

Server sent events

Very simple example of sending events with elixir
https://gist.github.com/rbishop/e7b1886d5e75b2f74d8b

Retire http_status

This is a refactoring issue.

The functionality in http_status should be contained with in the core raxx project. there is no need to have it separate. Also a reason phrase is not part of the HTTP/2 specification.

The function for generating a response start line should also not add a newline character.

The http_status package should be retired on hex.

multi line server sent events

Should be able to send data content with newline characters in it.

Best to testby property testing encode/decode.

Fail tests if any compiler warnings are present

The test step should fail if any compiler warnings are emitted. This condition should be added to the travis setup so that PR's will fail with any new warnings.

There seams to be some discussion around a --warnings-as-errors option to mix compile but I could not make it work.

https://stackoverflow.com/questions/31982577/is-it-possible-to-get-the-compiler-to-exit-early-failing-the-build-if-a-compil

Some considerations for header fields

raxx/lib/raxx.ex

Lines 258 to 260 in a73694e

    
           if String.downcase(name) != name do 
        
             raise "Header keys must be lowercase" 
        
           end

We don't need to raise an error here. See this: https://stackoverflow.com/a/5259004/44080

RFC 7230 explicitly states that field headers should be treated as case insensitive

Remove confusing defaults from request struct

Host should not start as www.example.com

Separate default content from `Raxx.Server`

Set up a Raxx.Default module that is included by Raxx.Server

use this new module in example cases for is_application? tests.

Fail build if code is not formatted

This will have to wait until the new year when elixir 1.6 is released. The CI tests should fail if running the formatter would result in a change to the code.

Not sure if such a mix task even exists, but I think it would be good. It would however mean that raxx required 1.6 to work.

use

mix format --check-formatted mix.exs "{lib,test}/**/*.{ex,exs}"

pipe get_content through stack of parsers

copy from plug.

also use the pattern

{buffer, partial}

Can be a middleware layer.

parsing as a stream to go with other middleware stuff. return a list so buffer can contain many parts

Implement headers

headers should be an extensible concept.

Consider having a module for each header eg Raxx.ContentType then other libraries can just implement Raxx.XMyHeader

Should we implement a behaviour module for a generic header?

core headers

Article explaining the purpose of raxx

http is a request response protocol. counter to jose post.

the plug object has a growing complexity
https://gist.github.com/jamonholmgren/fc3b995d2704b1780b55

add mount field to request

if the request has already been partially routed. this is the same as rack SCRIPT_NAME, (I believe)

virtual hosting and the mount field

Host header

All information in the host header is duplicated in other parts the request struct.
The Host header is always required.

Therefore should the host header be deleted from this list of headers?
It should never be relied on and users building request might add a host field but not a host header

Virtual host

Can the Host header have a path in the URL?

Raxx.Request.host + Raxx.Request.mount = virtual host

Router.host instead of Router.mount

In HTTP/2 can the authority header have a path component

What if we want to set / append / or change the existing query?

Raxx summary function

for logging really.

maybe called inspect

get "/path" (Host: example.com) (Cookie: foo=bar)

Version 1.0

List of decisions to be made before releasing 1.0

Is handle_headers a confusing name for a callback? I think perhaps the following might be clearer
- handle_head/2
- handle_body/2
- handle_tail/2
- handle_info/2
Deprecate named header modules, Raxx.Server and Raxx.TransferEncoding
?? Make it a requirement to always have a tail Raxx.Fragment does not need end_stream attribute
?? Rename Raxx.Fragment to Raxx.Body
?? Rename Raxx.Server to Raxx.Spec
Look to increase places used.
- Publish Apple Push Notification Client using Ace and Raxx
- GRPC implementation with GRPC.Request subset of Raxx.Request
- GraphQL

	if String.downcase(name) != name do
	raise "Header keys must be lowercase"
	end

crowdhailer / raxx Goto Github PK

raxx's People

Contributors

Stargazers

Watchers

Forkers

raxx's Issues

Resources

core headers

Host header

Virtual host

Recommend Projects

Recommend Topics

Recommend Org