Skip to content
Gas is a web framework writing in go
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
Example
logger
middleware
model
testfiles
validator
.travis.yml
LICENSE
Makefile
README.md
benchmark-pipeline.png
benchmark.png
benchmark_alloc.png
benchmark_latency.png
concurrency-pipeline.png
concurrency.png
concurrency_alloc.png
concurrency_latency.png
context.go
context_test.go
controller.go
gas.go
gas_test.go
logo.jpg
router.go
router_test.go
view.go

README.md

Gas

go-gas

Build Status codecov Go Report Card

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 Example Directory.

Install

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

Run demo

$ cd $GOPATH/src/github.com/go-gas/gas/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.

go-gas-benchmark

Benchmark-alloc

go-gas-benchmark-alloc

Benchmark-latency

go-gas-benchmark-latency

Benchmark-pipeline

go-gas-benchmark-pipeline

Concurrency

go-gas-concurrency

Concurrency-alloc

go-gas-concurrency-alloc

Concurrency-latency

go-gas-concurrency-latency

Concurrency-pipeline

go-gas-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)
You can’t perform that action at this time.