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())
})
})
}
})
})
