diff --git a/api/services/rootfs/rootfs.pb.go b/api/services/rootfs/rootfs.pb.go new file mode 100644 index 0000000..50a4893 --- /dev/null +++ b/api/services/rootfs/rootfs.pb.go @@ -0,0 +1,1134 @@ +// Code generated by protoc-gen-gogo. +// source: github.com/docker/containerd/api/services/rootfs/rootfs.proto +// DO NOT EDIT! + +/* + Package rootfs is a generated protocol buffer package. + + It is generated from these files: + github.com/docker/containerd/api/services/rootfs/rootfs.proto + + It has these top-level messages: + UnpackRequest + UnpackResponse + PrepareRequest + MountsRequest + MountResponse +*/ +package rootfs + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" +import containerd_v1_types "github.com/docker/containerd/api/types/mount" +import containerd_v1_types1 "github.com/docker/containerd/api/types/descriptor" + +import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" + +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 UnpackRequest struct { + Layers []*containerd_v1_types1.Descriptor `protobuf:"bytes,1,rep,name=layers" json:"layers,omitempty"` +} + +func (m *UnpackRequest) Reset() { *m = UnpackRequest{} } +func (*UnpackRequest) ProtoMessage() {} +func (*UnpackRequest) Descriptor() ([]byte, []int) { return fileDescriptorRootfs, []int{0} } + +type UnpackResponse struct { + ChainID github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=chainid,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"chainid"` +} + +func (m *UnpackResponse) Reset() { *m = UnpackResponse{} } +func (*UnpackResponse) ProtoMessage() {} +func (*UnpackResponse) Descriptor() ([]byte, []int) { return fileDescriptorRootfs, []int{1} } + +type PrepareRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + ChainID github_com_opencontainers_go_digest.Digest `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"chain_id"` + Readonly bool `protobuf:"varint,3,opt,name=readonly,proto3" json:"readonly,omitempty"` +} + +func (m *PrepareRequest) Reset() { *m = PrepareRequest{} } +func (*PrepareRequest) ProtoMessage() {} +func (*PrepareRequest) Descriptor() ([]byte, []int) { return fileDescriptorRootfs, []int{2} } + +type MountsRequest struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (m *MountsRequest) Reset() { *m = MountsRequest{} } +func (*MountsRequest) ProtoMessage() {} +func (*MountsRequest) Descriptor() ([]byte, []int) { return fileDescriptorRootfs, []int{3} } + +type MountResponse struct { + Mounts []*containerd_v1_types.Mount `protobuf:"bytes,1,rep,name=mounts" json:"mounts,omitempty"` +} + +func (m *MountResponse) Reset() { *m = MountResponse{} } +func (*MountResponse) ProtoMessage() {} +func (*MountResponse) Descriptor() ([]byte, []int) { return fileDescriptorRootfs, []int{4} } + +func init() { + proto.RegisterType((*UnpackRequest)(nil), "containerd.v1.UnpackRequest") + proto.RegisterType((*UnpackResponse)(nil), "containerd.v1.UnpackResponse") + proto.RegisterType((*PrepareRequest)(nil), "containerd.v1.PrepareRequest") + proto.RegisterType((*MountsRequest)(nil), "containerd.v1.MountsRequest") + proto.RegisterType((*MountResponse)(nil), "containerd.v1.MountResponse") +} + +// 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 RootFS service + +type RootFSClient interface { + Unpack(ctx context.Context, in *UnpackRequest, opts ...grpc.CallOption) (*UnpackResponse, error) + Prepare(ctx context.Context, in *PrepareRequest, opts ...grpc.CallOption) (*MountResponse, error) + Mounts(ctx context.Context, in *MountsRequest, opts ...grpc.CallOption) (*MountResponse, error) +} + +type rootFSClient struct { + cc *grpc.ClientConn +} + +func NewRootFSClient(cc *grpc.ClientConn) RootFSClient { + return &rootFSClient{cc} +} + +func (c *rootFSClient) Unpack(ctx context.Context, in *UnpackRequest, opts ...grpc.CallOption) (*UnpackResponse, error) { + out := new(UnpackResponse) + err := grpc.Invoke(ctx, "/containerd.v1.RootFS/Unpack", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *rootFSClient) Prepare(ctx context.Context, in *PrepareRequest, opts ...grpc.CallOption) (*MountResponse, error) { + out := new(MountResponse) + err := grpc.Invoke(ctx, "/containerd.v1.RootFS/Prepare", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *rootFSClient) Mounts(ctx context.Context, in *MountsRequest, opts ...grpc.CallOption) (*MountResponse, error) { + out := new(MountResponse) + err := grpc.Invoke(ctx, "/containerd.v1.RootFS/Mounts", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for RootFS service + +type RootFSServer interface { + Unpack(context.Context, *UnpackRequest) (*UnpackResponse, error) + Prepare(context.Context, *PrepareRequest) (*MountResponse, error) + Mounts(context.Context, *MountsRequest) (*MountResponse, error) +} + +func RegisterRootFSServer(s *grpc.Server, srv RootFSServer) { + s.RegisterService(&_RootFS_serviceDesc, srv) +} + +func _RootFS_Unpack_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnpackRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootFSServer).Unpack(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.RootFS/Unpack", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootFSServer).Unpack(ctx, req.(*UnpackRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RootFS_Prepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PrepareRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootFSServer).Prepare(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.RootFS/Prepare", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootFSServer).Prepare(ctx, req.(*PrepareRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RootFS_Mounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MountsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootFSServer).Mounts(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/containerd.v1.RootFS/Mounts", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootFSServer).Mounts(ctx, req.(*MountsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _RootFS_serviceDesc = grpc.ServiceDesc{ + ServiceName: "containerd.v1.RootFS", + HandlerType: (*RootFSServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Unpack", + Handler: _RootFS_Unpack_Handler, + }, + { + MethodName: "Prepare", + Handler: _RootFS_Prepare_Handler, + }, + { + MethodName: "Mounts", + Handler: _RootFS_Mounts_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "github.com/docker/containerd/api/services/rootfs/rootfs.proto", +} + +func (m *UnpackRequest) 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 *UnpackRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Layers) > 0 { + for _, msg := range m.Layers { + dAtA[i] = 0xa + i++ + i = encodeVarintRootfs(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *UnpackResponse) 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 *UnpackResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ChainID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintRootfs(dAtA, i, uint64(len(m.ChainID))) + i += copy(dAtA[i:], m.ChainID) + } + return i, nil +} + +func (m *PrepareRequest) 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 *PrepareRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintRootfs(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + if len(m.ChainID) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintRootfs(dAtA, i, uint64(len(m.ChainID))) + i += copy(dAtA[i:], m.ChainID) + } + if m.Readonly { + dAtA[i] = 0x18 + i++ + if m.Readonly { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + return i, nil +} + +func (m *MountsRequest) 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 *MountsRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintRootfs(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + return i, nil +} + +func (m *MountResponse) 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 *MountResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Mounts) > 0 { + for _, msg := range m.Mounts { + dAtA[i] = 0xa + i++ + i = encodeVarintRootfs(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func encodeFixed64Rootfs(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 encodeFixed32Rootfs(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 encodeVarintRootfs(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 *UnpackRequest) Size() (n int) { + var l int + _ = l + if len(m.Layers) > 0 { + for _, e := range m.Layers { + l = e.Size() + n += 1 + l + sovRootfs(uint64(l)) + } + } + return n +} + +func (m *UnpackResponse) Size() (n int) { + var l int + _ = l + l = len(m.ChainID) + if l > 0 { + n += 1 + l + sovRootfs(uint64(l)) + } + return n +} + +func (m *PrepareRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRootfs(uint64(l)) + } + l = len(m.ChainID) + if l > 0 { + n += 1 + l + sovRootfs(uint64(l)) + } + if m.Readonly { + n += 2 + } + return n +} + +func (m *MountsRequest) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRootfs(uint64(l)) + } + return n +} + +func (m *MountResponse) Size() (n int) { + var l int + _ = l + if len(m.Mounts) > 0 { + for _, e := range m.Mounts { + l = e.Size() + n += 1 + l + sovRootfs(uint64(l)) + } + } + return n +} + +func sovRootfs(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozRootfs(x uint64) (n int) { + return sovRootfs(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *UnpackRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnpackRequest{`, + `Layers:` + strings.Replace(fmt.Sprintf("%v", this.Layers), "Descriptor", "containerd_v1_types1.Descriptor", 1) + `,`, + `}`, + }, "") + return s +} +func (this *UnpackResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnpackResponse{`, + `ChainID:` + fmt.Sprintf("%v", this.ChainID) + `,`, + `}`, + }, "") + return s +} +func (this *PrepareRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PrepareRequest{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `ChainID:` + fmt.Sprintf("%v", this.ChainID) + `,`, + `Readonly:` + fmt.Sprintf("%v", this.Readonly) + `,`, + `}`, + }, "") + return s +} +func (this *MountsRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MountsRequest{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `}`, + }, "") + return s +} +func (this *MountResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MountResponse{`, + `Mounts:` + strings.Replace(fmt.Sprintf("%v", this.Mounts), "Mount", "containerd_v1_types.Mount", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringRootfs(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *UnpackRequest) 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 ErrIntOverflowRootfs + } + 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: UnpackRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnpackRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Layers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRootfs + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Layers = append(m.Layers, &containerd_v1_types1.Descriptor{}) + if err := m.Layers[len(m.Layers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRootfs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRootfs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnpackResponse) 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 ErrIntOverflowRootfs + } + 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: UnpackResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnpackResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + 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 ErrInvalidLengthRootfs + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainID = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRootfs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRootfs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrepareRequest) 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 ErrIntOverflowRootfs + } + 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: PrepareRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrepareRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + 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 ErrInvalidLengthRootfs + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + 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 ErrInvalidLengthRootfs + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainID = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Readonly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Readonly = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipRootfs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRootfs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MountsRequest) 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 ErrIntOverflowRootfs + } + 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: MountsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MountsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + 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 ErrInvalidLengthRootfs + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRootfs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRootfs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MountResponse) 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 ErrIntOverflowRootfs + } + 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: MountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MountResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRootfs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRootfs + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Mounts = append(m.Mounts, &containerd_v1_types.Mount{}) + if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRootfs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRootfs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipRootfs(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, ErrIntOverflowRootfs + } + 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, ErrIntOverflowRootfs + } + 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, ErrIntOverflowRootfs + } + 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, ErrInvalidLengthRootfs + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRootfs + } + 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 := skipRootfs(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 ( + ErrInvalidLengthRootfs = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowRootfs = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("github.com/docker/containerd/api/services/rootfs/rootfs.proto", fileDescriptorRootfs) +} + +var fileDescriptorRootfs = []byte{ + // 433 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x52, 0x4d, 0x6f, 0x13, 0x31, + 0x10, 0x8d, 0x29, 0xda, 0x04, 0xa3, 0xf4, 0x60, 0x71, 0x58, 0xad, 0x60, 0x13, 0x2d, 0x97, 0x08, + 0x89, 0xb5, 0x08, 0x07, 0xb8, 0xf4, 0x92, 0x86, 0x8a, 0x1e, 0x90, 0xd0, 0x22, 0x04, 0x37, 0xe4, + 0xae, 0x87, 0xad, 0xd5, 0xc6, 0x63, 0x6c, 0xa7, 0x52, 0x6e, 0xfc, 0x0e, 0x7e, 0x51, 0x8e, 0x1c, + 0x11, 0x12, 0x11, 0xdd, 0x5f, 0x82, 0xb2, 0x1f, 0xa1, 0x89, 0x0a, 0xf4, 0xc0, 0x65, 0x3d, 0x2b, + 0xbf, 0xf7, 0xe6, 0xcd, 0x1b, 0xd3, 0x83, 0x42, 0xf9, 0xd3, 0xf9, 0x49, 0x9a, 0xe3, 0x8c, 0x4b, + 0xcc, 0xcf, 0xc0, 0xf2, 0x1c, 0xb5, 0x17, 0x4a, 0x83, 0x95, 0x5c, 0x18, 0xc5, 0x1d, 0xd8, 0x0b, + 0x95, 0x83, 0xe3, 0x16, 0xd1, 0x7f, 0x6c, 0x8f, 0xd4, 0x58, 0xf4, 0xc8, 0xfa, 0xbf, 0xc1, 0xe9, + 0xc5, 0x93, 0xe8, 0x5e, 0x81, 0x05, 0x56, 0x37, 0x7c, 0x5d, 0xd5, 0xa0, 0xe8, 0xf9, 0x3f, 0x7b, + 0xf8, 0x85, 0x01, 0xc7, 0x67, 0x38, 0xd7, 0xbe, 0xfe, 0x36, 0xcc, 0xc9, 0x0d, 0x99, 0x12, 0x5c, + 0x6e, 0x95, 0xf1, 0x68, 0xaf, 0x94, 0xb5, 0x46, 0xf2, 0x92, 0xf6, 0xdf, 0x6a, 0x23, 0xf2, 0xb3, + 0x0c, 0x3e, 0xcd, 0xc1, 0x79, 0xf6, 0x8c, 0x06, 0xe7, 0x62, 0x01, 0xd6, 0x85, 0x64, 0xb8, 0x37, + 0xba, 0x3b, 0x1e, 0xa4, 0x5b, 0x43, 0xa4, 0x95, 0x64, 0x3a, 0xdd, 0xe8, 0x64, 0x0d, 0x3c, 0x51, + 0x74, 0xbf, 0x55, 0x72, 0x06, 0xb5, 0x03, 0xf6, 0x8e, 0x76, 0xf3, 0x53, 0xa1, 0xb4, 0x92, 0x21, + 0x19, 0x92, 0xd1, 0x9d, 0xc9, 0xc1, 0x72, 0x35, 0xe8, 0x7c, 0x5f, 0x0d, 0x1e, 0x5d, 0x31, 0x8e, + 0x06, 0xf4, 0xa6, 0x83, 0xe3, 0x05, 0x3e, 0x96, 0xaa, 0x00, 0xe7, 0xd3, 0x69, 0x75, 0x94, 0xab, + 0x41, 0xf7, 0x70, 0x2d, 0x72, 0x3c, 0xcd, 0x5a, 0xb5, 0xe4, 0x0b, 0xa1, 0xfb, 0xaf, 0x2d, 0x18, + 0x61, 0xa1, 0xb5, 0xcd, 0xe8, 0x6d, 0x2d, 0x66, 0x50, 0x37, 0xca, 0xaa, 0x9a, 0xbd, 0xa7, 0xbd, + 0x8a, 0xf1, 0x41, 0xc9, 0xf0, 0xd6, 0xff, 0x33, 0x70, 0x2c, 0x59, 0x44, 0x7b, 0x16, 0x84, 0x44, + 0x7d, 0xbe, 0x08, 0xf7, 0x86, 0x64, 0xd4, 0xcb, 0x36, 0xff, 0xc9, 0x43, 0xda, 0x7f, 0xb5, 0x5e, + 0x92, 0xfb, 0x8b, 0xb5, 0xe4, 0xb0, 0x01, 0x6d, 0xb2, 0x1a, 0xd3, 0xa0, 0x5a, 0x6d, 0x1b, 0x7b, + 0x74, 0x6d, 0xec, 0x35, 0xa7, 0x41, 0x8e, 0x7f, 0x10, 0x1a, 0x64, 0x88, 0xfe, 0xe8, 0x0d, 0x7b, + 0x41, 0x83, 0x3a, 0x7c, 0x76, 0x7f, 0x87, 0xb8, 0xb5, 0xdd, 0xe8, 0xc1, 0x1f, 0x6e, 0x1b, 0x17, + 0x47, 0xb4, 0xdb, 0xe4, 0xca, 0x76, 0x91, 0xdb, 0x79, 0x47, 0xbb, 0x6d, 0xb6, 0xa7, 0x99, 0xd2, + 0xa0, 0xce, 0x80, 0x5d, 0x8b, 0x73, 0x37, 0x52, 0x99, 0x84, 0xcb, 0xcb, 0xb8, 0xf3, 0xed, 0x32, + 0xee, 0x7c, 0x2e, 0x63, 0xb2, 0x2c, 0x63, 0xf2, 0xb5, 0x8c, 0xc9, 0xcf, 0x32, 0x26, 0x27, 0x41, + 0xf5, 0x78, 0x9f, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x52, 0xeb, 0x01, 0xe0, 0xa0, 0x03, 0x00, + 0x00, +} diff --git a/api/services/rootfs/rootfs.proto b/api/services/rootfs/rootfs.proto new file mode 100644 index 0000000..070f097 --- /dev/null +++ b/api/services/rootfs/rootfs.proto @@ -0,0 +1,35 @@ +syntax = "proto3"; + +package containerd.v1; + +import "gogoproto/gogo.proto"; +import "github.com/docker/containerd/api/types/mount/mount.proto"; +import "github.com/docker/containerd/api/types/descriptor/descriptor.proto"; + +service RootFS { + rpc Unpack(UnpackRequest) returns (UnpackResponse); + rpc Prepare(PrepareRequest) returns (MountResponse); + rpc Mounts(MountsRequest) returns (MountResponse); +} + +message UnpackRequest { + repeated containerd.v1.types.Descriptor layers = 1; +} + +message UnpackResponse { + string chainid = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false, (gogoproto.customname) = "ChainID"]; +} + +message PrepareRequest { + string name = 1; + string chain_id = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false, (gogoproto.customname) = "ChainID"]; + bool readonly = 3; +} + +message MountsRequest { + string name = 1; +} + +message MountResponse { + repeated containerd.v1.types.Mount mounts = 1; +} diff --git a/api/types/descriptor/descriptor.pb.go b/api/types/descriptor/descriptor.pb.go new file mode 100644 index 0000000..b924742 --- /dev/null +++ b/api/types/descriptor/descriptor.pb.go @@ -0,0 +1,422 @@ +// Code generated by protoc-gen-gogo. +// source: github.com/docker/containerd/api/types/descriptor/descriptor.proto +// DO NOT EDIT! + +/* + Package descriptor is a generated protocol buffer package. + + It is generated from these files: + github.com/docker/containerd/api/types/descriptor/descriptor.proto + + It has these top-level messages: + Descriptor +*/ +package descriptor + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" + +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 + +// Descriptor describes a blob in a content store. +// +// This descriptor can be used to reference content from an +// oci descriptor found in a manifest. +// See https://godoc.org/github.com/opencontainers/image-spec/specs-go/v1#Descriptor +type Descriptor struct { + MediaType string `protobuf:"bytes,1,opt,name=mediaType,proto3" json:"mediaType,omitempty"` + Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,2,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` + Size_ int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` +} + +func (m *Descriptor) Reset() { *m = Descriptor{} } +func (*Descriptor) ProtoMessage() {} +func (*Descriptor) Descriptor() ([]byte, []int) { return fileDescriptorDescriptor, []int{0} } + +func init() { + proto.RegisterType((*Descriptor)(nil), "containerd.v1.types.Descriptor") +} +func (m *Descriptor) 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 *Descriptor) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.MediaType) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintDescriptor(dAtA, i, uint64(len(m.MediaType))) + i += copy(dAtA[i:], m.MediaType) + } + if len(m.Digest) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintDescriptor(dAtA, i, uint64(len(m.Digest))) + i += copy(dAtA[i:], m.Digest) + } + if m.Size_ != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintDescriptor(dAtA, i, uint64(m.Size_)) + } + return i, nil +} + +func encodeFixed64Descriptor(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 encodeFixed32Descriptor(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 encodeVarintDescriptor(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 *Descriptor) Size() (n int) { + var l int + _ = l + l = len(m.MediaType) + if l > 0 { + n += 1 + l + sovDescriptor(uint64(l)) + } + l = len(m.Digest) + if l > 0 { + n += 1 + l + sovDescriptor(uint64(l)) + } + if m.Size_ != 0 { + n += 1 + sovDescriptor(uint64(m.Size_)) + } + return n +} + +func sovDescriptor(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozDescriptor(x uint64) (n int) { + return sovDescriptor(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Descriptor) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Descriptor{`, + `MediaType:` + fmt.Sprintf("%v", this.MediaType) + `,`, + `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, + `Size_:` + fmt.Sprintf("%v", this.Size_) + `,`, + `}`, + }, "") + return s +} +func valueToStringDescriptor(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Descriptor) 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 ErrIntOverflowDescriptor + } + 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: Descriptor: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Descriptor: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MediaType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDescriptor + } + 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 ErrInvalidLengthDescriptor + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MediaType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDescriptor + } + 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 ErrInvalidLengthDescriptor + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) + } + m.Size_ = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDescriptor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Size_ |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDescriptor(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthDescriptor + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDescriptor(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, ErrIntOverflowDescriptor + } + 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, ErrIntOverflowDescriptor + } + 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, ErrIntOverflowDescriptor + } + 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, ErrInvalidLengthDescriptor + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDescriptor + } + 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 := skipDescriptor(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 ( + ErrInvalidLengthDescriptor = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDescriptor = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("github.com/docker/containerd/api/types/descriptor/descriptor.proto", fileDescriptorDescriptor) +} + +var fileDescriptorDescriptor = []byte{ + // 231 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4a, 0xcf, 0x2c, 0xc9, + 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xc9, 0x4f, 0xce, 0x4e, 0x2d, 0xd2, 0x4f, 0xce, + 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0xd1, 0x4f, 0x2c, 0xc8, 0xd4, 0x2f, 0xa9, 0x2c, + 0x48, 0x2d, 0xd6, 0x4f, 0x49, 0x2d, 0x4e, 0x2e, 0xca, 0x2c, 0x28, 0xc9, 0x2f, 0x42, 0x62, 0xea, + 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x23, 0x74, 0xe8, 0x95, 0x19, 0xea, 0x81, 0x35, 0x48, + 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0xe5, 0xf5, 0x41, 0x2c, 0x88, 0x52, 0xa5, 0x2e, 0x46, 0x2e, + 0x2e, 0x17, 0xb8, 0x7e, 0x21, 0x19, 0x2e, 0xce, 0xdc, 0xd4, 0x94, 0xcc, 0xc4, 0x90, 0xca, 0x82, + 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x84, 0x80, 0x90, 0x17, 0x17, 0x5b, 0x4a, 0x66, + 0x7a, 0x6a, 0x71, 0x89, 0x04, 0x13, 0x48, 0xca, 0xc9, 0xe8, 0xc4, 0x3d, 0x79, 0x86, 0x5b, 0xf7, + 0xe4, 0xb5, 0x90, 0xdc, 0x9c, 0x5f, 0x90, 0x9a, 0x07, 0xb7, 0xbe, 0x58, 0x3f, 0x3d, 0x5f, 0x17, + 0xa2, 0x45, 0xcf, 0x05, 0x4c, 0x05, 0x41, 0x4d, 0x10, 0x12, 0xe2, 0x62, 0x29, 0xce, 0xac, 0x4a, + 0x95, 0x60, 0x56, 0x60, 0xd4, 0x60, 0x0e, 0x02, 0xb3, 0x9d, 0x24, 0x4e, 0x3c, 0x94, 0x63, 0xb8, + 0xf1, 0x50, 0x8e, 0xa1, 0xe1, 0x91, 0x1c, 0xe3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, + 0x3e, 0x78, 0x24, 0xc7, 0x98, 0xc4, 0x06, 0x76, 0xad, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x37, + 0xe8, 0x43, 0x79, 0x1e, 0x01, 0x00, 0x00, +} diff --git a/api/types/descriptor/descriptor.proto b/api/types/descriptor/descriptor.proto new file mode 100644 index 0000000..e44244e --- /dev/null +++ b/api/types/descriptor/descriptor.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; + +package containerd.v1.types; + +import "gogoproto/gogo.proto"; + +// Descriptor describes a blob in a content store. +// +// This descriptor can be used to reference content from an +// oci descriptor found in a manifest. +// See https://godoc.org/github.com/opencontainers/image-spec/specs-go/v1#Descriptor +message Descriptor { + string mediaType = 1; + string digest = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; + int64 size = 3; +} diff --git a/cmd/containerd/builtins.go b/cmd/containerd/builtins.go index 9620297..b5dd214 100644 --- a/cmd/containerd/builtins.go +++ b/cmd/containerd/builtins.go @@ -7,6 +7,7 @@ import ( _ "github.com/docker/containerd/services/execution" _ "github.com/docker/containerd/services/healthcheck" _ "github.com/docker/containerd/services/metrics" + _ "github.com/docker/containerd/services/rootfs" _ "github.com/docker/containerd/snapshot/btrfs" _ "github.com/docker/containerd/snapshot/overlay" ) diff --git a/cmd/containerd/main.go b/cmd/containerd/main.go index 5b69c6a..bd2d27a 100644 --- a/cmd/containerd/main.go +++ b/cmd/containerd/main.go @@ -19,6 +19,7 @@ import ( "github.com/docker/containerd" contentapi "github.com/docker/containerd/api/services/content" api "github.com/docker/containerd/api/services/execution" + rootfsapi "github.com/docker/containerd/api/services/rootfs" "github.com/docker/containerd/content" "github.com/docker/containerd/log" "github.com/docker/containerd/plugin" @@ -366,6 +367,8 @@ func interceptor(ctx gocontext.Context, ctx = log.WithModule(ctx, "execution") case contentapi.ContentServer: ctx = log.WithModule(ctx, "content") + case rootfsapi.RootFSServer: + ctx = log.WithModule(ctx, "rootfs") default: fmt.Printf("unknown GRPC server type: %#v\n", info.Server) } diff --git a/cmd/dist/main.go b/cmd/dist/main.go index cf96ad5..f29af17 100644 --- a/cmd/dist/main.go +++ b/cmd/dist/main.go @@ -69,6 +69,7 @@ distribution tool deleteCommand, listCommand, applyCommand, + rootfsCommand, } app.Before = func(context *cli.Context) error { var ( diff --git a/cmd/dist/rootfs.go b/cmd/dist/rootfs.go new file mode 100644 index 0000000..ca4e40e --- /dev/null +++ b/cmd/dist/rootfs.go @@ -0,0 +1,142 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "io/ioutil" + "os" + "strings" + + contentapi "github.com/docker/containerd/api/services/content" + rootfsapi "github.com/docker/containerd/api/services/rootfs" + "github.com/docker/containerd/content" + "github.com/docker/containerd/log" + contentservice "github.com/docker/containerd/services/content" + rootfsservice "github.com/docker/containerd/services/rootfs" + digest "github.com/opencontainers/go-digest" + ocispec "github.com/opencontainers/image-spec/specs-go/v1" + "github.com/urfave/cli" +) + +var rootfsCommand = cli.Command{ + Name: "rootfs", + Usage: "rootfs setups a rootfs", + Subcommands: []cli.Command{ + rootfsPrepareCommand, + rootfsInitCommand, + }, +} + +var rootfsPrepareCommand = cli.Command{ + Name: "unpack", + Usage: "unpack applies layers from a manifest to a snapshot", + ArgsUsage: "[flags] ", + Flags: []cli.Flag{}, + Action: func(clicontext *cli.Context) error { + var ( + ctx = background + ) + + dgst, err := digest.Parse(clicontext.Args().First()) + if err != nil { + return err + } + + log.G(ctx).Infof("unpacking layers from manifest %s", dgst.String()) + + conn, err := connectGRPC(clicontext) + if err != nil { + return err + } + + provider := contentservice.NewProviderFromClient(contentapi.NewContentClient(conn)) + m, err := resolveManifest(ctx, provider, dgst) + if err != nil { + return err + } + + unpacker := rootfsservice.NewUnpackerFromClient(rootfsapi.NewRootFSClient(conn)) + chainID, err := unpacker.Unpack(ctx, m.Layers) + if err != nil { + return err + } + + log.G(ctx).Infof("chain ID: %s", chainID.String()) + + return nil + }, +} + +var rootfsInitCommand = cli.Command{ + Name: "prepare", + Usage: "prepare gets mount commands for digest", + ArgsUsage: "[flags] ", + Flags: []cli.Flag{}, + Action: func(clicontext *cli.Context) error { + var ( + ctx = background + ) + + if clicontext.NArg() != 2 { + return cli.ShowSubcommandHelp(clicontext) + } + + dgst, err := digest.Parse(clicontext.Args().Get(0)) + if err != nil { + return err + } + target := clicontext.Args().Get(1) + + log.G(ctx).Infof("preparing mounts %s", dgst.String()) + + conn, err := connectGRPC(clicontext) + if err != nil { + return err + } + + rclient := rootfsapi.NewRootFSClient(conn) + + ir := &rootfsapi.PrepareRequest{ + Name: target, + ChainID: dgst, + } + + resp, err := rclient.Prepare(ctx, ir) + if err != nil { + return err + } + + for _, m := range resp.Mounts { + fmt.Fprintf(os.Stdout, "mount -t %s %s %s -o %s\n", m.Type, m.Source, target, strings.Join(m.Options, ",")) + } + + return nil + }, +} + +func resolveManifest(ctx context.Context, provider content.Provider, dgst digest.Digest) (ocispec.Manifest, error) { + p, err := readAll(ctx, provider, dgst) + if err != nil { + return ocispec.Manifest{}, err + } + + // TODO(stevvooe): This assumption that we get a manifest is unfortunate. + // Need to provide way to resolve what the type of the target is. + var manifest ocispec.Manifest + if err := json.Unmarshal(p, &manifest); err != nil { + return ocispec.Manifest{}, err + } + + return manifest, nil +} + +func readAll(ctx context.Context, provider content.Provider, dgst digest.Digest) ([]byte, error) { + rc, err := provider.Reader(ctx, dgst) + if err != nil { + return nil, err + } + defer rc.Close() + + return ioutil.ReadAll(rc) +} diff --git a/rootfs/apply.go b/rootfs/apply.go index e713a2c..f53e553 100644 --- a/rootfs/apply.go +++ b/rootfs/apply.go @@ -16,9 +16,13 @@ import ( "github.com/pkg/errors" ) +type Unpacker interface { + Unpack(ctx context.Context, layers []ocispec.Descriptor) (digest.Digest, error) +} + type Mounter interface { - Mount(mounts ...containerd.Mount) error - Unmount(mounts ...containerd.Mount) error + Mount(target string, mounts ...containerd.Mount) error + Unmount(target string) error } // ApplyLayer applies the layer to the provided parent. The resulting snapshot @@ -51,13 +55,13 @@ func ApplyLayer(snapshots snapshot.Snapshotter, mounter Mounter, rd io.Reader, p return "", err } - if err := mounter.Mount(mounts...); err != nil { + if err := mounter.Mount(dir, mounts...); err != nil { if err := snapshots.Remove(ctx, key); err != nil { log.L.WithError(err).Error("snapshot rollback failed") } return "", err } - defer mounter.Unmount(mounts...) + defer mounter.Unmount(dir) rd, err = dockerarchive.DecompressStream(rd) if err != nil { @@ -74,6 +78,9 @@ func ApplyLayer(snapshots snapshot.Snapshotter, mounter Mounter, rd io.Reader, p if parent != "" { chainID = identity.ChainID([]digest.Digest{parent, chainID}) } + if _, err := snapshots.Stat(ctx, chainID.String()); err == nil { + return diffID, nil //TODO: call snapshots.Remove(ctx, key) once implemented + } return diffID, snapshots.Commit(ctx, chainID.String(), key) } @@ -90,7 +97,7 @@ func Prepare(ctx context.Context, snapshots snapshot.Snapshotter, mounter Mounte // rootfs Controller. // // Just pass them in for now. - openBlob func(digest.Digest) (io.ReadCloser, error), + openBlob func(context.Context, digest.Digest) (io.ReadCloser, error), resolveDiffID func(digest.Digest) digest.Digest, registerDiffID func(diffID, dgst digest.Digest) error) (digest.Digest, error) { var ( @@ -116,7 +123,7 @@ func Prepare(ctx context.Context, snapshots snapshot.Snapshotter, mounter Mounte } } - rc, err := openBlob(layerDigest) + rc, err := openBlob(ctx, layerDigest) if err != nil { return "", err } diff --git a/rootfs/init.go b/rootfs/init.go new file mode 100644 index 0000000..4acbf7e --- /dev/null +++ b/rootfs/init.go @@ -0,0 +1,94 @@ +package rootfs + +import ( + "context" + "fmt" + "io/ioutil" + "os" + + "github.com/docker/containerd" + "github.com/docker/containerd/log" + "github.com/docker/containerd/snapshot" + digest "github.com/opencontainers/go-digest" + "github.com/pkg/errors" +) + +var ( + initializers = map[string]initializerFunc{} +) + +type initializerFunc func(string) error + +func InitRootFS(ctx context.Context, name string, parent digest.Digest, readonly bool, snapshotter snapshot.Snapshotter, mounter Mounter) ([]containerd.Mount, error) { + _, err := snapshotter.Stat(ctx, name) + if err == nil { + return nil, errors.Errorf("rootfs already exists") + } + // TODO: ensure not exist error once added to snapshot package + + parentS := parent.String() + + initName := defaultInitializer + initFn := initializers[initName] + if initFn != nil { + parentS, err = createInitLayer(ctx, parentS, initName, initFn, snapshotter, mounter) + if err != nil { + return nil, err + } + } + + if readonly { + return snapshotter.View(ctx, name, parentS) + } + + return snapshotter.Prepare(ctx, name, parentS) +} + +func createInitLayer(ctx context.Context, parent, initName string, initFn func(string) error, snapshotter snapshot.Snapshotter, mounter Mounter) (string, error) { + initS := fmt.Sprintf("%s %s", parent, initName) + if _, err := snapshotter.Stat(ctx, initS); err == nil { + return initS, nil + } + // TODO: ensure not exist error once added to snapshot package + + // Create tempdir + td, err := ioutil.TempDir("", "create-init-") + if err != nil { + return "", err + } + defer os.RemoveAll(td) + + mounts, err := snapshotter.Prepare(ctx, td, parent) + if err != nil { + return "", err + } + defer func() { + if err != nil { + // TODO: once implemented uncomment + //if rerr := snapshotter.Remove(ctx, td); rerr != nil { + // log.G(ctx).Errorf("Failed to remove snapshot %s: %v", td, merr) + //} + } + }() + + if err = mounter.Mount(td, mounts...); err != nil { + return "", err + } + + if err = initFn(td); err != nil { + if merr := mounter.Unmount(td); merr != nil { + log.G(ctx).Errorf("Failed to unmount %s: %v", td, merr) + } + return "", err + } + + if err = mounter.Unmount(td); err != nil { + return "", err + } + + if err := snapshotter.Commit(ctx, initS, td); err != nil { + return "", err + } + + return initS, nil +} diff --git a/rootfs/init_linux.go b/rootfs/init_linux.go new file mode 100644 index 0000000..cabc457 --- /dev/null +++ b/rootfs/init_linux.go @@ -0,0 +1,114 @@ +package rootfs + +import ( + "os" + "path/filepath" + "syscall" +) + +const ( + defaultInitializer = "linux-init" +) + +func init() { + initializers[defaultInitializer] = initFS +} + +func createDirectory(name string, uid, gid int) initializerFunc { + return func(root string) error { + dname := filepath.Join(root, name) + st, err := os.Stat(dname) + if err != nil && !os.IsNotExist(err) { + return err + } else if err == nil { + if st.IsDir() { + stat := st.Sys().(*syscall.Stat_t) + if int(stat.Gid) == gid && int(stat.Uid) == uid { + return nil + } + } else { + if err := os.Remove(dname); err != nil { + return err + } + if err := os.Mkdir(dname, 0755); err != nil { + return err + } + } + } else { + if err := os.Mkdir(dname, 0755); err != nil { + return err + } + } + + return os.Chown(dname, uid, gid) + } +} + +func touchFile(name string, uid, gid int) initializerFunc { + return func(root string) error { + fname := filepath.Join(root, name) + + st, err := os.Stat(fname) + if err != nil && !os.IsNotExist(err) { + return err + } else if err == nil { + stat := st.Sys().(*syscall.Stat_t) + if int(stat.Gid) == gid && int(stat.Uid) == uid { + return nil + } + return os.Chown(fname, uid, gid) + } + + f, err := os.OpenFile(fname, os.O_CREATE, 0644) + if err != nil { + return err + } + defer f.Close() + + return f.Chown(uid, gid) + } +} + +func symlink(oldname, newname string) initializerFunc { + return func(root string) error { + linkName := filepath.Join(root, newname) + if _, err := os.Stat(linkName); err != nil && !os.IsNotExist(err) { + return err + } else if err == nil { + return nil + } + return os.Symlink(oldname, linkName) + } +} + +func initFS(root string) error { + st, err := os.Stat(root) + if err != nil { + return err + } + stat := st.Sys().(*syscall.Stat_t) + uid := int(stat.Uid) + gid := int(stat.Gid) + + initFuncs := []initializerFunc{ + createDirectory("/dev", uid, gid), + createDirectory("/dev/pts", uid, gid), + createDirectory("/dev/shm", uid, gid), + touchFile("/dev/console", uid, gid), + createDirectory("/proc", uid, gid), + createDirectory("/sys", uid, gid), + createDirectory("/etc", uid, gid), + touchFile("/etc/resolv.conf", uid, gid), + touchFile("/etc/hosts", uid, gid), + touchFile("/etc/hostname", uid, gid), + symlink("/proc/mounts", "/etc/mtab"), + } + + for _, fn := range initFuncs { + if err := fn(root); err != nil { + return err + } + } + + return nil +} diff --git a/rootfs/init_other.go b/rootfs/init_other.go new file mode 100644 index 0000000..b5e04e2 --- /dev/null +++ b/rootfs/init_other.go @@ -0,0 +1,7 @@ +// +build !linux + +package rootfs + +const ( + defaultInitializer = "" +) diff --git a/services/rootfs/preparer.go b/services/rootfs/preparer.go new file mode 100644 index 0000000..52ad489 --- /dev/null +++ b/services/rootfs/preparer.go @@ -0,0 +1,39 @@ +package rootfs + +import ( + "context" + + rootfsapi "github.com/docker/containerd/api/services/rootfs" + containerd_v1_types "github.com/docker/containerd/api/types/descriptor" + "github.com/docker/containerd/rootfs" + digest "github.com/opencontainers/go-digest" + ocispec "github.com/opencontainers/image-spec/specs-go/v1" +) + +func NewUnpackerFromClient(client rootfsapi.RootFSClient) rootfs.Unpacker { + return remoteUnpacker{ + client: client, + } +} + +type remoteUnpacker struct { + client rootfsapi.RootFSClient +} + +func (rp remoteUnpacker) Unpack(ctx context.Context, layers []ocispec.Descriptor) (digest.Digest, error) { + pr := rootfsapi.UnpackRequest{ + Layers: make([]*containerd_v1_types.Descriptor, len(layers)), + } + for i, l := range layers { + pr.Layers[i] = &containerd_v1_types.Descriptor{ + MediaType: l.MediaType, + Digest: l.Digest, + Size_: l.Size, + } + } + resp, err := rp.client.Unpack(ctx, &pr) + if err != nil { + return "", nil + } + return resp.ChainID, nil +} diff --git a/services/rootfs/service.go b/services/rootfs/service.go new file mode 100644 index 0000000..21c98ca --- /dev/null +++ b/services/rootfs/service.go @@ -0,0 +1,115 @@ +package rootfs + +import ( + "syscall" + + "github.com/docker/containerd" + rootfsapi "github.com/docker/containerd/api/services/rootfs" + containerd_v1_types "github.com/docker/containerd/api/types/mount" + "github.com/docker/containerd/content" + "github.com/docker/containerd/log" + "github.com/docker/containerd/plugin" + "github.com/docker/containerd/rootfs" + "github.com/docker/containerd/snapshot" + digest "github.com/opencontainers/go-digest" + ocispec "github.com/opencontainers/image-spec/specs-go/v1" + "golang.org/x/net/context" + "google.golang.org/grpc" +) + +func init() { + plugin.Register("rootfs-grpc", &plugin.Registration{ + Type: plugin.GRPCPlugin, + Init: func(ic *plugin.InitContext) (interface{}, error) { + return NewService(ic.Store, ic.Snapshotter) + }, + }) +} + +type Service struct { + store *content.Store + snapshotter snapshot.Snapshotter +} + +func NewService(store *content.Store, snapshotter snapshot.Snapshotter) (*Service, error) { + return &Service{ + store: store, + snapshotter: snapshotter, + }, nil +} + +func (s *Service) Register(gs *grpc.Server) error { + rootfsapi.RegisterRootFSServer(gs, s) + return nil +} + +func (s *Service) Unpack(ctx context.Context, pr *rootfsapi.UnpackRequest) (*rootfsapi.UnpackResponse, error) { + layers := make([]ocispec.Descriptor, len(pr.Layers)) + for i, l := range pr.Layers { + layers[i] = ocispec.Descriptor{ + MediaType: l.MediaType, + Digest: l.Digest, + Size: l.Size_, + } + } + log.G(ctx).Infof("Preparing %#v", layers) + chainID, err := rootfs.Prepare(ctx, s.snapshotter, mounter{}, layers, s.store.Reader, emptyResolver, noopRegister) + if err != nil { + log.G(ctx).Errorf("Rootfs Prepare failed!: %v", err) + return nil, err + } + log.G(ctx).Infof("ChainID %#v", chainID) + return &rootfsapi.UnpackResponse{ + ChainID: chainID, + }, nil +} + +func (s *Service) Prepare(ctx context.Context, ir *rootfsapi.PrepareRequest) (*rootfsapi.MountResponse, error) { + mounts, err := rootfs.InitRootFS(ctx, ir.Name, ir.ChainID, ir.Readonly, s.snapshotter, mounter{}) + if err != nil { + return nil, err + } + return &rootfsapi.MountResponse{ + Mounts: apiMounts(mounts), + }, nil +} + +func (s *Service) Mounts(ctx context.Context, mr *rootfsapi.MountsRequest) (*rootfsapi.MountResponse, error) { + mounts, err := s.snapshotter.Mounts(ctx, mr.Name) + if err != nil { + return nil, err + } + return &rootfsapi.MountResponse{ + Mounts: apiMounts(mounts), + }, nil +} + +func apiMounts(mounts []containerd.Mount) []*containerd_v1_types.Mount { + am := make([]*containerd_v1_types.Mount, len(mounts)) + for i, m := range mounts { + am[i] = &containerd_v1_types.Mount{ + Type: m.Type, + Source: m.Source, + Options: m.Options, + } + } + return am +} + +type mounter struct{} + +func (mounter) Mount(dir string, mounts ...containerd.Mount) error { + return containerd.MountAll(mounts, dir) +} + +func (mounter) Unmount(dir string) error { + return syscall.Unmount(dir, 0) +} + +func emptyResolver(digest.Digest) digest.Digest { + return digest.Digest("") +} + +func noopRegister(digest.Digest, digest.Digest) error { + return nil +}