kasi is the transparent gateway(or bridge, or proxy) for the privately managed or public services, which are based on HTTP(HTTPS) . It can be in the middle of between your clients and services and be possible to make a single point of service.

In Kiswahili, kasi means speedy or speed. (http://en.wiktionary.org/wiki/kasi)

• support HTTP, HTTPS service 12 14
• virtualhost 1 9 16
• reshape the endpoint 7 8
• user-defined middlewares using javascript 13
• cache control 15 17
• timeout
• KeepAlive
• in-place response in config
• error back
• support CORS (Cross-Origin Resource Sharing) 2
• statistic
• service discovery
• configuration by YAML 3

If your managed source has some trouble and you want to send redirect response to the client for safety, you can easily make custom response within configuration e.g.

response: |
  HTTP/1.1 302 Found
  Location: http://www.iana.org/domains/example/

When failed to get the expected response from source, the custom response will be sent to the client, that response can be made in configuration easily. As you guess, this error back also can be possible using middleware.

when-error:
  status:
    - 400 - 499
    - 500
  response: |
    HTTP/1.1 302 Found
    Location: http://www.iana.org/

kasi has it's own middlewares and support the user-defined middlewares. You can write your own middlewares using javascript, so you easily manipulate the request and response.

The current middleware behaviors are higly affected by the Django Web Frameworks.

/*
`process_request` will be called before sending request to the target service.
*/
var process_request = function (endpointSetting, request) {
    // remove `If-Modified-Since`
    if (request.header["If-Modified-Since"]) {
        delete request.header["If-Modified-Since"];
    }
    
      // or, just return the response.
    var response = new Response();
    response.StatusCode = 304;
    response.Body = "";
    
    return response;
}

/*
`process_response` will be called after receiving the response from target service.
*/
var process_response = function (endpointSetting, reqeust, response) {
    response.Header["Expires"] = 10000;
    response.Body += "\n;";
    
    return response;
}

If you make the web application with ajax and your target service does not provide the CORS, you can make kasi can do it.

With cors and it's children settings, you can easily support CORS by services, endpoints or globally.

kasi provides it's own API, so you can add or remove the services without any break or reload of kasi.

kasi provides the special dashboard, it has the special statistic page. It will show you the current statistics for services.

• number of requests by services and it's endpoints
• statistics of status code by services and it's endpoints
• etc.

You also apply the "Measurement Protocole" of Google Analytics using the user defined middlewares by services. 6

Usually for performance reason, most of the web applications and servers support cache with their own ways, e.g. ETAG4, or using headers like If-Modified-Since or Expires.

kasi respects their own cache mechanisms, and further more, explicitly supports cache.

With using cache of kasi, kasi will cache the data from the services and produce the response with it.

Like nginx, kasi supports the virtualhost with SSL.

If you connect to the API of github, you can rename the API endpoint like this,

https://api.github.com/users/spikeekips to https://api.kasi.org/github/u/spikeekips/

Naturally the original endpoint will be hided. With the custom middleware, which you can write, you can manipulate the request and response.

The interesting feature in reshaping is the using the regular expression to reshape. e.g.

https://api.github.com/users/(?P<username>) to https://api.kasi/{username}

In config, the timeout will set the tomeout globally, services or endpoints.

This is example configuration.

%YAML 1.1

- default:
    cache:
        expire: 10m
        backend: [memory, memcache://127.0.0.1:11211, redis://127.0.0.1:6379]
    timeout: 5s

- service:
    bind: :8000
    hostname:
        - my0.github.com
        - my1.github.com
    ssl:
        cert: /secret/kasi-github.cert
        key: /secret/kasi-github.key
        pem: /secret/kasi-github.pem

    source: https://github.com/api/v1
    timeout: 10s
    endpoints:
        - endpoint:
            open: No
            to: /find/{username}
            from: /users/(?P<username>.*)
            source: [https://api0.github.com/v2, https://api1.github.com/v2]
        - endpoint:
            open: Yes
            source: https://api0.github.com/v2
            to: /github/\1
            from: (.*)
            timeout: 60s
            cors:
                allow-origin: http://localhost:9090
                # or allow-origin: [http://localhost:9090, http://localhost:9091]
                allow-methods: [GET, POST, PUT, OPTIONS, HEAD]
                allow-headers: [X-My-Header]
                allow-credentials: true
                max-age: 178000
...

• more testing code
• refactoring the entire code
• clean up the monkey patch