pimhwang
/
spreed-webrtc
mirror of https://github.com/strukturag/spreed-webrtc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Moved from Sleepy to Sloth.

pull/195/head
Simon Eisenmann 10 years ago
parent
22c1e889cc
commit
d6f5dcac9e
2 changed files with 2 additions and 236 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/app/spreed-webrtc-server/main.go
  2. 234
      src/app/spreed-webrtc-server/sleepy/core.go

4
src/app/spreed-webrtc-server/main.go
Unescape View File

@ -22,7 +22,6 @@ @@ -22,7 +22,6 @@
package main
import (
"app/spreed-webrtc-server/sleepy"
"bytes"
"crypto/rand"
"encoding/hex"
@ -32,6 +31,7 @@ import ( @@ -32,6 +31,7 @@ import (
"github.com/strukturag/goacceptlanguageparser"
"github.com/strukturag/httputils"
"github.com/strukturag/phoenix"
"github.com/strukturag/sloth"
"html/template"
"log"
"net/http"
@ -357,7 +357,7 @@ func runner(runtime phoenix.Runtime) error { @@ -357,7 +357,7 @@ func runner(runtime phoenix.Runtime) error {
r.HandleFunc("/{room}", httputils.MakeGzipHandler(roomHandler))
// Add API end points.
api := sleepy.NewAPI()
api := sloth.NewAPI()
api.SetMux(r.PathPrefix("/api/v1/").Subrouter())
api.AddResource(&Rooms{}, "/rooms")
api.AddResource(config, "/config")

234
src/app/spreed-webrtc-server/sleepy/core.go
Unescape View File

@ -1,234 +0,0 @@ @@ -1,234 +0,0 @@
/**
* A RESTful framework for Go
*
* Modified version of sleepy to support Gorilla muxers.
* https://github.com/strukturag/sleepy
*
* Copyright (c) 2014 struktur AG
* Copyright (c) 2013-2014 Doug Black and the Sleepy authors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
**/
package sleepy
import (
"encoding/json"
"errors"
"fmt"
"github.com/gorilla/mux"
"net/http"
)
const (
GET = "GET"
POST = "POST"
PUT = "PUT"
DELETE = "DELETE"
HEAD = "HEAD"
PATCH = "PATCH"
)
// GetSupported is the interface that provides the Get
// method a resource must support to receive HTTP GETs.
type GetSupported interface {
Get(*http.Request) (int, interface{}, http.Header)
}
// PostSupported is the interface that provides the Post
// method a resource must support to receive HTTP POSTs.
type PostSupported interface {
Post(*http.Request) (int, interface{}, http.Header)
}
// PutSupported is the interface that provides the Put
// method a resource must support to receive HTTP PUTs.
type PutSupported interface {
Put(*http.Request) (int, interface{}, http.Header)
}
// DeleteSupported is the interface that provides the Delete
// method a resource must support to receive HTTP DELETEs.
type DeleteSupported interface {
Delete(*http.Request) (int, interface{}, http.Header)
}
// HeadSupported is the interface that provides the Head
// method a resource must support to receive HTTP HEADs.
type HeadSupported interface {
Head(*http.Request) (int, interface{}, http.Header)
}
// PatchSupported is the interface that provides the Patch
// method a resource must support to receive HTTP PATCHs.
type PatchSupported interface {
Patch(*http.Request) (int, interface{}, http.Header)
}
// Interface for arbitrary muxer support (like http.ServeMux).
type APIMux interface {
HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) *mux.Route
ServeHTTP(w http.ResponseWriter, r *http.Request)
}
// An API manages a group of resources by routing requests
// to the correct method on a matching resource and marshalling
// the returned data to JSON for the HTTP response.
//
// You can instantiate multiple APIs on separate ports. Each API
// will manage its own set of resources.
type API struct {
mux APIMux
muxInitialized bool
}
// NewAPI allocates and returns a new API.
func NewAPI() *API {
return &API{}
}
func (api *API) requestHandler(resource interface{}) http.HandlerFunc {
return func(rw http.ResponseWriter, request *http.Request) {
if request.ParseForm() != nil {
rw.WriteHeader(http.StatusBadRequest)
return
}
var handler func(*http.Request) (int, interface{}, http.Header)
switch request.Method {
case GET:
if resource, ok := resource.(GetSupported); ok {
handler = resource.Get
}
case POST:
if resource, ok := resource.(PostSupported); ok {
handler = resource.Post
}
case PUT:
if resource, ok := resource.(PutSupported); ok {
handler = resource.Put
}
case DELETE:
if resource, ok := resource.(DeleteSupported); ok {
handler = resource.Delete
}
case HEAD:
if resource, ok := resource.(HeadSupported); ok {
handler = resource.Head
}
case PATCH:
if resource, ok := resource.(PatchSupported); ok {
handler = resource.Patch
}
}
if handler == nil {
rw.WriteHeader(http.StatusMethodNotAllowed)
return
}
code, data, header := handler(request)
var content []byte
var err error
switch data.(type) {
case string:
content = []byte(data.(string))
case []byte:
content = data.([]byte)
default:
// Encode JSON.
content, err = json.MarshalIndent(data, "", " ")
if err != nil {
if header == nil {
header = http.Header{"Content-Type": {"application/json"}}
} else if header.Get("Content-Type") == "" {
header.Set("Content-Type", "application/json")
}
}
}
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
return
}
for name, values := range header {
for _, value := range values {
rw.Header().Add(name, value)
}
}
rw.WriteHeader(code)
rw.Write(content)
}
}
// Mux returns the muxer used by an API. If a ServeMux does not
// yet exist, a new *http.ServeMux will be created and returned.
func (api *API) Mux() APIMux {
if api.muxInitialized {
return api.mux
} else {
api.mux = mux.NewRouter()
api.muxInitialized = true
return api.mux
}
}
// SetMux sets the muxer to use by an API. A muxer needs to
// implement the APIMux interface (eg. http.ServeMux).
func (api *API) SetMux(mux APIMux) error {
if api.muxInitialized {
return errors.New("You cannot set a muxer when already initialized.")
} else {
api.mux = mux
api.muxInitialized = true
return nil
}
}
// AddResource adds a new resource to an API. The API will route
// requests that match one of the given paths to the matching HTTP
// method on the resource.
func (api *API) AddResource(resource interface{}, paths ...string) {
for _, path := range paths {
api.Mux().HandleFunc(path, api.requestHandler(resource))
}
}
// AddResourceWithWrapper behaves exactly like AddResource but wraps
// the generated handler function with a give wrapper function to allow
// to hook in Gzip support and similar.
func (api *API) AddResourceWithWrapper(resource interface{}, wrapper func(handler http.HandlerFunc) http.HandlerFunc, paths ...string) {
for _, path := range paths {
api.Mux().HandleFunc(path, wrapper(api.requestHandler(resource)))
}
}
// Start causes the API to begin serving requests on the given port.
func (api *API) Start(port int) error {
if !api.muxInitialized {
return errors.New("You must add at least one resource to this API.")
}
portString := fmt.Sprintf(":%d", port)
return http.ListenAndServe(portString, api.Mux())
}
Write Preview
Loading…
Cancel
Save