-
Notifications
You must be signed in to change notification settings - Fork 15
/
express.go
159 lines (147 loc) · 3.97 KB
/
express.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// Package goexpress provides the actual hook that
// enables you to start building your application.
//
// The basic Express() functions returns an instance
// for the express which can be further be used as
// an express hook.
//
// app.Use(), app.Get(), app.Post(), app.Delete(), app.Push()
// app.Put() are the top level functions that can be used in
// the same fashion as the express-js ones are.
package goexpress
import (
"log"
http "net/http"
response "github.com/DronRathore/goexpress/response"
request "github.com/DronRathore/goexpress/request"
router "github.com/DronRathore/goexpress/router"
)
type express struct {
router *router.Router
started bool
properties map[string]interface{}
}
// Returns a new instance of express
func Express() *express{
var exp = &express{}
exp.router = &router.Router{}
exp.router.Init()
exp.properties = make(map[string]interface{})
return exp
}
// ServeHTTP
// Default function to handle HTTP request
func (e *express) ServeHTTP(res http.ResponseWriter,req *http.Request) {
hijack, ok := res.(http.Hijacker)
if !ok {
http.Error(res, "Request Hijacking not supported for this request", http.StatusInternalServerError)
} else {
conn, bufrw, err := hijack.Hijack()
if err != nil {
http.Error(res, err.Error(), http.StatusInternalServerError)
return
}
var response = &response.Response{}
var request = &request.Request{}
request.Init(req, &e.properties)
response.Init(res, req, bufrw, conn, &e.properties)
var index = 0
var executedRoutes = 0
var next func()
var _next router.NextFunc
_next = func(n router.NextFunc){
if response.HasEnded() == true {
// we are done
return
}
var handler, i, isMiddleware = e.router.FindNext(index, request.Method, request.URL, request)
if i == -1 {
// done handling
if executedRoutes == 0 {
// 404
response.Header.SetStatus(404)
response.Write("Not Found")
response.End()
return
} else {
// should close connection
if response.HasEnded() == false {
response.End()
return
}
}
} else {
if isMiddleware == false {
executedRoutes++
}
index = i + 1
handler(request, response, next)
if response.HasEnded() == false {
n(n)
}
}
}
next = func () {
_next(_next)
}
_next(_next)
}
}
// Extension to provide Router.Get functionalities
func (e *express) Get(url string, middleware router.Middleware) *express{
e.router.Get(url, middleware)
return e
}
// Extension to provide Router.Post functionality
func (e *express) Post(url string, middleware router.Middleware) *express{
e.router.Post(url, middleware)
return e
}
// Extension to provide Router.Put functionality
func (e *express) Put(url string, middleware router.Middleware) *express{
e.router.Put(url, middleware)
return e
}
// Extension to provide Router.Patch functionality
func (e *express) Patch(url string, middleware router.Middleware) *express{
e.router.Patch(url, middleware)
return e
}
// Extension to provide Router.Delete functionality
func (e *express) Delete(url string, middleware router.Middleware) *express{
e.router.Delete(url, middleware)
return e
}
// Extension to provide Router.Use functionality
func (e *express) Use(middleware interface{}) *express{
e.router.Use(middleware)
return e
}
// Returns a new instance of express Router
func Router() *router.Router {
var route *router.Router = &router.Router{}
route.Init()
return route;
}
// Sets global app properties that can be accessed under express struct
func (e *express) SetProp(key string, value interface{}) *express{
e.properties[key] = value
return e
}
// Return the app property
func (e *express) GetProp(key string, value interface{}) interface{}{
return e.properties[key]
}
// Starts the App Server
func (e *express) Start(port string) *express{
if e.started {
return e
}
log.Print("Listening at: ", port)
err := http.ListenAndServe("0.0.0.0:" + port, e)
if err != nil {
log.Fatal("Listen Error:", err)
}
e.started = true
return e
}