// fetches SC3ML and turns it into a protobuf.
func quakeTechnicalProto(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
if res := weft.CheckQuery(r, []string{}, []string{}); !res.Ok {
return res
}
by, res := getBytes(s3+strings.TrimPrefix(r.URL.Path, "/quake/technical/")+".xml", "")
if !res.Ok {
return res
}
q, err := sc3ml.QuakeTechnical(by)
if err != nil {
return weft.ServiceUnavailableError(err)
}
m, err := proto.Marshal(&q)
if err != nil {
return weft.ServiceUnavailableError(err)
}
b.Write(m)
h.Set("Content-Type", protobuf)
return &weft.StatusOK
}
func TestWarning(t *testing.T) {
hdr := http.Header{}
err := fmt.Errorf("modifier error")
Warning(hdr, err)
if got, want := len(hdr["Warning"]), 1; got != want {
t.Fatalf("len(hdr[%q]): got %d, want %d", "Warning", got, want)
}
want := `199 "martian" "modifier error"`
if got := hdr["Warning"][0]; !strings.HasPrefix(got, want) {
t.Errorf("hdr[%q][0]: got %q, want to have prefix %q", "Warning", got, want)
}
hdr.Set("Date", "Mon, 02 Jan 2006 15:04:05 GMT")
Warning(hdr, err)
if got, want := len(hdr["Warning"]), 2; got != want {
t.Fatalf("len(hdr[%q]): got %d, want %d", "Warning", got, want)
}
want = `199 "martian" "modifier error" "Mon, 02 Jan 2006 15:04:05 GMT"`
if got := hdr["Warning"][1]; got != want {
t.Errorf("hdr[%q][1]: got %q, want %q", "Warning", got, want)
}
}
func (s *Transport) createSubStream(parentID uint64) (*stream, error) {
referenceID := atomic.AddUint64(&s.referenceCounter, 1)
headers := http.Header{}
headers.Set("libchan-ref", strconv.FormatUint(referenceID, 10))
if parentID > 0 {
headers.Set("libchan-parent-ref", strconv.FormatUint(parentID, 10))
}
providedStream, err := s.provider.NewStream(headers)
if err != nil {
return nil, err
}
newStream := &stream{
referenceID: referenceID,
parentID: parentID,
stream: providedStream,
session: s,
}
// TODO: hold reference to the newly created stream
// for possible cleanup. This stream should not be put
// in the streams maps which holds remotely created
// streams and will can have reference id conflicts.
return newStream, nil
}
func (s *S) TestRespMustRevalidate(c *C) {
respHeaders := http.Header{}
respHeaders.Set("Cache-Control", "must-revalidate")
reqHeaders := http.Header{}
c.Assert(getFreshness(respHeaders, reqHeaders), Equals, stale)
}
// Retrieve the list of bytes already transferred by an unfinished upload
func (c *Client) GetUploadBytesSize(fileId, uploadId string, etags []string) (int, error) {
route := strings.Join([]string{FILE_ROUTE, fileId, "content"}, "/")
link := c.getURL(route, "")
newHeader := http.Header{}
newHeader.Set("Content-Range", "bytes /*/")
newHeader.Set("Upload-ID", uploadId)
newHeader.Set("Content-Length", "0")
if len(etags) > 0 {
for _, v := range etags {
newHeader.Add("If-Match", v)
}
}
res, err := c.request("PUT", link, &newHeader, nil)
defer res.Body.Close()
if err != nil {
return 0, nil
}
bytesUploaded, err := strconv.Atoi(res.Header.Get("Range"))
if err != nil {
return 0, errors.New("Unable to parse value of bytes transferred from HTTP-Header")
}
return bytesUploaded, err
}
func populateViaHeader(header http.Header, httpVersion string) {
via := httpVersion + " router"
if prior, ok := header["Via"]; ok {
via = strings.Join(prior, ", ") + ", " + via
}
header.Set("Via", via)
}
func fakeClientWith(testName string, t *testing.T, data map[string]string) ClientMapper {
return ClientMapperFunc(func(*meta.RESTMapping) (RESTClient, error) {
return &fake.RESTClient{
Codec: testapi.Default.Codec(),
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
p := req.URL.Path
q := req.URL.RawQuery
if len(q) != 0 {
p = p + "?" + q
}
body, ok := data[p]
if !ok {
t.Fatalf("%s: unexpected request: %s (%s)\n%#v", testName, p, req.URL, req)
}
header := http.Header{}
header.Set("Content-Type", runtime.ContentTypeJSON)
return &http.Response{
StatusCode: http.StatusOK,
Header: header,
Body: stringBody(body),
}, nil
}),
}, nil
})
}
func TestJWTAuthenticationWrongToken(t *testing.T) {
m := minion.Classic(minion.Options{JWTToken: "123"})
usersHandler := func(ctx *minion.Context) {
j := struct {
Message string `json:"message"`
}{
"ok",
}
ctx.JSON(200, j)
}
m.Get("/users", usersHandler)
ts := httptest.NewServer(m)
defer ts.Close()
var j, body string
var status int
tokenAuth := jwtauth.New("HS256", []byte("wrong"), nil)
_, tokenString, _ := tokenAuth.Encode(nil)
h := http.Header{}
h.Set("Authorization", "BEARER "+tokenString)
status, body = tst.Request(t, ts, "GET", "/users", h, nil)
tst.AssertEqual(t, 401, status)
j = `{"status":401,"message":"Unauthorized"}`
tst.AssertEqual(t, j, body)
}
func createFakeInfo(name string, labels map[string]string) *resource.Info {
pod := createFakePod(name, labels)
marshaledObj, _ := json.Marshal(pod)
mapping := &meta.RESTMapping{
Resource: name,
Scope: meta.RESTScopeNamespace,
GroupVersionKind: unversioned.GroupVersionKind{
Kind: "Pod",
Version: "v1",
}}
client := &fake.RESTClient{
Codec: testapi.Default.Codec(),
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
header := http.Header{}
header.Set("Content-Type", runtime.ContentTypeJSON)
return &http.Response{
StatusCode: 200,
Header: header,
Body: ioutil.NopCloser(bytes.NewReader(marshaledObj)),
}, nil
})}
info := resource.NewInfo(client, mapping, "default", "nginx", false)
info.Object = pod
return info
}
// setAllowHeader builds a Allow header based on the resource configuration.
func setAllowHeader(headers http.Header, isItem bool, conf resource.Conf) {
methods := []string{}
if isItem {
// Methods are sorted
if conf.IsModeAllowed(resource.Update) {
methods = append(methods, "DELETE")
}
if conf.IsModeAllowed(resource.Read) {
methods = append(methods, "GET, HEAD")
}
if conf.IsModeAllowed(resource.Update) {
methods = append(methods, "PATCH")
// See http://tools.ietf.org/html/rfc5789#section-3
headers.Set("Allow-Patch", "application/json")
}
if conf.IsModeAllowed(resource.Create) || conf.IsModeAllowed(resource.Replace) {
methods = append(methods, "PUT")
}
} else {
// Methods are sorted
if conf.IsModeAllowed(resource.Clear) {
methods = append(methods, "DELETE")
}
if conf.IsModeAllowed(resource.List) {
methods = append(methods, "GET, HEAD")
}
if conf.IsModeAllowed(resource.Create) {
methods = append(methods, "POST")
}
}
if len(methods) > 0 {
headers.Set("Allow", strings.Join(methods, ", "))
}
}
func TestJWTAuthentication(t *testing.T) {
m := minion.Classic(minion.Options{JWTToken: "123"})
usersHandler := func(ctx *minion.Context) {
j := struct {
Message string `json:"message"`
}{
"ok",
}
ctx.JSON(200, j)
}
m.Get("/users", usersHandler)
ts := httptest.NewServer(m)
defer ts.Close()
var j, body string
var status int
tokenString, _ := minion.CreateJWTToken(nil)
h := http.Header{}
h.Set("Authorization", "BEARER "+tokenString)
status, body = tst.Request(t, ts, "GET", "/users", h, nil)
tst.AssertEqual(t, 200, status)
j = `{"message":"ok"}`
tst.AssertEqual(t, j, body)
}
func TestEnv(t *testing.T) {
for k, c := range []struct {
expectedIP string
expectedOwner string
expectedUA string
request *http.Request
owner string
headers map[string]string
}{
{"1234", "peter", "firefox", &http.Request{RemoteAddr: "1234"}, "peter", map[string]string{"user-Agent": "firefox"}},
{"1234", "peter", "", &http.Request{RemoteAddr: "4321"}, "peter", map[string]string{"x-FoRwarded-FoR": "1234"}},
{"1234", "peter", "firefox", &http.Request{RemoteAddr: "4321"}, "peter", map[string]string{"x-FoRwarded-FoR": "1234", "user-Agent": "firefox"}},
} {
h := http.Header{}
for y, x := range c.headers {
h.Set(y, x)
}
r := c.request
r.Header = h
t.Logf("%v", r)
e := NewEnv(r)
e.Owner(c.owner)
assert.Equal(t, c.expectedIP, e.Ctx().ClientIP, "Case %d", k)
assert.Equal(t, c.expectedOwner, e.Ctx().Owner, "Case %d", k)
assert.Equal(t, c.expectedUA, e.Ctx().UserAgent, "Case %d", k)
}
}
// Here's the worker, of which we'll run several concurrent instances. Each
// worker will periodically make requests to the site to simulate users
// playing with it
func worker(done chan<- bool) {
// First connect to the WebSocket server
dialer := websocket.DefaultDialer
header := http.Header{}
header.Set("Origin", "http://bsprague.com")
conn, _, err := dialer.Dial("ws://192.168.2.1:8080/ws", header)
if err != nil {
fmt.Println("Error connecting to server", err)
done <- true
return
}
defer conn.Close()
go readLoop(conn)
// Tick regularly somewhere between every 25 and 75 ms
ticker := time.NewTicker(time.Millisecond * time.Duration(rand.Int63n(500)+250))
for _ = range ticker.C {
if err := conn.WriteJSON(randomBlock()); err != nil {
fmt.Println("Error sending block", err)
done <- true
return
}
}
done <- true
}
// SetViaHeader sets the Via header.
//
// If Via is already present, via is appended to
// the existing value.
//
// http://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-14#section-9.9
func SetViaHeader(header http.Header, via string) {
if v := header.Get("Via"); v != "" {
via = v + ", " + via
}
header.Set("Via", via)
}
func (imageService Service) queryImages(includeDetails bool, imagesResponseContainer interface{}, queryParameters *QueryParameters) error {
urlPostFix := "/images"
if includeDetails {
urlPostFix = urlPostFix + "/detail"
}
reqURL, err := buildQueryURL(imageService, queryParameters, urlPostFix)
if err != nil {
return err
}
var headers http.Header = http.Header{}
headers.Set("Accept", "application/json")
resp, err := imageService.Session.Get(reqURL.String(), nil, &headers)
if err != nil {
return err
}
err = util.CheckHTTPResponseStatusCode(resp)
if err != nil {
return err
}
rbody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return errors.New("aaa")
}
if err = json.Unmarshal(rbody, &imagesResponseContainer); err != nil {
return err
}
return nil
}
func copyHeaders(from, to http.Header) {
for k, list := range from {
for _, v := range list {
to.Set(k, v)
}
}
}
func (c *channel) createSubChannel(direction direction) (libchan.Sender, libchan.Receiver, error) {
if c.direction == inbound {
return nil, nil, errors.New("cannot create sub channel of an inbound channel")
}
referenceID := c.session.nextReferenceID()
headers := http.Header{}
headers.Set("libchan-ref", strconv.FormatUint(referenceID, 10))
headers.Set("libchan-parent-ref", strconv.FormatUint(c.referenceID, 10))
stream, streamErr := c.stream.CreateSubStream(headers, false)
if streamErr != nil {
return nil, nil, streamErr
}
subChannel := &channel{
referenceID: referenceID,
parentID: c.referenceID,
stream: stream,
session: c.session,
direction: direction,
}
c.session.channelC.L.Lock()
c.session.channels[referenceID] = subChannel
c.session.channelC.L.Unlock()
return subChannel, subChannel, nil
}
func redditRequest(method string, url string, values url.Values, header http.Header) ([]byte, error) {
form := strings.NewReader(values.Encode())
req, err := http.NewRequest(method, url, form)
if err != nil {
return nil, err
}
header.Set("User-Agent", userAgent)
header.Set("Content-Type", contentType)
req.Header = header
time.Sleep(timeBetweenRequests - time.Since(lastRequest))
lastRequest = time.Now()
fmt.Printf("Made request: %v\n", lastRequest)
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
return data, nil
}
func ExampleCORSConfig() {
// Simple Request using Test Browser
r := NewRouter()
r.SetGlobalCORS(CORSConfig{
Origins: []string{"*"},
Methods: []string{"POST", "PUT"},
Headers: []string{"X-Mangoes"},
ExposedHeaders: []string{"X-Mangoes"},
})
r.Get("/fruits", func(c *Context) {
c.RespondWith("GET fruits")
})
br := NewBrowser(r)
hdrs := http.Header{}
hdrs.Set("Origin", "http://bluecheese.com")
resp, err := br.Get("http://greencheese.com/fruits", hdrs)
if err != nil {
fmt.Println(err)
return
}
allowOrigin := resp.HeaderMap.Get("Access-Control-Allow-Origin")
exposedHeaders := resp.HeaderMap.Get("Access-Control-Expose-Headers")
fmt.Println(allowOrigin)
fmt.Println(exposedHeaders)
// Output:
// http://bluecheese.com
// X-Mangoes
}
// Build the Image
func (c *ImageService) Build(tag, dir string) error {
// tar the file
context, err := archive.Tar(dir, archive.Uncompressed)
if err != nil {
return err
}
var body io.Reader
body = ioutil.NopCloser(context)
// Upload the build context
v := url.Values{}
v.Set("t", tag)
v.Set("q", "1")
v.Set("rm", "1")
// url path
path := fmt.Sprintf("/build?%s", v.Encode())
// set content type to tar file
headers := http.Header{}
headers.Set("Content-Type", "application/tar")
// make the request
return c.stream("POST", path, body, os.Stdout, headers)
}
func (s *Transport) createSubStream(parentID uint64) (*stream, error) {
referenceID := atomic.AddUint64(&s.referenceCounter, 1)
headers := http.Header{}
headers.Set("libchan-ref", strconv.FormatUint(referenceID, 10))
if parentID > 0 {
headers.Set("libchan-parent-ref", strconv.FormatUint(parentID, 10))
}
providedStream, err := s.provider.NewStream(headers)
if err != nil {
return nil, err
}
newStream := &stream{
referenceID: referenceID,
parentID: parentID,
stream: providedStream,
session: s,
}
// TODO: Do not store reference
s.streamC.L.Lock()
s.streams[referenceID] = newStream
s.streamC.L.Unlock()
return newStream, nil
}
func valV2(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
if res := weft.CheckQuery(r, []string{}, []string{}); !res.Ok {
return res
}
var d string
err := db.QueryRow(`SELECT row_to_json(fc)
FROM ( SELECT 'FeatureCollection' as type, array_to_json(array_agg(f)) as features
FROM (SELECT 'Feature' as type,
ST_AsGeoJSON(v.location)::json as geometry,
row_to_json((SELECT l FROM
(
SELECT
id AS "volcanoID",
title AS "volcanoTitle",
alert_level as "level",
activity,
hazards
) as l
)) as properties FROM (haz.volcano JOIN haz.volcanic_alert_level using (alert_level)) as v ) As f ) as fc`).Scan(&d)
if err != nil {
return weft.ServiceUnavailableError(err)
}
b.WriteString(d)
h.Set("Content-Type", V2GeoJSON)
return &weft.StatusOK
}
func testGet(path string, headers map[string]string) *testResponse {
var header http.Header
for k, v := range headers {
header.Set(k, v)
}
return getTestResponse("GET", path, "", header, nil)
}
func volcanoRegionV2(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
if res := weft.CheckQuery(r, []string{}, []string{}); !res.Ok {
return res
}
var err error
var volcanoId string
if volcanoId, err = getVolcanoIDRegion(r); err != nil {
return weft.BadRequest(err.Error())
}
var d string
err = db.QueryRow(`SELECT row_to_json(fc)
FROM ( SELECT 'FeatureCollection' as type, COALESCE(array_to_json(array_agg(f)), '[]') as features
FROM (SELECT 'Feature' as type,
ST_AsGeoJSON(r.region)::json as geometry,
row_to_json((SELECT l FROM
(
SELECT id,
title
) as l
)) as properties
FROM haz.volcano as r
where id = $1) as f ) as fc;`, volcanoId).Scan(&d)
if err != nil {
return weft.ServiceUnavailableError(err)
}
b.WriteString(d)
h.Set("Content-Type", V2GeoJSON)
return &weft.StatusOK
}
func (c *Client) GetFileContent(fileId, rangeEtag string, startIndex, endIndex int, matchEtags []string) ([]byte, *http.Header, error) {
route := strings.Join([]string{FILE_ROUTE, fileId, "content"}, "/")
link := c.getURL(route, "")
// Construct header
byteRange := fmt.Sprintf("bytes=%d-%d", startIndex, endIndex)
newHeader := http.Header{}
newHeader.Add("Range", byteRange)
if rangeEtag != "" {
newHeader.Set("If-Range", rangeEtag)
}
if len(matchEtags) > 0 {
for _, v := range matchEtags {
newHeader.Add("If-None-Match", v)
}
}
res, err := c.request("GET", link, &newHeader, nil)
if err != nil {
return nil, nil, err
}
return unpackageResponse(res)
}
// getAuthSession returns an authenticated API Session
func (d *driver) getAuthSession() (session *napping.Session, err error) {
e := ApiError{}
s := napping.Session{
Userinfo: d.creds,
Client: d.httpClient,
}
url := d.url + loginUri
resp, err := s.Get(url, nil, nil, &e)
if err != nil {
return
}
token := resp.HttpResponse().Header.Get("X-SDS-AUTH-TOKEN")
h := http.Header{}
h.Set("X-SDS-AUTH-TOKEN", token)
session = &napping.Session{
Client: d.httpClient,
Header: &h,
}
return
}
func quakeV2(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
if res := weft.CheckQuery(r, []string{}, []string{}); !res.Ok {
return res
}
if len(r.URL.Query()) != 0 {
return weft.BadRequest("incorrect number of query parameters.")
}
var publicID string
var res *weft.Result
if publicID, res = getPublicIDPath(r); !res.Ok {
return res
}
var d string
err := db.QueryRow(quakeV2SQL, publicID).Scan(&d)
if err != nil {
return weft.ServiceUnavailableError(err)
}
b.WriteString(d)
h.Set("Content-Type", V2GeoJSON)
return &weft.StatusOK
}
// TranscribeWithIBM transcribes a given audio file using the IBM Watson
// Speech To Text API
func TranscribeWithIBM(filePath string, searchWords []string, IBMUsername string, IBMPassword string) (*IBMResult, error) {
result := new(IBMResult)
url := "wss://stream.watsonplatform.net/speech-to-text/api/v1/recognize?model=en-US_BroadbandModel"
header := http.Header{}
header.Set("Authorization", "Basic "+basicAuth(IBMUsername, IBMPassword))
dialer := websocket.DefaultDialer
ws, _, err := dialer.Dial(url, header)
if err != nil {
return nil, errors.Trace(err)
}
defer ws.Close()
requestArgs := map[string]interface{}{
"action": "start",
"content-type": "audio/flac",
"continuous": true,
"word_confidence": true,
"timestamps": true,
"profanity_filter": false,
"interim_results": false,
"inactivity_timeout": -1,
"keywords": searchWords,
"keywords_threshold": 0.5,
}
if err = ws.WriteJSON(requestArgs); err != nil {
return nil, errors.Trace(err)
}
log.Debug("Starting transcription using IBM")
if err = uploadFileWithWebsocket(ws, filePath); err != nil {
return nil, errors.Trace(err)
}
log.Debugf("Successfully uploaded %s to IBM", filePath)
// write empty message to indicate end of uploading file
if err = ws.WriteMessage(websocket.BinaryMessage, []byte{}); err != nil {
return nil, errors.Trace(err)
}
// IBM must receive a message every 30 seconds or it will close the websocket.
// This code concurrently writes a message every 5 second until returning.
ticker := time.NewTicker(5 * time.Second)
quit := make(chan struct{})
go keepConnectionOpen(ws, ticker, quit)
defer close(quit)
for {
err := ws.ReadJSON(&result)
if err != nil {
return nil, errors.Trace(err)
}
if len(result.Results) > 0 {
log.Debugf("IBM has returned results")
return result, nil
}
}
}
func (c *Client) prepareReq(method, rawurl string, header http.Header, in interface{}) (*http.Request, error) {
var payload io.Reader
switch v := in.(type) {
case io.Reader:
payload = v
case nil:
default:
var err error
payload, err = ToJSON(in)
if err != nil {
return nil, err
}
}
req, err := http.NewRequest(method, rawurl, payload)
if err != nil {
return nil, err
}
if header == nil {
header = make(http.Header)
}
if header.Get("Content-Type") == "" {
header.Set("Content-Type", "application/json")
}
req.Header = header
if c.Key != "" {
req.SetBasicAuth("", c.Key)
}
if c.Host != "" {
req.Host = c.Host
}
return req, nil
}
func quakeProto(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
if res := weft.CheckQuery(r, []string{}, []string{}); !res.Ok {
return res
}
var q haz.Quake
var res *weft.Result
if q.PublicID, res = getPublicIDPath(r); !res.Ok {
return res
}
var t time.Time
var mt time.Time
var err error
if err = db.QueryRow(quakeProtoSQL, q.PublicID).Scan(&t, &mt,
&q.Depth, &q.Magnitude, &q.Locality, &q.Mmi, &q.Quality,
&q.Longitude, &q.Latitude); err != nil {
return weft.ServiceUnavailableError(err)
}
q.Time = &haz.Timestamp{Sec: t.Unix(), Nsec: int64(t.Nanosecond())}
q.ModificationTime = &haz.Timestamp{Sec: mt.Unix(), Nsec: int64(mt.Nanosecond())}
var by []byte
if by, err = proto.Marshal(&q); err != nil {
return weft.ServiceUnavailableError(err)
}
b.Write(by)
h.Set("Content-Type", protobuf)
return &weft.StatusOK
}