Method ServeBCP

src/bcp/server.go:26–393

(ctx context.Context, ep blobcache.Endpoint, req Message, resp *Message)

}

func (s *Server) ServeBCP(ctx context.Context, ep blobcache.Endpoint, req Message, resp *Message) bool {
	svc := s.Access(ep.Node)
	if svc == nil {
		return false
	}

	switch req.Header().Code() {
	case MT_PING:
		resp.SetCode(MT_OK)
		resp.SetBody(nil)
	case MT_ENDPOINT:
		handleAsk(req, resp, &EndpointReq{}, func(req *EndpointReq) (*EndpointResp, error) {
			ep, err := svc.Endpoint(ctx)
			if err != nil {
				return nil, err
			}
			return &EndpointResp{Endpoint: ep}, nil
		})

	// BEGIN HANDLE
	case MT_HANDLE_DROP:
		handleAsk(req, resp, &DropReq{}, func(req *DropReq) (*DropResp, error) {
			if err := svc.Drop(ctx, req.Handle); err != nil {
				return nil, err
			}
			return &DropResp{}, nil
		})
	case MT_HANDLE_INSPECT:
		handleAsk(req, resp, &InspectHandleReq{}, func(req *InspectHandleReq) (*InspectHandleResp, error) {
			info, err := svc.InspectHandle(ctx, req.Handle)
			if err != nil {
				return nil, err
			}
			return &InspectHandleResp{Info: *info}, nil
		})
	case MT_HANDLE_KEEP_ALIVE:
		handleAsk(req, resp, &KeepAliveReq{}, func(req *KeepAliveReq) (*KeepAliveResp, error) {
			if err := svc.KeepAlive(ctx, req.Handles); err != nil {
				return nil, err
			}
			return &KeepAliveResp{}, nil
		})
	case MT_HANDLE_SHARE_OUT:
		handleAsk(req, resp, &ShareOutReq{}, func(req *ShareOutReq) (*ShareOutResp, error) {
			h, err := svc.ShareOut(ctx, req.Handle, req.Peer, req.Mask)
			if err != nil {
				return nil, err
			}
			return &ShareOutResp{Handle: *h}, nil
		})
	case MT_HANDLE_SHARE_IN:
		handleAsk(req, resp, &ShareInReq{}, func(req *ShareInReq) (*ShareInResp, error) {
			h, err := svc.ShareIn(ctx, req.Host, req.Handle)
			if err != nil {
				return nil, err
			}
			return &ShareInResp{Handle: h}, nil
		})