func (c *Connection) Stop(handle string, background, kill bool) (*warden.StopResponse, error) { res, err := c.RoundTrip( &warden.StopRequest{ Handle: proto.String(handle), Background: proto.Bool(background), Kill: proto.Bool(kill), }, &warden.StopResponse{}, ) if err != nil { return nil, err } return res.(*warden.StopResponse), nil }
func newTestMessage() *pb.MyMessage { msg := &pb.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), Quote: proto.String(`"I didn't want to go."`), Pet: []string{"bunny", "kitty", "horsey"}, Inner: &pb.InnerMessage{ Host: proto.String("footrest.syd"), Port: proto.Int32(7001), Connected: proto.Bool(true), }, Others: []*pb.OtherMessage{ { Key: proto.Int64(0xdeadbeef), Value: []byte{1, 65, 7, 12}, }, { Weight: proto.Float32(6.022), Inner: &pb.InnerMessage{ Host: proto.String("lesha.mtv"), Port: proto.Int32(8002), }, }, }, Bikeshed: pb.MyMessage_BLUE.Enum(), Somegroup: &pb.MyMessage_SomeGroup{ GroupField: proto.Int32(8), }, // One normally wouldn't do this. // This is an undeclared tag 13, as a varint (wire type 0) with value 4. XXX_unrecognized: []byte{13<<3 | 0, 4}, } ext := &pb.Ext{ Data: proto.String("Big gobs for big rats"), } if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil { panic(err) } greetings := []string{"adg", "easy", "cow"} if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil { panic(err) } // Add an unknown extension. We marshal a pb.Ext, and fake the ID. b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")}) if err != nil { panic(err) } b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...) proto.SetRawExtension(msg, 201, b) // Extensions can be plain fields, too, so let's test that. b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19) proto.SetRawExtension(msg, 202, b) return msg }
// Encodes the SnapshotResponse to a buffer. Returns the number of bytes // written and any error that may have occurred. func (resp *SnapshotResponse) Encode(w io.Writer) (int, error) { pb := &protobuf.SnapshotResponse{ Success: proto.Bool(resp.Success), } p, err := proto.Marshal(pb) if err != nil { return -1, err } return w.Write(p) }
// Creates a new AppendEntries response. func newAppendEntriesResponse(term uint64, success bool, index uint64, commitIndex uint64) *AppendEntriesResponse { pb := &protobuf.AppendEntriesResponse{ Term: proto.Uint64(term), Index: proto.Uint64(index), Success: proto.Bool(success), CommitIndex: proto.Uint64(commitIndex), } return &AppendEntriesResponse{ pb: pb, } }
// Encode writes the response to a writer. // Returns the number of bytes written and any error that occurs. func (req *SnapshotRecoveryResponse) Encode(w io.Writer) (int, error) { pb := &protobuf.SnapshotRecoveryResponse{ Term: proto.Uint64(req.Term), Success: proto.Bool(req.Success), CommitIndex: proto.Uint64(req.CommitIndex), } p, err := proto.Marshal(pb) if err != nil { return -1, err } return w.Write(p) }
// Encodes the RequestVoteResponse to a buffer. Returns the number of bytes // written and any error that may have occurred. func (resp *RequestVoteResponse) Encode(w io.Writer) (int, error) { pb := &protobuf.RequestVoteResponse{ Term: proto.Uint64(resp.Term), VoteGranted: proto.Bool(resp.VoteGranted), } p, err := proto.Marshal(pb) if err != nil { return -1, err } return w.Write(p) }
func (c *Connection) Spawn(handle, script string, discardOutput bool) (*warden.SpawnResponse, error) { res, err := c.RoundTrip( &warden.SpawnRequest{ Handle: proto.String(handle), Script: proto.String(script), DiscardOutput: proto.Bool(discardOutput), }, &warden.SpawnResponse{}, ) if err != nil { return nil, err } return res.(*warden.SpawnResponse), nil }
func streamStreamIn(conn connection.Connection) { for { buf := make([]byte, 64*1024) n, err := os.Stdin.Read(buf) if n > 0 { err := conn.SendMessage(&warden.StreamChunk{ Content: buf[:n], }) if err != nil { fmt.Println("writing content failed:", err) os.Exit(1) } } if err == io.EOF { err := conn.SendMessage(&warden.StreamChunk{ EOF: proto.Bool(true), }) if err != nil { fmt.Println("writing EOF failed:", err) os.Exit(1) } break } if err != nil { fmt.Println("stream interrupted:", err) os.Exit(1) } } resp := &warden.StreamInResponse{} err := conn.ReadResponse(resp) if err != nil { fmt.Println("stream failed:", err) os.Exit(1) } }
}) Describe("Stopping", func() { BeforeEach(func() { wardenMessages = append(wardenMessages, &protocol.StopResponse{}, ) }) It("should stop the container", func() { err := connection.Stop("foo", true, true) Ω(err).ShouldNot(HaveOccurred()) assertWriteBufferContains(&protocol.StopRequest{ Handle: proto.String("foo"), Background: proto.Bool(true), Kill: proto.Bool(true), }) }) }) Describe("Destroying", func() { BeforeEach(func() { wardenMessages = append(wardenMessages, &protocol.DestroyResponse{}, ) }) It("should stop the container", func() { err := connection.Destroy("foo") Ω(err).ShouldNot(HaveOccurred())
import ( "testing" "code.google.com/p/gogoprotobuf/proto" pb "./testdata" ) var cloneTestMessage = &pb.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), Pet: []string{"bunny", "kitty", "horsey"}, Inner: &pb.InnerMessage{ Host: proto.String("niles"), Port: proto.Int32(9099), Connected: proto.Bool(true), }, Others: []*pb.OtherMessage{ { Value: []byte("some bytes"), }, }, Somegroup: &pb.MyMessage_SomeGroup{ GroupField: proto.Int32(6), }, RepBytes: [][]byte{[]byte("sham"), []byte("wow")}, } func init() { ext := &pb.Ext{ Data: proto.String("extension"),
func findHandler(wr http.ResponseWriter, req *http.Request) { // URL: /metrics/find/?local=1&format=pickle&query=the.metric.path.with.glob Metrics.FindRequests.Add(1) req.ParseForm() format := req.FormValue("format") query := req.FormValue("query") if format != "json" && format != "pickle" && format != "protobuf" { Metrics.FindErrors.Add(1) log.Warnf("dropping invalid uri (format=%s): %s", format, req.URL.RequestURI()) http.Error(wr, "Bad request (unsupported format)", http.StatusBadRequest) return } if query == "" { Metrics.FindErrors.Add(1) log.Warnf("dropping invalid request (query=): %s", req.URL.RequestURI()) http.Error(wr, "Bad request (no query)", http.StatusBadRequest) return } /* things to glob: * - carbon.relays -> carbon.relays * - carbon.re -> carbon.relays, carbon.rewhatever * - carbon.[rz] -> carbon.relays, carbon.zipper * - carbon.{re,zi} -> carbon.relays, carbon.zipper * - match is either dir or .wsp file * unfortunately, filepath.Glob doesn't handle the curly brace * expansion for us */ query = strings.Replace(query, ".", "/", -1) var globs []string if !strings.HasSuffix(query, "*") { globs = append(globs, query+".wsp") } globs = append(globs, query) for { bracematch := false var newglobs []string for _, glob := range globs { lbrace := strings.Index(glob, "{") rbrace := -1 if lbrace > -1 { rbrace = strings.Index(glob[lbrace:], "}") if rbrace > -1 { rbrace += lbrace } } if lbrace > -1 && rbrace > -1 { bracematch = true expansion := glob[lbrace+1 : rbrace] parts := strings.Split(expansion, ",") for _, sub := range parts { if len(newglobs) > config.MaxGlobs { break } newglobs = append(newglobs, glob[:lbrace]+sub+glob[rbrace+1:]) } } else { if len(newglobs) > config.MaxGlobs { break } newglobs = append(newglobs, glob) } } globs = newglobs if !bracematch { break } } var files []string for _, glob := range globs { nfiles, err := filepath.Glob(config.WhisperData + "/" + glob) if err == nil { files = append(files, nfiles...) } } leafs := make([]bool, len(files)) for i, p := range files { p = p[len(config.WhisperData+"/"):] if strings.HasSuffix(p, ".wsp") { p = p[:len(p)-4] leafs[i] = true } else { leafs[i] = false } files[i] = strings.Replace(p, "/", ".", -1) } if format == "json" || format == "protobuf" { name := req.FormValue("query") response := pb.GlobResponse{ Name: &name, Matches: make([]*pb.GlobMatch, 0), } for i, p := range files { response.Matches = append(response.Matches, &pb.GlobMatch{Path: proto.String(p), IsLeaf: proto.Bool(leafs[i])}) } var b []byte var err error switch format { case "json": b, err = json.Marshal(response) case "protobuf": b, err = proto.Marshal(&response) } if err != nil { Metrics.FindErrors.Add(1) log.Errorf("failed to create %s data for glob %s: %s", format, *response.Name, err) return } wr.Write(b) } else if format == "pickle" { // [{'metric_path': 'metric', 'intervals': [(x,y)], 'isLeaf': True},] var metrics []map[string]interface{} var m map[string]interface{} for i, p := range files { m = make(map[string]interface{}) m["metric_path"] = p // m["intervals"] = dunno how to do a tuple here m["isLeaf"] = leafs[i] metrics = append(metrics, m) } wr.Header().Set("Content-Type", "application/pickle") pEnc := pickle.NewEncoder(wr) pEnc.Encode(metrics) } log.Infof("find: %d hits for %s", len(files), req.FormValue("query")) return }
It("should be able to create, stop and destroy a container", func() { res, err := client.Create() Ω(err).ShouldNot(HaveOccurred()) Ω(res.GetHandle()).Should(Equal("foo")) _, err = client.Stop("foo", true, true) Ω(err).ShouldNot(HaveOccurred()) _, err = client.Destroy("foo") Ω(err).ShouldNot(HaveOccurred()) expectedWriteBufferContents := string(warden.Messages( &warden.CreateRequest{}, &warden.StopRequest{ Handle: proto.String("foo"), Background: proto.Bool(true), Kill: proto.Bool(true), }, &warden.DestroyRequest{Handle: proto.String("foo")}, ).Bytes()) Ω(string(writeBuffer.Bytes())).Should(Equal(expectedWriteBufferContents)) }) }) Describe("Spawning and streaming", func() { BeforeEach(func() { provider = NewFakeConnectionProvider( warden.Messages( &warden.SpawnResponse{ JobId: proto.Uint32(42),