Golang Header Examples

Example #1

File: aoe_test.go Project: ConfusedReality/server_distributed-storage_torus

// headersEqual compares a response and request AoE header for equality, but
// does not factor in their Arg fields.
func headersEqual(res, req aoe.Header) bool {
	if !res.FlagResponse {
		panic("response AoE header did not have FlagResponse set, please verify parameter order")
	}

	// Set request's response flag for comparison
	req.FlagResponse = true

	// Clear arguments of both request and response so we can compare the
	// headers, and because the arguments are compared separately
	req.Arg = nil
	res.Arg = nil

	return reflect.DeepEqual(res, req)
}

Example #2

File: frame.go Project: ConfusedReality/server_distributed-storage_torus

func (fs *FrameSender) Send(hdr *aoe.Header) (int, error) {
	hdr.Version = 1
	hdr.FlagResponse = true
	hdr.Major = fs.major
	hdr.Minor = fs.minor
	hdr.Tag = fs.orig.Tag

	hbuf, err := hdr.MarshalBinary()
	if err != nil {
		panic(err)
	}

	frame := &ethernet.Frame{
		Destination: fs.dst,
		Source:      fs.src,
		EtherType:   aoe.EtherType,
		Payload:     hbuf,
	}

	ebuf, err := frame.MarshalBinary()
	if err != nil {
		panic(err)
	}

	clog.Debugf("send %d %s %+v", len(ebuf), fs.dst, hdr)
	//clog.Debugf("send arg %+v", hdr.Arg)

	return fs.conn.WriteTo(ebuf, &raw.Addr{HardwareAddr: fs.dst})
}

Example #3

File: aoe_test.go Project: ConfusedReality/server_distributed-storage_torus

// testRequest performs a single AoE request using the input request
// header and returns a single AoE response.
func testRequest(t *testing.T, req *aoe.Header) *aoe.Header {
	recv, send, run, done := testAoEServer(t)
	defer done()

	reqb, err := req.MarshalBinary()
	if err != nil {
		t.Fatalf("failed to marshal request AoE header: %v", err)
	}

	reqf := &ethernet.Frame{
		Payload: reqb,
	}

	reqfb, err := reqf.MarshalBinary()
	if err != nil {
		t.Fatalf("failed to marshal request Ethernet frame: %v", err)
	}

	if _, err := send.Write(reqfb); err != nil {
		t.Fatalf("failed to write request to server: %v", err)
	}

	if err := run(); err != nil {
		t.Fatalf("failed to run server: %v", err)
	}

	b, err := ioutil.ReadAll(recv)
	if err != nil {
		t.Fatalf("failed to read server response: %v", err)
	}

	resf := new(ethernet.Frame)
	if err := resf.UnmarshalBinary(b); err != nil {
		t.Fatalf("failed to unmarshal response Ethernet frame: %v", err)
	}

	resh := new(aoe.Header)
	if err := resh.UnmarshalBinary(resf.Payload); err != nil {
		t.Fatalf("failed to unmarshal response AoE header: %v", err)
	}

	return resh
}

Example #4

File: aoe_test.go Project: ConfusedReality/server_distributed-storage_torus

// testBPFProgram builds a BPF program for the input server and compares the
// output of the program against the input AoE header, returning whether or
// not the header was accepted by the filter.
func testBPFProgram(t *testing.T, s *Server, h *aoe.Header) bool {
	filter, ok := bpf.Disassemble(s.mustAssembleBPF(testMTU))
	if !ok {
		t.Fatal("failed to decode all BPF instructions")
	}

	vm, err := bpf.NewVM(filter)
	if !ok {
		t.Fatalf("failed to load BPF program: %v", err)
	}

	// Fill in empty AoE header fields not relevant to this test
	h.Version = aoe.Version
	h.Command = aoe.CommandQueryConfigInformation
	h.Arg = &aoe.ConfigArg{
		Command: aoe.ConfigCommandRead,
	}

	hb, err := h.MarshalBinary()
	if err != nil {
		t.Fatalf("failed to marshal AoE header to binary: %v", err)
	}

	f := &ethernet.Frame{
		EtherType: aoe.EtherType,
		Payload:   hb,
	}
	fb, err := f.MarshalBinary()
	if err != nil {
		t.Fatalf("failed to marshal Ethernet frame to binary: %v", err)
	}

	out, err := vm.Run(fb)
	if err != nil {
		t.Fatalf("failed to run BPF program: %v", err)
	}

	return out > 0
}