diff --git a/Makefile b/Makefile index c3afcaf70..17117614e 100644 --- a/Makefile +++ b/Makefile @@ -4,8 +4,9 @@ ROOTDIR=$(dir $(abspath $(lastword $(MAKEFILE_LIST)))) # Base path used to install. DESTDIR=/usr/local -# Used to populate version variable in main package. +# Used to populate variables in version package. VERSION=$(shell git describe --match 'v[0-9]*' --dirty='.m' --always) +REVISION=$(shell git rev-parse HEAD)$(shell if ! git diff --no-ext-diff --quiet --exit-code; then echo .m; fi) PKG=github.com/containerd/containerd @@ -37,7 +38,7 @@ ifeq ("$(GOOS)", "windows") endif -GO_LDFLAGS=-ldflags "-X $(PKG).Version=$(VERSION) -X $(PKG).Package=$(PKG)" +GO_LDFLAGS=-ldflags "-X $(PKG)/version.Version=$(VERSION) -X $(PKG)/version.Revision=$(REVISION) -X $(PKG)/version.Package=$(PKG)" # Flags passed to `go test` TESTFLAGS ?=-parallel 8 -race diff --git a/api/services/content/content.pb.go b/api/services/content/content.pb.go index f0dedda52..9300eea94 100644 --- a/api/services/content/content.pb.go +++ b/api/services/content/content.pb.go @@ -347,8 +347,8 @@ type ContentClient interface { // stream. // // Typically, this will yield a large response, chunked into messages. - // Clients should make provisions to ensure they can't handle the entire - // data set. + // Clients should make provisions to ensure they can handle the entire data + // set. List(ctx context.Context, in *ListContentRequest, opts ...grpc.CallOption) (Content_ListClient, error) // Delete will delete the referenced object. Delete(ctx context.Context, in *DeleteContentRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) @@ -536,8 +536,8 @@ type ContentServer interface { // stream. // // Typically, this will yield a large response, chunked into messages. - // Clients should make provisions to ensure they can't handle the entire - // data set. + // Clients should make provisions to ensure they can handle the entire data + // set. List(*ListContentRequest, Content_ListServer) error // Delete will delete the referenced object. Delete(context.Context, *DeleteContentRequest) (*google_protobuf2.Empty, error) diff --git a/api/services/version/version.pb.go b/api/services/version/version.pb.go new file mode 100644 index 000000000..5dc5fd697 --- /dev/null +++ b/api/services/version/version.pb.go @@ -0,0 +1,465 @@ +// Code generated by protoc-gen-gogo. +// source: github.com/containerd/containerd/api/services/version/version.proto +// DO NOT EDIT! + +/* + Package version is a generated protocol buffer package. + + It is generated from these files: + github.com/containerd/containerd/api/services/version/version.proto + + It has these top-level messages: + VersionResponse +*/ +package version + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/golang/protobuf/ptypes/empty" +import _ "github.com/gogo/protobuf/gogoproto" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +import strings "strings" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type VersionResponse struct { + Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` + Revision string `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"` +} + +func (m *VersionResponse) Reset() { *m = VersionResponse{} } +func (*VersionResponse) ProtoMessage() {} +func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptorVersion, []int{0} } + +func init() { + proto.RegisterType((*VersionResponse)(nil), "containerd.v1.VersionResponse") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// 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.SupportPackageIsVersion4 + +// Client API for Version service + +type VersionClient interface { + Version(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VersionResponse, error) +} + +type versionClient struct { + cc *grpc.ClientConn +} + +func NewVersionClient(cc *grpc.ClientConn) VersionClient { + return &versionClient{cc} +} + +func (c *versionClient) Version(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VersionResponse, error) { + out := new(VersionResponse) + err := grpc.Invoke(ctx, "/containerd.v1.Version/Version", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for Version service + +type VersionServer interface { + Version(context.Context, *google_protobuf.Empty) (*VersionResponse, error) +} + +func RegisterVersionServer(s *grpc.Server, srv VersionServer) { + s.RegisterService(&_Version_serviceDesc, srv) +} + +func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(google_protobuf.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(VersionServer).Version(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.Version/Version", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(VersionServer).Version(ctx, req.(*google_protobuf.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +var _Version_serviceDesc = grpc.ServiceDesc{ + ServiceName: "containerd.v1.Version", + HandlerType: (*VersionServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Version", + Handler: _Version_Version_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "github.com/containerd/containerd/api/services/version/version.proto", +} + +func (m *VersionResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *VersionResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Version) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintVersion(dAtA, i, uint64(len(m.Version))) + i += copy(dAtA[i:], m.Version) + } + if len(m.Revision) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintVersion(dAtA, i, uint64(len(m.Revision))) + i += copy(dAtA[i:], m.Revision) + } + return i, nil +} + +func encodeFixed64Version(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Version(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintVersion(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *VersionResponse) Size() (n int) { + var l int + _ = l + l = len(m.Version) + if l > 0 { + n += 1 + l + sovVersion(uint64(l)) + } + l = len(m.Revision) + if l > 0 { + n += 1 + l + sovVersion(uint64(l)) + } + return n +} + +func sovVersion(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozVersion(x uint64) (n int) { + return sovVersion(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *VersionResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&VersionResponse{`, + `Version:` + fmt.Sprintf("%v", this.Version) + `,`, + `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, + `}`, + }, "") + return s +} +func valueToStringVersion(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *VersionResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersion + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: VersionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VersionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersion + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthVersion + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersion + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthVersion + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Revision = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipVersion(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthVersion + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipVersion(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersion + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersion + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersion + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthVersion + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersion + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipVersion(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthVersion = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowVersion = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("github.com/containerd/containerd/api/services/version/version.proto", fileDescriptorVersion) +} + +var fileDescriptorVersion = []byte{ + // 225 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4e, 0xcf, 0x2c, 0xc9, + 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, + 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb, + 0x97, 0xa5, 0x16, 0x15, 0x67, 0xe6, 0xe7, 0xc1, 0x68, 0xbd, 0x82, 0xa2, 0xfc, 0x92, 0x7c, 0x21, + 0x5e, 0x84, 0x72, 0xbd, 0x32, 0x43, 0x29, 0xe9, 0xf4, 0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0x7d, 0xb0, + 0x64, 0x52, 0x69, 0x9a, 0x7e, 0x6a, 0x6e, 0x41, 0x49, 0x25, 0x44, 0xad, 0x94, 0x48, 0x7a, 0x7e, + 0x7a, 0x3e, 0x98, 0xa9, 0x0f, 0x62, 0x41, 0x44, 0x95, 0xdc, 0xb9, 0xf8, 0xc3, 0x20, 0x46, 0x06, + 0xa5, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0x49, 0x70, 0xb1, 0x43, 0x6d, 0x91, 0x60, 0x54, + 0x60, 0xd4, 0xe0, 0x0c, 0x82, 0x71, 0x85, 0xa4, 0xb8, 0x38, 0x8a, 0x52, 0xcb, 0x32, 0xc1, 0x52, + 0x4c, 0x60, 0x29, 0x38, 0xdf, 0xc8, 0x87, 0x8b, 0x1d, 0x6a, 0x90, 0x90, 0x23, 0x82, 0x29, 0xa6, + 0x07, 0x71, 0x92, 0x1e, 0xcc, 0x49, 0x7a, 0xae, 0x20, 0x27, 0x49, 0xc9, 0xe9, 0xa1, 0xb8, 0x5c, + 0x0f, 0xcd, 0x0d, 0x4e, 0x12, 0x27, 0x1e, 0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, + 0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x4c, 0x62, + 0x03, 0x9b, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x27, 0xa4, 0xd8, 0x40, 0x01, 0x00, + 0x00, +} diff --git a/api/services/version/version.proto b/api/services/version/version.proto new file mode 100644 index 000000000..a2ed79fd7 --- /dev/null +++ b/api/services/version/version.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package containerd.v1; + +import "google/protobuf/empty.proto"; +import "gogoproto/gogo.proto"; + +service Version { + rpc Version(google.protobuf.Empty) returns (VersionResponse); +} + +message VersionResponse { + string version = 1; + string revision = 2; +} diff --git a/cmd/containerd-shim/main_unix.go b/cmd/containerd-shim/main_unix.go index db17a6e91..0ad41ac1b 100644 --- a/cmd/containerd-shim/main_unix.go +++ b/cmd/containerd-shim/main_unix.go @@ -14,11 +14,11 @@ import ( "google.golang.org/grpc" "github.com/Sirupsen/logrus" - "github.com/containerd/containerd" shimapi "github.com/containerd/containerd/api/services/shim" "github.com/containerd/containerd/linux/shim" "github.com/containerd/containerd/reaper" "github.com/containerd/containerd/sys" + "github.com/containerd/containerd/version" runc "github.com/containerd/go-runc" "github.com/urfave/cli" ) @@ -36,7 +36,7 @@ shim for container lifecycle and reconnection func main() { app := cli.NewApp() app.Name = "containerd-shim" - app.Version = containerd.Version + app.Version = version.Version app.Usage = usage app.Flags = []cli.Flag{ cli.BoolFlag{ diff --git a/cmd/containerd/builtins.go b/cmd/containerd/builtins.go index 2ae7a09c7..2888dd1d2 100644 --- a/cmd/containerd/builtins.go +++ b/cmd/containerd/builtins.go @@ -8,4 +8,5 @@ import ( _ "github.com/containerd/containerd/services/images" _ "github.com/containerd/containerd/services/metrics" _ "github.com/containerd/containerd/services/rootfs" + _ "github.com/containerd/containerd/services/version" ) diff --git a/cmd/containerd/main.go b/cmd/containerd/main.go index e8d3c3dd8..836d45aac 100644 --- a/cmd/containerd/main.go +++ b/cmd/containerd/main.go @@ -22,12 +22,14 @@ import ( api "github.com/containerd/containerd/api/services/execution" imagesapi "github.com/containerd/containerd/api/services/images" rootfsapi "github.com/containerd/containerd/api/services/rootfs" + versionapi "github.com/containerd/containerd/api/services/version" "github.com/containerd/containerd/content" "github.com/containerd/containerd/images" "github.com/containerd/containerd/log" "github.com/containerd/containerd/plugin" "github.com/containerd/containerd/snapshot" "github.com/containerd/containerd/sys" + "github.com/containerd/containerd/version" metrics "github.com/docker/go-metrics" "github.com/pkg/errors" "github.com/urfave/cli" @@ -50,14 +52,14 @@ var ( func init() { cli.VersionPrinter = func(c *cli.Context) { - fmt.Println(c.App.Name, containerd.Package, c.App.Version) + fmt.Println(c.App.Name, version.Package, c.App.Version) } } func main() { app := cli.NewApp() app.Name = "containerd" - app.Version = containerd.Version + app.Version = version.Version app.Usage = usage app.Flags = []cli.Flag{ cli.StringFlag{ @@ -422,6 +424,8 @@ func interceptor(ctx gocontext.Context, ctx = log.WithModule(ctx, "images") case grpc_health_v1.HealthServer: // No need to change the context + case versionapi.VersionServer: + ctx = log.WithModule(ctx, "version") default: log.G(ctx).Warnf("unknown GRPC server type: %#v\n", info.Server) } diff --git a/cmd/ctr/main.go b/cmd/ctr/main.go index 9497a15ea..693ae2afd 100644 --- a/cmd/ctr/main.go +++ b/cmd/ctr/main.go @@ -5,7 +5,7 @@ import ( "os" "github.com/Sirupsen/logrus" - "github.com/containerd/containerd" + "github.com/containerd/containerd/version" "github.com/urfave/cli" ) @@ -15,14 +15,14 @@ var ( func init() { cli.VersionPrinter = func(c *cli.Context) { - fmt.Println(c.App.Name, containerd.Package, c.App.Version) + fmt.Println(c.App.Name, version.Package, c.App.Version) } } func main() { app := cli.NewApp() app.Name = "ctr" - app.Version = containerd.Version + app.Version = version.Version app.Usage = ` __ _____/ /______ @@ -61,6 +61,7 @@ containerd client execCommand, pauseCommand, resumeCommand, + versionCommand, } app.Commands = append(app.Commands, extraCmds...) app.Before = func(context *cli.Context) error { diff --git a/cmd/ctr/utils.go b/cmd/ctr/utils.go index f6bb22059..36ce2dd27 100644 --- a/cmd/ctr/utils.go +++ b/cmd/ctr/utils.go @@ -16,6 +16,7 @@ import ( "github.com/containerd/containerd/api/services/execution" imagesapi "github.com/containerd/containerd/api/services/images" rootfsapi "github.com/containerd/containerd/api/services/rootfs" + versionservice "github.com/containerd/containerd/api/services/version" "github.com/containerd/containerd/api/types/container" "github.com/containerd/containerd/content" "github.com/containerd/containerd/images" @@ -59,6 +60,14 @@ func getImageStore(clicontext *cli.Context) (images.Store, error) { return imagesservice.NewStoreFromClient(imagesapi.NewImagesClient(conn)), nil } +func getVersionService(context *cli.Context) (versionservice.VersionClient, error) { + conn, err := getGRPCConnection(context) + if err != nil { + return nil, err + } + return versionservice.NewVersionClient(conn), nil +} + func getTempDir(id string) (string, error) { err := os.MkdirAll(filepath.Join(os.TempDir(), "ctr"), 0700) if err != nil { diff --git a/cmd/ctr/version.go b/cmd/ctr/version.go new file mode 100644 index 000000000..169c03e1e --- /dev/null +++ b/cmd/ctr/version.go @@ -0,0 +1,43 @@ +package main + +import ( + gocontext "context" + "fmt" + "os" + + "github.com/containerd/containerd/version" + empty "github.com/golang/protobuf/ptypes/empty" + "github.com/urfave/cli" +) + +var versionCommand = cli.Command{ + Name: "version", + Usage: "print the version", + Action: func(context *cli.Context) error { + if context.NArg() > 0 { + return fmt.Errorf("no argument expected") + } + fmt.Println("Client:") + fmt.Printf(" Version: %s\n", version.Version) + fmt.Printf(" Revision: %s\n", version.Revision) + fmt.Println("") + vs, err := getVersionService(context) + if err != nil { + return err + } + v, err := vs.Version(gocontext.Background(), &empty.Empty{}) + if err != nil { + return err + } + fmt.Println("Server:") + fmt.Printf(" Version: %s\n", v.Version) + fmt.Printf(" Revision: %s\n", v.Revision) + if v.Version != version.Version { + fmt.Fprintf(os.Stderr, "WARNING: version mismatch\n") + } + if v.Revision != version.Revision { + fmt.Fprintf(os.Stderr, "WARNING: revision mismatch\n") + } + return nil + }, +} diff --git a/cmd/dist/main.go b/cmd/dist/main.go index eea90d85d..a4c13bc57 100644 --- a/cmd/dist/main.go +++ b/cmd/dist/main.go @@ -7,7 +7,7 @@ import ( "time" "github.com/Sirupsen/logrus" - "github.com/containerd/containerd" + "github.com/containerd/containerd/version" "github.com/urfave/cli" ) @@ -17,7 +17,7 @@ var ( func init() { cli.VersionPrinter = func(c *cli.Context) { - fmt.Println(c.App.Name, containerd.Package, c.App.Version) + fmt.Println(c.App.Name, version.Package, c.App.Version) } } @@ -33,7 +33,7 @@ func appContext() (contextpkg.Context, contextpkg.CancelFunc) { func main() { app := cli.NewApp() app.Name = "dist" - app.Version = containerd.Version + app.Version = version.Version app.Usage = ` ___ __ ____/ (_)____/ /_ diff --git a/services/version/service.go b/services/version/service.go new file mode 100644 index 000000000..7df3d4ae2 --- /dev/null +++ b/services/version/service.go @@ -0,0 +1,38 @@ +package version + +import ( + api "github.com/containerd/containerd/api/services/version" + "github.com/containerd/containerd/plugin" + ctrdversion "github.com/containerd/containerd/version" + empty "github.com/golang/protobuf/ptypes/empty" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +var _ api.VersionServer = &Service{} + +func init() { + plugin.Register("version-grpc", &plugin.Registration{ + Type: plugin.GRPCPlugin, + Init: New, + }) +} + +func New(ic *plugin.InitContext) (interface{}, error) { + return &Service{}, nil +} + +type Service struct { +} + +func (s *Service) Register(server *grpc.Server) error { + api.RegisterVersionServer(server, s) + return nil +} + +func (s *Service) Version(ctx context.Context, _ *empty.Empty) (*api.VersionResponse, error) { + return &api.VersionResponse{ + Version: ctrdversion.Version, + Revision: ctrdversion.Revision, + }, nil +} diff --git a/version.go b/version.go deleted file mode 100644 index 7a944869c..000000000 --- a/version.go +++ /dev/null @@ -1,12 +0,0 @@ -package containerd - -var ( - Package = "github.com/containerd/containerd" - - // Version holds the complete version number. - Version = "1.0-dev+unknown" - - // GitCommit is filled with the Git revision being used to build the - // program at linking time - GitCommit = "" -) diff --git a/version/version.go b/version/version.go new file mode 100644 index 000000000..8572a4365 --- /dev/null +++ b/version/version.go @@ -0,0 +1,14 @@ +package version + +var ( + // Package is filled at linking time + Package = "github.com/containerd/containerd" + + // Version holds the complete version number. + // Filled at linking time. + Version = "1.0.0-dev+unknown" + + // Revision is filled with the VCS (e.g. git) revision being used to build the + // program at linking time + Revision = "" +)