suaveio/suave

Suave is a simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition.

suave's Issues

Async.DefaultCancellationToken - not great since it's a global

Cancelling it might cause other async workflows to get cancelled inadvertently, if I understand the docs correctly.

git-tag nuget versions

git tag 0.0.2

and then

git push --tags

Install package with NuGet fail

Suave 0.1.78 (1/19/2014)

Package Manager Console Host Version 2.7.41101.371

PM> install-package Suave
install-package : An item with the same key has already been added.
At line:1 char:1
+ install-package Suave
+ ~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Install-Package], ArgumentException
    + FullyQualifiedErrorId : NuGetCmdletUnhandledException,NuGet.PowerShell.Commands.InstallPackageCommand

I tried it with MSVS 2013 and MSVS 2012 with new F# library project, same error.

Have a sample with exported private key in pfx

mmc > CTRL+M > Computer Account > "Personal>Certificates" > All Tasks > Private key-something > Export... > Follow guide, check export private key checkbox

Right now the pfx is missing a private key

Document warnings from compilation

C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Common.targets(1605,5): warning MSB3270: There was a mismatch between the processor
architecture of the project being built "MSIL" and the processor architecture of the reference "ManagedOpenSsl", "x86". This mismatch may ca
use runtime failures. Please consider changing the targeted processor architecture of your project through the Configuration Manager so as t
o align the processor architectures between your project and references, or take a dependency on references with a processor architecture th
at matches the targeted processor architecture of your project. [Z:\dev\_vendor\suave\Suave\suave.fsproj]
  suave -> Z:\dev\_vendor\suave\Suave\bin\Release\suave.dll

Are we OK with these?

Consider extracting some pieces into external assemblies

As long as they compose, this should be doable. Example: Data.fs that does data interop.

File upload form performance issues

Hello,

Facing performance issues (slow) when handling post data from a form, it seems a 40mb zip will take a 10 minutes when suave is hosted on localhost. Interestingly there is exactly 25% CPU usage (1 of 4 cores) utilised during this period, which indicates that there may be some unnecessary processing (and also some cpu-synchronicity issues)

HTML:

SuaveIO (just hooked up to handle all post as upload):
POST >>== handleUpload

FOUND doesn't set Connection close or Content-Length

Add some labels to issues?

What about these?

Closing this issue to keep it tidy in here ;)

Matchers for the common request methods

See https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods

Fix the web site, link in description in this repo, create org

Write failed: Broken pipe

After running for about a week it died with 'Write failed: Broken pipe'

Funky release notes for v0.0.5

See the nuget it says Full version: 0.0.4.f577a9.

Is this OWIN or IIS based?

Is there OWIN support. If not will it be added?

Generate documentation for the combinators

Would be nice to extract the XML docs directly from Http.fsi and style them.

Otherwise we could work with the already generated suave.xml and extract and filter the ones we want to publish docs for from there.

Improve the logging to be replaceable and configurable

• configurability
• lock globally on using printf, or there will be text interleaving
• allow configuration on launch

Add documentation on public API methods

• Utils.fs
• Html.fs
• Log.fs
• Tcp.fs
• Sscanf.fs
• Types.fs
• Http.fs
• Web.fs
• Template.fs
• Data.fs
• Json.fs
• Session.fs
• Proxy.fs

Misc

• Remove all trailling whitespace

When using DateTime, prefer UTC times, unless displaying in a globalised GUI

E.g. when printing, there's no saying in what timezone the server is.

Support OpenSSL-Base64-encoded DER certificates (.pem)

Right now it seems that only PKCS#12 certificates are supported, but they are a Microsoft-thing, less of a unix thing.

Decide where to write docs

I saw the gh-pages branch, is that where we decide to write docs? What about me linking to the github page from the readme?

Rewrite TCP layer to use SocketAsyncEventArgs

I have done some work in this direction.

Write load tests for the library

I started a branch locally with Tsung for generating some load. I think it would be a good idea to run some load tests on a web server, for every commit.

• start and tear down the server in test cases
• keep track of performance changes over time

[question] Interop with NancyFX

Have you seen Nancyfx. Perhaps you can some of the best features of this project also or perhaps have a interoperability bridge.

Consider different abstraction than hard-coded 'username', 'password'

The abstraction for authentication could be improved.

In .Net it's IClaimPrincipal nowadays, but there could be other ways of writing authentication with a client, such as client certificates, SAML2 tokens, JWT, Hawk or Kerberos.

Consider moving the properties from the HttpRequest type to some context that has helpers to look up. Or do it as external assemblies that attach methods/properties to HttpRequest.

Extract stringly typed values into data carriers

E.g. IPAddress is stringly typed throughout and that can make it a bit hard to know where to pass it and in what format. Many things are strings in a web server.

Tests Organization

Ademar,

Should Suave tests go in the Tests project? If so, should the Suave and Example Tests be separated into folders?

If not, should Suave (Suave.Tests) tests have its own project?

Finally, should the *.Tests project/s be included in the solution?

Scott

Support Windows?

When doing repeated connections/socket terminations on Windows, the server crashes.

x64 libs

Hi,

fyi It seems the libs that are bundled are only x86-32, so it isn't possible to build a 64-bit server with HTTPS (or so VS tells me). Not really an issue, but some may be unaware

Write tests for the library

Text

• UTF-8 in query strings, bodies
• ISO-8859-1 and URI encoding for headers

IO

• state based generators from connecting clients, perhaps something like QuickCheck for TCP for testing how sending "funny" data on the TCP level works out
• specialise QuickCheck for HTTP protocol (?)
• test internal state - try to model state machine, FsCheck for generation/shrinking?

Framework-parts

• scaffolding / code that makes it quick to get started with a server implementation

Happstack talks about Grammar Driven Testing. I'm not sure what grammar they are referring to and the article doesn't say. If we can make FsCheck generate valid (and invalid) HTTP requests I would be happy enough.

Similarly Prowess could be of use when they produce something.

Getting some confidence quickly with tsung

Secure Cookies

Implement cookie abstraction with the following attributes:

name    : string
value   : string
expires : date
path    : string
domain  : string
secure  : bool
httpOnly: bool

Common abstraction points

As I read through the code-base there are a couple of abstraction points that I would implement in the long run, to ensure easy testability and extensibility of the project. This issue is more a discussion issue; I want more feedback, and I would also like to know how these topics would affect performance and if there would be enough gain by implementing it.

Basically anything that is non-functional/non-referentially transparent is this issue.

File IO

It's often nice to be able to stub or use in-memory file systems when writing integration tests of web sites and there are libraries in .Net that allow such abstractions across operating systems, with even better semantics than what .Net gives. One example is DotNetIO. Using it would allow you to stub file systems, serve with in-memory file systems and would allow you to work cross-platform.

Example of existing code, Http.fs:

    if Directory.Exists dirname then
      let di = new DirectoryInfo(dirname)
      (di.GetFileSystemInfos()) |> Array.sortBy (fun x -> x.Name) |> Array.iter buildLine
      ok (bytes (result.ToString())) req
    else fail

DateTime handling

E.g. when adding code that traces an execution, is can be helpful in tests to 'own' the time. This allows you to test edge cases and NTP daemons moving time backwards.

I normally introduce a Clock interface that can be mocked/stubbed and expected on.

Example from existing code, Log.fs (related to #17):

/// Log a line with the given format, printing the current time in UTC ISO-8601 format
/// and then the string, like such:
/// '2013-10-13T13:03:50.2950037Z: today is the day'
let log format =
  Printf.kprintf (lock sync_root <| fun () -> printfn "%s: %s" (DateTime.UtcNow.ToString("o"))) format

Session support, idempotency handling

By moving away from globals we gain testability. While we can use function composition/currying to compose the application, such points of inversion (composing functions) need to be stated from the 'start' of the composition. In other words, it's easy to use a global variable 'far down' into the application and then have to do a lot of refactoring to expose that variable as an interface...

Example from code:

/// Static dictionary of sessions
let session_map = new ConcurrentDictionary<string, ConcurrentDictionary<string, obj>>()

/// Get the session from the HttpRequest
let session (request : HttpRequest) =
  let sessionId = request.SessionId
  // snip

(which by the way has a race condition)

While this doesn't mean that we necessarily use this global variable, it's still easy for a dev to use what's in the example:

 url "/session"
    >>= session_support
// snip

and be hit by the fact that suddenly the web app is no longer possible to load-balance without bugs. Instead session_support could take a parameter with a session store implementation:

url "/session" >>= session_support Globals.AppDomainSessionStore

if identical semantics is wanted.

Similarly, idempotency handling based on request ids or hashes could be made composable based on a single-purpose protocol.

Similarly for uploads (ties into the abstraction of a file system).

Types.fs - HttpRequest - Disposing pattern

I was under the impression that one can't use managed collection and similar during a Finalize() call to Dispose, that makes it Dispose(false). But the code seems to be iterating a file collection.

Proxy capability: return a response based on request data

As a developer,
Sometimes I want to verify an invariant about a request,
In which case I create a proxy that responds to the request if needed.

File upload is broken

Tested with pre-whitespace-formatting bout and post-whitespace-formatting bout, so it's not my changes that have broken it.

I'm testing this in particular on Windows 8, Firefox 24. Trying to upload a jpg file, about 2 MB large, named a.jpg. Suave goes into 40% file usage doesn't return within my human built-in timeout.

Testing only single-file upload, by navigating to test.html.

Under HTTP 1.1 connections should be always persistent

In HTTP 1.1, all connections are considered persistent unless declared otherwise.[1: http://tools.ietf.org/html/rfc2616#section-8.1] The HTTP persistent connections do not use separate keepalive messages, they just allow multiple requests to use a single connection.

See https://github.com/SuaveIO/suave/blob/master/Suave/Web.fs#L371

[core] Implement chunked transfer encoding

Http.local_file - isn't current directory the default?

** Removed **

Used with absolute paths, documenting that.

Suave.Http.send_file does synchronous read of file

Open file stream in async mode and read async instead

NuGet install fails

With error: An item with the same key has already been added.

On Visual Studio 2012, Nuget package manager version 2.7.41101.299. Same error with the 2.7 command line exe.

Web.fs:208

Hi ,

Seems there is some incomplete handling (only aesthetics) on web.fs:208, reproduced by cancelling an upload half way through. Was tempted to do a pull request but I don't have git happening yet.

Adding Mozilla Persona support

I may well be writing a small website using Suave that will use Mozilla Persona. Would you appreciate the server side requirements being submitted as a pull request implemented in a similar way to the Basic Auth Webpart?

Bad-ass documentation on common methods

• document HTTP verbs
• document HTTP status codes á la REST best practices
• format README code like guidelines say

Sauve.Http should have same version as nuget version is

Serve suave.io with Suave itself

I'll setup a VM for this.

Support Debug configuration

License?

I really like Suave. It is cleanly written and the only web application toolkit I know of that is written in F# and also builds cleanly on Mono. Great work!

What is the license on Suave?

Thanks you!

Expose a CancellationToken instead of having the Async.DefaultToken alone

Normalise coding standards

E.g. how methods are named;

• Utils.fs uses names like my_method_name, Json.fs uses fromJson.
• Many lines have trailling whitespace
• Consistent whitespace around method parameters, e.g. for this method: let toString ( buff: byte[], index:int, count:int) = which uses both whitespace before parameters, no-whitespace-before-type and whitespace-before-type.
• Consistent formatting for matches, e.g.:

let bind p rest =
    match p with
        | None -> fail
        | Some r -> rest r

let rec choose options arg = 
    match options with
    |[] -> None
    |p::tail  -> match p arg with
                 |None -> choose tail arg
                 |Some(x)  -> Some(x)

• Such things:

let warbler f a = f a a //wich bird? A Warbler!

Property-based tests sometimes block/never exit

Sometimes the async start blocks the tests from running.

Repro: rake tests:property many times, until they don't run quickly, but blocks without running.

Improve static file MIME-types through extensions/conventions

NancyFX has a nice list for this.