diff --git a/Dockerfile b/Dockerfile index bea06624c..e8726201a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -34,7 +34,9 @@ RUN --mount=type=cache,target=/root/.cache/go-build \ make xbins FROM scratch AS protos -COPY --from=make-protos /go/src/github.com/docker/api/backend/v1/*.pb.go . +COPY --from=make-protos /go/src/github.com/docker/api/backend/v1/*.pb.go ./backend/v1/ +COPY --from=make-protos /go/src/github.com/docker/api/compose/v1/*.pb.go ./compose/v1/ +COPY --from=make-protos /go/src/github.com/docker/api/cli/v1/*.pb.go ./cli/v1/ FROM scratch AS bins COPY --from=make-bins /go/src/github.com/docker/api/bin/* . diff --git a/Makefile b/Makefile index 969ad76b3..f662ce130 100644 --- a/Makefile +++ b/Makefile @@ -49,7 +49,7 @@ xcli: cli dprotos: docker build . \ - --output type=local,dest=./backend/v1 \ + --output type=local,dest=. \ --target protos dbins: dprotos diff --git a/azure/backend.go b/azure/backend.go index 884a9dc4a..cf06f17cc 100644 --- a/azure/backend.go +++ b/azure/backend.go @@ -30,15 +30,15 @@ func getter() interface{} { func New(ctx context.Context) (containers.ContainerService, error) { cc := apicontext.CurrentContext(ctx) - s, err := store.New() + contextStore, err := store.New() if err != nil { return nil, err } - m, err := s.Get(cc, getter) + metadata, err := contextStore.Get(cc, getter) if err != nil { return nil, errors.Wrap(err, "wrong context type") } - tc, _ := m.Metadata.Data.(store.AciContext) + tc, _ := metadata.Metadata.Data.(store.AciContext) auth, _ := auth.NewAuthorizerFromCLI() containerGroupsClient := containerinstance.NewContainerGroupsClient(tc.SubscriptionID) diff --git a/backend/backend.go b/backend/backend.go index fec32c865..914cdac9e 100644 --- a/backend/backend.go +++ b/backend/backend.go @@ -3,6 +3,7 @@ package backend import ( "context" "errors" + "fmt" ) var ( @@ -50,5 +51,5 @@ func Get(ctx context.Context, backendType string) (interface{}, error) { } } - return nil, errors.New("not found") + return nil, fmt.Errorf("backend not found for context %q", backendType) } diff --git a/cli/cmd/ps.go b/cli/cmd/ps.go index dc8a74691..ecad35043 100644 --- a/cli/cmd/ps.go +++ b/cli/cmd/ps.go @@ -21,7 +21,7 @@ var PsCommand = cobra.Command{ return errors.Wrap(err, "cannot connect to backend") } - containers, err := c.ContainerService(ctx).List(ctx) + containers, err := c.ContainerService().List(ctx) if err != nil { return errors.Wrap(err, "fetch containers") } diff --git a/cli/cmd/serve.go b/cli/cmd/serve.go new file mode 100644 index 000000000..544aff3f2 --- /dev/null +++ b/cli/cmd/serve.go @@ -0,0 +1,88 @@ +package cmd + +import ( + "context" + "net" + + cliv1 "github.com/docker/api/cli/v1" + containersv1 "github.com/docker/api/containers/v1" + "github.com/docker/api/context/store" + "github.com/docker/api/server" + "github.com/docker/api/server/proxy" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" + + "github.com/spf13/cobra" +) + +type serveOpts struct { + address string +} + +func ServeCommand() *cobra.Command { + var opts serveOpts + cmd := &cobra.Command{ + Use: "serve", + Short: "Start an api server", + RunE: func(cmd *cobra.Command, args []string) error { + return runServe(cmd.Context(), opts) + }, + } + + cmd.Flags().StringVar(&opts.address, "address", "", "The address to listen to") + + return cmd +} + +func runServe(ctx context.Context, opts serveOpts) error { + s := server.New() + + listener, err := net.Listen("unix", opts.address) + if err != nil { + return errors.Wrap(err, "listen unix socket") + } + defer listener.Close() + + p := proxy.NewContainerApi() + + containersv1.RegisterContainersServer(s, p) + cliv1.RegisterCliServer(s, &cliServer{ + ctx, + }) + + go func() { + <-ctx.Done() + logrus.Info("stopping server") + s.Stop() + }() + + logrus.WithField("address", opts.address).Info("serving daemon API") + + // start the GRPC server to serve on the listener + return s.Serve(listener) +} + +type cliServer struct { + ctx context.Context +} + +func (cs *cliServer) Contexts(ctx context.Context, request *cliv1.ContextsRequest) (*cliv1.ContextsResponse, error) { + s, err := store.New() + if err != nil { + logrus.Error(err) + return &cliv1.ContextsResponse{}, err + } + contexts, err := s.List() + if err != nil { + logrus.Error(err) + return &cliv1.ContextsResponse{}, err + } + result := &cliv1.ContextsResponse{} + for _, c := range contexts { + result.Contexts = append(result.Contexts, &cliv1.Context{ + Name: c.Name, + ContextType: c.Metadata.Type, + }) + } + return result, nil +} diff --git a/cli/main.go b/cli/main.go index a1cda0d3f..b44a78aad 100644 --- a/cli/main.go +++ b/cli/main.go @@ -65,14 +65,14 @@ func init() { } } -func isContextCommand(cmd *cobra.Command) bool { +func isOwnCommand(cmd *cobra.Command) bool { if cmd == nil { return false } - if cmd.Name() == "context" { + if cmd.Name() == "context" || cmd.Name() == "serve" { return true } - return isContextCommand(cmd.Parent()) + return isOwnCommand(cmd.Parent()) } func main() { @@ -82,7 +82,7 @@ func main() { Long: "docker for the 2020s", SilenceErrors: true, PersistentPreRunE: func(cmd *cobra.Command, args []string) error { - if !isContextCommand(cmd) { + if !isOwnCommand(cmd) { execMoby(cmd.Context()) } return nil @@ -94,7 +94,7 @@ func main() { helpFunc := root.HelpFunc() root.SetHelpFunc(func(cmd *cobra.Command, args []string) { - if !isContextCommand(cmd) { + if !isOwnCommand(cmd) { execMoby(cmd.Context()) } helpFunc(cmd, args) @@ -112,13 +112,26 @@ func main() { root.AddCommand( cmd.ContextCommand(), &cmd.PsCommand, + cmd.ServeCommand(), &cmd.ExampleCommand, ) ctx, cancel := util.NewSigContext() defer cancel() - ctx, err := apicontext.WithCurrentContext(ctx, opts.Config, opts.Context) + config, err := apicontext.LoadConfigFile(opts.Config, "config.json") + if err != nil { + logrus.Fatal("unable ot find configuration") + } + currentContext := opts.Context + if currentContext == "" { + currentContext = config.CurrentContext + } + if currentContext == "" { + currentContext = "default" + } + + ctx = apicontext.WithCurrentContext(ctx, currentContext) if err != nil { logrus.Fatal(err) } diff --git a/cli/v1/cli.pb.go b/cli/v1/cli.pb.go new file mode 100644 index 000000000..7990f2982 --- /dev/null +++ b/cli/v1/cli.pb.go @@ -0,0 +1,371 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.21.0-devel +// protoc v3.6.1 +// source: cli/v1/cli.proto + +package v1 + +import ( + context "context" + proto "github.com/golang/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// This is a compile-time assertion that a sufficiently up-to-date version +// of the legacy proto package is being used. +const _ = proto.ProtoPackageIsVersion4 + +type Context struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + ContextType string `protobuf:"bytes,2,opt,name=contextType,proto3" json:"contextType,omitempty"` +} + +func (x *Context) Reset() { + *x = Context{} + if protoimpl.UnsafeEnabled { + mi := &file_cli_v1_cli_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Context) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Context) ProtoMessage() {} + +func (x *Context) ProtoReflect() protoreflect.Message { + mi := &file_cli_v1_cli_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Context.ProtoReflect.Descriptor instead. +func (*Context) Descriptor() ([]byte, []int) { + return file_cli_v1_cli_proto_rawDescGZIP(), []int{0} +} + +func (x *Context) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Context) GetContextType() string { + if x != nil { + return x.ContextType + } + return "" +} + +type ContextsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ContextsRequest) Reset() { + *x = ContextsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cli_v1_cli_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContextsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContextsRequest) ProtoMessage() {} + +func (x *ContextsRequest) ProtoReflect() protoreflect.Message { + mi := &file_cli_v1_cli_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContextsRequest.ProtoReflect.Descriptor instead. +func (*ContextsRequest) Descriptor() ([]byte, []int) { + return file_cli_v1_cli_proto_rawDescGZIP(), []int{1} +} + +type ContextsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Contexts []*Context `protobuf:"bytes,1,rep,name=contexts,proto3" json:"contexts,omitempty"` +} + +func (x *ContextsResponse) Reset() { + *x = ContextsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cli_v1_cli_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ContextsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ContextsResponse) ProtoMessage() {} + +func (x *ContextsResponse) ProtoReflect() protoreflect.Message { + mi := &file_cli_v1_cli_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ContextsResponse.ProtoReflect.Descriptor instead. +func (*ContextsResponse) Descriptor() ([]byte, []int) { + return file_cli_v1_cli_proto_rawDescGZIP(), []int{2} +} + +func (x *ContextsResponse) GetContexts() []*Context { + if x != nil { + return x.Contexts + } + return nil +} + +var File_cli_v1_cli_proto protoreflect.FileDescriptor + +var file_cli_v1_cli_proto_rawDesc = []byte{ + 0x0a, 0x10, 0x63, 0x6c, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x61, + 0x70, 0x69, 0x2e, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x22, 0x3f, 0x0a, 0x07, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x78, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x4e, 0x0a, + 0x10, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x3a, 0x0a, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, + 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x52, 0x08, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, 0x32, 0x62, 0x0a, + 0x03, 0x43, 0x6c, 0x69, 0x12, 0x5b, 0x0a, 0x08, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, + 0x12, 0x26, 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x63, 0x6f, 0x6d, 0x2e, 0x64, + 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x63, 0x6c, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x42, 0x21, 0x5a, 0x1f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6c, 0x69, 0x2f, 0x76, + 0x31, 0x3b, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_cli_v1_cli_proto_rawDescOnce sync.Once + file_cli_v1_cli_proto_rawDescData = file_cli_v1_cli_proto_rawDesc +) + +func file_cli_v1_cli_proto_rawDescGZIP() []byte { + file_cli_v1_cli_proto_rawDescOnce.Do(func() { + file_cli_v1_cli_proto_rawDescData = protoimpl.X.CompressGZIP(file_cli_v1_cli_proto_rawDescData) + }) + return file_cli_v1_cli_proto_rawDescData +} + +var file_cli_v1_cli_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_cli_v1_cli_proto_goTypes = []interface{}{ + (*Context)(nil), // 0: com.docker.api.cli.v1.Context + (*ContextsRequest)(nil), // 1: com.docker.api.cli.v1.ContextsRequest + (*ContextsResponse)(nil), // 2: com.docker.api.cli.v1.ContextsResponse +} +var file_cli_v1_cli_proto_depIdxs = []int32{ + 0, // 0: com.docker.api.cli.v1.ContextsResponse.contexts:type_name -> com.docker.api.cli.v1.Context + 1, // 1: com.docker.api.cli.v1.Cli.Contexts:input_type -> com.docker.api.cli.v1.ContextsRequest + 2, // 2: com.docker.api.cli.v1.Cli.Contexts:output_type -> com.docker.api.cli.v1.ContextsResponse + 2, // [2:3] is the sub-list for method output_type + 1, // [1:2] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_cli_v1_cli_proto_init() } +func file_cli_v1_cli_proto_init() { + if File_cli_v1_cli_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_cli_v1_cli_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Context); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cli_v1_cli_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContextsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cli_v1_cli_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ContextsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_cli_v1_cli_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_cli_v1_cli_proto_goTypes, + DependencyIndexes: file_cli_v1_cli_proto_depIdxs, + MessageInfos: file_cli_v1_cli_proto_msgTypes, + }.Build() + File_cli_v1_cli_proto = out.File + file_cli_v1_cli_proto_rawDesc = nil + file_cli_v1_cli_proto_goTypes = nil + file_cli_v1_cli_proto_depIdxs = nil +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConnInterface + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion6 + +// CliClient is the client API for Cli service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type CliClient interface { + // Returns the list of existing contexts + Contexts(ctx context.Context, in *ContextsRequest, opts ...grpc.CallOption) (*ContextsResponse, error) +} + +type cliClient struct { + cc grpc.ClientConnInterface +} + +func NewCliClient(cc grpc.ClientConnInterface) CliClient { + return &cliClient{cc} +} + +func (c *cliClient) Contexts(ctx context.Context, in *ContextsRequest, opts ...grpc.CallOption) (*ContextsResponse, error) { + out := new(ContextsResponse) + err := c.cc.Invoke(ctx, "/com.docker.api.cli.v1.Cli/Contexts", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// CliServer is the server API for Cli service. +type CliServer interface { + // Returns the list of existing contexts + Contexts(context.Context, *ContextsRequest) (*ContextsResponse, error) +} + +// UnimplementedCliServer can be embedded to have forward compatible implementations. +type UnimplementedCliServer struct { +} + +func (*UnimplementedCliServer) Contexts(context.Context, *ContextsRequest) (*ContextsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Contexts not implemented") +} + +func RegisterCliServer(s *grpc.Server, srv CliServer) { + s.RegisterService(&_Cli_serviceDesc, srv) +} + +func _Cli_Contexts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ContextsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CliServer).Contexts(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/com.docker.api.cli.v1.Cli/Contexts", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CliServer).Contexts(ctx, req.(*ContextsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Cli_serviceDesc = grpc.ServiceDesc{ + ServiceName: "com.docker.api.cli.v1.Cli", + HandlerType: (*CliServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Contexts", + Handler: _Cli_Contexts_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cli/v1/cli.proto", +} diff --git a/cli/v1/cli.proto b/cli/v1/cli.proto new file mode 100644 index 000000000..ba16bdff1 --- /dev/null +++ b/cli/v1/cli.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; + +package com.docker.api.cli.v1; + + +option go_package = "github.com/docker/api/cli/v1;v1"; + +service Cli { + // Returns the list of existing contexts + rpc Contexts(ContextsRequest) returns (ContextsResponse); +} + +message Context { + string name = 1; + string contextType = 2; +} + +message ContextsRequest { + +} + +message ContextsResponse { + repeated Context contexts = 1; +} diff --git a/client/client.go b/client/client.go index 1d4556834..d8b7baf31 100644 --- a/client/client.go +++ b/client/client.go @@ -69,6 +69,6 @@ type Client struct { cc containers.ContainerService } -func (c *Client) ContainerService(ctx context.Context) containers.ContainerService { +func (c *Client) ContainerService() containers.ContainerService { return c.cc } diff --git a/compose/v1/compose.pb.go b/compose/v1/compose.pb.go index ad484b3a0..afc98e3cf 100644 --- a/compose/v1/compose.pb.go +++ b/compose/v1/compose.pb.go @@ -1,3 +1,29 @@ +// +//Copyright (c) 2020 Docker Inc. +// +//Permission is hereby granted, free of charge, to any person +//obtaining a copy of this software and associated documentation +//files (the "Software"), to deal in the Software without +//restriction, including without limitation the rights to use, copy, +//modify, merge, publish, distribute, sublicense, and/or sell copies +//of the Software, and to permit persons to whom the Software is +//furnished to do so, subject to the following conditions: +// +//The above copyright notice and this permission notice shall be +//included in all copies or substantial portions of the Software. +// +//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +//EXPRESS OR IMPLIED, +//INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +//IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +//HOLDERS BE LIABLE FOR ANY CLAIM, +//DAMAGES OR OTHER LIABILITY, +//WHETHER IN AN ACTION OF CONTRACT, +//TORT OR OTHERWISE, +//ARISING FROM, OUT OF OR IN CONNECTION WITH +//THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.21.0-devel diff --git a/context/context.go b/context/context.go index 39a696fdd..58d79fdc4 100644 --- a/context/context.go +++ b/context/context.go @@ -3,29 +3,15 @@ package context import ( gocontext "context" - "github.com/sirupsen/logrus" "golang.org/x/net/context" ) +const KEY = "context_key" + type currentContextKey struct{} -func WithCurrentContext(ctx gocontext.Context, configName string, contextName string) (context.Context, error) { - config, err := LoadConfigFile(configName, "config.json") - if err != nil { - return ctx, err - } - - currentContext := contextName - if currentContext == "" { - currentContext = config.CurrentContext - } - if currentContext == "" { - currentContext = "default" - } - - logrus.Debugf("Current context %q", currentContext) - - return context.WithValue(ctx, currentContextKey{}, currentContext), nil +func WithCurrentContext(ctx gocontext.Context, contextName string) context.Context { + return context.WithValue(ctx, currentContextKey{}, contextName) } // CurrentContext returns the current context name diff --git a/context/store/store.go b/context/store/store.go index a9e46588e..3c22b41c6 100644 --- a/context/store/store.go +++ b/context/store/store.go @@ -112,7 +112,14 @@ func New(opts ...StoreOpt) (Store, error) { // Get returns the context with the given name func (s *store) Get(name string, getter func() interface{}) (*Metadata, error) { meta := filepath.Join(s.root, contextsDir, metadataDir, contextdirOf(name), metaFile) - return read(meta, getter) + m, err := read(meta, getter) + if os.IsNotExist(err) { + return nil, fmt.Errorf("unknown context %q", name) + } else if err != nil { + return nil, err + } + + return m, nil } func read(meta string, getter func() interface{}) (*Metadata, error) { diff --git a/server/proxy/proxy.go b/server/proxy/proxy.go new file mode 100644 index 000000000..b5cd4fe0c --- /dev/null +++ b/server/proxy/proxy.go @@ -0,0 +1,75 @@ +package proxy + +import ( + "context" + + "github.com/docker/api/client" + v1 "github.com/docker/api/containers/v1" + "github.com/golang/protobuf/ptypes/empty" +) + +type clientKey struct{} + +func WithClient(ctx context.Context, c *client.Client) (context.Context, error) { + return context.WithValue(ctx, clientKey{}, c), nil +} + +func Client(ctx context.Context) *client.Client { + c, _ := ctx.Value(clientKey{}).(*client.Client) + return c +} + +func NewContainerApi() v1.ContainersServer { + return &proxyContainerApi{} +} + +type proxyContainerApi struct{} + +func (p *proxyContainerApi) List(ctx context.Context, _ *v1.ListRequest) (*v1.ListResponse, error) { + client := Client(ctx) + + c, err := client.ContainerService().List(ctx) + if err != nil { + return &v1.ListResponse{}, nil + } + + response := &v1.ListResponse{ + Containers: []*v1.Container{}, + } + for _, container := range c { + response.Containers = append(response.Containers, &v1.Container{ + Id: container.ID, + Image: container.Image, + }) + } + + return response, nil +} + +func (p *proxyContainerApi) Create(_ context.Context, _ *v1.CreateRequest) (*v1.CreateResponse, error) { + panic("not implemented") // TODO: Implement +} + +func (p *proxyContainerApi) Start(_ context.Context, _ *v1.StartRequest) (*v1.StartResponse, error) { + panic("not implemented") // TODO: Implement +} + +func (p *proxyContainerApi) Stop(_ context.Context, _ *v1.StopRequest) (*empty.Empty, error) { + panic("not implemented") // TODO: Implement +} + +func (p *proxyContainerApi) Kill(_ context.Context, _ *v1.KillRequest) (*empty.Empty, error) { + panic("not implemented") // TODO: Implement +} + +func (p *proxyContainerApi) Delete(_ context.Context, _ *v1.DeleteRequest) (*empty.Empty, error) { + panic("not implemented") // TODO: Implement +} + +func (p *proxyContainerApi) Update(_ context.Context, _ *v1.UpdateRequest) (*v1.UpdateResponse, error) { + panic("not implemented") // TODO: Implement +} + +func (p *proxyContainerApi) Exec(_ context.Context, _ *v1.ExecRequest) (*v1.ExecResponse, error) { + panic("not implemented") // TODO: Implement +} diff --git a/server/server.go b/server/server.go index 770083b34..f99a2972f 100644 --- a/server/server.go +++ b/server/server.go @@ -29,17 +29,26 @@ package server import ( "context" + "errors" + "github.com/docker/api/client" + apicontext "github.com/docker/api/context" + "github.com/docker/api/context/store" + "github.com/docker/api/server/proxy" grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus" "google.golang.org/grpc" "google.golang.org/grpc/health" "google.golang.org/grpc/health/grpc_health_v1" + "google.golang.org/grpc/metadata" ) // New returns a new GRPC server. func New() *grpc.Server { s := grpc.NewServer( - grpc.UnaryInterceptor(unary), + grpc.ChainUnaryInterceptor( + unaryMeta, + unary, + ), grpc.StreamInterceptor(stream), ) hs := health.NewServer() @@ -54,3 +63,33 @@ func unary(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, han func stream(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error { return grpc_prometheus.StreamServerInterceptor(srv, ss, info, handler) } + +func unaryMeta(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) { + md, ok := metadata.FromIncomingContext(ctx) + if !ok { + return nil, errors.New("missing metadata") + } + + key := md[apicontext.KEY] + + if len(key) == 1 { + s, err := store.New() + if err != nil { + return nil, err + } + ctx = store.WithContextStore(ctx, s) + + ctx = apicontext.WithCurrentContext(ctx, key[0]) + + c, err := client.New(ctx) + if err != nil { + return nil, err + } + ctx, err = proxy.WithClient(ctx, c) + if err != nil { + return nil, err + } + } + m, err := handler(ctx, req) + return m, err +}