func ReadMessage(read *bufio.Reader, response proto.Message) error { payload, err := readPayload(read) if err != nil { return err } message := &protocol.Message{} err = proto.Unmarshal(payload, message) if err != nil { return err } // error response from server if message.GetType() == protocol.Message_Type(1) { errorResponse := &protocol.ErrorResponse{} err = proto.Unmarshal(message.Payload, errorResponse) if err != nil { return errors.New("error unmarshalling error!") } return &WardenError{ Message: errorResponse.GetMessage(), Data: errorResponse.GetData(), Backtrace: errorResponse.GetBacktrace(), } } responseType := protocol.TypeForMessage(response) if message.GetType() != responseType { return &TypeMismatchError{ Expected: responseType, Received: message.GetType(), } } return proto.Unmarshal(message.GetPayload(), response) }
func (c *connection) sendMessage(req proto.Message) error { c.writeLock.Lock() defer c.writeLock.Unlock() request, err := proto.Marshal(req) if err != nil { return err } msg := &protocol.Message{ Type: protocol.TypeForMessage(req).Enum(), Payload: request, } data, err := proto.Marshal(msg) if err != nil { return err } _, err = c.conn.Write( []byte( fmt.Sprintf( "%d\r\n%s\r\n", len(data), data, ), ), ) if err != nil { c.notifyDisconnected() return err } return nil }
"backtrace line 1", "backtrace line 2", }, }, )) }) }) Context("when a message of the wrong type is received", func() { It("returns a TypeMismatchError", func() { var dummyResponse protocol.PingResponse actualResponse := &protocol.EchoResponse{ Message: proto.String("some message"), } err := transport.ReadMessage( bufio.NewReader(protocol.Messages(actualResponse)), &dummyResponse, ) Expect(err).To(Equal( &transport.TypeMismatchError{ Expected: protocol.TypeForMessage(&dummyResponse), Received: protocol.TypeForMessage(actualResponse), }, )) }) }) })
func generateCommand(request reflect.Value) cli.Command { typ := request.Elem().Type() commandName := lowercase(strings.TrimSuffix(typ.Name(), "Request")) usage := USAGE[commandName] flags := []cli.Flag{} for i := 0; i < typ.NumField(); i++ { field := typ.Field(i) flag, ok := flagForField(field, usage.Flags) if ok { flags = append(flags, flag) } } return cli.Command{ Name: commandName, Flags: flags, Usage: usage.Usage, Description: usage.Description, Action: func(c *cli.Context) { cp := connectionInfo(c) conn, err := cp.ProvideConnection() if err != nil { fmt.Println("failed to connect to warden:", err) os.Exit(1) } request := requestFromInput(request, flags, c) response := warden.ResponseMessageForType(warden.TypeForMessage(request)) encoder := json.NewEncoder(os.Stdout) if commandName == "attach" { err := conn.SendMessage(request) if err != nil { fmt.Println("request-response failed:", err) os.Exit(1) } streamProcessPayloads(conn, encoder) return } err = conn.RoundTrip(request, response) if err != nil { fmt.Println("request-response failed:", err) os.Exit(1) } if commandName == "streamOut" { streamStreamOut(conn) return } if commandName == "streamIn" { streamStreamIn(conn) return } encoder.Encode(response) if commandName == "run" { streamProcessPayloads(conn, encoder) } }, } }
fakeContainer := container.(*fake_backend.FakeContainer) fakeContainer.StreamedProcessChunks = []warden.ProcessStream{ { ExitStatus: &exitStatus, }, } }) It("does not wait for it to complete", func() { writeMessages(request) time.Sleep(10 * time.Millisecond) before := time.Now() wardenServer.Stop() Expect(time.Since(before)).To(BeNumerically("<", 50*time.Millisecond)) response := protocol.ResponseMessageForType(protocol.TypeForMessage(request)) readResponse(response) _, err := protocol.Messages(&protocol.PingRequest{}).WriteTo(serverConnection) Expect(err).To(HaveOccurred()) }) }) } }) })