Gas

Gas is a Web framework written in Go. And this is not a total complete project.

I just did a minimum workable architechture.

The workable feature is:

• Router (based on fasthttprouter package)
• Context (It can easy to render view and print json string)
• Middleware
• Logger middleware
• Log package
• Read config from a yaml file

And Model is not complete yet. Just finished MySQL sql Builder

all feature you can see in gas-example.

Install

$ go get github.com/go-gas/gas

Run demo

$ git clone https://github.com/go-gas/example.git && cd example
$ go run main.go

Your project file structure

|-- $GOPATH
|   |-- src
|       |--Your_Project_Name
|          |-- config
|              |-- default.yaml
|          |-- controllers
|              |-- default.go
|          |-- log
|          |-- models
|          |-- routers
|              |-- routers.go
|          |-- static
|          |-- views
|          |-- main.go

Quick start

Import

import (
    "Your_Project_Name/routers"
    "github.com/go-gas/gas"
    "github.com/go-gas/gas/middleware"
)

New

g := gas.New() // will load "config/default.yaml"

or

g := gas.New("config/path")

Register Routes

routers.RegistRout(g.Router)

Then in your routers.go

package routers

import (
    "Your_Project_Name/controllers"
    "github.com/go-gas/gas"
)

func RegistRout(r *gas.Router)  {

    r.Get("/", controllers.IndexPage)
    r.Post("/post/:param", controllers.PostTest)

    rc := &controllers.RestController{}
    r.REST("/User", rc)

}

Register middleware

g.Router.Use(middleware.LogMiddleware)

And you can write your own middleware function

func LogMiddleware(next gas.CHandler) gas.CHandler {
    return func (c *gas.Context) error  {

       // do something before next handler

       err := next(c)

       // do something after next handler

       return err
    }
}

And done

g.Run()

Benchmark

Using go-web-framework-benchmark to benchmark with another web fframework.

Benchmark-alloc

Benchmark-latency

Benchmark-pipeline

Concurrency

Concurrency-alloc

Concurrency-latency

Concurrency-pipeline

Benchmark conclusion

Iris is still the fastest web framework.

But gas is very new, so in the future

I wish this framework might not be a fastest but it will very fast and full featured.

Roadmap

• Models
• Model fields mapping
• ORM
• Relation mapping
• Transaction
• QueryBuilder
• Session
• Filesystem
• Database
• Redis
• Memcache
• Cache
• Memory
• File
• Redis
• Memcache
• i18n
• HTTPS
• Command line tools
• Form handler (maybe next version)
• Security check features(csrf, xss filter...etc)