From bb20dbde436813ec93cf1d12225d68792a5fc4e3 Mon Sep 17 00:00:00 2001 From: Alex Dadgar Date: Thu, 9 Aug 2018 15:29:00 -0700 Subject: [PATCH 1/4] move protos --- plugins/base/{ => proto}/base.pb.go | 109 ++++++++++++++-------------- plugins/base/{ => proto}/base.proto | 2 +- 2 files changed, 56 insertions(+), 55 deletions(-) rename plugins/base/{ => proto}/base.pb.go (77%) rename plugins/base/{ => proto}/base.proto (97%) diff --git a/plugins/base/base.pb.go b/plugins/base/proto/base.pb.go similarity index 77% rename from plugins/base/base.pb.go rename to plugins/base/proto/base.pb.go index 669ce2842..67bb0b3e2 100644 --- a/plugins/base/base.pb.go +++ b/plugins/base/proto/base.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go. DO NOT EDIT. -// source: github.com/hashicorp/nomad/plugins/base/base.proto +// source: github.com/hashicorp/nomad/plugins/base/proto/base.proto package base @@ -48,7 +48,7 @@ func (x PluginType) String() string { return proto.EnumName(PluginType_name, int32(x)) } func (PluginType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{0} + return fileDescriptor_base_01259c48147dbaa4, []int{0} } // PluginInfoRequest is used to request the plugins basic information. @@ -62,7 +62,7 @@ func (m *PluginInfoRequest) Reset() { *m = PluginInfoRequest{} } func (m *PluginInfoRequest) String() string { return proto.CompactTextString(m) } func (*PluginInfoRequest) ProtoMessage() {} func (*PluginInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{0} + return fileDescriptor_base_01259c48147dbaa4, []int{0} } func (m *PluginInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PluginInfoRequest.Unmarshal(m, b) @@ -86,7 +86,7 @@ var xxx_messageInfo_PluginInfoRequest proto.InternalMessageInfo // that Nomad can decide whether to load the plugin or not. type PluginInfoResponse struct { // type indicates what type of plugin this is. - Type PluginType `protobuf:"varint,1,opt,name=type,proto3,enum=hashicorp.nomad.plugins.base.PluginType" json:"type,omitempty"` + Type PluginType `protobuf:"varint,1,opt,name=type,proto3,enum=hashicorp.nomad.plugins.base.proto.PluginType" json:"type,omitempty"` // plugin_api_version indicates the version of the Nomad Plugin API // this plugin is built against. PluginApiVersion string `protobuf:"bytes,2,opt,name=plugin_api_version,json=pluginApiVersion,proto3" json:"plugin_api_version,omitempty"` @@ -104,7 +104,7 @@ func (m *PluginInfoResponse) Reset() { *m = PluginInfoResponse{} } func (m *PluginInfoResponse) String() string { return proto.CompactTextString(m) } func (*PluginInfoResponse) ProtoMessage() {} func (*PluginInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{1} + return fileDescriptor_base_01259c48147dbaa4, []int{1} } func (m *PluginInfoResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PluginInfoResponse.Unmarshal(m, b) @@ -163,7 +163,7 @@ func (m *ConfigSchemaRequest) Reset() { *m = ConfigSchemaRequest{} } func (m *ConfigSchemaRequest) String() string { return proto.CompactTextString(m) } func (*ConfigSchemaRequest) ProtoMessage() {} func (*ConfigSchemaRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{2} + return fileDescriptor_base_01259c48147dbaa4, []int{2} } func (m *ConfigSchemaRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfigSchemaRequest.Unmarshal(m, b) @@ -196,7 +196,7 @@ func (m *ConfigSchemaResponse) Reset() { *m = ConfigSchemaResponse{} } func (m *ConfigSchemaResponse) String() string { return proto.CompactTextString(m) } func (*ConfigSchemaResponse) ProtoMessage() {} func (*ConfigSchemaResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{3} + return fileDescriptor_base_01259c48147dbaa4, []int{3} } func (m *ConfigSchemaResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfigSchemaResponse.Unmarshal(m, b) @@ -236,7 +236,7 @@ func (m *SetConfigRequest) Reset() { *m = SetConfigRequest{} } func (m *SetConfigRequest) String() string { return proto.CompactTextString(m) } func (*SetConfigRequest) ProtoMessage() {} func (*SetConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{4} + return fileDescriptor_base_01259c48147dbaa4, []int{4} } func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SetConfigRequest.Unmarshal(m, b) @@ -274,7 +274,7 @@ func (m *SetConfigResponse) Reset() { *m = SetConfigResponse{} } func (m *SetConfigResponse) String() string { return proto.CompactTextString(m) } func (*SetConfigResponse) ProtoMessage() {} func (*SetConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_0160727fc8db573d, []int{5} + return fileDescriptor_base_01259c48147dbaa4, []int{5} } func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SetConfigResponse.Unmarshal(m, b) @@ -295,13 +295,13 @@ func (m *SetConfigResponse) XXX_DiscardUnknown() { var xxx_messageInfo_SetConfigResponse proto.InternalMessageInfo func init() { - proto.RegisterType((*PluginInfoRequest)(nil), "hashicorp.nomad.plugins.base.PluginInfoRequest") - proto.RegisterType((*PluginInfoResponse)(nil), "hashicorp.nomad.plugins.base.PluginInfoResponse") - proto.RegisterType((*ConfigSchemaRequest)(nil), "hashicorp.nomad.plugins.base.ConfigSchemaRequest") - proto.RegisterType((*ConfigSchemaResponse)(nil), "hashicorp.nomad.plugins.base.ConfigSchemaResponse") - proto.RegisterType((*SetConfigRequest)(nil), "hashicorp.nomad.plugins.base.SetConfigRequest") - proto.RegisterType((*SetConfigResponse)(nil), "hashicorp.nomad.plugins.base.SetConfigResponse") - proto.RegisterEnum("hashicorp.nomad.plugins.base.PluginType", PluginType_name, PluginType_value) + proto.RegisterType((*PluginInfoRequest)(nil), "hashicorp.nomad.plugins.base.proto.PluginInfoRequest") + proto.RegisterType((*PluginInfoResponse)(nil), "hashicorp.nomad.plugins.base.proto.PluginInfoResponse") + proto.RegisterType((*ConfigSchemaRequest)(nil), "hashicorp.nomad.plugins.base.proto.ConfigSchemaRequest") + proto.RegisterType((*ConfigSchemaResponse)(nil), "hashicorp.nomad.plugins.base.proto.ConfigSchemaResponse") + proto.RegisterType((*SetConfigRequest)(nil), "hashicorp.nomad.plugins.base.proto.SetConfigRequest") + proto.RegisterType((*SetConfigResponse)(nil), "hashicorp.nomad.plugins.base.proto.SetConfigResponse") + proto.RegisterEnum("hashicorp.nomad.plugins.base.proto.PluginType", PluginType_name, PluginType_value) } // Reference imports to suppress errors if they are not otherwise used. @@ -334,7 +334,7 @@ func NewBasePluginClient(cc *grpc.ClientConn) BasePluginClient { func (c *basePluginClient) PluginInfo(ctx context.Context, in *PluginInfoRequest, opts ...grpc.CallOption) (*PluginInfoResponse, error) { out := new(PluginInfoResponse) - err := c.cc.Invoke(ctx, "/hashicorp.nomad.plugins.base.BasePlugin/PluginInfo", in, out, opts...) + err := c.cc.Invoke(ctx, "/hashicorp.nomad.plugins.base.proto.BasePlugin/PluginInfo", in, out, opts...) if err != nil { return nil, err } @@ -343,7 +343,7 @@ func (c *basePluginClient) PluginInfo(ctx context.Context, in *PluginInfoRequest func (c *basePluginClient) ConfigSchema(ctx context.Context, in *ConfigSchemaRequest, opts ...grpc.CallOption) (*ConfigSchemaResponse, error) { out := new(ConfigSchemaResponse) - err := c.cc.Invoke(ctx, "/hashicorp.nomad.plugins.base.BasePlugin/ConfigSchema", in, out, opts...) + err := c.cc.Invoke(ctx, "/hashicorp.nomad.plugins.base.proto.BasePlugin/ConfigSchema", in, out, opts...) if err != nil { return nil, err } @@ -352,7 +352,7 @@ func (c *basePluginClient) ConfigSchema(ctx context.Context, in *ConfigSchemaReq func (c *basePluginClient) SetConfig(ctx context.Context, in *SetConfigRequest, opts ...grpc.CallOption) (*SetConfigResponse, error) { out := new(SetConfigResponse) - err := c.cc.Invoke(ctx, "/hashicorp.nomad.plugins.base.BasePlugin/SetConfig", in, out, opts...) + err := c.cc.Invoke(ctx, "/hashicorp.nomad.plugins.base.proto.BasePlugin/SetConfig", in, out, opts...) if err != nil { return nil, err } @@ -383,7 +383,7 @@ func _BasePlugin_PluginInfo_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hashicorp.nomad.plugins.base.BasePlugin/PluginInfo", + FullMethod: "/hashicorp.nomad.plugins.base.proto.BasePlugin/PluginInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BasePluginServer).PluginInfo(ctx, req.(*PluginInfoRequest)) @@ -401,7 +401,7 @@ func _BasePlugin_ConfigSchema_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hashicorp.nomad.plugins.base.BasePlugin/ConfigSchema", + FullMethod: "/hashicorp.nomad.plugins.base.proto.BasePlugin/ConfigSchema", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BasePluginServer).ConfigSchema(ctx, req.(*ConfigSchemaRequest)) @@ -419,7 +419,7 @@ func _BasePlugin_SetConfig_Handler(srv interface{}, ctx context.Context, dec fun } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/hashicorp.nomad.plugins.base.BasePlugin/SetConfig", + FullMethod: "/hashicorp.nomad.plugins.base.proto.BasePlugin/SetConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BasePluginServer).SetConfig(ctx, req.(*SetConfigRequest)) @@ -428,7 +428,7 @@ func _BasePlugin_SetConfig_Handler(srv interface{}, ctx context.Context, dec fun } var _BasePlugin_serviceDesc = grpc.ServiceDesc{ - ServiceName: "hashicorp.nomad.plugins.base.BasePlugin", + ServiceName: "hashicorp.nomad.plugins.base.proto.BasePlugin", HandlerType: (*BasePluginServer)(nil), Methods: []grpc.MethodDesc{ { @@ -445,40 +445,41 @@ var _BasePlugin_serviceDesc = grpc.ServiceDesc{ }, }, Streams: []grpc.StreamDesc{}, - Metadata: "github.com/hashicorp/nomad/plugins/base/base.proto", + Metadata: "github.com/hashicorp/nomad/plugins/base/proto/base.proto", } func init() { - proto.RegisterFile("github.com/hashicorp/nomad/plugins/base/base.proto", fileDescriptor_base_0160727fc8db573d) + proto.RegisterFile("github.com/hashicorp/nomad/plugins/base/proto/base.proto", fileDescriptor_base_01259c48147dbaa4) } -var fileDescriptor_base_0160727fc8db573d = []byte{ - // 430 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xdf, 0x8b, 0xd3, 0x40, - 0x10, 0xbe, 0xd4, 0x50, 0xb9, 0xb9, 0x1f, 0xc4, 0x3d, 0x85, 0x12, 0x7c, 0x38, 0x02, 0x42, 0x91, - 0x63, 0xe3, 0xc5, 0x27, 0xc1, 0x87, 0xb3, 0xb5, 0x0f, 0x45, 0xa8, 0x92, 0x6a, 0x15, 0x5f, 0xc2, - 0x76, 0xbb, 0x4d, 0x82, 0xcd, 0xee, 0x36, 0x9b, 0x2a, 0xfd, 0xdb, 0xfc, 0x87, 0xfc, 0x33, 0x64, - 0x77, 0x93, 0x1a, 0x45, 0x4b, 0x7c, 0x49, 0x86, 0x99, 0xef, 0xfb, 0x66, 0xe6, 0x1b, 0x16, 0xa2, - 0x34, 0xaf, 0xb2, 0xdd, 0x12, 0x53, 0x51, 0x84, 0x19, 0x51, 0x59, 0x4e, 0x45, 0x29, 0x43, 0x2e, - 0x0a, 0xb2, 0x0a, 0xe5, 0x66, 0x97, 0xe6, 0x5c, 0x85, 0x4b, 0xa2, 0x98, 0xf9, 0x60, 0x59, 0x8a, - 0x4a, 0xa0, 0xc7, 0x07, 0x20, 0x36, 0x40, 0x5c, 0x03, 0xb1, 0xc6, 0xf8, 0x77, 0x1d, 0x14, 0x55, - 0x46, 0x4a, 0xb6, 0x0a, 0x33, 0xba, 0x51, 0x92, 0x51, 0xfd, 0x4f, 0x74, 0x60, 0xf5, 0x83, 0x2b, - 0x78, 0xf0, 0xce, 0x00, 0xa7, 0x7c, 0x2d, 0x62, 0xb6, 0xdd, 0x31, 0x55, 0x05, 0xdf, 0x1d, 0x40, - 0xed, 0xac, 0x92, 0x82, 0x2b, 0x86, 0x5e, 0x82, 0x5b, 0xed, 0x25, 0x1b, 0x38, 0xd7, 0xce, 0xf0, - 0x32, 0x1a, 0xe2, 0x63, 0xa3, 0x61, 0xcb, 0x7f, 0xbf, 0x97, 0x2c, 0x36, 0x2c, 0x74, 0x03, 0xc8, - 0x02, 0x12, 0x22, 0xf3, 0xe4, 0x2b, 0x2b, 0x55, 0x2e, 0xf8, 0xa0, 0x77, 0xed, 0x0c, 0x4f, 0x63, - 0xcf, 0x56, 0x5e, 0xc9, 0x7c, 0x61, 0xf3, 0xe8, 0x09, 0x5c, 0xd6, 0xe8, 0x06, 0x79, 0xcf, 0x20, - 0x2f, 0x6c, 0xb6, 0x81, 0x21, 0x70, 0x39, 0x29, 0xd8, 0xc0, 0x35, 0x45, 0x13, 0x07, 0x8f, 0xe0, - 0x6a, 0x2c, 0xf8, 0x3a, 0x4f, 0xe7, 0x34, 0x63, 0x05, 0x69, 0x96, 0xfa, 0x04, 0x0f, 0x7f, 0x4f, - 0xd7, 0x5b, 0xdd, 0x81, 0xab, 0xfd, 0x30, 0x5b, 0x9d, 0x45, 0x37, 0xff, 0xdc, 0xca, 0xfa, 0x88, - 0x6b, 0x1f, 0xf1, 0x5c, 0x32, 0x1a, 0x1b, 0x66, 0xf0, 0x02, 0xbc, 0x39, 0xab, 0xac, 0x78, 0xdd, - 0x4d, 0xcf, 0x5f, 0xa8, 0x54, 0x12, 0xfa, 0x25, 0xa1, 0xa6, 0x60, 0xf4, 0xcf, 0xe3, 0x8b, 0x3a, - 0x6b, 0xd1, 0xda, 0xfe, 0x16, 0xd5, 0x4e, 0xf4, 0xf4, 0x16, 0xe0, 0x97, 0x7b, 0xe8, 0x0c, 0xee, - 0x7f, 0x98, 0xbd, 0x99, 0xbd, 0xfd, 0x38, 0xf3, 0x4e, 0x10, 0x40, 0xff, 0x75, 0x3c, 0x5d, 0x4c, - 0x62, 0xcf, 0x31, 0xf1, 0x64, 0x31, 0x1d, 0x4f, 0xbc, 0x5e, 0xf4, 0xa3, 0x07, 0x30, 0x22, 0x8a, - 0x59, 0x1e, 0xda, 0x36, 0x0a, 0xfa, 0x7e, 0x28, 0xec, 0x72, 0xa9, 0xd6, 0xfd, 0xfd, 0x67, 0xdd, - 0x09, 0x76, 0xe4, 0xe0, 0x04, 0x7d, 0x83, 0xf3, 0xb6, 0xbd, 0xe8, 0xf6, 0xb8, 0xc6, 0x5f, 0x2e, - 0xe4, 0x47, 0xff, 0x43, 0x39, 0x34, 0xe6, 0x70, 0x7a, 0xb0, 0x10, 0xe1, 0xe3, 0x12, 0x7f, 0x9e, - 0xc9, 0x0f, 0x3b, 0xe3, 0x9b, 0x7e, 0xa3, 0xfe, 0x67, 0x57, 0xd7, 0x96, 0x7d, 0xf3, 0x80, 0x9e, - 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x66, 0xa2, 0xc0, 0xe2, 0xd6, 0x03, 0x00, 0x00, +var fileDescriptor_base_01259c48147dbaa4 = []byte{ + // 435 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcf, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x37, 0xbb, 0xa1, 0xb2, 0x6f, 0xb7, 0x25, 0x4e, 0x15, 0x4a, 0x4e, 0x25, 0x20, 0x14, + 0x29, 0x13, 0xac, 0x56, 0xeb, 0xad, 0xb6, 0xf6, 0x50, 0x84, 0x2a, 0xa9, 0x56, 0xf1, 0x12, 0xa6, + 0xd3, 0x69, 0x12, 0x6c, 0x32, 0x63, 0x26, 0x15, 0x2a, 0x78, 0xf2, 0xec, 0x1f, 0xe5, 0x7f, 0x26, + 0x99, 0x49, 0xda, 0x28, 0x8a, 0xe9, 0x29, 0x8f, 0xf7, 0x3e, 0xdf, 0xef, 0xbc, 0x1f, 0x81, 0x51, + 0x10, 0x65, 0xe1, 0x7e, 0x8d, 0x29, 0x8f, 0xdd, 0x90, 0xc8, 0x30, 0xa2, 0x3c, 0x15, 0x6e, 0xc2, + 0x63, 0xb2, 0x71, 0xc5, 0x6e, 0x1f, 0x44, 0x89, 0x74, 0xd7, 0x44, 0x32, 0x57, 0xa4, 0x3c, 0xe3, + 0x2a, 0xc4, 0x2a, 0x44, 0xce, 0x11, 0xc7, 0x0a, 0xc7, 0x05, 0x8e, 0x4f, 0x8c, 0x3d, 0xae, 0xe1, + 0x2e, 0x43, 0x92, 0xb2, 0x8d, 0x1b, 0xd2, 0x9d, 0x14, 0x8c, 0xe6, 0x5f, 0x3f, 0x0f, 0xb4, 0x83, + 0xd3, 0x86, 0xbb, 0x6f, 0x14, 0x38, 0x4f, 0xb6, 0xdc, 0x63, 0x9f, 0xf7, 0x4c, 0x66, 0xce, 0x4f, + 0x03, 0x50, 0x35, 0x2b, 0x05, 0x4f, 0x24, 0x43, 0x13, 0x30, 0xb3, 0x83, 0x60, 0x1d, 0xa3, 0x6b, + 0xf4, 0x5a, 0x03, 0x8c, 0xff, 0xdf, 0x20, 0xd6, 0x2e, 0x6f, 0x0f, 0x82, 0x79, 0x4a, 0x8b, 0xfa, + 0x80, 0x34, 0xe6, 0x13, 0x11, 0xf9, 0x5f, 0x58, 0x2a, 0x23, 0x9e, 0x74, 0x2e, 0xbb, 0x46, 0xef, + 0xda, 0xb3, 0x74, 0xe5, 0x85, 0x88, 0x56, 0x3a, 0x8f, 0x1e, 0x40, 0xab, 0xa0, 0x4b, 0xf2, 0x4a, + 0x91, 0x4d, 0x9d, 0x2d, 0x31, 0x04, 0x66, 0x42, 0x62, 0xd6, 0x31, 0x55, 0x51, 0xc5, 0xce, 0x7d, + 0x68, 0x4f, 0x79, 0xb2, 0x8d, 0x82, 0x25, 0x0d, 0x59, 0x4c, 0xca, 0xd1, 0x3e, 0xc0, 0xbd, 0xdf, + 0xd3, 0xc5, 0x6c, 0x63, 0x30, 0xf3, 0xad, 0xa8, 0xd9, 0x6e, 0x06, 0xfd, 0x7f, 0xce, 0xa6, 0xb7, + 0x89, 0x8b, 0x6d, 0xe2, 0xa5, 0x60, 0xd4, 0x53, 0x4a, 0xe7, 0x39, 0x58, 0x4b, 0x96, 0x69, 0xf3, + 0xe2, 0xb5, 0xbc, 0xff, 0x58, 0x06, 0x82, 0xd0, 0x4f, 0x3e, 0x55, 0x05, 0xe5, 0x7f, 0xeb, 0x35, + 0x8b, 0xac, 0xa6, 0xf3, 0x23, 0x54, 0xa4, 0xba, 0xa3, 0x87, 0x8f, 0x00, 0x4e, 0xdb, 0x43, 0x37, + 0x70, 0xe7, 0xdd, 0xe2, 0xd5, 0xe2, 0xf5, 0xfb, 0x85, 0x75, 0x81, 0x00, 0x1a, 0x2f, 0xbd, 0xf9, + 0x6a, 0xe6, 0x59, 0x86, 0x8a, 0x67, 0xab, 0xf9, 0x74, 0x66, 0x5d, 0x0e, 0x7e, 0x5c, 0x01, 0x4c, + 0x88, 0x64, 0x5a, 0x87, 0xbe, 0x95, 0x0e, 0xf9, 0x15, 0xd1, 0xb0, 0xfe, 0xbd, 0x2a, 0xff, 0x82, + 0xfd, 0xf4, 0x5c, 0x99, 0x6e, 0xdf, 0xb9, 0x40, 0xdf, 0x0d, 0xb8, 0xad, 0xee, 0x1a, 0x3d, 0xab, + 0x63, 0xf5, 0x97, 0xa3, 0xd9, 0xa3, 0xf3, 0x85, 0xc7, 0x2e, 0xbe, 0xc2, 0xf5, 0x71, 0xb7, 0xe8, + 0x49, 0x1d, 0xa3, 0x3f, 0xaf, 0x68, 0x0f, 0xcf, 0x54, 0x95, 0x6f, 0x4f, 0x1a, 0x1f, 0xcd, 0x9c, + 0x58, 0x37, 0x14, 0xf2, 0xf8, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x3e, 0xab, 0xdf, 0x0d, + 0x04, 0x00, 0x00, } diff --git a/plugins/base/base.proto b/plugins/base/proto/base.proto similarity index 97% rename from plugins/base/base.proto rename to plugins/base/proto/base.proto index 5254eacb9..892f53e85 100644 --- a/plugins/base/base.proto +++ b/plugins/base/proto/base.proto @@ -1,5 +1,5 @@ syntax = "proto3"; -package hashicorp.nomad.plugins.base; +package hashicorp.nomad.plugins.base.proto; option go_package = "base"; import "github.com/hashicorp/nomad/plugins/shared/hclspec/hcl_spec.proto"; From c324e98a251387f4c8483376852205f3a5edeb59 Mon Sep 17 00:00:00 2001 From: Alex Dadgar Date: Fri, 10 Aug 2018 10:50:09 -0700 Subject: [PATCH 2/4] Initial go-plugin --- plugins/base/base.go | 35 ++ plugins/base/client.go | 61 ++ plugins/base/mock.go | 18 + plugins/base/plugin.go | 43 ++ plugins/base/plugin_test.go | 176 ++++++ plugins/base/proto/base.pb.go | 93 +-- plugins/base/proto/base.proto | 7 +- plugins/base/server.go | 66 +++ .../vmihailenco/msgpack/CHANGELOG.md | 18 + vendor/github.com/vmihailenco/msgpack/LICENSE | 25 + .../github.com/vmihailenco/msgpack/Makefile | 5 + .../github.com/vmihailenco/msgpack/README.md | 69 +++ .../vmihailenco/msgpack/codes/codes.go | 86 +++ .../github.com/vmihailenco/msgpack/decode.go | 536 ++++++++++++++++++ .../vmihailenco/msgpack/decode_map.go | 289 ++++++++++ .../vmihailenco/msgpack/decode_number.go | 307 ++++++++++ .../vmihailenco/msgpack/decode_query.go | 158 ++++++ .../vmihailenco/msgpack/decode_slice.go | 192 +++++++ .../vmihailenco/msgpack/decode_string.go | 175 ++++++ .../vmihailenco/msgpack/decode_value.go | 292 ++++++++++ .../github.com/vmihailenco/msgpack/encode.go | 162 ++++++ .../vmihailenco/msgpack/encode_map.go | 172 ++++++ .../vmihailenco/msgpack/encode_number.go | 108 ++++ .../vmihailenco/msgpack/encode_slice.go | 124 ++++ .../vmihailenco/msgpack/encode_value.go | 167 ++++++ vendor/github.com/vmihailenco/msgpack/ext.go | 212 +++++++ .../github.com/vmihailenco/msgpack/msgpack.go | 17 + vendor/github.com/vmihailenco/msgpack/tag.go | 42 ++ vendor/github.com/vmihailenco/msgpack/time.go | 145 +++++ .../github.com/vmihailenco/msgpack/types.go | 307 ++++++++++ .../zclconf/go-cty/cty/msgpack/doc.go | 14 + .../zclconf/go-cty/cty/msgpack/dynamic.go | 31 + .../zclconf/go-cty/cty/msgpack/infinity.go | 8 + .../zclconf/go-cty/cty/msgpack/marshal.go | 207 +++++++ .../go-cty/cty/msgpack/type_implied.go | 167 ++++++ .../zclconf/go-cty/cty/msgpack/unknown.go | 16 + .../zclconf/go-cty/cty/msgpack/unmarshal.go | 311 ++++++++++ vendor/vendor.json | 3 + 38 files changed, 4816 insertions(+), 48 deletions(-) create mode 100644 plugins/base/base.go create mode 100644 plugins/base/client.go create mode 100644 plugins/base/mock.go create mode 100644 plugins/base/plugin.go create mode 100644 plugins/base/plugin_test.go create mode 100644 plugins/base/server.go create mode 100644 vendor/github.com/vmihailenco/msgpack/CHANGELOG.md create mode 100644 vendor/github.com/vmihailenco/msgpack/LICENSE create mode 100644 vendor/github.com/vmihailenco/msgpack/Makefile create mode 100644 vendor/github.com/vmihailenco/msgpack/README.md create mode 100644 vendor/github.com/vmihailenco/msgpack/codes/codes.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode_map.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode_number.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode_query.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode_slice.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode_string.go create mode 100644 vendor/github.com/vmihailenco/msgpack/decode_value.go create mode 100644 vendor/github.com/vmihailenco/msgpack/encode.go create mode 100644 vendor/github.com/vmihailenco/msgpack/encode_map.go create mode 100644 vendor/github.com/vmihailenco/msgpack/encode_number.go create mode 100644 vendor/github.com/vmihailenco/msgpack/encode_slice.go create mode 100644 vendor/github.com/vmihailenco/msgpack/encode_value.go create mode 100644 vendor/github.com/vmihailenco/msgpack/ext.go create mode 100644 vendor/github.com/vmihailenco/msgpack/msgpack.go create mode 100644 vendor/github.com/vmihailenco/msgpack/tag.go create mode 100644 vendor/github.com/vmihailenco/msgpack/time.go create mode 100644 vendor/github.com/vmihailenco/msgpack/types.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go create mode 100644 vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go diff --git a/plugins/base/base.go b/plugins/base/base.go new file mode 100644 index 000000000..416667f57 --- /dev/null +++ b/plugins/base/base.go @@ -0,0 +1,35 @@ +package shared + +import ( + "github.com/hashicorp/nomad/plugins/shared/hclspec" +) + +// BasePlugin is the interface that all Nomad plugins must support. +type BasePlugin interface { + // PluginInfo describes the type and version of a plugin. + PluginInfo() (*PluginInfoResponse, error) + + // ConfigSchema returns the schema for parsing the plugins configuration. + ConfigSchema() (*hclspec.Spec, error) + + // SetConfig is used to set the configuration by passing a MessagePack + // encoding of it. + SetConfig(data []byte) error +} + +// PluginInfoResponse returns basic information about the plugin such that Nomad +// can decide whether to load the plugin or not. +type PluginInfoResponse struct { + // Type returns the plugins type + Type string + + // PluginApiVersion returns the version of the Nomad plugin API it is built + // against. + PluginApiVersion string + + // PluginVersion is the version of the plugin. + PluginVersion string + + // Name is the plugins name. + Name string +} diff --git a/plugins/base/client.go b/plugins/base/client.go new file mode 100644 index 000000000..481b2838b --- /dev/null +++ b/plugins/base/client.go @@ -0,0 +1,61 @@ +package shared + +import ( + "fmt" + + "github.com/hashicorp/nomad/plugins/base/proto" + "github.com/hashicorp/nomad/plugins/shared/hclspec" + "golang.org/x/net/context" +) + +// basePluginClient implements the client side of a remote base plugin, using +// gRPC to communicate to the remote plugin. +type basePluginClient struct { + client proto.BasePluginClient +} + +func (b *basePluginClient) PluginInfo() (*PluginInfoResponse, error) { + presp, err := b.client.PluginInfo(context.Background(), &proto.PluginInfoRequest{}) + if err != nil { + return nil, err + } + + var ptype string + switch presp.GetType() { + case proto.PluginType_BASE: + ptype = PluginTypeBase + case proto.PluginType_DRIVER: + ptype = PluginTypeDriver + case proto.PluginType_DEVICE: + ptype = PluginTypeDevice + default: + return nil, fmt.Errorf("plugin is of unknown type: %q", presp.GetType().String()) + } + + resp := &PluginInfoResponse{ + Type: ptype, + PluginApiVersion: presp.GetPluginApiVersion(), + PluginVersion: presp.GetPluginVersion(), + Name: presp.GetName(), + } + + return resp, nil +} + +func (b *basePluginClient) ConfigSchema() (*hclspec.Spec, error) { + presp, err := b.client.ConfigSchema(context.Background(), &proto.ConfigSchemaRequest{}) + if err != nil { + return nil, err + } + + return presp.GetSpec(), nil +} + +func (b *basePluginClient) SetConfig(data []byte) error { + // Send the config + _, err := b.client.SetConfig(context.Background(), &proto.SetConfigRequest{ + MsgpackConfig: data, + }) + + return err +} diff --git a/plugins/base/mock.go b/plugins/base/mock.go new file mode 100644 index 000000000..fa0110dfa --- /dev/null +++ b/plugins/base/mock.go @@ -0,0 +1,18 @@ +package shared + +import ( + "github.com/hashicorp/nomad/plugins/shared/hclspec" +) + +// MockPlugin is used for testing. +// Each function can be set as a closure to make assertions about how data +// is passed through the base plugin layer. +type MockPlugin struct { + PluginInfoF func() (*PluginInfoResponse, error) + ConfigSchemaF func() (*hclspec.Spec, error) + SetConfigF func([]byte) error +} + +func (p *MockPlugin) PluginInfo() (*PluginInfoResponse, error) { return p.PluginInfoF() } +func (p *MockPlugin) ConfigSchema() (*hclspec.Spec, error) { return p.ConfigSchemaF() } +func (p *MockPlugin) SetConfig(data []byte) error { return p.SetConfigF(data) } diff --git a/plugins/base/plugin.go b/plugins/base/plugin.go new file mode 100644 index 000000000..79ddcc885 --- /dev/null +++ b/plugins/base/plugin.go @@ -0,0 +1,43 @@ +package shared + +import ( + "golang.org/x/net/context" + + plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/nomad/plugins/base/proto" + "google.golang.org/grpc" +) + +const ( + // PluginTypeBase implements the base plugin driver interface + PluginTypeBase = "base" + + // PluginTypeDriver implements the driver plugin interface + PluginTypeDriver = "driver" + + // PluginTypeDevice implements the device plugin interface + PluginTypeDevice = "device" +) + +var ( + // Handshake is a common handshake that is shared by all plugins and Nomad. + Handshake = plugin.HandshakeConfig{ + ProtocolVersion: 1, + MagicCookieKey: "NOMAD_PLUGIN_MAGIC_COOKIE", + MagicCookieValue: "e4327c2e01eabfd75a8a67adb114fb34a757d57eee7728d857a8cec6e91a7255", + } +) + +type PluginBase struct { + plugin.NetRPCUnsupportedPlugin + impl BasePlugin +} + +func (p *PluginBase) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error { + proto.RegisterBasePluginServer(s, &basePluginServer{impl: p.impl}) + return nil +} + +func (p *PluginBase) GRPCClient(ctx context.Context, broker *plugin.GRPCBroker, c *grpc.ClientConn) (interface{}, error) { + return &basePluginClient{client: proto.NewBasePluginClient(c)}, nil +} diff --git a/plugins/base/plugin_test.go b/plugins/base/plugin_test.go new file mode 100644 index 000000000..b00debe92 --- /dev/null +++ b/plugins/base/plugin_test.go @@ -0,0 +1,176 @@ +package shared + +import ( + "testing" + + pb "github.com/golang/protobuf/proto" + plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/nomad/nomad/structs" + "github.com/hashicorp/nomad/plugins/base/proto" + "github.com/hashicorp/nomad/plugins/shared/hclspec" + "github.com/stretchr/testify/require" + "github.com/zclconf/go-cty/cty" + "github.com/zclconf/go-cty/cty/msgpack" + "google.golang.org/grpc" +) + +var ( + // testSpec is an hcl Spec for testing + testSpec = &hclspec.Spec{ + Block: &hclspec.Spec_Object{ + &hclspec.Object{ + Attributes: map[string]*hclspec.Spec{ + "foo": &hclspec.Spec{ + Block: &hclspec.Spec_Attr{ + &hclspec.Attr{ + Type: "string", + Required: false, + }, + }, + }, + "bar": &hclspec.Spec{ + Block: &hclspec.Spec_Attr{ + &hclspec.Attr{ + Type: "number", + Required: true, + }, + }, + }, + "baz": &hclspec.Spec{ + Block: &hclspec.Spec_Attr{ + &hclspec.Attr{ + Type: "bool", + }, + }, + }, + }, + }, + }, + } +) + +// testConfig is used to decode a config from the testSpec +type testConfig struct { + Foo string `cty:"foo" codec:"foo"` + Bar int64 `cty:"bar" codec:"bar"` + Baz bool `cty:"baz" codec:"baz"` +} + +func TestBasePlugin_PluginInfo_GRPC(t *testing.T) { + t.Parallel() + require := require.New(t) + + const ( + apiVersion = "v0.1.0" + pluginVersion = "v0.2.1" + pluginName = "mock" + ) + + knownType := func() (*PluginInfoResponse, error) { + info := &PluginInfoResponse{ + Type: PluginTypeBase, + PluginApiVersion: apiVersion, + PluginVersion: pluginVersion, + Name: pluginName, + } + return info, nil + } + unknownType := func() (*PluginInfoResponse, error) { + info := &PluginInfoResponse{ + Type: "bad", + PluginApiVersion: apiVersion, + PluginVersion: pluginVersion, + Name: pluginName, + } + return info, nil + } + + mock := &MockPlugin{ + PluginInfoF: knownType, + } + + conn, server := plugin.TestGRPCConn(t, func(s *grpc.Server) { + proto.RegisterBasePluginServer(s, &basePluginServer{impl: mock}) + }) + defer conn.Close() + defer server.Stop() + grpcClient := proto.NewBasePluginClient(conn) + client := basePluginClient{client: grpcClient} + + resp, err := client.PluginInfo() + require.NoError(err) + require.Equal(apiVersion, resp.PluginApiVersion) + require.Equal(pluginVersion, resp.PluginVersion) + require.Equal(pluginName, resp.Name) + require.Equal(PluginTypeBase, resp.Type) + + // Swap the implementation to return an unknown type + mock.PluginInfoF = unknownType + _, err = client.PluginInfo() + require.Error(err) + require.Contains(err.Error(), "unknown type") +} + +func TestBasePlugin_ConfigSchema(t *testing.T) { + t.Parallel() + require := require.New(t) + + mock := &MockPlugin{ + ConfigSchemaF: func() (*hclspec.Spec, error) { + return testSpec, nil + }, + } + + conn, server := plugin.TestGRPCConn(t, func(s *grpc.Server) { + proto.RegisterBasePluginServer(s, &basePluginServer{impl: mock}) + }) + defer conn.Close() + defer server.Stop() + grpcClient := proto.NewBasePluginClient(conn) + client := basePluginClient{client: grpcClient} + + specOut, err := client.ConfigSchema() + require.NoError(err) + require.True(pb.Equal(testSpec, specOut)) +} + +func TestBasePlugin_SetConfig(t *testing.T) { + t.Parallel() + require := require.New(t) + + var receivedData []byte + mock := &MockPlugin{ + ConfigSchemaF: func() (*hclspec.Spec, error) { + return testSpec, nil + }, + SetConfigF: func(data []byte) error { + receivedData = data + return nil + }, + } + + conn, server := plugin.TestGRPCConn(t, func(s *grpc.Server) { + proto.RegisterBasePluginServer(s, &basePluginServer{impl: mock}) + }) + defer conn.Close() + defer server.Stop() + grpcClient := proto.NewBasePluginClient(conn) + client := basePluginClient{client: grpcClient} + + config := cty.ObjectVal(map[string]cty.Value{ + "foo": cty.StringVal("v1"), + "bar": cty.NumberIntVal(1337), + "baz": cty.BoolVal(true), + }) + cdata, err := msgpack.Marshal(config, config.Type()) + require.NoError(err) + require.NoError(client.SetConfig(cdata)) + require.Equal(cdata, receivedData) + + // Decode the value back + var actual testConfig + require.NoError(structs.Decode(receivedData, &actual)) + require.Equal("v1", actual.Foo) + require.EqualValues(1337, actual.Bar) + require.True(actual.Baz) +} diff --git a/plugins/base/proto/base.pb.go b/plugins/base/proto/base.pb.go index 67bb0b3e2..e2bf6a172 100644 --- a/plugins/base/proto/base.pb.go +++ b/plugins/base/proto/base.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: github.com/hashicorp/nomad/plugins/base/proto/base.proto -package base +package proto import proto "github.com/golang/protobuf/proto" import fmt "fmt" @@ -29,26 +29,29 @@ type PluginType int32 const ( PluginType_UNKNOWN PluginType = 0 - PluginType_DRIVER PluginType = 1 - PluginType_DEVICE PluginType = 2 + PluginType_BASE PluginType = 1 + PluginType_DRIVER PluginType = 2 + PluginType_DEVICE PluginType = 3 ) var PluginType_name = map[int32]string{ 0: "UNKNOWN", - 1: "DRIVER", - 2: "DEVICE", + 1: "BASE", + 2: "DRIVER", + 3: "DEVICE", } var PluginType_value = map[string]int32{ "UNKNOWN": 0, - "DRIVER": 1, - "DEVICE": 2, + "BASE": 1, + "DRIVER": 2, + "DEVICE": 3, } func (x PluginType) String() string { return proto.EnumName(PluginType_name, int32(x)) } func (PluginType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{0} + return fileDescriptor_base_d24a6a23488adb59, []int{0} } // PluginInfoRequest is used to request the plugins basic information. @@ -62,7 +65,7 @@ func (m *PluginInfoRequest) Reset() { *m = PluginInfoRequest{} } func (m *PluginInfoRequest) String() string { return proto.CompactTextString(m) } func (*PluginInfoRequest) ProtoMessage() {} func (*PluginInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{0} + return fileDescriptor_base_d24a6a23488adb59, []int{0} } func (m *PluginInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PluginInfoRequest.Unmarshal(m, b) @@ -104,7 +107,7 @@ func (m *PluginInfoResponse) Reset() { *m = PluginInfoResponse{} } func (m *PluginInfoResponse) String() string { return proto.CompactTextString(m) } func (*PluginInfoResponse) ProtoMessage() {} func (*PluginInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{1} + return fileDescriptor_base_d24a6a23488adb59, []int{1} } func (m *PluginInfoResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PluginInfoResponse.Unmarshal(m, b) @@ -163,7 +166,7 @@ func (m *ConfigSchemaRequest) Reset() { *m = ConfigSchemaRequest{} } func (m *ConfigSchemaRequest) String() string { return proto.CompactTextString(m) } func (*ConfigSchemaRequest) ProtoMessage() {} func (*ConfigSchemaRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{2} + return fileDescriptor_base_d24a6a23488adb59, []int{2} } func (m *ConfigSchemaRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfigSchemaRequest.Unmarshal(m, b) @@ -196,7 +199,7 @@ func (m *ConfigSchemaResponse) Reset() { *m = ConfigSchemaResponse{} } func (m *ConfigSchemaResponse) String() string { return proto.CompactTextString(m) } func (*ConfigSchemaResponse) ProtoMessage() {} func (*ConfigSchemaResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{3} + return fileDescriptor_base_d24a6a23488adb59, []int{3} } func (m *ConfigSchemaResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfigSchemaResponse.Unmarshal(m, b) @@ -236,7 +239,7 @@ func (m *SetConfigRequest) Reset() { *m = SetConfigRequest{} } func (m *SetConfigRequest) String() string { return proto.CompactTextString(m) } func (*SetConfigRequest) ProtoMessage() {} func (*SetConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{4} + return fileDescriptor_base_d24a6a23488adb59, []int{4} } func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SetConfigRequest.Unmarshal(m, b) @@ -274,7 +277,7 @@ func (m *SetConfigResponse) Reset() { *m = SetConfigResponse{} } func (m *SetConfigResponse) String() string { return proto.CompactTextString(m) } func (*SetConfigResponse) ProtoMessage() {} func (*SetConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_01259c48147dbaa4, []int{5} + return fileDescriptor_base_d24a6a23488adb59, []int{5} } func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SetConfigResponse.Unmarshal(m, b) @@ -449,37 +452,37 @@ var _BasePlugin_serviceDesc = grpc.ServiceDesc{ } func init() { - proto.RegisterFile("github.com/hashicorp/nomad/plugins/base/proto/base.proto", fileDescriptor_base_01259c48147dbaa4) + proto.RegisterFile("github.com/hashicorp/nomad/plugins/base/proto/base.proto", fileDescriptor_base_d24a6a23488adb59) } -var fileDescriptor_base_01259c48147dbaa4 = []byte{ - // 435 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcf, 0x8b, 0xd3, 0x40, - 0x14, 0xc7, 0x37, 0xbb, 0xa1, 0xb2, 0x6f, 0xb7, 0x25, 0x4e, 0x15, 0x4a, 0x4e, 0x25, 0x20, 0x14, - 0x29, 0x13, 0xac, 0x56, 0xeb, 0xad, 0xb6, 0xf6, 0x50, 0x84, 0x2a, 0xa9, 0x56, 0xf1, 0x12, 0xa6, - 0xd3, 0x69, 0x12, 0x6c, 0x32, 0x63, 0x26, 0x15, 0x2a, 0x78, 0xf2, 0xec, 0x1f, 0xe5, 0x7f, 0x26, - 0x99, 0x49, 0xda, 0x28, 0x8a, 0xe9, 0x29, 0x8f, 0xf7, 0x3e, 0xdf, 0xef, 0xbc, 0x1f, 0x81, 0x51, - 0x10, 0x65, 0xe1, 0x7e, 0x8d, 0x29, 0x8f, 0xdd, 0x90, 0xc8, 0x30, 0xa2, 0x3c, 0x15, 0x6e, 0xc2, - 0x63, 0xb2, 0x71, 0xc5, 0x6e, 0x1f, 0x44, 0x89, 0x74, 0xd7, 0x44, 0x32, 0x57, 0xa4, 0x3c, 0xe3, - 0x2a, 0xc4, 0x2a, 0x44, 0xce, 0x11, 0xc7, 0x0a, 0xc7, 0x05, 0x8e, 0x4f, 0x8c, 0x3d, 0xae, 0xe1, - 0x2e, 0x43, 0x92, 0xb2, 0x8d, 0x1b, 0xd2, 0x9d, 0x14, 0x8c, 0xe6, 0x5f, 0x3f, 0x0f, 0xb4, 0x83, - 0xd3, 0x86, 0xbb, 0x6f, 0x14, 0x38, 0x4f, 0xb6, 0xdc, 0x63, 0x9f, 0xf7, 0x4c, 0x66, 0xce, 0x4f, - 0x03, 0x50, 0x35, 0x2b, 0x05, 0x4f, 0x24, 0x43, 0x13, 0x30, 0xb3, 0x83, 0x60, 0x1d, 0xa3, 0x6b, - 0xf4, 0x5a, 0x03, 0x8c, 0xff, 0xdf, 0x20, 0xd6, 0x2e, 0x6f, 0x0f, 0x82, 0x79, 0x4a, 0x8b, 0xfa, - 0x80, 0x34, 0xe6, 0x13, 0x11, 0xf9, 0x5f, 0x58, 0x2a, 0x23, 0x9e, 0x74, 0x2e, 0xbb, 0x46, 0xef, - 0xda, 0xb3, 0x74, 0xe5, 0x85, 0x88, 0x56, 0x3a, 0x8f, 0x1e, 0x40, 0xab, 0xa0, 0x4b, 0xf2, 0x4a, - 0x91, 0x4d, 0x9d, 0x2d, 0x31, 0x04, 0x66, 0x42, 0x62, 0xd6, 0x31, 0x55, 0x51, 0xc5, 0xce, 0x7d, - 0x68, 0x4f, 0x79, 0xb2, 0x8d, 0x82, 0x25, 0x0d, 0x59, 0x4c, 0xca, 0xd1, 0x3e, 0xc0, 0xbd, 0xdf, - 0xd3, 0xc5, 0x6c, 0x63, 0x30, 0xf3, 0xad, 0xa8, 0xd9, 0x6e, 0x06, 0xfd, 0x7f, 0xce, 0xa6, 0xb7, - 0x89, 0x8b, 0x6d, 0xe2, 0xa5, 0x60, 0xd4, 0x53, 0x4a, 0xe7, 0x39, 0x58, 0x4b, 0x96, 0x69, 0xf3, - 0xe2, 0xb5, 0xbc, 0xff, 0x58, 0x06, 0x82, 0xd0, 0x4f, 0x3e, 0x55, 0x05, 0xe5, 0x7f, 0xeb, 0x35, - 0x8b, 0xac, 0xa6, 0xf3, 0x23, 0x54, 0xa4, 0xba, 0xa3, 0x87, 0x8f, 0x00, 0x4e, 0xdb, 0x43, 0x37, - 0x70, 0xe7, 0xdd, 0xe2, 0xd5, 0xe2, 0xf5, 0xfb, 0x85, 0x75, 0x81, 0x00, 0x1a, 0x2f, 0xbd, 0xf9, - 0x6a, 0xe6, 0x59, 0x86, 0x8a, 0x67, 0xab, 0xf9, 0x74, 0x66, 0x5d, 0x0e, 0x7e, 0x5c, 0x01, 0x4c, - 0x88, 0x64, 0x5a, 0x87, 0xbe, 0x95, 0x0e, 0xf9, 0x15, 0xd1, 0xb0, 0xfe, 0xbd, 0x2a, 0xff, 0x82, - 0xfd, 0xf4, 0x5c, 0x99, 0x6e, 0xdf, 0xb9, 0x40, 0xdf, 0x0d, 0xb8, 0xad, 0xee, 0x1a, 0x3d, 0xab, - 0x63, 0xf5, 0x97, 0xa3, 0xd9, 0xa3, 0xf3, 0x85, 0xc7, 0x2e, 0xbe, 0xc2, 0xf5, 0x71, 0xb7, 0xe8, - 0x49, 0x1d, 0xa3, 0x3f, 0xaf, 0x68, 0x0f, 0xcf, 0x54, 0x95, 0x6f, 0x4f, 0x1a, 0x1f, 0xcd, 0x9c, - 0x58, 0x37, 0x14, 0xf2, 0xf8, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x3e, 0xab, 0xdf, 0x0d, - 0x04, 0x00, 0x00, +var fileDescriptor_base_d24a6a23488adb59 = []byte{ + // 446 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xdf, 0x8b, 0xd3, 0x40, + 0x10, 0xc7, 0x2f, 0xd7, 0x78, 0xe7, 0xcd, 0xfd, 0x20, 0xee, 0x29, 0x94, 0x3c, 0x1d, 0x01, 0xe1, + 0x90, 0x63, 0x03, 0xd5, 0xd3, 0x13, 0x5f, 0xae, 0xa9, 0x79, 0x28, 0x42, 0x95, 0x44, 0xab, 0xf8, + 0x12, 0xb6, 0xdb, 0x6d, 0x12, 0x6c, 0xb2, 0x6b, 0x36, 0x15, 0x2a, 0xf8, 0xe4, 0xb3, 0x7f, 0x94, + 0xff, 0x99, 0x64, 0x37, 0x69, 0xa3, 0x28, 0xa6, 0x4f, 0x19, 0x66, 0x3e, 0xf3, 0xdd, 0x99, 0xef, + 0x04, 0x6e, 0xe2, 0xb4, 0x4c, 0x56, 0x33, 0x4c, 0x79, 0xe6, 0x26, 0x44, 0x26, 0x29, 0xe5, 0x85, + 0x70, 0x73, 0x9e, 0x91, 0xb9, 0x2b, 0x96, 0xab, 0x38, 0xcd, 0xa5, 0x3b, 0x23, 0x92, 0xb9, 0xa2, + 0xe0, 0x25, 0x57, 0x21, 0x56, 0x21, 0x72, 0x36, 0x38, 0x56, 0x38, 0xae, 0x71, 0xbc, 0x65, 0xec, + 0xdb, 0x0e, 0xea, 0x32, 0x21, 0x05, 0x9b, 0xbb, 0x09, 0x5d, 0x4a, 0xc1, 0x68, 0xf5, 0x8d, 0xaa, + 0x40, 0x2b, 0x38, 0xe7, 0x70, 0xef, 0x8d, 0x02, 0xc7, 0xf9, 0x82, 0x07, 0xec, 0xf3, 0x8a, 0xc9, + 0xd2, 0xf9, 0x69, 0x00, 0x6a, 0x67, 0xa5, 0xe0, 0xb9, 0x64, 0xc8, 0x03, 0xb3, 0x5c, 0x0b, 0xd6, + 0x37, 0x2e, 0x8c, 0xcb, 0xb3, 0x01, 0xc6, 0xff, 0x1f, 0x10, 0x6b, 0x95, 0xb7, 0x6b, 0xc1, 0x02, + 0xd5, 0x8b, 0xae, 0x00, 0x69, 0x2c, 0x22, 0x22, 0x8d, 0xbe, 0xb0, 0x42, 0xa6, 0x3c, 0xef, 0xef, + 0x5f, 0x18, 0x97, 0x47, 0x81, 0xa5, 0x2b, 0x43, 0x91, 0x4e, 0x75, 0x1e, 0x3d, 0x84, 0xb3, 0x9a, + 0x6e, 0xc8, 0x9e, 0x22, 0x4f, 0x75, 0xb6, 0xc1, 0x10, 0x98, 0x39, 0xc9, 0x58, 0xdf, 0x54, 0x45, + 0x15, 0x3b, 0x0f, 0xe0, 0x7c, 0xc4, 0xf3, 0x45, 0x1a, 0x87, 0x34, 0x61, 0x19, 0x69, 0x56, 0xfb, + 0x00, 0xf7, 0x7f, 0x4f, 0xd7, 0xbb, 0xdd, 0x82, 0x59, 0xb9, 0xa2, 0x76, 0x3b, 0x1e, 0x5c, 0xfd, + 0x73, 0x37, 0xed, 0x26, 0xae, 0xdd, 0xc4, 0xa1, 0x60, 0x34, 0x50, 0x9d, 0xce, 0x73, 0xb0, 0x42, + 0x56, 0x6a, 0xf1, 0xfa, 0xb5, 0x6a, 0xfe, 0x4c, 0xc6, 0x82, 0xd0, 0x4f, 0x11, 0x55, 0x05, 0xa5, + 0x7f, 0x12, 0x9c, 0xd6, 0x59, 0x4d, 0x57, 0x47, 0x68, 0xb5, 0xea, 0x89, 0x1e, 0xbd, 0x00, 0xd8, + 0xba, 0x87, 0x8e, 0xe1, 0xf0, 0xdd, 0xe4, 0xd5, 0xe4, 0xf5, 0xfb, 0x89, 0xb5, 0x87, 0xee, 0x82, + 0xe9, 0x0d, 0x43, 0xdf, 0x32, 0x10, 0xc0, 0xc1, 0xcb, 0x60, 0x3c, 0xf5, 0x03, 0x6b, 0x5f, 0xc5, + 0xfe, 0x74, 0x3c, 0xf2, 0xad, 0xde, 0xe0, 0x47, 0x0f, 0xc0, 0x23, 0x92, 0x69, 0x05, 0xf4, 0xad, + 0xd1, 0xaa, 0xee, 0x89, 0xae, 0xbb, 0x5f, 0xae, 0xf5, 0x57, 0xd8, 0x4f, 0x77, 0x6d, 0xd3, 0x8b, + 0x38, 0x7b, 0xe8, 0xbb, 0x01, 0x27, 0x6d, 0xd7, 0xd1, 0xb3, 0x2e, 0x52, 0x7f, 0x39, 0x9f, 0x7d, + 0xb3, 0x7b, 0xe3, 0x66, 0x8a, 0xaf, 0x70, 0xb4, 0x71, 0x19, 0x3d, 0xe9, 0x22, 0xf4, 0xe7, 0x3d, + 0xed, 0xeb, 0x1d, 0xbb, 0x9a, 0xb7, 0xbd, 0xc3, 0x8f, 0x77, 0x54, 0x71, 0x76, 0xa0, 0x3e, 0x8f, + 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x73, 0x54, 0x60, 0xaa, 0x18, 0x04, 0x00, 0x00, } diff --git a/plugins/base/proto/base.proto b/plugins/base/proto/base.proto index 892f53e85..b5f359cca 100644 --- a/plugins/base/proto/base.proto +++ b/plugins/base/proto/base.proto @@ -1,6 +1,6 @@ syntax = "proto3"; package hashicorp.nomad.plugins.base.proto; -option go_package = "base"; +option go_package = "proto"; import "github.com/hashicorp/nomad/plugins/shared/hclspec/hcl_spec.proto"; @@ -20,8 +20,9 @@ service BasePlugin { // PluginType enumerates the type of plugins Nomad supports enum PluginType { UNKNOWN = 0; - DRIVER = 1; - DEVICE = 2; + BASE = 1; + DRIVER = 2; + DEVICE = 3; } // PluginInfoRequest is used to request the plugins basic information. diff --git a/plugins/base/server.go b/plugins/base/server.go new file mode 100644 index 000000000..af2c9dc0e --- /dev/null +++ b/plugins/base/server.go @@ -0,0 +1,66 @@ +package shared + +import ( + "fmt" + + "golang.org/x/net/context" + + plugin "github.com/hashicorp/go-plugin" + "github.com/hashicorp/nomad/plugins/base/proto" +) + +// basePluginServer wraps a base plugin and exposes it via gRPC. +type basePluginServer struct { + broker *plugin.GRPCBroker + impl BasePlugin +} + +func (b *basePluginServer) PluginInfo(context.Context, *proto.PluginInfoRequest) (*proto.PluginInfoResponse, error) { + resp, err := b.impl.PluginInfo() + if err != nil { + return nil, err + } + + var ptype proto.PluginType + switch resp.Type { + case PluginTypeBase: + ptype = proto.PluginType_BASE + case PluginTypeDriver: + ptype = proto.PluginType_DRIVER + case PluginTypeDevice: + ptype = proto.PluginType_DEVICE + default: + return nil, fmt.Errorf("plugin is of unknown type: %q", resp.Type) + } + + presp := &proto.PluginInfoResponse{ + Type: ptype, + PluginApiVersion: resp.PluginApiVersion, + PluginVersion: resp.PluginVersion, + Name: resp.Name, + } + + return presp, nil +} + +func (b *basePluginServer) ConfigSchema(context.Context, *proto.ConfigSchemaRequest) (*proto.ConfigSchemaResponse, error) { + spec, err := b.impl.ConfigSchema() + if err != nil { + return nil, err + } + + presp := &proto.ConfigSchemaResponse{ + Spec: spec, + } + + return presp, nil +} + +func (b *basePluginServer) SetConfig(ctx context.Context, req *proto.SetConfigRequest) (*proto.SetConfigResponse, error) { + // Set the config + if err := b.impl.SetConfig(req.GetMsgpackConfig()); err != nil { + return nil, fmt.Errorf("SetConfig failed: %v", err) + } + + return &proto.SetConfigResponse{}, nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/CHANGELOG.md b/vendor/github.com/vmihailenco/msgpack/CHANGELOG.md new file mode 100644 index 000000000..569e171fe --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/CHANGELOG.md @@ -0,0 +1,18 @@ +## v3.3 + +- `msgpack:",inline"` tag is restored to force inlining structs. + +## v3.2 + +- Decoding extension types returns pointer to the value instead of the value. Fixes #153 + +## v3 + +- gopkg.in is not supported any more. Update import path to github.com/vmihailenco/msgpack. +- Msgpack maps are decoded into map[string]interface{} by default. +- EncodeSliceLen is removed in favor of EncodeArrayLen. DecodeSliceLen is removed in favor of DecodeArrayLen. +- Embedded structs are automatically inlined where possible. +- Time is encoded using extension as described in https://github.com/msgpack/msgpack/pull/209. Old format is supported as well. +- EncodeInt8/16/32/64 is replaced with EncodeInt. EncodeUint8/16/32/64 is replaced with EncodeUint. There should be no performance differences. +- DecodeInterface can now return int8/16/32 and uint8/16/32. +- PeekCode returns codes.Code instead of byte. diff --git a/vendor/github.com/vmihailenco/msgpack/LICENSE b/vendor/github.com/vmihailenco/msgpack/LICENSE new file mode 100644 index 000000000..b749d0707 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2013 The github.com/vmihailenco/msgpack Authors. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/vmihailenco/msgpack/Makefile b/vendor/github.com/vmihailenco/msgpack/Makefile new file mode 100644 index 000000000..b62ae6a46 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/Makefile @@ -0,0 +1,5 @@ +all: + go test ./... + env GOOS=linux GOARCH=386 go test ./... + go test ./... -short -race + go vet diff --git a/vendor/github.com/vmihailenco/msgpack/README.md b/vendor/github.com/vmihailenco/msgpack/README.md new file mode 100644 index 000000000..0c75ae16e --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/README.md @@ -0,0 +1,69 @@ +# MessagePack encoding for Golang + +[![Build Status](https://travis-ci.org/vmihailenco/msgpack.svg?branch=v2)](https://travis-ci.org/vmihailenco/msgpack) +[![GoDoc](https://godoc.org/github.com/vmihailenco/msgpack?status.svg)](https://godoc.org/github.com/vmihailenco/msgpack) + +Supports: +- Primitives, arrays, maps, structs, time.Time and interface{}. +- Appengine *datastore.Key and datastore.Cursor. +- [CustomEncoder](https://godoc.org/github.com/vmihailenco/msgpack#example-CustomEncoder)/CustomDecoder interfaces for custom encoding. +- [Extensions](https://godoc.org/github.com/vmihailenco/msgpack#example-RegisterExt) to encode type information. +- Renaming fields via `msgpack:"my_field_name"`. +- Omitting individual empty fields via `msgpack:",omitempty"` tag or all [empty fields in a struct](https://godoc.org/github.com/vmihailenco/msgpack#example-Marshal--OmitEmpty). +- [Map keys sorting](https://godoc.org/github.com/vmihailenco/msgpack#Encoder.SortMapKeys). +- Encoding/decoding all [structs as arrays](https://godoc.org/github.com/vmihailenco/msgpack#Encoder.StructAsArray) or [individual structs](https://godoc.org/github.com/vmihailenco/msgpack#example-Marshal--AsArray). +- [Encoder.UseJSONTag](https://godoc.org/github.com/vmihailenco/msgpack#Encoder.UseJSONTag) with [Decoder.UseJSONTag](https://godoc.org/github.com/vmihailenco/msgpack#Decoder.UseJSONTag) can turn msgpack into drop-in replacement for JSON. +- Simple but very fast and efficient [queries](https://godoc.org/github.com/vmihailenco/msgpack#example-Decoder-Query). + +API docs: https://godoc.org/github.com/vmihailenco/msgpack. +Examples: https://godoc.org/github.com/vmihailenco/msgpack#pkg-examples. + +## Installation + +Install: + +```shell +go get -u github.com/vmihailenco/msgpack +``` + +## Quickstart + +```go +func ExampleMarshal() { + type Item struct { + Foo string + } + + b, err := msgpack.Marshal(&Item{Foo: "bar"}) + if err != nil { + panic(err) + } + + var item Item + err = msgpack.Unmarshal(b, &item) + if err != nil { + panic(err) + } + fmt.Println(item.Foo) + // Output: bar +} +``` + +## Benchmark + +``` +BenchmarkStructVmihailencoMsgpack-4 200000 12814 ns/op 2128 B/op 26 allocs/op +BenchmarkStructUgorjiGoMsgpack-4 100000 17678 ns/op 3616 B/op 70 allocs/op +BenchmarkStructUgorjiGoCodec-4 100000 19053 ns/op 7346 B/op 23 allocs/op +BenchmarkStructJSON-4 20000 69438 ns/op 7864 B/op 26 allocs/op +BenchmarkStructGOB-4 10000 104331 ns/op 14664 B/op 278 allocs/op +``` + +## Howto + +Please go through [examples](https://godoc.org/github.com/vmihailenco/msgpack#pkg-examples) to get an idea how to use this package. + +## See also + +- [Golang PostgreSQL ORM](https://github.com/go-pg/pg) +- [Golang message task queue](https://github.com/go-msgqueue/msgqueue) diff --git a/vendor/github.com/vmihailenco/msgpack/codes/codes.go b/vendor/github.com/vmihailenco/msgpack/codes/codes.go new file mode 100644 index 000000000..906af376e --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/codes/codes.go @@ -0,0 +1,86 @@ +package codes + +type Code byte + +var ( + PosFixedNumHigh Code = 0x7f + NegFixedNumLow Code = 0xe0 + + Nil Code = 0xc0 + + False Code = 0xc2 + True Code = 0xc3 + + Float Code = 0xca + Double Code = 0xcb + + Uint8 Code = 0xcc + Uint16 Code = 0xcd + Uint32 Code = 0xce + Uint64 Code = 0xcf + + Int8 Code = 0xd0 + Int16 Code = 0xd1 + Int32 Code = 0xd2 + Int64 Code = 0xd3 + + FixedStrLow Code = 0xa0 + FixedStrHigh Code = 0xbf + FixedStrMask Code = 0x1f + Str8 Code = 0xd9 + Str16 Code = 0xda + Str32 Code = 0xdb + + Bin8 Code = 0xc4 + Bin16 Code = 0xc5 + Bin32 Code = 0xc6 + + FixedArrayLow Code = 0x90 + FixedArrayHigh Code = 0x9f + FixedArrayMask Code = 0xf + Array16 Code = 0xdc + Array32 Code = 0xdd + + FixedMapLow Code = 0x80 + FixedMapHigh Code = 0x8f + FixedMapMask Code = 0xf + Map16 Code = 0xde + Map32 Code = 0xdf + + FixExt1 Code = 0xd4 + FixExt2 Code = 0xd5 + FixExt4 Code = 0xd6 + FixExt8 Code = 0xd7 + FixExt16 Code = 0xd8 + Ext8 Code = 0xc7 + Ext16 Code = 0xc8 + Ext32 Code = 0xc9 +) + +func IsFixedNum(c Code) bool { + return c <= PosFixedNumHigh || c >= NegFixedNumLow +} + +func IsFixedMap(c Code) bool { + return c >= FixedMapLow && c <= FixedMapHigh +} + +func IsFixedArray(c Code) bool { + return c >= FixedArrayLow && c <= FixedArrayHigh +} + +func IsFixedString(c Code) bool { + return c >= FixedStrLow && c <= FixedStrHigh +} + +func IsString(c Code) bool { + return IsFixedString(c) || c == Str8 || c == Str16 || c == Str32 +} + +func IsFixedExt(c Code) bool { + return c >= FixExt1 && c <= FixExt16 +} + +func IsExt(c Code) bool { + return IsFixedExt(c) || c == Ext8 || c == Ext16 || c == Ext32 +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode.go b/vendor/github.com/vmihailenco/msgpack/decode.go new file mode 100644 index 000000000..7ad2cf6cf --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode.go @@ -0,0 +1,536 @@ +package msgpack + +import ( + "bufio" + "bytes" + "errors" + "fmt" + "io" + "reflect" + "time" + + "github.com/vmihailenco/msgpack/codes" +) + +const bytesAllocLimit = 1024 * 1024 // 1mb + +type bufReader interface { + io.Reader + io.ByteScanner +} + +func newBufReader(r io.Reader) bufReader { + if br, ok := r.(bufReader); ok { + return br + } + return bufio.NewReader(r) +} + +func makeBuffer() []byte { + return make([]byte, 0, 64) +} + +// Unmarshal decodes the MessagePack-encoded data and stores the result +// in the value pointed to by v. +func Unmarshal(data []byte, v ...interface{}) error { + return NewDecoder(bytes.NewReader(data)).Decode(v...) +} + +type Decoder struct { + r io.Reader + s io.ByteScanner + buf []byte + + extLen int + rec []byte // accumulates read data if not nil + + useLoose bool + useJSONTag bool + + decodeMapFunc func(*Decoder) (interface{}, error) +} + +// NewDecoder returns a new decoder that reads from r. +// +// The decoder introduces its own buffering and may read data from r +// beyond the MessagePack values requested. Buffering can be disabled +// by passing a reader that implements io.ByteScanner interface. +func NewDecoder(r io.Reader) *Decoder { + d := &Decoder{ + decodeMapFunc: decodeMap, + + buf: makeBuffer(), + } + d.resetReader(r) + return d +} + +func (d *Decoder) SetDecodeMapFunc(fn func(*Decoder) (interface{}, error)) { + d.decodeMapFunc = fn +} + +// UseDecodeInterfaceLoose causes decoder to use DecodeInterfaceLoose +// to decode msgpack value into Go interface{}. +func (d *Decoder) UseDecodeInterfaceLoose(flag bool) { + d.useLoose = flag +} + +// UseJSONTag causes the Decoder to use json struct tag as fallback option +// if there is no msgpack tag. +func (d *Decoder) UseJSONTag(v bool) *Decoder { + d.useJSONTag = v + return d +} + +func (d *Decoder) Reset(r io.Reader) error { + d.resetReader(r) + return nil +} + +func (d *Decoder) resetReader(r io.Reader) { + reader := newBufReader(r) + d.r = reader + d.s = reader +} + +func (d *Decoder) Decode(v ...interface{}) error { + for _, vv := range v { + if err := d.decode(vv); err != nil { + return err + } + } + return nil +} + +func (d *Decoder) decode(dst interface{}) error { + var err error + switch v := dst.(type) { + case *string: + if v != nil { + *v, err = d.DecodeString() + return err + } + case *[]byte: + if v != nil { + return d.decodeBytesPtr(v) + } + case *int: + if v != nil { + *v, err = d.DecodeInt() + return err + } + case *int8: + if v != nil { + *v, err = d.DecodeInt8() + return err + } + case *int16: + if v != nil { + *v, err = d.DecodeInt16() + return err + } + case *int32: + if v != nil { + *v, err = d.DecodeInt32() + return err + } + case *int64: + if v != nil { + *v, err = d.DecodeInt64() + return err + } + case *uint: + if v != nil { + *v, err = d.DecodeUint() + return err + } + case *uint8: + if v != nil { + *v, err = d.DecodeUint8() + return err + } + case *uint16: + if v != nil { + *v, err = d.DecodeUint16() + return err + } + case *uint32: + if v != nil { + *v, err = d.DecodeUint32() + return err + } + case *uint64: + if v != nil { + *v, err = d.DecodeUint64() + return err + } + case *bool: + if v != nil { + *v, err = d.DecodeBool() + return err + } + case *float32: + if v != nil { + *v, err = d.DecodeFloat32() + return err + } + case *float64: + if v != nil { + *v, err = d.DecodeFloat64() + return err + } + case *[]string: + return d.decodeStringSlicePtr(v) + case *map[string]string: + return d.decodeMapStringStringPtr(v) + case *map[string]interface{}: + return d.decodeMapStringInterfacePtr(v) + case *time.Duration: + if v != nil { + vv, err := d.DecodeInt64() + *v = time.Duration(vv) + return err + } + case *time.Time: + if v != nil { + *v, err = d.DecodeTime() + return err + } + } + + v := reflect.ValueOf(dst) + if !v.IsValid() { + return errors.New("msgpack: Decode(nil)") + } + if v.Kind() != reflect.Ptr { + return fmt.Errorf("msgpack: Decode(nonsettable %T)", dst) + } + v = v.Elem() + if !v.IsValid() { + return fmt.Errorf("msgpack: Decode(nonsettable %T)", dst) + } + return d.DecodeValue(v) +} + +func (d *Decoder) decodeInterface() (interface{}, error) { + if d.useLoose { + return d.DecodeInterfaceLoose() + } + return d.DecodeInterface() +} + +func (d *Decoder) DecodeValue(v reflect.Value) error { + decode := getDecoder(v.Type()) + return decode(d, v) +} + +func (d *Decoder) DecodeNil() error { + c, err := d.readCode() + if err != nil { + return err + } + if c != codes.Nil { + return fmt.Errorf("msgpack: invalid code=%x decoding nil", c) + } + return nil +} + +func (d *Decoder) decodeNilValue(v reflect.Value) error { + err := d.DecodeNil() + if v.IsNil() { + return err + } + if v.Kind() == reflect.Ptr { + v = v.Elem() + } + v.Set(reflect.Zero(v.Type())) + return err +} + +func (d *Decoder) DecodeBool() (bool, error) { + c, err := d.readCode() + if err != nil { + return false, err + } + return d.bool(c) +} + +func (d *Decoder) bool(c codes.Code) (bool, error) { + if c == codes.False { + return false, nil + } + if c == codes.True { + return true, nil + } + return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c) +} + +// DecodeInterface decodes value into interface. It returns following types: +// - nil, +// - bool, +// - int8, int16, int32, int64, +// - uint8, uint16, uint32, uint64, +// - float32 and float64, +// - string, +// - []byte, +// - slices of any of the above, +// - maps of any of the above. +// +// DecodeInterface should be used only when you don't know the type of value +// you are decoding. For example, if you are decoding number it is better to use +// DecodeInt64 for negative numbers and DecodeUint64 for positive numbers. +func (d *Decoder) DecodeInterface() (interface{}, error) { + c, err := d.readCode() + if err != nil { + return nil, err + } + + if codes.IsFixedNum(c) { + return int8(c), nil + } + if codes.IsFixedMap(c) { + _ = d.s.UnreadByte() + return d.DecodeMap() + } + if codes.IsFixedArray(c) { + return d.decodeSlice(c) + } + if codes.IsFixedString(c) { + return d.string(c) + } + + switch c { + case codes.Nil: + return nil, nil + case codes.False, codes.True: + return d.bool(c) + case codes.Float: + return d.float32(c) + case codes.Double: + return d.float64(c) + case codes.Uint8: + return d.uint8() + case codes.Uint16: + return d.uint16() + case codes.Uint32: + return d.uint32() + case codes.Uint64: + return d.uint64() + case codes.Int8: + return d.int8() + case codes.Int16: + return d.int16() + case codes.Int32: + return d.int32() + case codes.Int64: + return d.int64() + case codes.Bin8, codes.Bin16, codes.Bin32: + return d.bytes(c, nil) + case codes.Str8, codes.Str16, codes.Str32: + return d.string(c) + case codes.Array16, codes.Array32: + return d.decodeSlice(c) + case codes.Map16, codes.Map32: + d.s.UnreadByte() + return d.DecodeMap() + case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, + codes.Ext8, codes.Ext16, codes.Ext32: + return d.extInterface(c) + } + + return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c) +} + +// DecodeInterfaceLoose is like DecodeInterface except that: +// - int8, int16, and int32 are converted to int64, +// - uint8, uint16, and uint32 are converted to uint64, +// - float32 is converted to float64. +func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) { + c, err := d.readCode() + if err != nil { + return nil, err + } + + if codes.IsFixedNum(c) { + return int64(c), nil + } + if codes.IsFixedMap(c) { + d.s.UnreadByte() + return d.DecodeMap() + } + if codes.IsFixedArray(c) { + return d.decodeSlice(c) + } + if codes.IsFixedString(c) { + return d.string(c) + } + + switch c { + case codes.Nil: + return nil, nil + case codes.False, codes.True: + return d.bool(c) + case codes.Float, codes.Double: + return d.float64(c) + case codes.Uint8, codes.Uint16, codes.Uint32, codes.Uint64: + return d.uint(c) + case codes.Int8, codes.Int16, codes.Int32, codes.Int64: + return d.int(c) + case codes.Bin8, codes.Bin16, codes.Bin32: + return d.bytes(c, nil) + case codes.Str8, codes.Str16, codes.Str32: + return d.string(c) + case codes.Array16, codes.Array32: + return d.decodeSlice(c) + case codes.Map16, codes.Map32: + d.s.UnreadByte() + return d.DecodeMap() + case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, + codes.Ext8, codes.Ext16, codes.Ext32: + return d.extInterface(c) + } + + return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c) +} + +// Skip skips next value. +func (d *Decoder) Skip() error { + c, err := d.readCode() + if err != nil { + return err + } + + if codes.IsFixedNum(c) { + return nil + } else if codes.IsFixedMap(c) { + return d.skipMap(c) + } else if codes.IsFixedArray(c) { + return d.skipSlice(c) + } else if codes.IsFixedString(c) { + return d.skipBytes(c) + } + + switch c { + case codes.Nil, codes.False, codes.True: + return nil + case codes.Uint8, codes.Int8: + return d.skipN(1) + case codes.Uint16, codes.Int16: + return d.skipN(2) + case codes.Uint32, codes.Int32, codes.Float: + return d.skipN(4) + case codes.Uint64, codes.Int64, codes.Double: + return d.skipN(8) + case codes.Bin8, codes.Bin16, codes.Bin32: + return d.skipBytes(c) + case codes.Str8, codes.Str16, codes.Str32: + return d.skipBytes(c) + case codes.Array16, codes.Array32: + return d.skipSlice(c) + case codes.Map16, codes.Map32: + return d.skipMap(c) + case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, + codes.Ext8, codes.Ext16, codes.Ext32: + return d.skipExt(c) + } + + return fmt.Errorf("msgpack: unknown code %x", c) +} + +// PeekCode returns the next MessagePack code without advancing the reader. +// Subpackage msgpack/codes contains list of available codes. +func (d *Decoder) PeekCode() (codes.Code, error) { + c, err := d.s.ReadByte() + if err != nil { + return 0, err + } + return codes.Code(c), d.s.UnreadByte() +} + +func (d *Decoder) hasNilCode() bool { + code, err := d.PeekCode() + return err == nil && code == codes.Nil +} + +func (d *Decoder) readCode() (codes.Code, error) { + d.extLen = 0 + c, err := d.s.ReadByte() + if err != nil { + return 0, err + } + if d.rec != nil { + d.rec = append(d.rec, c) + } + return codes.Code(c), nil +} + +func (d *Decoder) readFull(b []byte) error { + _, err := io.ReadFull(d.r, b) + if err != nil { + return err + } + if d.rec != nil { + d.rec = append(d.rec, b...) + } + return nil +} + +func (d *Decoder) readN(n int) ([]byte, error) { + buf, err := readN(d.r, d.buf, n) + if err != nil { + return nil, err + } + d.buf = buf + if d.rec != nil { + d.rec = append(d.rec, buf...) + } + return buf, nil +} + +func readN(r io.Reader, b []byte, n int) ([]byte, error) { + if b == nil { + if n == 0 { + return make([]byte, 0), nil + } + if n <= bytesAllocLimit { + b = make([]byte, n) + } else { + b = make([]byte, bytesAllocLimit) + } + } + + if n <= cap(b) { + b = b[:n] + _, err := io.ReadFull(r, b) + return b, err + } + b = b[:cap(b)] + + var pos int + for { + alloc := n - len(b) + if alloc > bytesAllocLimit { + alloc = bytesAllocLimit + } + b = append(b, make([]byte, alloc)...) + + _, err := io.ReadFull(r, b[pos:]) + if err != nil { + return nil, err + } + + if len(b) == n { + break + } + pos = len(b) + } + + return b, nil +} + +func min(a, b int) int { + if a <= b { + return a + } + return b +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode_map.go b/vendor/github.com/vmihailenco/msgpack/decode_map.go new file mode 100644 index 000000000..b08e8568d --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode_map.go @@ -0,0 +1,289 @@ +package msgpack + +import ( + "errors" + "fmt" + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +const mapElemsAllocLimit = 1e4 + +var mapStringStringPtrType = reflect.TypeOf((*map[string]string)(nil)) +var mapStringStringType = mapStringStringPtrType.Elem() + +var mapStringInterfacePtrType = reflect.TypeOf((*map[string]interface{})(nil)) +var mapStringInterfaceType = mapStringInterfacePtrType.Elem() + +var errInvalidCode = errors.New("invalid code") + +func decodeMapValue(d *Decoder, v reflect.Value) error { + n, err := d.DecodeMapLen() + if err != nil { + return err + } + + typ := v.Type() + if n == -1 { + v.Set(reflect.Zero(typ)) + return nil + } + + if v.IsNil() { + v.Set(reflect.MakeMap(typ)) + } + keyType := typ.Key() + valueType := typ.Elem() + + for i := 0; i < n; i++ { + mk := reflect.New(keyType).Elem() + if err := d.DecodeValue(mk); err != nil { + return err + } + + mv := reflect.New(valueType).Elem() + if err := d.DecodeValue(mv); err != nil { + return err + } + + v.SetMapIndex(mk, mv) + } + + return nil +} + +func decodeMap(d *Decoder) (interface{}, error) { + n, err := d.DecodeMapLen() + if err != nil { + return nil, err + } + if n == -1 { + return nil, nil + } + + m := make(map[string]interface{}, min(n, mapElemsAllocLimit)) + for i := 0; i < n; i++ { + mk, err := d.DecodeString() + if err != nil { + return nil, err + } + mv, err := d.decodeInterface() + if err != nil { + return nil, err + } + m[mk] = mv + } + return m, nil +} + +func (d *Decoder) DecodeMapLen() (int, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + + if codes.IsExt(c) { + if err = d.skipExtHeader(c); err != nil { + return 0, err + } + + c, err = d.readCode() + if err != nil { + return 0, err + } + } + return d.mapLen(c) +} + +func (d *Decoder) mapLen(c codes.Code) (int, error) { + n, err := d._mapLen(c) + err = expandInvalidCodeMapLenError(c, err) + return n, err +} + +func (d *Decoder) _mapLen(c codes.Code) (int, error) { + if c == codes.Nil { + return -1, nil + } + if c >= codes.FixedMapLow && c <= codes.FixedMapHigh { + return int(c & codes.FixedMapMask), nil + } + if c == codes.Map16 { + n, err := d.uint16() + return int(n), err + } + if c == codes.Map32 { + n, err := d.uint32() + return int(n), err + } + return 0, errInvalidCode +} + +func expandInvalidCodeMapLenError(c codes.Code, err error) error { + if err == errInvalidCode { + return fmt.Errorf("msgpack: invalid code=%x decoding map length", c) + } + return err +} + +func decodeMapStringStringValue(d *Decoder, v reflect.Value) error { + mptr := v.Addr().Convert(mapStringStringPtrType).Interface().(*map[string]string) + return d.decodeMapStringStringPtr(mptr) +} + +func (d *Decoder) decodeMapStringStringPtr(ptr *map[string]string) error { + n, err := d.DecodeMapLen() + if err != nil { + return err + } + if n == -1 { + *ptr = nil + return nil + } + + m := *ptr + if m == nil { + *ptr = make(map[string]string, min(n, mapElemsAllocLimit)) + m = *ptr + } + + for i := 0; i < n; i++ { + mk, err := d.DecodeString() + if err != nil { + return err + } + mv, err := d.DecodeString() + if err != nil { + return err + } + m[mk] = mv + } + + return nil +} + +func decodeMapStringInterfaceValue(d *Decoder, v reflect.Value) error { + ptr := v.Addr().Convert(mapStringInterfacePtrType).Interface().(*map[string]interface{}) + return d.decodeMapStringInterfacePtr(ptr) +} + +func (d *Decoder) decodeMapStringInterfacePtr(ptr *map[string]interface{}) error { + n, err := d.DecodeMapLen() + if err != nil { + return err + } + if n == -1 { + *ptr = nil + return nil + } + + m := *ptr + if m == nil { + *ptr = make(map[string]interface{}, min(n, mapElemsAllocLimit)) + m = *ptr + } + + for i := 0; i < n; i++ { + mk, err := d.DecodeString() + if err != nil { + return err + } + mv, err := d.decodeInterface() + if err != nil { + return err + } + m[mk] = mv + } + + return nil +} + +func (d *Decoder) DecodeMap() (interface{}, error) { + return d.decodeMapFunc(d) +} + +func (d *Decoder) skipMap(c codes.Code) error { + n, err := d.mapLen(c) + if err != nil { + return err + } + for i := 0; i < n; i++ { + if err := d.Skip(); err != nil { + return err + } + if err := d.Skip(); err != nil { + return err + } + } + return nil +} + +func decodeStructValue(d *Decoder, v reflect.Value) error { + c, err := d.readCode() + if err != nil { + return err + } + + var isArray bool + + n, err := d._mapLen(c) + if err != nil { + var err2 error + n, err2 = d.arrayLen(c) + if err2 != nil { + return expandInvalidCodeMapLenError(c, err) + } + isArray = true + } + if n == -1 { + if err = mustSet(v); err != nil { + return err + } + v.Set(reflect.Zero(v.Type())) + return nil + } + + var fields *fields + if d.useJSONTag { + fields = jsonStructs.Fields(v.Type()) + } else { + fields = structs.Fields(v.Type()) + } + + if isArray { + for i, f := range fields.List { + if i >= n { + break + } + if err := f.DecodeValue(d, v); err != nil { + return err + } + } + // Skip extra values. + for i := len(fields.List); i < n; i++ { + if err := d.Skip(); err != nil { + return err + } + } + return nil + } + + for i := 0; i < n; i++ { + name, err := d.DecodeString() + if err != nil { + return err + } + if f := fields.Table[name]; f != nil { + if err := f.DecodeValue(d, v); err != nil { + return err + } + } else { + if err := d.Skip(); err != nil { + return err + } + } + } + + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode_number.go b/vendor/github.com/vmihailenco/msgpack/decode_number.go new file mode 100644 index 000000000..15019cc97 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode_number.go @@ -0,0 +1,307 @@ +package msgpack + +import ( + "fmt" + "math" + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +func (d *Decoder) skipN(n int) error { + _, err := d.readN(n) + return err +} + +func (d *Decoder) uint8() (uint8, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return uint8(c), nil +} + +func (d *Decoder) int8() (int8, error) { + n, err := d.uint8() + return int8(n), err +} + +func (d *Decoder) uint16() (uint16, error) { + b, err := d.readN(2) + if err != nil { + return 0, err + } + return (uint16(b[0]) << 8) | uint16(b[1]), nil +} + +func (d *Decoder) int16() (int16, error) { + n, err := d.uint16() + return int16(n), err +} + +func (d *Decoder) uint32() (uint32, error) { + b, err := d.readN(4) + if err != nil { + return 0, err + } + n := (uint32(b[0]) << 24) | + (uint32(b[1]) << 16) | + (uint32(b[2]) << 8) | + uint32(b[3]) + return n, nil +} + +func (d *Decoder) int32() (int32, error) { + n, err := d.uint32() + return int32(n), err +} + +func (d *Decoder) uint64() (uint64, error) { + b, err := d.readN(8) + if err != nil { + return 0, err + } + n := (uint64(b[0]) << 56) | + (uint64(b[1]) << 48) | + (uint64(b[2]) << 40) | + (uint64(b[3]) << 32) | + (uint64(b[4]) << 24) | + (uint64(b[5]) << 16) | + (uint64(b[6]) << 8) | + uint64(b[7]) + return n, nil +} + +func (d *Decoder) int64() (int64, error) { + n, err := d.uint64() + return int64(n), err +} + +// DecodeUint64 decodes msgpack int8/16/32/64 and uint8/16/32/64 +// into Go uint64. +func (d *Decoder) DecodeUint64() (uint64, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return d.uint(c) +} + +func (d *Decoder) uint(c codes.Code) (uint64, error) { + if c == codes.Nil { + return 0, nil + } + if codes.IsFixedNum(c) { + return uint64(int8(c)), nil + } + switch c { + case codes.Uint8: + n, err := d.uint8() + return uint64(n), err + case codes.Int8: + n, err := d.int8() + return uint64(n), err + case codes.Uint16: + n, err := d.uint16() + return uint64(n), err + case codes.Int16: + n, err := d.int16() + return uint64(n), err + case codes.Uint32: + n, err := d.uint32() + return uint64(n), err + case codes.Int32: + n, err := d.int32() + return uint64(n), err + case codes.Uint64, codes.Int64: + return d.uint64() + } + return 0, fmt.Errorf("msgpack: invalid code=%x decoding uint64", c) +} + +// DecodeInt64 decodes msgpack int8/16/32/64 and uint8/16/32/64 +// into Go int64. +func (d *Decoder) DecodeInt64() (int64, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return d.int(c) +} + +func (d *Decoder) int(c codes.Code) (int64, error) { + if c == codes.Nil { + return 0, nil + } + if codes.IsFixedNum(c) { + return int64(int8(c)), nil + } + switch c { + case codes.Uint8: + n, err := d.uint8() + return int64(n), err + case codes.Int8: + n, err := d.uint8() + return int64(int8(n)), err + case codes.Uint16: + n, err := d.uint16() + return int64(n), err + case codes.Int16: + n, err := d.uint16() + return int64(int16(n)), err + case codes.Uint32: + n, err := d.uint32() + return int64(n), err + case codes.Int32: + n, err := d.uint32() + return int64(int32(n)), err + case codes.Uint64, codes.Int64: + n, err := d.uint64() + return int64(n), err + } + return 0, fmt.Errorf("msgpack: invalid code=%x decoding int64", c) +} + +func (d *Decoder) DecodeFloat32() (float32, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return d.float32(c) +} + +func (d *Decoder) float32(c codes.Code) (float32, error) { + if c == codes.Float { + n, err := d.uint32() + if err != nil { + return 0, err + } + return math.Float32frombits(n), nil + } + + n, err := d.int(c) + if err != nil { + return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c) + } + return float32(n), nil +} + +// DecodeFloat64 decodes msgpack float32/64 into Go float64. +func (d *Decoder) DecodeFloat64() (float64, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return d.float64(c) +} + +func (d *Decoder) float64(c codes.Code) (float64, error) { + switch c { + case codes.Float: + n, err := d.float32(c) + if err != nil { + return 0, err + } + return float64(n), nil + case codes.Double: + n, err := d.uint64() + if err != nil { + return 0, err + } + return math.Float64frombits(n), nil + } + + n, err := d.int(c) + if err != nil { + return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c) + } + return float64(n), nil +} + +func (d *Decoder) DecodeUint() (uint, error) { + n, err := d.DecodeUint64() + return uint(n), err +} + +func (d *Decoder) DecodeUint8() (uint8, error) { + n, err := d.DecodeUint64() + return uint8(n), err +} + +func (d *Decoder) DecodeUint16() (uint16, error) { + n, err := d.DecodeUint64() + return uint16(n), err +} + +func (d *Decoder) DecodeUint32() (uint32, error) { + n, err := d.DecodeUint64() + return uint32(n), err +} + +func (d *Decoder) DecodeInt() (int, error) { + n, err := d.DecodeInt64() + return int(n), err +} + +func (d *Decoder) DecodeInt8() (int8, error) { + n, err := d.DecodeInt64() + return int8(n), err +} + +func (d *Decoder) DecodeInt16() (int16, error) { + n, err := d.DecodeInt64() + return int16(n), err +} + +func (d *Decoder) DecodeInt32() (int32, error) { + n, err := d.DecodeInt64() + return int32(n), err +} + +func decodeFloat32Value(d *Decoder, v reflect.Value) error { + f, err := d.DecodeFloat32() + if err != nil { + return err + } + if err = mustSet(v); err != nil { + return err + } + v.SetFloat(float64(f)) + return nil +} + +func decodeFloat64Value(d *Decoder, v reflect.Value) error { + f, err := d.DecodeFloat64() + if err != nil { + return err + } + if err = mustSet(v); err != nil { + return err + } + v.SetFloat(f) + return nil +} + +func decodeInt64Value(d *Decoder, v reflect.Value) error { + n, err := d.DecodeInt64() + if err != nil { + return err + } + if err = mustSet(v); err != nil { + return err + } + v.SetInt(n) + return nil +} + +func decodeUint64Value(d *Decoder, v reflect.Value) error { + n, err := d.DecodeUint64() + if err != nil { + return err + } + if err = mustSet(v); err != nil { + return err + } + v.SetUint(n) + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode_query.go b/vendor/github.com/vmihailenco/msgpack/decode_query.go new file mode 100644 index 000000000..97c663ad4 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode_query.go @@ -0,0 +1,158 @@ +package msgpack + +import ( + "fmt" + "strconv" + "strings" + + "github.com/vmihailenco/msgpack/codes" +) + +type queryResult struct { + query string + key string + hasAsterisk bool + + values []interface{} +} + +func (q *queryResult) nextKey() { + ind := strings.IndexByte(q.query, '.') + if ind == -1 { + q.key = q.query + q.query = "" + return + } + q.key = q.query[:ind] + q.query = q.query[ind+1:] +} + +// Query extracts data specified by the query from the msgpack stream skipping +// any other data. Query consists of map keys and array indexes separated with dot, +// e.g. key1.0.key2. +func (d *Decoder) Query(query string) ([]interface{}, error) { + res := queryResult{ + query: query, + } + if err := d.query(&res); err != nil { + return nil, err + } + return res.values, nil +} + +func (d *Decoder) query(q *queryResult) error { + q.nextKey() + if q.key == "" { + v, err := d.decodeInterface() + if err != nil { + return err + } + q.values = append(q.values, v) + return nil + } + + code, err := d.PeekCode() + if err != nil { + return err + } + + switch { + case code == codes.Map16 || code == codes.Map32 || codes.IsFixedMap(code): + err = d.queryMapKey(q) + case code == codes.Array16 || code == codes.Array32 || codes.IsFixedArray(code): + err = d.queryArrayIndex(q) + default: + err = fmt.Errorf("msgpack: unsupported code=%x decoding key=%q", code, q.key) + } + return err +} + +func (d *Decoder) queryMapKey(q *queryResult) error { + n, err := d.DecodeMapLen() + if err != nil { + return err + } + if n == -1 { + return nil + } + + for i := 0; i < n; i++ { + k, err := d.bytesNoCopy() + if err != nil { + return err + } + + if string(k) == q.key { + if err := d.query(q); err != nil { + return err + } + if q.hasAsterisk { + return d.skipNext((n - i - 1) * 2) + } + return nil + } + + if err := d.Skip(); err != nil { + return err + } + } + + return nil +} + +func (d *Decoder) queryArrayIndex(q *queryResult) error { + n, err := d.DecodeArrayLen() + if err != nil { + return err + } + if n == -1 { + return nil + } + + if q.key == "*" { + q.hasAsterisk = true + + query := q.query + for i := 0; i < n; i++ { + q.query = query + if err := d.query(q); err != nil { + return err + } + } + + q.hasAsterisk = false + return nil + } + + ind, err := strconv.Atoi(q.key) + if err != nil { + return err + } + + for i := 0; i < n; i++ { + if i == ind { + if err := d.query(q); err != nil { + return err + } + if q.hasAsterisk { + return d.skipNext(n - i - 1) + } + return nil + } + + if err := d.Skip(); err != nil { + return err + } + } + + return nil +} + +func (d *Decoder) skipNext(n int) error { + for i := 0; i < n; i++ { + if err := d.Skip(); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode_slice.go b/vendor/github.com/vmihailenco/msgpack/decode_slice.go new file mode 100644 index 000000000..fef87aad7 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode_slice.go @@ -0,0 +1,192 @@ +package msgpack + +import ( + "fmt" + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +const sliceElemsAllocLimit = 1e4 + +var sliceStringPtrType = reflect.TypeOf((*[]string)(nil)) + +func (d *Decoder) DecodeArrayLen() (int, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return d.arrayLen(c) +} + +func (d *Decoder) arrayLen(c codes.Code) (int, error) { + if c == codes.Nil { + return -1, nil + } else if c >= codes.FixedArrayLow && c <= codes.FixedArrayHigh { + return int(c & codes.FixedArrayMask), nil + } + switch c { + case codes.Array16: + n, err := d.uint16() + return int(n), err + case codes.Array32: + n, err := d.uint32() + return int(n), err + } + return 0, fmt.Errorf("msgpack: invalid code=%x decoding array length", c) +} + +func decodeStringSliceValue(d *Decoder, v reflect.Value) error { + ptr := v.Addr().Convert(sliceStringPtrType).Interface().(*[]string) + return d.decodeStringSlicePtr(ptr) +} + +func (d *Decoder) decodeStringSlicePtr(ptr *[]string) error { + n, err := d.DecodeArrayLen() + if err != nil { + return err + } + if n == -1 { + return nil + } + + ss := setStringsCap(*ptr, n) + for i := 0; i < n; i++ { + s, err := d.DecodeString() + if err != nil { + return err + } + ss = append(ss, s) + } + *ptr = ss + + return nil +} + +func setStringsCap(s []string, n int) []string { + if n > sliceElemsAllocLimit { + n = sliceElemsAllocLimit + } + + if s == nil { + return make([]string, 0, n) + } + + if cap(s) >= n { + return s[:0] + } + + s = s[:cap(s)] + s = append(s, make([]string, n-len(s))...) + return s[:0] +} + +func decodeSliceValue(d *Decoder, v reflect.Value) error { + n, err := d.DecodeArrayLen() + if err != nil { + return err + } + + if n == -1 { + v.Set(reflect.Zero(v.Type())) + return nil + } + if n == 0 && v.IsNil() { + v.Set(reflect.MakeSlice(v.Type(), 0, 0)) + return nil + } + + if v.Cap() >= n { + v.Set(v.Slice(0, n)) + } else if v.Len() < v.Cap() { + v.Set(v.Slice(0, v.Cap())) + } + + for i := 0; i < n; i++ { + if i >= v.Len() { + v.Set(growSliceValue(v, n)) + } + sv := v.Index(i) + if err := d.DecodeValue(sv); err != nil { + return err + } + } + + return nil +} + +func growSliceValue(v reflect.Value, n int) reflect.Value { + diff := n - v.Len() + if diff > sliceElemsAllocLimit { + diff = sliceElemsAllocLimit + } + v = reflect.AppendSlice(v, reflect.MakeSlice(v.Type(), diff, diff)) + return v +} + +func decodeArrayValue(d *Decoder, v reflect.Value) error { + n, err := d.DecodeArrayLen() + if err != nil { + return err + } + + if n == -1 { + return nil + } + + if n > v.Len() { + return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n) + } + for i := 0; i < n; i++ { + sv := v.Index(i) + if err := d.DecodeValue(sv); err != nil { + return err + } + } + + return nil +} + +func (d *Decoder) DecodeSlice() ([]interface{}, error) { + c, err := d.readCode() + if err != nil { + return nil, err + } + return d.decodeSlice(c) +} + +func (d *Decoder) decodeSlice(c codes.Code) ([]interface{}, error) { + n, err := d.arrayLen(c) + if err != nil { + return nil, err + } + if n == -1 { + return nil, nil + } + + s := make([]interface{}, 0, min(n, sliceElemsAllocLimit)) + for i := 0; i < n; i++ { + v, err := d.decodeInterface() + if err != nil { + return nil, err + } + s = append(s, v) + } + + return s, nil +} + +func (d *Decoder) skipSlice(c codes.Code) error { + n, err := d.arrayLen(c) + if err != nil { + return err + } + + for i := 0; i < n; i++ { + if err := d.Skip(); err != nil { + return err + } + } + + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode_string.go b/vendor/github.com/vmihailenco/msgpack/decode_string.go new file mode 100644 index 000000000..5402022ee --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode_string.go @@ -0,0 +1,175 @@ +package msgpack + +import ( + "fmt" + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +func (d *Decoder) bytesLen(c codes.Code) (int, error) { + if c == codes.Nil { + return -1, nil + } else if codes.IsFixedString(c) { + return int(c & codes.FixedStrMask), nil + } + switch c { + case codes.Str8, codes.Bin8: + n, err := d.uint8() + return int(n), err + case codes.Str16, codes.Bin16: + n, err := d.uint16() + return int(n), err + case codes.Str32, codes.Bin32: + n, err := d.uint32() + return int(n), err + } + return 0, fmt.Errorf("msgpack: invalid code=%x decoding bytes length", c) +} + +func (d *Decoder) DecodeString() (string, error) { + c, err := d.readCode() + if err != nil { + return "", err + } + return d.string(c) +} + +func (d *Decoder) string(c codes.Code) (string, error) { + n, err := d.bytesLen(c) + if err != nil { + return "", err + } + if n == -1 { + return "", nil + } + b, err := d.readN(n) + return string(b), err +} + +func decodeStringValue(d *Decoder, v reflect.Value) error { + s, err := d.DecodeString() + if err != nil { + return err + } + if err = mustSet(v); err != nil { + return err + } + v.SetString(s) + return nil +} + +func (d *Decoder) DecodeBytesLen() (int, error) { + c, err := d.readCode() + if err != nil { + return 0, err + } + return d.bytesLen(c) +} + +func (d *Decoder) DecodeBytes() ([]byte, error) { + c, err := d.readCode() + if err != nil { + return nil, err + } + return d.bytes(c, nil) +} + +func (d *Decoder) bytes(c codes.Code, b []byte) ([]byte, error) { + n, err := d.bytesLen(c) + if err != nil { + return nil, err + } + if n == -1 { + return nil, nil + } + return readN(d.r, b, n) +} + +func (d *Decoder) bytesNoCopy() ([]byte, error) { + c, err := d.readCode() + if err != nil { + return nil, err + } + n, err := d.bytesLen(c) + if err != nil { + return nil, err + } + if n == -1 { + return nil, nil + } + return d.readN(n) +} + +func (d *Decoder) decodeBytesPtr(ptr *[]byte) error { + c, err := d.readCode() + if err != nil { + return err + } + return d.bytesPtr(c, ptr) +} + +func (d *Decoder) bytesPtr(c codes.Code, ptr *[]byte) error { + n, err := d.bytesLen(c) + if err != nil { + return err + } + if n == -1 { + *ptr = nil + return nil + } + + *ptr, err = readN(d.r, *ptr, n) + return err +} + +func (d *Decoder) skipBytes(c codes.Code) error { + n, err := d.bytesLen(c) + if err != nil { + return err + } + if n == -1 { + return nil + } + return d.skipN(n) +} + +func decodeBytesValue(d *Decoder, v reflect.Value) error { + c, err := d.readCode() + if err != nil { + return err + } + + b, err := d.bytes(c, v.Bytes()) + if err != nil { + return err + } + + if err = mustSet(v); err != nil { + return err + } + v.SetBytes(b) + + return nil +} + +func decodeByteArrayValue(d *Decoder, v reflect.Value) error { + c, err := d.readCode() + if err != nil { + return err + } + + n, err := d.bytesLen(c) + if err != nil { + return err + } + if n == -1 { + return nil + } + if n > v.Len() { + return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n) + } + + b := v.Slice(0, n).Bytes() + return d.readFull(b) +} diff --git a/vendor/github.com/vmihailenco/msgpack/decode_value.go b/vendor/github.com/vmihailenco/msgpack/decode_value.go new file mode 100644 index 000000000..10022b478 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/decode_value.go @@ -0,0 +1,292 @@ +package msgpack + +import ( + "errors" + "fmt" + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +var interfaceType = reflect.TypeOf((*interface{})(nil)).Elem() +var stringType = reflect.TypeOf((*string)(nil)).Elem() + +var valueDecoders []decoderFunc + +func init() { + valueDecoders = []decoderFunc{ + reflect.Bool: decodeBoolValue, + reflect.Int: decodeInt64Value, + reflect.Int8: decodeInt64Value, + reflect.Int16: decodeInt64Value, + reflect.Int32: decodeInt64Value, + reflect.Int64: decodeInt64Value, + reflect.Uint: decodeUint64Value, + reflect.Uint8: decodeUint64Value, + reflect.Uint16: decodeUint64Value, + reflect.Uint32: decodeUint64Value, + reflect.Uint64: decodeUint64Value, + reflect.Float32: decodeFloat32Value, + reflect.Float64: decodeFloat64Value, + reflect.Complex64: decodeUnsupportedValue, + reflect.Complex128: decodeUnsupportedValue, + reflect.Array: decodeArrayValue, + reflect.Chan: decodeUnsupportedValue, + reflect.Func: decodeUnsupportedValue, + reflect.Interface: decodeInterfaceValue, + reflect.Map: decodeMapValue, + reflect.Ptr: decodeUnsupportedValue, + reflect.Slice: decodeSliceValue, + reflect.String: decodeStringValue, + reflect.Struct: decodeStructValue, + reflect.UnsafePointer: decodeUnsupportedValue, + } +} + +func mustSet(v reflect.Value) error { + if !v.CanSet() { + return fmt.Errorf("msgpack: Decode(nonsettable %s)", v.Type()) + } + return nil +} + +func getDecoder(typ reflect.Type) decoderFunc { + kind := typ.Kind() + + if decoder, ok := typDecMap[typ]; ok { + return decoder + } + + if typ.Implements(customDecoderType) { + return decodeCustomValue + } + if typ.Implements(unmarshalerType) { + return unmarshalValue + } + + // Addressable struct field value. + if kind != reflect.Ptr { + ptr := reflect.PtrTo(typ) + if ptr.Implements(customDecoderType) { + return decodeCustomValueAddr + } + if ptr.Implements(unmarshalerType) { + return unmarshalValueAddr + } + } + + switch kind { + case reflect.Ptr: + return ptrDecoderFunc(typ) + case reflect.Slice: + elem := typ.Elem() + switch elem.Kind() { + case reflect.Uint8: + return decodeBytesValue + } + switch elem { + case stringType: + return decodeStringSliceValue + } + case reflect.Array: + if typ.Elem().Kind() == reflect.Uint8 { + return decodeByteArrayValue + } + case reflect.Map: + if typ.Key() == stringType { + switch typ.Elem() { + case stringType: + return decodeMapStringStringValue + case interfaceType: + return decodeMapStringInterfaceValue + } + } + } + return valueDecoders[kind] +} + +func ptrDecoderFunc(typ reflect.Type) decoderFunc { + decoder := getDecoder(typ.Elem()) + return func(d *Decoder, v reflect.Value) error { + if d.hasNilCode() { + if err := mustSet(v); err != nil { + return err + } + v.Set(reflect.Zero(v.Type())) + return d.DecodeNil() + } + if v.IsNil() { + if err := mustSet(v); err != nil { + return err + } + v.Set(reflect.New(v.Type().Elem())) + } + return decoder(d, v.Elem()) + } +} + +func decodeCustomValueAddr(d *Decoder, v reflect.Value) error { + if !v.CanAddr() { + return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface()) + } + return decodeCustomValue(d, v.Addr()) +} + +func decodeCustomValue(d *Decoder, v reflect.Value) error { + c, err := d.PeekCode() + if err != nil { + return err + } + + if codes.IsExt(c) { + c, err = d.readCode() + if err != nil { + return err + } + + extLen, err := d.parseExtLen(c) + if err != nil { + return err + } + + _, err = d.readCode() + if err != nil { + return err + } + + c, err = d.PeekCode() + if err != nil { + return err + } + + d.extLen = extLen + } + + if c == codes.Nil { + return d.decodeNilValue(v) + } + + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + + decoder := v.Interface().(CustomDecoder) + return decoder.DecodeMsgpack(d) +} + +func unmarshalValueAddr(d *Decoder, v reflect.Value) error { + if !v.CanAddr() { + return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface()) + } + return unmarshalValue(d, v.Addr()) +} + +func unmarshalValue(d *Decoder, v reflect.Value) error { + c, err := d.PeekCode() + if err != nil { + return err + } + + extLen := d.extLen + d.extLen = 0 + + if extLen == 0 && codes.IsExt(c) { + c, err = d.readCode() + if err != nil { + return err + } + + extLen, err = d.parseExtLen(c) + if err != nil { + return err + } + + _, err = d.readCode() + if err != nil { + return err + } + + c, err = d.PeekCode() + if err != nil { + return err + } + } + + if c == codes.Nil { + return d.decodeNilValue(v) + } + + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + + if extLen != 0 { + b, err := d.readN(extLen) + if err != nil { + return err + } + d.rec = b + } else { + d.rec = makeBuffer() + if err := d.Skip(); err != nil { + return err + } + } + + unmarshaler := v.Interface().(Unmarshaler) + err = unmarshaler.UnmarshalMsgpack(d.rec) + d.rec = nil + return err +} + +func decodeBoolValue(d *Decoder, v reflect.Value) error { + flag, err := d.DecodeBool() + if err != nil { + return err + } + if err = mustSet(v); err != nil { + return err + } + v.SetBool(flag) + return nil +} + +func decodeInterfaceValue(d *Decoder, v reflect.Value) error { + if v.IsNil() { + return d.interfaceValue(v) + } + + elem := v.Elem() + if !elem.CanAddr() { + if d.hasNilCode() { + v.Set(reflect.Zero(v.Type())) + return d.DecodeNil() + } + } + + return d.DecodeValue(elem) +} + +func (d *Decoder) interfaceValue(v reflect.Value) error { + vv, err := d.decodeInterface() + if err != nil { + return err + } + + if vv != nil { + if v.Type() == errorType { + if vv, ok := vv.(string); ok { + v.Set(reflect.ValueOf(errors.New(vv))) + return nil + } + } + + v.Set(reflect.ValueOf(vv)) + } + + return nil +} + +func decodeUnsupportedValue(d *Decoder, v reflect.Value) error { + return fmt.Errorf("msgpack: Decode(unsupported %s)", v.Type()) +} diff --git a/vendor/github.com/vmihailenco/msgpack/encode.go b/vendor/github.com/vmihailenco/msgpack/encode.go new file mode 100644 index 000000000..2da9a6a52 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/encode.go @@ -0,0 +1,162 @@ +package msgpack + +import ( + "bytes" + "io" + "reflect" + "time" + + "github.com/vmihailenco/msgpack/codes" +) + +type writer interface { + io.Writer + WriteByte(byte) error + WriteString(string) (int, error) +} + +type byteWriter struct { + io.Writer + + buf []byte + bootstrap [64]byte +} + +func newByteWriter(w io.Writer) *byteWriter { + bw := &byteWriter{ + Writer: w, + } + bw.buf = bw.bootstrap[:] + return bw +} + +func (w *byteWriter) WriteByte(c byte) error { + w.buf = w.buf[:1] + w.buf[0] = c + _, err := w.Write(w.buf) + return err +} + +func (w *byteWriter) WriteString(s string) (int, error) { + w.buf = append(w.buf[:0], s...) + return w.Write(w.buf) +} + +// Marshal returns the MessagePack encoding of v. +func Marshal(v ...interface{}) ([]byte, error) { + var buf bytes.Buffer + err := NewEncoder(&buf).Encode(v...) + return buf.Bytes(), err +} + +type Encoder struct { + w writer + buf []byte + + sortMapKeys bool + structAsArray bool + useJSONTag bool +} + +// NewEncoder returns a new encoder that writes to w. +func NewEncoder(w io.Writer) *Encoder { + bw, ok := w.(writer) + if !ok { + bw = newByteWriter(w) + } + return &Encoder{ + w: bw, + buf: make([]byte, 9), + } +} + +// SortMapKeys causes the Encoder to encode map keys in increasing order. +// Supported map types are: +// - map[string]string +// - map[string]interface{} +func (e *Encoder) SortMapKeys(v bool) *Encoder { + e.sortMapKeys = v + return e +} + +// StructAsArray causes the Encoder to encode Go structs as MessagePack arrays. +func (e *Encoder) StructAsArray(v bool) *Encoder { + e.structAsArray = v + return e +} + +// UseJSONTag causes the Encoder to use json struct tag as fallback option +// if there is no msgpack tag. +func (e *Encoder) UseJSONTag(v bool) *Encoder { + e.useJSONTag = v + return e +} + +func (e *Encoder) Encode(v ...interface{}) error { + for _, vv := range v { + if err := e.encode(vv); err != nil { + return err + } + } + return nil +} + +func (e *Encoder) encode(v interface{}) error { + switch v := v.(type) { + case nil: + return e.EncodeNil() + case string: + return e.EncodeString(v) + case []byte: + return e.EncodeBytes(v) + case int: + return e.EncodeInt(int64(v)) + case int64: + return e.EncodeInt(v) + case uint: + return e.EncodeUint(uint64(v)) + case uint64: + return e.EncodeUint(v) + case bool: + return e.EncodeBool(v) + case float32: + return e.EncodeFloat32(v) + case float64: + return e.EncodeFloat64(v) + case time.Duration: + return e.EncodeInt(int64(v)) + case time.Time: + return e.EncodeTime(v) + } + return e.EncodeValue(reflect.ValueOf(v)) +} + +func (e *Encoder) EncodeValue(v reflect.Value) error { + encode := getEncoder(v.Type()) + return encode(e, v) +} + +func (e *Encoder) EncodeNil() error { + return e.writeCode(codes.Nil) +} + +func (e *Encoder) EncodeBool(value bool) error { + if value { + return e.writeCode(codes.True) + } + return e.writeCode(codes.False) +} + +func (e *Encoder) writeCode(c codes.Code) error { + return e.w.WriteByte(byte(c)) +} + +func (e *Encoder) write(b []byte) error { + _, err := e.w.Write(b) + return err +} + +func (e *Encoder) writeString(s string) error { + _, err := e.w.WriteString(s) + return err +} diff --git a/vendor/github.com/vmihailenco/msgpack/encode_map.go b/vendor/github.com/vmihailenco/msgpack/encode_map.go new file mode 100644 index 000000000..f1e9f5091 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/encode_map.go @@ -0,0 +1,172 @@ +package msgpack + +import ( + "reflect" + "sort" + + "github.com/vmihailenco/msgpack/codes" +) + +func encodeMapValue(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + + if err := e.EncodeMapLen(v.Len()); err != nil { + return err + } + + for _, key := range v.MapKeys() { + if err := e.EncodeValue(key); err != nil { + return err + } + if err := e.EncodeValue(v.MapIndex(key)); err != nil { + return err + } + } + + return nil +} + +func encodeMapStringStringValue(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + + if err := e.EncodeMapLen(v.Len()); err != nil { + return err + } + + m := v.Convert(mapStringStringType).Interface().(map[string]string) + if e.sortMapKeys { + return e.encodeSortedMapStringString(m) + } + + for mk, mv := range m { + if err := e.EncodeString(mk); err != nil { + return err + } + if err := e.EncodeString(mv); err != nil { + return err + } + } + + return nil +} + +func encodeMapStringInterfaceValue(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + + if err := e.EncodeMapLen(v.Len()); err != nil { + return err + } + + m := v.Convert(mapStringInterfaceType).Interface().(map[string]interface{}) + if e.sortMapKeys { + return e.encodeSortedMapStringInterface(m) + } + + for mk, mv := range m { + if err := e.EncodeString(mk); err != nil { + return err + } + if err := e.Encode(mv); err != nil { + return err + } + } + + return nil +} + +func (e *Encoder) encodeSortedMapStringString(m map[string]string) error { + keys := make([]string, 0, len(m)) + for k, _ := range m { + keys = append(keys, k) + } + sort.Strings(keys) + + for _, k := range keys { + err := e.EncodeString(k) + if err != nil { + return err + } + if err = e.EncodeString(m[k]); err != nil { + return err + } + } + + return nil +} + +func (e *Encoder) encodeSortedMapStringInterface(m map[string]interface{}) error { + keys := make([]string, 0, len(m)) + for k, _ := range m { + keys = append(keys, k) + } + sort.Strings(keys) + + for _, k := range keys { + err := e.EncodeString(k) + if err != nil { + return err + } + if err = e.Encode(m[k]); err != nil { + return err + } + } + + return nil +} + +func (e *Encoder) EncodeMapLen(l int) error { + if l < 16 { + return e.writeCode(codes.FixedMapLow | codes.Code(l)) + } + if l < 65536 { + return e.write2(codes.Map16, uint64(l)) + } + return e.write4(codes.Map32, uint32(l)) +} + +func encodeStructValue(e *Encoder, strct reflect.Value) error { + var structFields *fields + if e.useJSONTag { + structFields = jsonStructs.Fields(strct.Type()) + } else { + structFields = structs.Fields(strct.Type()) + } + + if e.structAsArray || structFields.AsArray { + return encodeStructValueAsArray(e, strct, structFields.List) + } + fields := structFields.OmitEmpty(strct) + + if err := e.EncodeMapLen(len(fields)); err != nil { + return err + } + + for _, f := range fields { + if err := e.EncodeString(f.name); err != nil { + return err + } + if err := f.EncodeValue(e, strct); err != nil { + return err + } + } + + return nil +} + +func encodeStructValueAsArray(e *Encoder, strct reflect.Value, fields []*field) error { + if err := e.EncodeArrayLen(len(fields)); err != nil { + return err + } + for _, f := range fields { + if err := f.EncodeValue(e, strct); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/encode_number.go b/vendor/github.com/vmihailenco/msgpack/encode_number.go new file mode 100644 index 000000000..e3615850a --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/encode_number.go @@ -0,0 +1,108 @@ +package msgpack + +import ( + "math" + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +// EncodeUint encodes an uint64 in 1, 2, 3, 5, or 9 bytes. +func (e *Encoder) EncodeUint(v uint64) error { + if v <= math.MaxInt8 { + return e.w.WriteByte(byte(v)) + } + if v <= math.MaxUint8 { + return e.write1(codes.Uint8, v) + } + if v <= math.MaxUint16 { + return e.write2(codes.Uint16, v) + } + if v <= math.MaxUint32 { + return e.write4(codes.Uint32, uint32(v)) + } + return e.write8(codes.Uint64, v) +} + +// EncodeInt encodes an int64 in 1, 2, 3, 5, or 9 bytes. +func (e *Encoder) EncodeInt(v int64) error { + if v >= 0 { + return e.EncodeUint(uint64(v)) + } + if v >= int64(int8(codes.NegFixedNumLow)) { + return e.w.WriteByte(byte(v)) + } + if v >= math.MinInt8 { + return e.write1(codes.Int8, uint64(v)) + } + if v >= math.MinInt16 { + return e.write2(codes.Int16, uint64(v)) + } + if v >= math.MinInt32 { + return e.write4(codes.Int32, uint32(v)) + } + return e.write8(codes.Int64, uint64(v)) +} + +func (e *Encoder) EncodeFloat32(n float32) error { + return e.write4(codes.Float, math.Float32bits(n)) +} + +func (e *Encoder) EncodeFloat64(n float64) error { + return e.write8(codes.Double, math.Float64bits(n)) +} + +func (e *Encoder) write1(code codes.Code, n uint64) error { + e.buf = e.buf[:2] + e.buf[0] = byte(code) + e.buf[1] = byte(n) + return e.write(e.buf) +} + +func (e *Encoder) write2(code codes.Code, n uint64) error { + e.buf = e.buf[:3] + e.buf[0] = byte(code) + e.buf[1] = byte(n >> 8) + e.buf[2] = byte(n) + return e.write(e.buf) +} + +func (e *Encoder) write4(code codes.Code, n uint32) error { + e.buf = e.buf[:5] + e.buf[0] = byte(code) + e.buf[1] = byte(n >> 24) + e.buf[2] = byte(n >> 16) + e.buf[3] = byte(n >> 8) + e.buf[4] = byte(n) + return e.write(e.buf) +} + +func (e *Encoder) write8(code codes.Code, n uint64) error { + e.buf = e.buf[:9] + e.buf[0] = byte(code) + e.buf[1] = byte(n >> 56) + e.buf[2] = byte(n >> 48) + e.buf[3] = byte(n >> 40) + e.buf[4] = byte(n >> 32) + e.buf[5] = byte(n >> 24) + e.buf[6] = byte(n >> 16) + e.buf[7] = byte(n >> 8) + e.buf[8] = byte(n) + return e.write(e.buf) +} + +func encodeInt64Value(e *Encoder, v reflect.Value) error { + return e.EncodeInt(v.Int()) +} + +func encodeUint64Value(e *Encoder, v reflect.Value) error { + return e.EncodeUint(v.Uint()) +} + +func encodeFloat32Value(e *Encoder, v reflect.Value) error { + return e.EncodeFloat32(float32(v.Float())) +} + +func encodeFloat64Value(e *Encoder, v reflect.Value) error { + return e.EncodeFloat64(v.Float()) +} diff --git a/vendor/github.com/vmihailenco/msgpack/encode_slice.go b/vendor/github.com/vmihailenco/msgpack/encode_slice.go new file mode 100644 index 000000000..8f01e9534 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/encode_slice.go @@ -0,0 +1,124 @@ +package msgpack + +import ( + "reflect" + + "github.com/vmihailenco/msgpack/codes" +) + +func encodeStringValue(e *Encoder, v reflect.Value) error { + return e.EncodeString(v.String()) +} + +func encodeByteSliceValue(e *Encoder, v reflect.Value) error { + return e.EncodeBytes(v.Bytes()) +} + +func encodeByteArrayValue(e *Encoder, v reflect.Value) error { + if err := e.EncodeBytesLen(v.Len()); err != nil { + return err + } + + if v.CanAddr() { + b := v.Slice(0, v.Len()).Bytes() + return e.write(b) + } + + e.buf = grow(e.buf, v.Len()) + reflect.Copy(reflect.ValueOf(e.buf), v) + return e.write(e.buf) +} + +func grow(b []byte, n int) []byte { + if cap(b) >= n { + return b[:n] + } + b = b[:cap(b)] + b = append(b, make([]byte, n-len(b))...) + return b +} + +func (e *Encoder) EncodeBytesLen(l int) error { + if l < 256 { + return e.write1(codes.Bin8, uint64(l)) + } + if l < 65536 { + return e.write2(codes.Bin16, uint64(l)) + } + return e.write4(codes.Bin32, uint32(l)) +} + +func (e *Encoder) encodeStrLen(l int) error { + if l < 32 { + return e.writeCode(codes.FixedStrLow | codes.Code(l)) + } + if l < 256 { + return e.write1(codes.Str8, uint64(l)) + } + if l < 65536 { + return e.write2(codes.Str16, uint64(l)) + } + return e.write4(codes.Str32, uint32(l)) +} + +func (e *Encoder) EncodeString(v string) error { + if err := e.encodeStrLen(len(v)); err != nil { + return err + } + return e.writeString(v) +} + +func (e *Encoder) EncodeBytes(v []byte) error { + if v == nil { + return e.EncodeNil() + } + if err := e.EncodeBytesLen(len(v)); err != nil { + return err + } + return e.write(v) +} + +func (e *Encoder) EncodeArrayLen(l int) error { + if l < 16 { + return e.writeCode(codes.FixedArrayLow | codes.Code(l)) + } + if l < 65536 { + return e.write2(codes.Array16, uint64(l)) + } + return e.write4(codes.Array32, uint32(l)) +} + +func (e *Encoder) encodeStringSlice(s []string) error { + if s == nil { + return e.EncodeNil() + } + if err := e.EncodeArrayLen(len(s)); err != nil { + return err + } + for _, v := range s { + if err := e.EncodeString(v); err != nil { + return err + } + } + return nil +} + +func encodeSliceValue(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + return encodeArrayValue(e, v) +} + +func encodeArrayValue(e *Encoder, v reflect.Value) error { + l := v.Len() + if err := e.EncodeArrayLen(l); err != nil { + return err + } + for i := 0; i < l; i++ { + if err := e.EncodeValue(v.Index(i)); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/encode_value.go b/vendor/github.com/vmihailenco/msgpack/encode_value.go new file mode 100644 index 000000000..2f5a3509a --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/encode_value.go @@ -0,0 +1,167 @@ +package msgpack + +import ( + "fmt" + "reflect" +) + +var valueEncoders []encoderFunc + +func init() { + valueEncoders = []encoderFunc{ + reflect.Bool: encodeBoolValue, + reflect.Int: encodeInt64Value, + reflect.Int8: encodeInt64Value, + reflect.Int16: encodeInt64Value, + reflect.Int32: encodeInt64Value, + reflect.Int64: encodeInt64Value, + reflect.Uint: encodeUint64Value, + reflect.Uint8: encodeUint64Value, + reflect.Uint16: encodeUint64Value, + reflect.Uint32: encodeUint64Value, + reflect.Uint64: encodeUint64Value, + reflect.Float32: encodeFloat32Value, + reflect.Float64: encodeFloat64Value, + reflect.Complex64: encodeUnsupportedValue, + reflect.Complex128: encodeUnsupportedValue, + reflect.Array: encodeArrayValue, + reflect.Chan: encodeUnsupportedValue, + reflect.Func: encodeUnsupportedValue, + reflect.Interface: encodeInterfaceValue, + reflect.Map: encodeMapValue, + reflect.Ptr: encodeUnsupportedValue, + reflect.Slice: encodeSliceValue, + reflect.String: encodeStringValue, + reflect.Struct: encodeStructValue, + reflect.UnsafePointer: encodeUnsupportedValue, + } +} + +func getEncoder(typ reflect.Type) encoderFunc { + if encoder, ok := typEncMap[typ]; ok { + return encoder + } + + if typ.Implements(customEncoderType) { + return encodeCustomValue + } + if typ.Implements(marshalerType) { + return marshalValue + } + + kind := typ.Kind() + + // Addressable struct field value. + if kind != reflect.Ptr { + ptr := reflect.PtrTo(typ) + if ptr.Implements(customEncoderType) { + return encodeCustomValuePtr + } + if ptr.Implements(marshalerType) { + return marshalValuePtr + } + } + + if typ == errorType { + return encodeErrorValue + } + + switch kind { + case reflect.Ptr: + return ptrEncoderFunc(typ) + case reflect.Slice: + if typ.Elem().Kind() == reflect.Uint8 { + return encodeByteSliceValue + } + case reflect.Array: + if typ.Elem().Kind() == reflect.Uint8 { + return encodeByteArrayValue + } + case reflect.Map: + if typ.Key() == stringType { + switch typ.Elem() { + case stringType: + return encodeMapStringStringValue + case interfaceType: + return encodeMapStringInterfaceValue + } + } + } + return valueEncoders[kind] +} + +func ptrEncoderFunc(typ reflect.Type) encoderFunc { + encoder := getEncoder(typ.Elem()) + return func(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + return encoder(e, v.Elem()) + } +} + +func encodeCustomValuePtr(e *Encoder, v reflect.Value) error { + if !v.CanAddr() { + return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface()) + } + encoder := v.Addr().Interface().(CustomEncoder) + return encoder.EncodeMsgpack(e) +} + +func encodeCustomValue(e *Encoder, v reflect.Value) error { + switch v.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + if v.IsNil() { + return e.EncodeNil() + } + } + + encoder := v.Interface().(CustomEncoder) + return encoder.EncodeMsgpack(e) +} + +func marshalValuePtr(e *Encoder, v reflect.Value) error { + if !v.CanAddr() { + return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface()) + } + return marshalValue(e, v.Addr()) +} + +func marshalValue(e *Encoder, v reflect.Value) error { + switch v.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + if v.IsNil() { + return e.EncodeNil() + } + } + + marshaler := v.Interface().(Marshaler) + b, err := marshaler.MarshalMsgpack() + if err != nil { + return err + } + _, err = e.w.Write(b) + return err +} + +func encodeBoolValue(e *Encoder, v reflect.Value) error { + return e.EncodeBool(v.Bool()) +} + +func encodeInterfaceValue(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + return e.EncodeValue(v.Elem()) +} + +func encodeErrorValue(e *Encoder, v reflect.Value) error { + if v.IsNil() { + return e.EncodeNil() + } + return e.EncodeString(v.Interface().(error).Error()) +} + +func encodeUnsupportedValue(e *Encoder, v reflect.Value) error { + return fmt.Errorf("msgpack: Encode(unsupported %s)", v.Type()) +} diff --git a/vendor/github.com/vmihailenco/msgpack/ext.go b/vendor/github.com/vmihailenco/msgpack/ext.go new file mode 100644 index 000000000..420f01be0 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/ext.go @@ -0,0 +1,212 @@ +package msgpack + +import ( + "bytes" + "fmt" + "reflect" + "sync" + + "github.com/vmihailenco/msgpack/codes" +) + +var extTypes = make(map[int8]reflect.Type) + +var bufferPool = &sync.Pool{ + New: func() interface{} { + return new(bytes.Buffer) + }, +} + +// RegisterExt records a type, identified by a value for that type, +// under the provided id. That id will identify the concrete type of a value +// sent or received as an interface variable. Only types that will be +// transferred as implementations of interface values need to be registered. +// Expecting to be used only during initialization, it panics if the mapping +// between types and ids is not a bijection. +func RegisterExt(id int8, value interface{}) { + typ := reflect.TypeOf(value) + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + } + ptr := reflect.PtrTo(typ) + + if _, ok := extTypes[id]; ok { + panic(fmt.Errorf("msgpack: ext with id=%d is already registered", id)) + } + + registerExt(id, ptr, getEncoder(ptr), nil) + registerExt(id, typ, getEncoder(typ), getDecoder(typ)) +} + +func registerExt(id int8, typ reflect.Type, enc encoderFunc, dec decoderFunc) { + if dec != nil { + extTypes[id] = typ + } + if enc != nil { + typEncMap[typ] = makeExtEncoder(id, enc) + } + if dec != nil { + typDecMap[typ] = dec + } +} + +func (e *Encoder) EncodeExtHeader(typeId int8, length int) error { + if err := e.encodeExtLen(length); err != nil { + return err + } + if err := e.w.WriteByte(byte(typeId)); err != nil { + return err + } + return nil +} + +func makeExtEncoder(typeId int8, enc encoderFunc) encoderFunc { + return func(e *Encoder, v reflect.Value) error { + buf := bufferPool.Get().(*bytes.Buffer) + defer bufferPool.Put(buf) + buf.Reset() + + oldw := e.w + e.w = buf + err := enc(e, v) + e.w = oldw + + if err != nil { + return err + } + + if err := e.EncodeExtHeader(typeId, buf.Len()); err != nil { + return err + } + return e.write(buf.Bytes()) + } +} + +func (e *Encoder) encodeExtLen(l int) error { + switch l { + case 1: + return e.writeCode(codes.FixExt1) + case 2: + return e.writeCode(codes.FixExt2) + case 4: + return e.writeCode(codes.FixExt4) + case 8: + return e.writeCode(codes.FixExt8) + case 16: + return e.writeCode(codes.FixExt16) + } + if l < 256 { + return e.write1(codes.Ext8, uint64(l)) + } + if l < 65536 { + return e.write2(codes.Ext16, uint64(l)) + } + return e.write4(codes.Ext32, uint32(l)) +} + +func (d *Decoder) parseExtLen(c codes.Code) (int, error) { + switch c { + case codes.FixExt1: + return 1, nil + case codes.FixExt2: + return 2, nil + case codes.FixExt4: + return 4, nil + case codes.FixExt8: + return 8, nil + case codes.FixExt16: + return 16, nil + case codes.Ext8: + n, err := d.uint8() + return int(n), err + case codes.Ext16: + n, err := d.uint16() + return int(n), err + case codes.Ext32: + n, err := d.uint32() + return int(n), err + default: + return 0, fmt.Errorf("msgpack: invalid code=%x decoding ext length", c) + } +} + +func (d *Decoder) decodeExtHeader(c codes.Code) (int8, int, error) { + length, err := d.parseExtLen(c) + if err != nil { + return 0, 0, err + } + + typeId, err := d.readCode() + if err != nil { + return 0, 0, err + } + + return int8(typeId), length, nil +} + +func (d *Decoder) DecodeExtHeader() (typeId int8, length int, err error) { + c, err := d.readCode() + if err != nil { + return + } + return d.decodeExtHeader(c) +} + +func (d *Decoder) extInterface(c codes.Code) (interface{}, error) { + extId, extLen, err := d.decodeExtHeader(c) + if err != nil { + return nil, err + } + + typ, ok := extTypes[extId] + if !ok { + return nil, fmt.Errorf("msgpack: unregistered ext id=%d", extId) + } + + v := reflect.New(typ) + + d.extLen = extLen + err = d.DecodeValue(v.Elem()) + d.extLen = 0 + if err != nil { + return nil, err + } + + return v.Interface(), nil +} + +func (d *Decoder) skipExt(c codes.Code) error { + n, err := d.parseExtLen(c) + if err != nil { + return err + } + return d.skipN(n + 1) +} + +func (d *Decoder) skipExtHeader(c codes.Code) error { + // Read ext type. + _, err := d.readCode() + if err != nil { + return err + } + // Read ext body len. + for i := 0; i < extHeaderLen(c); i++ { + _, err := d.readCode() + if err != nil { + return err + } + } + return nil +} + +func extHeaderLen(c codes.Code) int { + switch c { + case codes.Ext8: + return 1 + case codes.Ext16: + return 2 + case codes.Ext32: + return 4 + } + return 0 +} diff --git a/vendor/github.com/vmihailenco/msgpack/msgpack.go b/vendor/github.com/vmihailenco/msgpack/msgpack.go new file mode 100644 index 000000000..220b43c47 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/msgpack.go @@ -0,0 +1,17 @@ +package msgpack + +type Marshaler interface { + MarshalMsgpack() ([]byte, error) +} + +type Unmarshaler interface { + UnmarshalMsgpack([]byte) error +} + +type CustomEncoder interface { + EncodeMsgpack(*Encoder) error +} + +type CustomDecoder interface { + DecodeMsgpack(*Decoder) error +} diff --git a/vendor/github.com/vmihailenco/msgpack/tag.go b/vendor/github.com/vmihailenco/msgpack/tag.go new file mode 100644 index 000000000..48e6f942c --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/tag.go @@ -0,0 +1,42 @@ +package msgpack + +import ( + "strings" +) + +type tagOptions string + +func (o tagOptions) Get(name string) (string, bool) { + s := string(o) + for len(s) > 0 { + var next string + idx := strings.IndexByte(s, ',') + if idx >= 0 { + s, next = s[:idx], s[idx+1:] + } + if strings.HasPrefix(s, name) { + return s[len(name):], true + } + s = next + } + return "", false +} + +func (o tagOptions) Contains(name string) bool { + _, ok := o.Get(name) + return ok +} + +func parseTag(tag string) (string, tagOptions) { + if idx := strings.IndexByte(tag, ','); idx != -1 { + name := tag[:idx] + if strings.IndexByte(name, ':') == -1 { + return name, tagOptions(tag[idx+1:]) + } + } + + if strings.IndexByte(tag, ':') == -1 { + return tag, "" + } + return "", tagOptions(tag) +} diff --git a/vendor/github.com/vmihailenco/msgpack/time.go b/vendor/github.com/vmihailenco/msgpack/time.go new file mode 100644 index 000000000..f7409690a --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/time.go @@ -0,0 +1,145 @@ +package msgpack + +import ( + "encoding/binary" + "fmt" + "reflect" + "time" + + "github.com/vmihailenco/msgpack/codes" +) + +var timeExtId int8 = -1 + +func init() { + timeType := reflect.TypeOf((*time.Time)(nil)).Elem() + registerExt(timeExtId, timeType, encodeTimeValue, decodeTimeValue) +} + +func (e *Encoder) EncodeTime(tm time.Time) error { + b := e.encodeTime(tm) + if err := e.encodeExtLen(len(b)); err != nil { + return err + } + if err := e.w.WriteByte(byte(timeExtId)); err != nil { + return err + } + return e.write(b) +} + +func (e *Encoder) encodeTime(tm time.Time) []byte { + secs := uint64(tm.Unix()) + if secs>>34 == 0 { + data := uint64(tm.Nanosecond())<<34 | secs + if data&0xffffffff00000000 == 0 { + b := make([]byte, 4) + binary.BigEndian.PutUint32(b, uint32(data)) + return b + } else { + b := make([]byte, 8) + binary.BigEndian.PutUint64(b, data) + return b + } + } + + b := make([]byte, 12) + binary.BigEndian.PutUint32(b, uint32(tm.Nanosecond())) + binary.BigEndian.PutUint64(b[4:], uint64(secs)) + return b +} + +func (d *Decoder) DecodeTime() (time.Time, error) { + tm, err := d.decodeTime() + if err != nil { + return tm, err + } + + if tm.IsZero() { + // Assume that zero time does not have timezone information. + return tm.UTC(), nil + } + return tm, nil +} + +func (d *Decoder) decodeTime() (time.Time, error) { + extLen := d.extLen + d.extLen = 0 + if extLen == 0 { + c, err := d.readCode() + if err != nil { + return time.Time{}, err + } + + // Legacy format. + if c == codes.FixedArrayLow|2 { + sec, err := d.DecodeInt64() + if err != nil { + return time.Time{}, err + } + + nsec, err := d.DecodeInt64() + if err != nil { + return time.Time{}, err + } + + return time.Unix(sec, nsec), nil + } + + if codes.IsString(c) { + s, err := d.string(c) + if err != nil { + return time.Time{}, err + } + return time.Parse(time.RFC3339Nano, s) + } + + extLen, err = d.parseExtLen(c) + if err != nil { + return time.Time{}, err + } + + // Skip ext id. + _, err = d.s.ReadByte() + if err != nil { + return time.Time{}, nil + } + } + + b, err := d.readN(extLen) + if err != nil { + return time.Time{}, err + } + + switch len(b) { + case 4: + sec := binary.BigEndian.Uint32(b) + return time.Unix(int64(sec), 0), nil + case 8: + sec := binary.BigEndian.Uint64(b) + nsec := int64(sec >> 34) + sec &= 0x00000003ffffffff + return time.Unix(int64(sec), nsec), nil + case 12: + nsec := binary.BigEndian.Uint32(b) + sec := binary.BigEndian.Uint64(b[4:]) + return time.Unix(int64(sec), int64(nsec)), nil + default: + err = fmt.Errorf("msgpack: invalid ext len=%d decoding time", extLen) + return time.Time{}, err + } +} + +func encodeTimeValue(e *Encoder, v reflect.Value) error { + tm := v.Interface().(time.Time) + b := e.encodeTime(tm) + return e.write(b) +} + +func decodeTimeValue(d *Decoder, v reflect.Value) error { + tm, err := d.DecodeTime() + if err != nil { + return err + } + v.Set(reflect.ValueOf(tm)) + return nil +} diff --git a/vendor/github.com/vmihailenco/msgpack/types.go b/vendor/github.com/vmihailenco/msgpack/types.go new file mode 100644 index 000000000..4013010e7 --- /dev/null +++ b/vendor/github.com/vmihailenco/msgpack/types.go @@ -0,0 +1,307 @@ +package msgpack + +import ( + "reflect" + "sync" +) + +var errorType = reflect.TypeOf((*error)(nil)).Elem() + +var customEncoderType = reflect.TypeOf((*CustomEncoder)(nil)).Elem() +var customDecoderType = reflect.TypeOf((*CustomDecoder)(nil)).Elem() + +var marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem() +var unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem() + +type encoderFunc func(*Encoder, reflect.Value) error +type decoderFunc func(*Decoder, reflect.Value) error + +var typEncMap = make(map[reflect.Type]encoderFunc) +var typDecMap = make(map[reflect.Type]decoderFunc) + +// Register registers encoder and decoder functions for a value. +// This is low level API and in most cases you should prefer implementing +// Marshaler/CustomEncoder and Unmarshaler/CustomDecoder interfaces. +func Register(value interface{}, enc encoderFunc, dec decoderFunc) { + typ := reflect.TypeOf(value) + if enc != nil { + typEncMap[typ] = enc + } + if dec != nil { + typDecMap[typ] = dec + } +} + +//------------------------------------------------------------------------------ + +var structs = newStructCache(false) +var jsonStructs = newStructCache(true) + +type structCache struct { + mu sync.RWMutex + m map[reflect.Type]*fields + + useJSONTag bool +} + +func newStructCache(useJSONTag bool) *structCache { + return &structCache{ + m: make(map[reflect.Type]*fields), + + useJSONTag: useJSONTag, + } +} + +func (m *structCache) Fields(typ reflect.Type) *fields { + m.mu.RLock() + fs, ok := m.m[typ] + m.mu.RUnlock() + if ok { + return fs + } + + m.mu.Lock() + fs, ok = m.m[typ] + if !ok { + fs = getFields(typ, m.useJSONTag) + m.m[typ] = fs + } + m.mu.Unlock() + + return fs +} + +//------------------------------------------------------------------------------ + +type field struct { + name string + index []int + omitEmpty bool + encoder encoderFunc + decoder decoderFunc +} + +func (f *field) value(v reflect.Value) reflect.Value { + return fieldByIndex(v, f.index) +} + +func (f *field) Omit(strct reflect.Value) bool { + return f.omitEmpty && isEmptyValue(f.value(strct)) +} + +func (f *field) EncodeValue(e *Encoder, strct reflect.Value) error { + return f.encoder(e, f.value(strct)) +} + +func (f *field) DecodeValue(d *Decoder, strct reflect.Value) error { + return f.decoder(d, f.value(strct)) +} + +//------------------------------------------------------------------------------ + +type fields struct { + Table map[string]*field + List []*field + AsArray bool + + hasOmitEmpty bool +} + +func newFields(numField int) *fields { + return &fields{ + Table: make(map[string]*field, numField), + List: make([]*field, 0, numField), + } +} + +func (fs *fields) Add(field *field) { + fs.Table[field.name] = field + fs.List = append(fs.List, field) + if field.omitEmpty { + fs.hasOmitEmpty = true + } +} + +func (fs *fields) OmitEmpty(strct reflect.Value) []*field { + if !fs.hasOmitEmpty { + return fs.List + } + + fields := make([]*field, 0, len(fs.List)) + for _, f := range fs.List { + if !f.Omit(strct) { + fields = append(fields, f) + } + } + return fields +} + +func getFields(typ reflect.Type, useJSONTag bool) *fields { + numField := typ.NumField() + fs := newFields(numField) + + var omitEmpty bool + for i := 0; i < numField; i++ { + f := typ.Field(i) + + tag := f.Tag.Get("msgpack") + if useJSONTag && tag == "" { + tag = f.Tag.Get("json") + } + + name, opt := parseTag(tag) + if name == "-" { + continue + } + + if f.Name == "_msgpack" { + if opt.Contains("asArray") { + fs.AsArray = true + } + if opt.Contains("omitempty") { + omitEmpty = true + } + } + + if f.PkgPath != "" && !f.Anonymous { + continue + } + + field := &field{ + name: name, + index: f.Index, + omitEmpty: omitEmpty || opt.Contains("omitempty"), + encoder: getEncoder(f.Type), + decoder: getDecoder(f.Type), + } + + if field.name == "" { + field.name = f.Name + } + + if f.Anonymous { + if opt.Contains("inline") { + inlineFields(fs, f.Type, field, useJSONTag) + continue + } + if autoinlineFields(fs, f.Type, field, useJSONTag) { + continue + } + } + + fs.Add(field) + } + return fs +} + +var encodeStructValuePtr uintptr +var decodeStructValuePtr uintptr + +func init() { + encodeStructValuePtr = reflect.ValueOf(encodeStructValue).Pointer() + decodeStructValuePtr = reflect.ValueOf(decodeStructValue).Pointer() +} + +func inlineFields(fs *fields, typ reflect.Type, f *field, useJSONTag bool) { + inlinedFields := getFields(typ, useJSONTag).List + for _, field := range inlinedFields { + if _, ok := fs.Table[field.name]; ok { + // Don't inline shadowed fields. + continue + } + field.index = append(f.index, field.index...) + fs.Add(field) + } +} + +func autoinlineFields(fs *fields, typ reflect.Type, f *field, useJSONTag bool) bool { + var encoder encoderFunc + var decoder decoderFunc + + if typ.Kind() == reflect.Struct { + encoder = f.encoder + decoder = f.decoder + } else { + for typ.Kind() == reflect.Ptr { + typ = typ.Elem() + encoder = getEncoder(typ) + decoder = getDecoder(typ) + } + if typ.Kind() != reflect.Struct { + return false + } + } + + if reflect.ValueOf(encoder).Pointer() != encodeStructValuePtr { + return false + } + if reflect.ValueOf(decoder).Pointer() != decodeStructValuePtr { + return false + } + + inlinedFields := getFields(typ, useJSONTag).List + for _, field := range inlinedFields { + if _, ok := fs.Table[field.name]; ok { + // Don't inline shadowed fields. + return false + } + } + + for _, field := range inlinedFields { + field.index = append(f.index, field.index...) + fs.Add(field) + } + return true +} + +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + } + return false +} + +func fieldByIndex(v reflect.Value, index []int) reflect.Value { + if len(index) == 1 { + return v.Field(index[0]) + } + for i, x := range index { + if i > 0 { + var ok bool + v, ok = indirectNew(v) + if !ok { + return v + } + } + v = v.Field(x) + } + return v +} + +func indirectNew(v reflect.Value) (reflect.Value, bool) { + if v.Kind() == reflect.Ptr { + if v.IsNil() { + if !v.CanSet() { + return v, false + } + elemType := v.Type().Elem() + if elemType.Kind() != reflect.Struct { + return v, false + } + v.Set(reflect.New(elemType)) + } + v = v.Elem() + } + return v, true +} diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go new file mode 100644 index 000000000..1eb99f28a --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go @@ -0,0 +1,14 @@ +// Package msgpack provides functions for serializing cty values in the +// msgpack encoding, and decoding them again. +// +// If the same type information is provided both at encoding and decoding time +// then values can be round-tripped without loss, except for capsule types +// which are not currently supported. +// +// If any unknown values are passed to Marshal then they will be represented +// using a msgpack extension with type code zero, which is understood by +// the Unmarshal function within this package but will not be understood by +// a generic (non-cty-aware) msgpack decoder. Ensure that no unknown values +// are used if interoperability with other msgpack implementations is +// required. +package msgpack diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go new file mode 100644 index 000000000..1b631d0a1 --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go @@ -0,0 +1,31 @@ +package msgpack + +import ( + "bytes" + + "github.com/vmihailenco/msgpack" + "github.com/zclconf/go-cty/cty" +) + +type dynamicVal struct { + Value cty.Value + Path cty.Path +} + +func (dv *dynamicVal) MarshalMsgpack() ([]byte, error) { + // Rather than defining a msgpack-specific serialization of types, + // instead we use the existing JSON serialization. + typeJSON, err := dv.Value.Type().MarshalJSON() + if err != nil { + return nil, dv.Path.NewErrorf("failed to serialize type: %s", err) + } + var buf bytes.Buffer + enc := msgpack.NewEncoder(&buf) + enc.EncodeArrayLen(2) + enc.EncodeBytes(typeJSON) + err = marshal(dv.Value, dv.Value.Type(), dv.Path, enc) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go new file mode 100644 index 000000000..6db0815e4 --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go @@ -0,0 +1,8 @@ +package msgpack + +import ( + "math" +) + +var negativeInfinity = math.Inf(-1) +var positiveInfinity = math.Inf(1) diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go new file mode 100644 index 000000000..87b096ca4 --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go @@ -0,0 +1,207 @@ +package msgpack + +import ( + "bytes" + "math/big" + "sort" + + "github.com/vmihailenco/msgpack" + "github.com/zclconf/go-cty/cty" + "github.com/zclconf/go-cty/cty/convert" +) + +// Marshal produces a msgpack serialization of the given value that +// can be decoded into the given type later using Unmarshal. +// +// The given value must conform to the given type, or an error will +// be returned. +func Marshal(val cty.Value, ty cty.Type) ([]byte, error) { + errs := val.Type().TestConformance(ty) + if errs != nil { + // Attempt a conversion + var err error + val, err = convert.Convert(val, ty) + if err != nil { + return nil, err + } + } + + // From this point onward, val can be assumed to be conforming to t. + + var path cty.Path + var buf bytes.Buffer + enc := msgpack.NewEncoder(&buf) + + err := marshal(val, ty, path, enc) + if err != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +func marshal(val cty.Value, ty cty.Type, path cty.Path, enc *msgpack.Encoder) error { + // If we're going to decode as DynamicPseudoType then we need to save + // dynamic type information to recover the real type. + if ty == cty.DynamicPseudoType && val.Type() != cty.DynamicPseudoType { + return marshalDynamic(val, path, enc) + } + + if !val.IsKnown() { + err := enc.Encode(unknownVal) + if err != nil { + return path.NewError(err) + } + return nil + } + if val.IsNull() { + err := enc.EncodeNil() + if err != nil { + return path.NewError(err) + } + return nil + } + + // The caller should've guaranteed that the given val is conformant with + // the given type ty, so we'll proceed under that assumption here. + switch { + case ty.IsPrimitiveType(): + switch ty { + case cty.String: + err := enc.EncodeString(val.AsString()) + if err != nil { + return path.NewError(err) + } + return nil + case cty.Number: + var err error + switch { + case val.RawEquals(cty.PositiveInfinity): + err = enc.EncodeFloat64(positiveInfinity) + case val.RawEquals(cty.NegativeInfinity): + err = enc.EncodeFloat64(negativeInfinity) + default: + bf := val.AsBigFloat() + if iv, acc := bf.Int64(); acc == big.Exact { + err = enc.EncodeInt(iv) + } else if fv, acc := bf.Float64(); acc == big.Exact { + err = enc.EncodeFloat64(fv) + } else { + err = enc.EncodeString(bf.Text('f', -1)) + } + } + if err != nil { + return path.NewError(err) + } + return nil + case cty.Bool: + err := enc.EncodeBool(val.True()) + if err != nil { + return path.NewError(err) + } + return nil + default: + panic("unsupported primitive type") + } + case ty.IsListType(), ty.IsSetType(): + enc.EncodeArrayLen(val.LengthInt()) + ety := ty.ElementType() + it := val.ElementIterator() + path := append(path, nil) // local override of 'path' with extra element + for it.Next() { + ek, ev := it.Element() + path[len(path)-1] = cty.IndexStep{ + Key: ek, + } + err := marshal(ev, ety, path, enc) + if err != nil { + return err + } + } + return nil + case ty.IsMapType(): + enc.EncodeMapLen(val.LengthInt()) + ety := ty.ElementType() + it := val.ElementIterator() + path := append(path, nil) // local override of 'path' with extra element + for it.Next() { + ek, ev := it.Element() + path[len(path)-1] = cty.IndexStep{ + Key: ek, + } + var err error + err = marshal(ek, ek.Type(), path, enc) + if err != nil { + return err + } + err = marshal(ev, ety, path, enc) + if err != nil { + return err + } + } + return nil + case ty.IsTupleType(): + etys := ty.TupleElementTypes() + it := val.ElementIterator() + path := append(path, nil) // local override of 'path' with extra element + i := 0 + enc.EncodeArrayLen(len(etys)) + for it.Next() { + ety := etys[i] + ek, ev := it.Element() + path[len(path)-1] = cty.IndexStep{ + Key: ek, + } + err := marshal(ev, ety, path, enc) + if err != nil { + return err + } + i++ + } + return nil + case ty.IsObjectType(): + atys := ty.AttributeTypes() + path := append(path, nil) // local override of 'path' with extra element + + names := make([]string, 0, len(atys)) + for k := range atys { + names = append(names, k) + } + sort.Strings(names) + + enc.EncodeMapLen(len(names)) + + for _, k := range names { + aty := atys[k] + av := val.GetAttr(k) + path[len(path)-1] = cty.GetAttrStep{ + Name: k, + } + var err error + err = marshal(cty.StringVal(k), cty.String, path, enc) + if err != nil { + return err + } + err = marshal(av, aty, path, enc) + if err != nil { + return err + } + } + return nil + case ty.IsCapsuleType(): + return path.NewErrorf("capsule types not supported for msgpack encoding") + default: + // should never happen + return path.NewErrorf("cannot msgpack-serialize %s", ty.FriendlyName()) + } +} + +// marshalDynamic adds an extra wrapping object containing dynamic type +// information for the given value. +func marshalDynamic(val cty.Value, path cty.Path, enc *msgpack.Encoder) error { + dv := dynamicVal{ + Value: val, + Path: path, + } + return enc.Encode(&dv) +} diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go new file mode 100644 index 000000000..6f6022e4d --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go @@ -0,0 +1,167 @@ +package msgpack + +import ( + "bytes" + "fmt" + "io" + + "github.com/vmihailenco/msgpack" + msgpackcodes "github.com/vmihailenco/msgpack/codes" + "github.com/zclconf/go-cty/cty" +) + +// ImpliedType returns the cty Type implied by the structure of the given +// msgpack-compliant buffer. This function implements the default type mapping +// behavior used when decoding arbitrary msgpack without explicit cty Type +// information. +// +// The rules are as follows: +// +// msgpack strings, numbers and bools map to their equivalent primitive type in +// cty. +// +// msgpack maps become cty object types, with the attributes defined by the +// map keys and the types of their values. +// +// msgpack arrays become cty tuple types, with the elements defined by the +// types of the array members. +// +// Any nulls are typed as DynamicPseudoType, so callers of this function +// must be prepared to deal with this. Callers that do not wish to deal with +// dynamic typing should not use this function and should instead describe +// their required types explicitly with a cty.Type instance when decoding. +// +// Any unknown values are similarly typed as DynamicPseudoType, because these +// do not carry type information on the wire. +// +// Any parse errors will be returned as an error, and the type will be the +// invalid value cty.NilType. +func ImpliedType(buf []byte) (cty.Type, error) { + r := bytes.NewReader(buf) + dec := msgpack.NewDecoder(r) + + ty, err := impliedType(dec) + if err != nil { + return cty.NilType, err + } + + // We must now be at the end of the buffer + err = dec.Skip() + if err != io.EOF { + return ty, fmt.Errorf("extra bytes after msgpack value") + } + + return ty, nil +} + +func impliedType(dec *msgpack.Decoder) (cty.Type, error) { + // If this function returns with a nil error then it must have already + // consumed the next value from the decoder, since when called recursively + // the caller will be expecting to find a following value here. + + code, err := dec.PeekCode() + if err != nil { + return cty.NilType, err + } + + switch { + + case code == msgpackcodes.Nil || msgpackcodes.IsExt(code): + err := dec.Skip() + return cty.DynamicPseudoType, err + + case code == msgpackcodes.True || code == msgpackcodes.False: + _, err := dec.DecodeBool() + return cty.Bool, err + + case msgpackcodes.IsFixedNum(code): + _, err := dec.DecodeInt64() + return cty.Number, err + + case code == msgpackcodes.Int8 || code == msgpackcodes.Int16 || code == msgpackcodes.Int32 || code == msgpackcodes.Int64: + _, err := dec.DecodeInt64() + return cty.Number, err + + case code == msgpackcodes.Uint8 || code == msgpackcodes.Uint16 || code == msgpackcodes.Uint32 || code == msgpackcodes.Uint64: + _, err := dec.DecodeUint64() + return cty.Number, err + + case code == msgpackcodes.Float || code == msgpackcodes.Double: + _, err := dec.DecodeFloat64() + return cty.Number, err + + case msgpackcodes.IsString(code): + _, err := dec.DecodeString() + return cty.String, err + + case msgpackcodes.IsFixedMap(code) || code == msgpackcodes.Map16 || code == msgpackcodes.Map32: + return impliedObjectType(dec) + + case msgpackcodes.IsFixedArray(code) || code == msgpackcodes.Array16 || code == msgpackcodes.Array32: + return impliedTupleType(dec) + + default: + return cty.NilType, fmt.Errorf("unsupported msgpack code %#v", code) + } +} + +func impliedObjectType(dec *msgpack.Decoder) (cty.Type, error) { + // If we get in here then we've already peeked the next code and know + // it's some sort of map. + l, err := dec.DecodeMapLen() + if err != nil { + return cty.DynamicPseudoType, nil + } + + var atys map[string]cty.Type + + for i := 0; i < l; i++ { + // Read the map key first. We require maps to be strings, but msgpack + // doesn't so we're prepared to error here if not. + k, err := dec.DecodeString() + if err != nil { + return cty.DynamicPseudoType, err + } + + aty, err := impliedType(dec) + if err != nil { + return cty.DynamicPseudoType, err + } + + if atys == nil { + atys = make(map[string]cty.Type) + } + atys[k] = aty + } + + if len(atys) == 0 { + return cty.EmptyObject, nil + } + + return cty.Object(atys), nil +} + +func impliedTupleType(dec *msgpack.Decoder) (cty.Type, error) { + // If we get in here then we've already peeked the next code and know + // it's some sort of array. + l, err := dec.DecodeArrayLen() + if err != nil { + return cty.DynamicPseudoType, nil + } + + if l == 0 { + return cty.EmptyTuple, nil + } + + etys := make([]cty.Type, l) + + for i := 0; i < l; i++ { + ety, err := impliedType(dec) + if err != nil { + return cty.DynamicPseudoType, err + } + etys[i] = ety + } + + return cty.Tuple(etys), nil +} diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go new file mode 100644 index 000000000..6507bc4be --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go @@ -0,0 +1,16 @@ +package msgpack + +type unknownType struct{} + +var unknownVal = unknownType{} + +// unknownValBytes is the raw bytes of the msgpack fixext1 value we +// write to represent an unknown value. It's an extension value of +// type zero whose value is irrelevant. Since it's irrelevant, we +// set it to a single byte whose value is also zero, since that's +// the most compact possible representation. +var unknownValBytes = []byte{0xd4, 0, 0} + +func (uv unknownType) MarshalMsgpack() ([]byte, error) { + return unknownValBytes, nil +} diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go new file mode 100644 index 000000000..450804f34 --- /dev/null +++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go @@ -0,0 +1,311 @@ +package msgpack + +import ( + "bytes" + "math/big" + + "github.com/vmihailenco/msgpack" + msgpackCodes "github.com/vmihailenco/msgpack/codes" + "github.com/zclconf/go-cty/cty" +) + +// Unmarshal interprets the given bytes as a msgpack-encoded cty Value of +// the given type, returning the result. +// +// If an error is returned, the error is written with a hypothetical +// end-user that wrote the msgpack file as its audience, using cty type +// system concepts rather than Go type system concepts. +func Unmarshal(b []byte, ty cty.Type) (cty.Value, error) { + r := bytes.NewReader(b) + dec := msgpack.NewDecoder(r) + + var path cty.Path + return unmarshal(dec, ty, path) +} + +func unmarshal(dec *msgpack.Decoder, ty cty.Type, path cty.Path) (cty.Value, error) { + peek, err := dec.PeekCode() + if err != nil { + return cty.DynamicVal, path.NewError(err) + } + if msgpackCodes.IsExt(peek) { + // We just assume _all_ extensions are unknown values, + // since we don't have any other extensions. + return cty.UnknownVal(ty), nil + } + if ty == cty.DynamicPseudoType { + return unmarshalDynamic(dec, path) + } + if peek == msgpackCodes.Nil { + return cty.NullVal(ty), nil + } + + switch { + case ty.IsPrimitiveType(): + val, err := unmarshalPrimitive(dec, ty, path) + if err != nil { + return cty.NilVal, err + } + return val, nil + case ty.IsListType(): + return unmarshalList(dec, ty.ElementType(), path) + case ty.IsSetType(): + return unmarshalSet(dec, ty.ElementType(), path) + case ty.IsMapType(): + return unmarshalMap(dec, ty.ElementType(), path) + case ty.IsTupleType(): + return unmarshalTuple(dec, ty.TupleElementTypes(), path) + case ty.IsObjectType(): + return unmarshalObject(dec, ty.AttributeTypes(), path) + default: + return cty.NilVal, path.NewErrorf("unsupported type %s", ty.FriendlyName()) + } +} + +func unmarshalPrimitive(dec *msgpack.Decoder, ty cty.Type, path cty.Path) (cty.Value, error) { + switch ty { + case cty.Bool: + rv, err := dec.DecodeBool() + if err != nil { + return cty.DynamicVal, path.NewErrorf("bool is required") + } + return cty.BoolVal(rv), nil + case cty.Number: + // Marshal will try int and float first, if the value can be + // losslessly represented in these encodings, and then fall + // back on a string if the number is too large or too precise. + peek, err := dec.PeekCode() + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + + if msgpackCodes.IsFixedNum(peek) { + rv, err := dec.DecodeInt64() + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + return cty.NumberIntVal(rv), nil + } + + switch peek { + case msgpackCodes.Int8, msgpackCodes.Int16, msgpackCodes.Int32, msgpackCodes.Int64: + rv, err := dec.DecodeInt64() + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + return cty.NumberIntVal(rv), nil + case msgpackCodes.Uint8, msgpackCodes.Uint16, msgpackCodes.Uint32, msgpackCodes.Uint64: + rv, err := dec.DecodeUint64() + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + return cty.NumberUIntVal(rv), nil + case msgpackCodes.Float, msgpackCodes.Double: + rv, err := dec.DecodeFloat64() + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + return cty.NumberFloatVal(rv), nil + default: + rv, err := dec.DecodeString() + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + bf := &big.Float{} + _, _, err = bf.Parse(rv, 10) + if err != nil { + return cty.DynamicVal, path.NewErrorf("number is required") + } + return cty.NumberVal(bf), nil + } + case cty.String: + rv, err := dec.DecodeString() + if err != nil { + return cty.DynamicVal, path.NewErrorf("string is required") + } + return cty.StringVal(rv), nil + default: + // should never happen + panic("unsupported primitive type") + } +} + +func unmarshalList(dec *msgpack.Decoder, ety cty.Type, path cty.Path) (cty.Value, error) { + length, err := dec.DecodeArrayLen() + if err != nil { + return cty.DynamicVal, path.NewErrorf("a list is required") + } + + if length == 0 { + return cty.ListValEmpty(ety), nil + } + + vals := make([]cty.Value, 0, length) + path = append(path, nil) + for i := 0; i < length; i++ { + path[len(path)-1] = cty.IndexStep{ + Key: cty.NumberIntVal(int64(i)), + } + + val, err := unmarshal(dec, ety, path) + if err != nil { + return cty.DynamicVal, err + } + + vals = append(vals, val) + } + + return cty.ListVal(vals), nil +} + +func unmarshalSet(dec *msgpack.Decoder, ety cty.Type, path cty.Path) (cty.Value, error) { + length, err := dec.DecodeArrayLen() + if err != nil { + return cty.DynamicVal, path.NewErrorf("a set is required") + } + + if length == 0 { + return cty.SetValEmpty(ety), nil + } + + vals := make([]cty.Value, 0, length) + path = append(path, nil) + for i := 0; i < length; i++ { + path[len(path)-1] = cty.IndexStep{ + Key: cty.NumberIntVal(int64(i)), + } + + val, err := unmarshal(dec, ety, path) + if err != nil { + return cty.DynamicVal, err + } + + vals = append(vals, val) + } + + return cty.SetVal(vals), nil +} + +func unmarshalMap(dec *msgpack.Decoder, ety cty.Type, path cty.Path) (cty.Value, error) { + length, err := dec.DecodeMapLen() + if err != nil { + return cty.DynamicVal, path.NewErrorf("a map is required") + } + + if length == 0 { + return cty.MapValEmpty(ety), nil + } + + vals := make(map[string]cty.Value, length) + path = append(path, nil) + for i := 0; i < length; i++ { + key, err := dec.DecodeString() + if err != nil { + path[:len(path)-1].NewErrorf("non-string key in map") + } + + path[len(path)-1] = cty.IndexStep{ + Key: cty.StringVal(key), + } + + val, err := unmarshal(dec, ety, path) + if err != nil { + return cty.DynamicVal, err + } + + vals[key] = val + } + + return cty.MapVal(vals), nil +} + +func unmarshalTuple(dec *msgpack.Decoder, etys []cty.Type, path cty.Path) (cty.Value, error) { + length, err := dec.DecodeArrayLen() + if err != nil { + return cty.DynamicVal, path.NewErrorf("a tuple is required") + } + + if length != len(etys) { + return cty.DynamicVal, path.NewErrorf("a tuple of length %d is required", len(etys)) + } + + vals := make([]cty.Value, 0, length) + path = append(path, nil) + for i := 0; i < length; i++ { + path[len(path)-1] = cty.IndexStep{ + Key: cty.NumberIntVal(int64(i)), + } + ety := etys[i] + + val, err := unmarshal(dec, ety, path) + if err != nil { + return cty.DynamicVal, err + } + + vals = append(vals, val) + } + + return cty.TupleVal(vals), nil +} + +func unmarshalObject(dec *msgpack.Decoder, atys map[string]cty.Type, path cty.Path) (cty.Value, error) { + length, err := dec.DecodeMapLen() + if err != nil { + return cty.DynamicVal, path.NewErrorf("an object is required") + } + + if length != len(atys) { + return cty.DynamicVal, path.NewErrorf("an object with %d attributes is required", len(atys)) + } + + vals := make(map[string]cty.Value, length) + path = append(path, nil) + for i := 0; i < length; i++ { + key, err := dec.DecodeString() + if err != nil { + return cty.DynamicVal, path[:len(path)-1].NewErrorf("all keys must be strings") + } + + path[len(path)-1] = cty.IndexStep{ + Key: cty.StringVal(key), + } + aty, exists := atys[key] + if !exists { + return cty.DynamicVal, path.NewErrorf("unsupported attribute") + } + + val, err := unmarshal(dec, aty, path) + if err != nil { + return cty.DynamicVal, err + } + + vals[key] = val + } + + return cty.ObjectVal(vals), nil +} + +func unmarshalDynamic(dec *msgpack.Decoder, path cty.Path) (cty.Value, error) { + length, err := dec.DecodeArrayLen() + if err != nil { + return cty.DynamicVal, path.NewError(err) + } + + if length != 2 { + return cty.DynamicVal, path.NewErrorf( + "dynamic value array must have exactly two elements", + ) + } + + typeJSON, err := dec.DecodeBytes() + if err != nil { + return cty.DynamicVal, path.NewError(err) + } + var ty cty.Type + err = (&ty).UnmarshalJSON(typeJSON) + if err != nil { + return cty.DynamicVal, path.NewError(err) + } + + return unmarshal(dec, ty, path) +} diff --git a/vendor/vendor.json b/vendor/vendor.json index d756d1e37..0367854ae 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -312,12 +312,15 @@ {"path":"github.com/ulikunitz/xz/internal/hash","checksumSHA1":"vjnTkzNrMs5Xj6so/fq0mQ6dT1c=","revision":"0c6b41e72360850ca4f98dc341fd999726ea007f","revisionTime":"2017-06-05T21:53:11Z"}, {"path":"github.com/ulikunitz/xz/internal/xlog","checksumSHA1":"m0pm57ASBK/CTdmC0ppRHO17mBs=","revision":"0c6b41e72360850ca4f98dc341fd999726ea007f","revisionTime":"2017-06-05T21:53:11Z"}, {"path":"github.com/ulikunitz/xz/lzma","checksumSHA1":"2vZw6zc8xuNlyVz2QKvdlNSZQ1U=","revision":"0c6b41e72360850ca4f98dc341fd999726ea007f","revisionTime":"2017-06-05T21:53:11Z"}, + {"path":"github.com/vmihailenco/msgpack","checksumSHA1":"t9A/EE2GhHFPHzK+ksAKgKW9ZC8=","revision":"b5e691b1eb52a28c05e67ab9df303626c095c23b","revisionTime":"2018-06-13T09:15:15Z"}, + {"path":"github.com/vmihailenco/msgpack/codes","checksumSHA1":"OcTSGT2v7/2saIGq06nDhEZwm8I=","revision":"b5e691b1eb52a28c05e67ab9df303626c095c23b","revisionTime":"2018-06-13T09:15:15Z"}, {"path":"github.com/zclconf/go-cty/cty","checksumSHA1":"Ej+3WWvyjn0xg3aujsyT+yvvmdc=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"github.com/zclconf/go-cty/cty/convert","checksumSHA1":"1WGUPe776lvMMbaRerAbqOx19nQ=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"github.com/zclconf/go-cty/cty/function","checksumSHA1":"MyyLCGg3RREMllTJyK6ehZl/dHk=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"github.com/zclconf/go-cty/cty/function/stdlib","checksumSHA1":"kcTJOuL131/stXJ4U9tC3SASQLs=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"github.com/zclconf/go-cty/cty/gocty","checksumSHA1":"tmCzwfNXOEB1sSO7TKVzilb2vjA=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"github.com/zclconf/go-cty/cty/json","checksumSHA1":"1ApmO+Q33+Oem/3f6BU6sztJWNc=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, + {"path":"github.com/zclconf/go-cty/cty/msgpack","checksumSHA1":"8H+2pufGi2Eo3d8cXFfJs31wk+I=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"github.com/zclconf/go-cty/cty/set","checksumSHA1":"y5Sk+n6SOspFj8mlyb8swr4DMIs=","revision":"02bd58e97b5759d478019c5a6333edbfdfed16a0","revisionTime":"2018-07-18T22:05:26Z"}, {"path":"go4.org/errorutil","checksumSHA1":"PMr/a5kcnC4toJtVwWhlU5E4tJY=","revision":"034d17a462f7b2dcd1a4a73553ec5357ff6e6c6e","revisionTime":"2017-05-24T23:16:39Z"}, {"path":"golang.org/x/crypto/blake2b","checksumSHA1":"iBXpCGzDbbbm0sWfaOY3aKDJ31U=","revision":"a49355c7e3f8fe157a85be2f77e6e269a0f89602","revisionTime":"2018-06-20T09:14:27Z"}, From 19cffc9a3ad5eac501dbb34005609220af4ba730 Mon Sep 17 00:00:00 2001 From: Alex Dadgar Date: Mon, 13 Aug 2018 10:52:59 -0700 Subject: [PATCH 3/4] Review comments --- plugins/base/base.go | 2 +- plugins/base/client.go | 6 +-- plugins/base/mock.go | 2 +- plugins/base/plugin.go | 9 ++-- plugins/base/plugin_test.go | 70 ++++++++++++++++++++----------- plugins/base/proto/base.pb.go | 79 +++++++++++++++++------------------ plugins/base/proto/base.proto | 1 - plugins/base/server.go | 4 +- 8 files changed, 93 insertions(+), 80 deletions(-) diff --git a/plugins/base/base.go b/plugins/base/base.go index 416667f57..dafbcf8fb 100644 --- a/plugins/base/base.go +++ b/plugins/base/base.go @@ -1,4 +1,4 @@ -package shared +package base import ( "github.com/hashicorp/nomad/plugins/shared/hclspec" diff --git a/plugins/base/client.go b/plugins/base/client.go index 481b2838b..58d2e57d5 100644 --- a/plugins/base/client.go +++ b/plugins/base/client.go @@ -1,11 +1,11 @@ -package shared +package base import ( + "context" "fmt" "github.com/hashicorp/nomad/plugins/base/proto" "github.com/hashicorp/nomad/plugins/shared/hclspec" - "golang.org/x/net/context" ) // basePluginClient implements the client side of a remote base plugin, using @@ -22,8 +22,6 @@ func (b *basePluginClient) PluginInfo() (*PluginInfoResponse, error) { var ptype string switch presp.GetType() { - case proto.PluginType_BASE: - ptype = PluginTypeBase case proto.PluginType_DRIVER: ptype = PluginTypeDriver case proto.PluginType_DEVICE: diff --git a/plugins/base/mock.go b/plugins/base/mock.go index fa0110dfa..7a3c5c77d 100644 --- a/plugins/base/mock.go +++ b/plugins/base/mock.go @@ -1,4 +1,4 @@ -package shared +package base import ( "github.com/hashicorp/nomad/plugins/shared/hclspec" diff --git a/plugins/base/plugin.go b/plugins/base/plugin.go index 79ddcc885..a466d70a6 100644 --- a/plugins/base/plugin.go +++ b/plugins/base/plugin.go @@ -1,7 +1,7 @@ -package shared +package base import ( - "golang.org/x/net/context" + "context" plugin "github.com/hashicorp/go-plugin" "github.com/hashicorp/nomad/plugins/base/proto" @@ -9,9 +9,6 @@ import ( ) const ( - // PluginTypeBase implements the base plugin driver interface - PluginTypeBase = "base" - // PluginTypeDriver implements the driver plugin interface PluginTypeDriver = "driver" @@ -28,6 +25,8 @@ var ( } ) +// PluginBase is wraps a BasePlugin and implements go-plugins GRPCPlugin +// interface to expose the interface over gRPC. type PluginBase struct { plugin.NetRPCUnsupportedPlugin impl BasePlugin diff --git a/plugins/base/plugin_test.go b/plugins/base/plugin_test.go index b00debe92..5c4568fab 100644 --- a/plugins/base/plugin_test.go +++ b/plugins/base/plugin_test.go @@ -1,4 +1,4 @@ -package shared +package base import ( "testing" @@ -6,12 +6,10 @@ import ( pb "github.com/golang/protobuf/proto" plugin "github.com/hashicorp/go-plugin" "github.com/hashicorp/nomad/nomad/structs" - "github.com/hashicorp/nomad/plugins/base/proto" "github.com/hashicorp/nomad/plugins/shared/hclspec" "github.com/stretchr/testify/require" "github.com/zclconf/go-cty/cty" "github.com/zclconf/go-cty/cty/msgpack" - "google.golang.org/grpc" ) var ( @@ -68,7 +66,7 @@ func TestBasePlugin_PluginInfo_GRPC(t *testing.T) { knownType := func() (*PluginInfoResponse, error) { info := &PluginInfoResponse{ - Type: PluginTypeBase, + Type: PluginTypeDriver, PluginApiVersion: apiVersion, PluginVersion: pluginVersion, Name: pluginName, @@ -89,24 +87,32 @@ func TestBasePlugin_PluginInfo_GRPC(t *testing.T) { PluginInfoF: knownType, } - conn, server := plugin.TestGRPCConn(t, func(s *grpc.Server) { - proto.RegisterBasePluginServer(s, &basePluginServer{impl: mock}) + client, server := plugin.TestPluginGRPCConn(t, map[string]plugin.Plugin{ + "base": &PluginBase{impl: mock}, }) - defer conn.Close() defer server.Stop() - grpcClient := proto.NewBasePluginClient(conn) - client := basePluginClient{client: grpcClient} + defer client.Close() - resp, err := client.PluginInfo() + raw, err := client.Dispense("base") + if err != nil { + t.Fatalf("err: %s", err) + } + + impl, ok := raw.(BasePlugin) + if !ok { + t.Fatalf("bad: %#v", raw) + } + + resp, err := impl.PluginInfo() require.NoError(err) require.Equal(apiVersion, resp.PluginApiVersion) require.Equal(pluginVersion, resp.PluginVersion) require.Equal(pluginName, resp.Name) - require.Equal(PluginTypeBase, resp.Type) + require.Equal(PluginTypeDriver, resp.Type) // Swap the implementation to return an unknown type mock.PluginInfoF = unknownType - _, err = client.PluginInfo() + _, err = impl.PluginInfo() require.Error(err) require.Contains(err.Error(), "unknown type") } @@ -121,15 +127,23 @@ func TestBasePlugin_ConfigSchema(t *testing.T) { }, } - conn, server := plugin.TestGRPCConn(t, func(s *grpc.Server) { - proto.RegisterBasePluginServer(s, &basePluginServer{impl: mock}) + client, server := plugin.TestPluginGRPCConn(t, map[string]plugin.Plugin{ + "base": &PluginBase{impl: mock}, }) - defer conn.Close() defer server.Stop() - grpcClient := proto.NewBasePluginClient(conn) - client := basePluginClient{client: grpcClient} + defer client.Close() - specOut, err := client.ConfigSchema() + raw, err := client.Dispense("base") + if err != nil { + t.Fatalf("err: %s", err) + } + + impl, ok := raw.(BasePlugin) + if !ok { + t.Fatalf("bad: %#v", raw) + } + + specOut, err := impl.ConfigSchema() require.NoError(err) require.True(pb.Equal(testSpec, specOut)) } @@ -149,13 +163,21 @@ func TestBasePlugin_SetConfig(t *testing.T) { }, } - conn, server := plugin.TestGRPCConn(t, func(s *grpc.Server) { - proto.RegisterBasePluginServer(s, &basePluginServer{impl: mock}) + client, server := plugin.TestPluginGRPCConn(t, map[string]plugin.Plugin{ + "base": &PluginBase{impl: mock}, }) - defer conn.Close() defer server.Stop() - grpcClient := proto.NewBasePluginClient(conn) - client := basePluginClient{client: grpcClient} + defer client.Close() + + raw, err := client.Dispense("base") + if err != nil { + t.Fatalf("err: %s", err) + } + + impl, ok := raw.(BasePlugin) + if !ok { + t.Fatalf("bad: %#v", raw) + } config := cty.ObjectVal(map[string]cty.Value{ "foo": cty.StringVal("v1"), @@ -164,7 +186,7 @@ func TestBasePlugin_SetConfig(t *testing.T) { }) cdata, err := msgpack.Marshal(config, config.Type()) require.NoError(err) - require.NoError(client.SetConfig(cdata)) + require.NoError(impl.SetConfig(cdata)) require.Equal(cdata, receivedData) // Decode the value back diff --git a/plugins/base/proto/base.pb.go b/plugins/base/proto/base.pb.go index e2bf6a172..907ca860e 100644 --- a/plugins/base/proto/base.pb.go +++ b/plugins/base/proto/base.pb.go @@ -29,20 +29,17 @@ type PluginType int32 const ( PluginType_UNKNOWN PluginType = 0 - PluginType_BASE PluginType = 1 PluginType_DRIVER PluginType = 2 PluginType_DEVICE PluginType = 3 ) var PluginType_name = map[int32]string{ 0: "UNKNOWN", - 1: "BASE", 2: "DRIVER", 3: "DEVICE", } var PluginType_value = map[string]int32{ "UNKNOWN": 0, - "BASE": 1, "DRIVER": 2, "DEVICE": 3, } @@ -51,7 +48,7 @@ func (x PluginType) String() string { return proto.EnumName(PluginType_name, int32(x)) } func (PluginType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{0} + return fileDescriptor_base_9cc78dc32b158b08, []int{0} } // PluginInfoRequest is used to request the plugins basic information. @@ -65,7 +62,7 @@ func (m *PluginInfoRequest) Reset() { *m = PluginInfoRequest{} } func (m *PluginInfoRequest) String() string { return proto.CompactTextString(m) } func (*PluginInfoRequest) ProtoMessage() {} func (*PluginInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{0} + return fileDescriptor_base_9cc78dc32b158b08, []int{0} } func (m *PluginInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PluginInfoRequest.Unmarshal(m, b) @@ -107,7 +104,7 @@ func (m *PluginInfoResponse) Reset() { *m = PluginInfoResponse{} } func (m *PluginInfoResponse) String() string { return proto.CompactTextString(m) } func (*PluginInfoResponse) ProtoMessage() {} func (*PluginInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{1} + return fileDescriptor_base_9cc78dc32b158b08, []int{1} } func (m *PluginInfoResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PluginInfoResponse.Unmarshal(m, b) @@ -166,7 +163,7 @@ func (m *ConfigSchemaRequest) Reset() { *m = ConfigSchemaRequest{} } func (m *ConfigSchemaRequest) String() string { return proto.CompactTextString(m) } func (*ConfigSchemaRequest) ProtoMessage() {} func (*ConfigSchemaRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{2} + return fileDescriptor_base_9cc78dc32b158b08, []int{2} } func (m *ConfigSchemaRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfigSchemaRequest.Unmarshal(m, b) @@ -199,7 +196,7 @@ func (m *ConfigSchemaResponse) Reset() { *m = ConfigSchemaResponse{} } func (m *ConfigSchemaResponse) String() string { return proto.CompactTextString(m) } func (*ConfigSchemaResponse) ProtoMessage() {} func (*ConfigSchemaResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{3} + return fileDescriptor_base_9cc78dc32b158b08, []int{3} } func (m *ConfigSchemaResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfigSchemaResponse.Unmarshal(m, b) @@ -239,7 +236,7 @@ func (m *SetConfigRequest) Reset() { *m = SetConfigRequest{} } func (m *SetConfigRequest) String() string { return proto.CompactTextString(m) } func (*SetConfigRequest) ProtoMessage() {} func (*SetConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{4} + return fileDescriptor_base_9cc78dc32b158b08, []int{4} } func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SetConfigRequest.Unmarshal(m, b) @@ -277,7 +274,7 @@ func (m *SetConfigResponse) Reset() { *m = SetConfigResponse{} } func (m *SetConfigResponse) String() string { return proto.CompactTextString(m) } func (*SetConfigResponse) ProtoMessage() {} func (*SetConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_base_d24a6a23488adb59, []int{5} + return fileDescriptor_base_9cc78dc32b158b08, []int{5} } func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SetConfigResponse.Unmarshal(m, b) @@ -452,37 +449,37 @@ var _BasePlugin_serviceDesc = grpc.ServiceDesc{ } func init() { - proto.RegisterFile("github.com/hashicorp/nomad/plugins/base/proto/base.proto", fileDescriptor_base_d24a6a23488adb59) + proto.RegisterFile("github.com/hashicorp/nomad/plugins/base/proto/base.proto", fileDescriptor_base_9cc78dc32b158b08) } -var fileDescriptor_base_d24a6a23488adb59 = []byte{ - // 446 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xdf, 0x8b, 0xd3, 0x40, - 0x10, 0xc7, 0x2f, 0xd7, 0x78, 0xe7, 0xcd, 0xfd, 0x20, 0xee, 0x29, 0x94, 0x3c, 0x1d, 0x01, 0xe1, - 0x90, 0x63, 0x03, 0xd5, 0xd3, 0x13, 0x5f, 0xae, 0xa9, 0x79, 0x28, 0x42, 0x95, 0x44, 0xab, 0xf8, - 0x12, 0xb6, 0xdb, 0x6d, 0x12, 0x6c, 0xb2, 0x6b, 0x36, 0x15, 0x2a, 0xf8, 0xe4, 0xb3, 0x7f, 0x94, - 0xff, 0x99, 0x64, 0x37, 0x69, 0xa3, 0x28, 0xa6, 0x4f, 0x19, 0x66, 0x3e, 0xf3, 0xdd, 0x99, 0xef, - 0x04, 0x6e, 0xe2, 0xb4, 0x4c, 0x56, 0x33, 0x4c, 0x79, 0xe6, 0x26, 0x44, 0x26, 0x29, 0xe5, 0x85, - 0x70, 0x73, 0x9e, 0x91, 0xb9, 0x2b, 0x96, 0xab, 0x38, 0xcd, 0xa5, 0x3b, 0x23, 0x92, 0xb9, 0xa2, - 0xe0, 0x25, 0x57, 0x21, 0x56, 0x21, 0x72, 0x36, 0x38, 0x56, 0x38, 0xae, 0x71, 0xbc, 0x65, 0xec, - 0xdb, 0x0e, 0xea, 0x32, 0x21, 0x05, 0x9b, 0xbb, 0x09, 0x5d, 0x4a, 0xc1, 0x68, 0xf5, 0x8d, 0xaa, - 0x40, 0x2b, 0x38, 0xe7, 0x70, 0xef, 0x8d, 0x02, 0xc7, 0xf9, 0x82, 0x07, 0xec, 0xf3, 0x8a, 0xc9, - 0xd2, 0xf9, 0x69, 0x00, 0x6a, 0x67, 0xa5, 0xe0, 0xb9, 0x64, 0xc8, 0x03, 0xb3, 0x5c, 0x0b, 0xd6, - 0x37, 0x2e, 0x8c, 0xcb, 0xb3, 0x01, 0xc6, 0xff, 0x1f, 0x10, 0x6b, 0x95, 0xb7, 0x6b, 0xc1, 0x02, - 0xd5, 0x8b, 0xae, 0x00, 0x69, 0x2c, 0x22, 0x22, 0x8d, 0xbe, 0xb0, 0x42, 0xa6, 0x3c, 0xef, 0xef, - 0x5f, 0x18, 0x97, 0x47, 0x81, 0xa5, 0x2b, 0x43, 0x91, 0x4e, 0x75, 0x1e, 0x3d, 0x84, 0xb3, 0x9a, - 0x6e, 0xc8, 0x9e, 0x22, 0x4f, 0x75, 0xb6, 0xc1, 0x10, 0x98, 0x39, 0xc9, 0x58, 0xdf, 0x54, 0x45, - 0x15, 0x3b, 0x0f, 0xe0, 0x7c, 0xc4, 0xf3, 0x45, 0x1a, 0x87, 0x34, 0x61, 0x19, 0x69, 0x56, 0xfb, - 0x00, 0xf7, 0x7f, 0x4f, 0xd7, 0xbb, 0xdd, 0x82, 0x59, 0xb9, 0xa2, 0x76, 0x3b, 0x1e, 0x5c, 0xfd, - 0x73, 0x37, 0xed, 0x26, 0xae, 0xdd, 0xc4, 0xa1, 0x60, 0x34, 0x50, 0x9d, 0xce, 0x73, 0xb0, 0x42, - 0x56, 0x6a, 0xf1, 0xfa, 0xb5, 0x6a, 0xfe, 0x4c, 0xc6, 0x82, 0xd0, 0x4f, 0x11, 0x55, 0x05, 0xa5, - 0x7f, 0x12, 0x9c, 0xd6, 0x59, 0x4d, 0x57, 0x47, 0x68, 0xb5, 0xea, 0x89, 0x1e, 0xbd, 0x00, 0xd8, - 0xba, 0x87, 0x8e, 0xe1, 0xf0, 0xdd, 0xe4, 0xd5, 0xe4, 0xf5, 0xfb, 0x89, 0xb5, 0x87, 0xee, 0x82, - 0xe9, 0x0d, 0x43, 0xdf, 0x32, 0x10, 0xc0, 0xc1, 0xcb, 0x60, 0x3c, 0xf5, 0x03, 0x6b, 0x5f, 0xc5, - 0xfe, 0x74, 0x3c, 0xf2, 0xad, 0xde, 0xe0, 0x47, 0x0f, 0xc0, 0x23, 0x92, 0x69, 0x05, 0xf4, 0xad, - 0xd1, 0xaa, 0xee, 0x89, 0xae, 0xbb, 0x5f, 0xae, 0xf5, 0x57, 0xd8, 0x4f, 0x77, 0x6d, 0xd3, 0x8b, - 0x38, 0x7b, 0xe8, 0xbb, 0x01, 0x27, 0x6d, 0xd7, 0xd1, 0xb3, 0x2e, 0x52, 0x7f, 0x39, 0x9f, 0x7d, - 0xb3, 0x7b, 0xe3, 0x66, 0x8a, 0xaf, 0x70, 0xb4, 0x71, 0x19, 0x3d, 0xe9, 0x22, 0xf4, 0xe7, 0x3d, - 0xed, 0xeb, 0x1d, 0xbb, 0x9a, 0xb7, 0xbd, 0xc3, 0x8f, 0x77, 0x54, 0x71, 0x76, 0xa0, 0x3e, 0x8f, - 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x73, 0x54, 0x60, 0xaa, 0x18, 0x04, 0x00, 0x00, +var fileDescriptor_base_9cc78dc32b158b08 = []byte{ + // 436 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcf, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x37, 0xdb, 0xb8, 0xcb, 0xbe, 0xdd, 0x2d, 0x71, 0xaa, 0x50, 0x72, 0x2a, 0x01, 0xa1, + 0x48, 0x99, 0x60, 0xb5, 0x5a, 0x6f, 0xb5, 0xb5, 0x87, 0x22, 0x54, 0x49, 0xb5, 0x8a, 0x97, 0x30, + 0x9d, 0x4e, 0x93, 0x60, 0x93, 0x19, 0x33, 0xa9, 0x50, 0xc1, 0x93, 0x67, 0xff, 0x28, 0xff, 0x33, + 0xc9, 0x4c, 0xd2, 0x46, 0x51, 0x4c, 0x4f, 0x79, 0xbc, 0xf7, 0xf9, 0x7e, 0xe7, 0xfd, 0x08, 0x0c, + 0x83, 0x28, 0x0b, 0x77, 0x2b, 0x4c, 0x79, 0xec, 0x86, 0x44, 0x86, 0x11, 0xe5, 0xa9, 0x70, 0x13, + 0x1e, 0x93, 0xb5, 0x2b, 0xb6, 0xbb, 0x20, 0x4a, 0xa4, 0xbb, 0x22, 0x92, 0xb9, 0x22, 0xe5, 0x19, + 0x57, 0x21, 0x56, 0x21, 0x72, 0x0e, 0x38, 0x56, 0x38, 0x2e, 0x70, 0x7c, 0x64, 0xec, 0x51, 0x0d, + 0x77, 0x19, 0x92, 0x94, 0xad, 0xdd, 0x90, 0x6e, 0xa5, 0x60, 0x34, 0xff, 0xfa, 0x79, 0xa0, 0x1d, + 0x9c, 0x16, 0xdc, 0x7d, 0xa3, 0xc0, 0x59, 0xb2, 0xe1, 0x1e, 0xfb, 0xbc, 0x63, 0x32, 0x73, 0x7e, + 0x1a, 0x80, 0xaa, 0x59, 0x29, 0x78, 0x22, 0x19, 0x1a, 0x83, 0x99, 0xed, 0x05, 0x6b, 0x1b, 0x1d, + 0xa3, 0xdb, 0xec, 0x63, 0xfc, 0xff, 0x06, 0xb1, 0x76, 0x79, 0xbb, 0x17, 0xcc, 0x53, 0x5a, 0xd4, + 0x03, 0xa4, 0x31, 0x9f, 0x88, 0xc8, 0xff, 0xc2, 0x52, 0x19, 0xf1, 0xa4, 0x7d, 0xde, 0x31, 0xba, + 0x57, 0x9e, 0xa5, 0x2b, 0x2f, 0x44, 0xb4, 0xd4, 0x79, 0xf4, 0x00, 0x9a, 0x05, 0x5d, 0x92, 0x0d, + 0x45, 0xde, 0xea, 0x6c, 0x89, 0x21, 0x30, 0x13, 0x12, 0xb3, 0xb6, 0xa9, 0x8a, 0x2a, 0x76, 0xee, + 0x43, 0x6b, 0xc2, 0x93, 0x4d, 0x14, 0x2c, 0x68, 0xc8, 0x62, 0x52, 0x8e, 0xf6, 0x01, 0xee, 0xfd, + 0x9e, 0x2e, 0x66, 0x1b, 0x81, 0x99, 0x6f, 0x45, 0xcd, 0x76, 0xdd, 0xef, 0xfd, 0x73, 0x36, 0xbd, + 0x4d, 0x5c, 0x6c, 0x13, 0x2f, 0x04, 0xa3, 0x9e, 0x52, 0x3a, 0xcf, 0xc1, 0x5a, 0xb0, 0x4c, 0x9b, + 0x17, 0xaf, 0xe5, 0xfd, 0xc7, 0x32, 0x10, 0x84, 0x7e, 0xf2, 0xa9, 0x2a, 0x28, 0xff, 0x1b, 0xef, + 0xb6, 0xc8, 0x6a, 0x3a, 0x3f, 0x42, 0x45, 0xaa, 0x3b, 0x7a, 0xf8, 0x08, 0xe0, 0xb8, 0x3d, 0x74, + 0x0d, 0x97, 0xef, 0xe6, 0xaf, 0xe6, 0xaf, 0xdf, 0xcf, 0xad, 0x33, 0x04, 0x70, 0xf1, 0xd2, 0x9b, + 0x2d, 0xa7, 0x9e, 0x75, 0xae, 0xe2, 0xe9, 0x72, 0x36, 0x99, 0x5a, 0x8d, 0xfe, 0x8f, 0x06, 0xc0, + 0x98, 0x48, 0xa6, 0x75, 0xe8, 0x5b, 0xe9, 0x90, 0x5f, 0x11, 0x0d, 0xea, 0xdf, 0xab, 0xf2, 0x2f, + 0xd8, 0x4f, 0x4f, 0x95, 0xe9, 0xf6, 0x9d, 0x33, 0xf4, 0xdd, 0x80, 0x9b, 0xea, 0xae, 0xd1, 0xb3, + 0x3a, 0x56, 0x7f, 0x39, 0x9a, 0x3d, 0x3c, 0x5d, 0x78, 0xe8, 0xe2, 0x2b, 0x5c, 0x1d, 0x76, 0x8b, + 0x9e, 0xd4, 0x31, 0xfa, 0xf3, 0x8a, 0xf6, 0xe0, 0x44, 0x55, 0xf9, 0xf6, 0xf8, 0xf2, 0xe3, 0x1d, + 0x55, 0x5c, 0x5d, 0xa8, 0xcf, 0xe3, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x29, 0x9a, 0xb0, + 0x0e, 0x04, 0x00, 0x00, } diff --git a/plugins/base/proto/base.proto b/plugins/base/proto/base.proto index b5f359cca..36bc4d23a 100644 --- a/plugins/base/proto/base.proto +++ b/plugins/base/proto/base.proto @@ -20,7 +20,6 @@ service BasePlugin { // PluginType enumerates the type of plugins Nomad supports enum PluginType { UNKNOWN = 0; - BASE = 1; DRIVER = 2; DEVICE = 3; } diff --git a/plugins/base/server.go b/plugins/base/server.go index af2c9dc0e..b6193229f 100644 --- a/plugins/base/server.go +++ b/plugins/base/server.go @@ -1,4 +1,4 @@ -package shared +package base import ( "fmt" @@ -23,8 +23,6 @@ func (b *basePluginServer) PluginInfo(context.Context, *proto.PluginInfoRequest) var ptype proto.PluginType switch resp.Type { - case PluginTypeBase: - ptype = proto.PluginType_BASE case PluginTypeDriver: ptype = proto.PluginType_DRIVER case PluginTypeDevice: From c49beed26eae9217ad58aebff68701276524a16f Mon Sep 17 00:00:00 2001 From: Alex Dadgar Date: Mon, 13 Aug 2018 11:10:33 -0700 Subject: [PATCH 4/4] vet --- plugins/base/plugin.go | 5 ++++- plugins/base/plugin_test.go | 14 +++++++------- plugins/shared/hclspec/dec.go | 2 -- plugins/shared/hclspec/dec_test.go | 10 +++++----- 4 files changed, 16 insertions(+), 15 deletions(-) diff --git a/plugins/base/plugin.go b/plugins/base/plugin.go index a466d70a6..7f0219b29 100644 --- a/plugins/base/plugin.go +++ b/plugins/base/plugin.go @@ -33,7 +33,10 @@ type PluginBase struct { } func (p *PluginBase) GRPCServer(broker *plugin.GRPCBroker, s *grpc.Server) error { - proto.RegisterBasePluginServer(s, &basePluginServer{impl: p.impl}) + proto.RegisterBasePluginServer(s, &basePluginServer{ + impl: p.impl, + broker: broker, + }) return nil } diff --git a/plugins/base/plugin_test.go b/plugins/base/plugin_test.go index 5c4568fab..2e7d1c19f 100644 --- a/plugins/base/plugin_test.go +++ b/plugins/base/plugin_test.go @@ -16,27 +16,27 @@ var ( // testSpec is an hcl Spec for testing testSpec = &hclspec.Spec{ Block: &hclspec.Spec_Object{ - &hclspec.Object{ + Object: &hclspec.Object{ Attributes: map[string]*hclspec.Spec{ - "foo": &hclspec.Spec{ + "foo": { Block: &hclspec.Spec_Attr{ - &hclspec.Attr{ + Attr: &hclspec.Attr{ Type: "string", Required: false, }, }, }, - "bar": &hclspec.Spec{ + "bar": { Block: &hclspec.Spec_Attr{ - &hclspec.Attr{ + Attr: &hclspec.Attr{ Type: "number", Required: true, }, }, }, - "baz": &hclspec.Spec{ + "baz": { Block: &hclspec.Spec_Attr{ - &hclspec.Attr{ + Attr: &hclspec.Attr{ Type: "bool", }, }, diff --git a/plugins/shared/hclspec/dec.go b/plugins/shared/hclspec/dec.go index b7721a357..a6ebb193b 100644 --- a/plugins/shared/hclspec/dec.go +++ b/plugins/shared/hclspec/dec.go @@ -82,8 +82,6 @@ func decodeSpecBlock(spec *Spec, impliedName string) (hcldec.Spec, hcl.Diagnosti }) return nil, diags } - - return nil, nil } func decodeObjectSpec(obj *Object) (hcldec.Spec, hcl.Diagnostics) { diff --git a/plugins/shared/hclspec/dec_test.go b/plugins/shared/hclspec/dec_test.go index 40d9e988b..b490153c5 100644 --- a/plugins/shared/hclspec/dec_test.go +++ b/plugins/shared/hclspec/dec_test.go @@ -46,7 +46,7 @@ func TestDec_Convert_Object(t *testing.T) { Block: &Spec_Object{ &Object{ Attributes: map[string]*Spec{ - "foo": &Spec{ + "foo": { Block: &Spec_Attr{ &Attr{ Type: "string", @@ -54,7 +54,7 @@ func TestDec_Convert_Object(t *testing.T) { }, }, }, - "bar": &Spec{ + "bar": { Block: &Spec_Attr{ &Attr{ Type: "number", @@ -62,7 +62,7 @@ func TestDec_Convert_Object(t *testing.T) { }, }, }, - "baz": &Spec{ + "baz": { Block: &Spec_Attr{ &Attr{ Type: "bool", @@ -106,7 +106,7 @@ func TestDec_Convert_Array(t *testing.T) { Block: &Spec_Array{ Array: &Array{ Values: []*Spec{ - &Spec{ + { Block: &Spec_Attr{ &Attr{ Name: "foo", @@ -115,7 +115,7 @@ func TestDec_Convert_Array(t *testing.T) { }, }, }, - &Spec{ + { Block: &Spec_Attr{ &Attr{ Name: "bar",