| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // source: tls/wiring.proto |
| |
| package tls |
| |
| import ( |
| context "context" |
| fmt "fmt" |
| proto "github.com/golang/protobuf/proto" |
| xmlrpc "go.chromium.org/chromiumos/infra/proto/go/xmlrpc" |
| grpc "google.golang.org/grpc" |
| codes "google.golang.org/grpc/codes" |
| status "google.golang.org/grpc/status" |
| math "math" |
| ) |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the proto package it is being compiled against. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package |
| |
| type OpenDutPortResponse_Status int32 |
| |
| const ( |
| OpenDutPortResponse_STATUS_UNKNOWN OpenDutPortResponse_Status = 0 |
| OpenDutPortResponse_STATUS_OK OpenDutPortResponse_Status = 1 |
| // STATUS_BAD_DUT indicates that the DUT is not known, |
| // or the caller does not have access to it. |
| OpenDutPortResponse_STATUS_BAD_DUT OpenDutPortResponse_Status = 2 |
| // STATUS_DUT_UNREACHABLE indicates that the DUT is not reachable |
| // over the network. |
| OpenDutPortResponse_STATUS_DUT_UNREACHABLE OpenDutPortResponse_Status = 3 |
| ) |
| |
| var OpenDutPortResponse_Status_name = map[int32]string{ |
| 0: "STATUS_UNKNOWN", |
| 1: "STATUS_OK", |
| 2: "STATUS_BAD_DUT", |
| 3: "STATUS_DUT_UNREACHABLE", |
| } |
| |
| var OpenDutPortResponse_Status_value = map[string]int32{ |
| "STATUS_UNKNOWN": 0, |
| "STATUS_OK": 1, |
| "STATUS_BAD_DUT": 2, |
| "STATUS_DUT_UNREACHABLE": 3, |
| } |
| |
| func (x OpenDutPortResponse_Status) String() string { |
| return proto.EnumName(OpenDutPortResponse_Status_name, int32(x)) |
| } |
| |
| func (OpenDutPortResponse_Status) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{1, 0} |
| } |
| |
| type SetDutPowerSupplyRequest_State int32 |
| |
| const ( |
| SetDutPowerSupplyRequest_STATE_UNKNOWN SetDutPowerSupplyRequest_State = 0 |
| SetDutPowerSupplyRequest_STATE_ON SetDutPowerSupplyRequest_State = 1 |
| SetDutPowerSupplyRequest_STATE_OFF SetDutPowerSupplyRequest_State = 2 |
| ) |
| |
| var SetDutPowerSupplyRequest_State_name = map[int32]string{ |
| 0: "STATE_UNKNOWN", |
| 1: "STATE_ON", |
| 2: "STATE_OFF", |
| } |
| |
| var SetDutPowerSupplyRequest_State_value = map[string]int32{ |
| "STATE_UNKNOWN": 0, |
| "STATE_ON": 1, |
| "STATE_OFF": 2, |
| } |
| |
| func (x SetDutPowerSupplyRequest_State) String() string { |
| return proto.EnumName(SetDutPowerSupplyRequest_State_name, int32(x)) |
| } |
| |
| func (SetDutPowerSupplyRequest_State) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{2, 0} |
| } |
| |
| type SetDutPowerSupplyResponse_Status int32 |
| |
| const ( |
| SetDutPowerSupplyResponse_STATUS_UNKNOWN SetDutPowerSupplyResponse_Status = 0 |
| SetDutPowerSupplyResponse_STATUS_OK SetDutPowerSupplyResponse_Status = 1 |
| // STATUS_BAD_DUT indicates that the DUT is not known, |
| // or the caller does not have access to it. |
| SetDutPowerSupplyResponse_STATUS_BAD_DUT SetDutPowerSupplyResponse_Status = 2 |
| // STATUS_BAD_REQUEST indicates that the request was invalid, |
| // e.g., passing an invalid state. |
| SetDutPowerSupplyResponse_STATUS_BAD_REQUEST SetDutPowerSupplyResponse_Status = 3 |
| SetDutPowerSupplyResponse_STATUS_NO_RPM SetDutPowerSupplyResponse_Status = 4 |
| SetDutPowerSupplyResponse_STATUS_RPM_ERROR SetDutPowerSupplyResponse_Status = 5 |
| ) |
| |
| var SetDutPowerSupplyResponse_Status_name = map[int32]string{ |
| 0: "STATUS_UNKNOWN", |
| 1: "STATUS_OK", |
| 2: "STATUS_BAD_DUT", |
| 3: "STATUS_BAD_REQUEST", |
| 4: "STATUS_NO_RPM", |
| 5: "STATUS_RPM_ERROR", |
| } |
| |
| var SetDutPowerSupplyResponse_Status_value = map[string]int32{ |
| "STATUS_UNKNOWN": 0, |
| "STATUS_OK": 1, |
| "STATUS_BAD_DUT": 2, |
| "STATUS_BAD_REQUEST": 3, |
| "STATUS_NO_RPM": 4, |
| "STATUS_RPM_ERROR": 5, |
| } |
| |
| func (x SetDutPowerSupplyResponse_Status) String() string { |
| return proto.EnumName(SetDutPowerSupplyResponse_Status_name, int32(x)) |
| } |
| |
| func (SetDutPowerSupplyResponse_Status) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{3, 0} |
| } |
| |
| type CacheForDutResponse_Status int32 |
| |
| const ( |
| CacheForDutResponse_STATUS_UNKNOWN CacheForDutResponse_Status = 0 |
| CacheForDutResponse_STATUS_OK CacheForDutResponse_Status = 1 |
| CacheForDutResponse_STATUS_CONTINUE CacheForDutResponse_Status = 2 |
| CacheForDutResponse_STATUS_NOT_FOUND CacheForDutResponse_Status = 3 |
| CacheForDutResponse_STATUS_TIMEOUT CacheForDutResponse_Status = 4 |
| ) |
| |
| var CacheForDutResponse_Status_name = map[int32]string{ |
| 0: "STATUS_UNKNOWN", |
| 1: "STATUS_OK", |
| 2: "STATUS_CONTINUE", |
| 3: "STATUS_NOT_FOUND", |
| 4: "STATUS_TIMEOUT", |
| } |
| |
| var CacheForDutResponse_Status_value = map[string]int32{ |
| "STATUS_UNKNOWN": 0, |
| "STATUS_OK": 1, |
| "STATUS_CONTINUE": 2, |
| "STATUS_NOT_FOUND": 3, |
| "STATUS_TIMEOUT": 4, |
| } |
| |
| func (x CacheForDutResponse_Status) String() string { |
| return proto.EnumName(CacheForDutResponse_Status_name, int32(x)) |
| } |
| |
| func (CacheForDutResponse_Status) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{5, 0} |
| } |
| |
| type CallServoXmlRpcResponse_Status int32 |
| |
| const ( |
| CallServoXmlRpcResponse_STATUS_UNKNOWN CallServoXmlRpcResponse_Status = 0 |
| CallServoXmlRpcResponse_STATUS_OK CallServoXmlRpcResponse_Status = 1 |
| // STATUS_BAD_DUT indicates that the DUT is not known, |
| // or the caller does not have access to it. |
| CallServoXmlRpcResponse_STATUS_BAD_DUT CallServoXmlRpcResponse_Status = 2 |
| // STATUS_NO_METHOD indicates that the requested method does not |
| // exist. |
| CallServoXmlRpcResponse_STATUS_NO_METHOD CallServoXmlRpcResponse_Status = 3 |
| CallServoXmlRpcResponse_STATUS_NO_SERVO CallServoXmlRpcResponse_Status = 4 |
| CallServoXmlRpcResponse_STATUS_SERVO_ERROR CallServoXmlRpcResponse_Status = 5 |
| ) |
| |
| var CallServoXmlRpcResponse_Status_name = map[int32]string{ |
| 0: "STATUS_UNKNOWN", |
| 1: "STATUS_OK", |
| 2: "STATUS_BAD_DUT", |
| 3: "STATUS_NO_METHOD", |
| 4: "STATUS_NO_SERVO", |
| 5: "STATUS_SERVO_ERROR", |
| } |
| |
| var CallServoXmlRpcResponse_Status_value = map[string]int32{ |
| "STATUS_UNKNOWN": 0, |
| "STATUS_OK": 1, |
| "STATUS_BAD_DUT": 2, |
| "STATUS_NO_METHOD": 3, |
| "STATUS_NO_SERVO": 4, |
| "STATUS_SERVO_ERROR": 5, |
| } |
| |
| func (x CallServoXmlRpcResponse_Status) String() string { |
| return proto.EnumName(CallServoXmlRpcResponse_Status_name, int32(x)) |
| } |
| |
| func (CallServoXmlRpcResponse_Status) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{7, 0} |
| } |
| |
| type OpenDutPortRequest struct { |
| // dut is some identifier for the DUT. |
| // The DUT ID is passed to the RTD when it is started. |
| // This could be the DUT hostname, but the caller should not be able |
| // to use the hostname to SSH or otherwise interact with the DUT |
| // directly. |
| Dut string `protobuf:"bytes,1,opt,name=dut,proto3" json:"dut,omitempty"` |
| // Port to open on the DUT. |
| DutPort int32 `protobuf:"varint,2,opt,name=dut_port,json=dutPort,proto3" json:"dut_port,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *OpenDutPortRequest) Reset() { *m = OpenDutPortRequest{} } |
| func (m *OpenDutPortRequest) String() string { return proto.CompactTextString(m) } |
| func (*OpenDutPortRequest) ProtoMessage() {} |
| func (*OpenDutPortRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{0} |
| } |
| |
| func (m *OpenDutPortRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_OpenDutPortRequest.Unmarshal(m, b) |
| } |
| func (m *OpenDutPortRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_OpenDutPortRequest.Marshal(b, m, deterministic) |
| } |
| func (m *OpenDutPortRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_OpenDutPortRequest.Merge(m, src) |
| } |
| func (m *OpenDutPortRequest) XXX_Size() int { |
| return xxx_messageInfo_OpenDutPortRequest.Size(m) |
| } |
| func (m *OpenDutPortRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_OpenDutPortRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_OpenDutPortRequest proto.InternalMessageInfo |
| |
| func (m *OpenDutPortRequest) GetDut() string { |
| if m != nil { |
| return m.Dut |
| } |
| return "" |
| } |
| |
| func (m *OpenDutPortRequest) GetDutPort() int32 { |
| if m != nil { |
| return m.DutPort |
| } |
| return 0 |
| } |
| |
| type OpenDutPortResponse struct { |
| Status OpenDutPortResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=tls.OpenDutPortResponse_Status" json:"status,omitempty"` |
| // address which is forwarded to the DUT, in the form host:port. |
| // TLEs should return an IP address to avoid name resolution issues. |
| // If TLEs return a hostname, they should ensure that the hostname is |
| // resolveable by the RTD via standard name resolution facilities. |
| Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` |
| // reason provides human friendly context for any error status. |
| Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *OpenDutPortResponse) Reset() { *m = OpenDutPortResponse{} } |
| func (m *OpenDutPortResponse) String() string { return proto.CompactTextString(m) } |
| func (*OpenDutPortResponse) ProtoMessage() {} |
| func (*OpenDutPortResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{1} |
| } |
| |
| func (m *OpenDutPortResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_OpenDutPortResponse.Unmarshal(m, b) |
| } |
| func (m *OpenDutPortResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_OpenDutPortResponse.Marshal(b, m, deterministic) |
| } |
| func (m *OpenDutPortResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_OpenDutPortResponse.Merge(m, src) |
| } |
| func (m *OpenDutPortResponse) XXX_Size() int { |
| return xxx_messageInfo_OpenDutPortResponse.Size(m) |
| } |
| func (m *OpenDutPortResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_OpenDutPortResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_OpenDutPortResponse proto.InternalMessageInfo |
| |
| func (m *OpenDutPortResponse) GetStatus() OpenDutPortResponse_Status { |
| if m != nil { |
| return m.Status |
| } |
| return OpenDutPortResponse_STATUS_UNKNOWN |
| } |
| |
| func (m *OpenDutPortResponse) GetAddress() string { |
| if m != nil { |
| return m.Address |
| } |
| return "" |
| } |
| |
| func (m *OpenDutPortResponse) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type SetDutPowerSupplyRequest struct { |
| Dut string `protobuf:"bytes,1,opt,name=dut,proto3" json:"dut,omitempty"` |
| State SetDutPowerSupplyRequest_State `protobuf:"varint,2,opt,name=state,proto3,enum=tls.SetDutPowerSupplyRequest_State" json:"state,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *SetDutPowerSupplyRequest) Reset() { *m = SetDutPowerSupplyRequest{} } |
| func (m *SetDutPowerSupplyRequest) String() string { return proto.CompactTextString(m) } |
| func (*SetDutPowerSupplyRequest) ProtoMessage() {} |
| func (*SetDutPowerSupplyRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{2} |
| } |
| |
| func (m *SetDutPowerSupplyRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_SetDutPowerSupplyRequest.Unmarshal(m, b) |
| } |
| func (m *SetDutPowerSupplyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_SetDutPowerSupplyRequest.Marshal(b, m, deterministic) |
| } |
| func (m *SetDutPowerSupplyRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SetDutPowerSupplyRequest.Merge(m, src) |
| } |
| func (m *SetDutPowerSupplyRequest) XXX_Size() int { |
| return xxx_messageInfo_SetDutPowerSupplyRequest.Size(m) |
| } |
| func (m *SetDutPowerSupplyRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_SetDutPowerSupplyRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SetDutPowerSupplyRequest proto.InternalMessageInfo |
| |
| func (m *SetDutPowerSupplyRequest) GetDut() string { |
| if m != nil { |
| return m.Dut |
| } |
| return "" |
| } |
| |
| func (m *SetDutPowerSupplyRequest) GetState() SetDutPowerSupplyRequest_State { |
| if m != nil { |
| return m.State |
| } |
| return SetDutPowerSupplyRequest_STATE_UNKNOWN |
| } |
| |
| type SetDutPowerSupplyResponse struct { |
| Status SetDutPowerSupplyResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=tls.SetDutPowerSupplyResponse_Status" json:"status,omitempty"` |
| // reason provides human friendly context for any error status. |
| Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *SetDutPowerSupplyResponse) Reset() { *m = SetDutPowerSupplyResponse{} } |
| func (m *SetDutPowerSupplyResponse) String() string { return proto.CompactTextString(m) } |
| func (*SetDutPowerSupplyResponse) ProtoMessage() {} |
| func (*SetDutPowerSupplyResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{3} |
| } |
| |
| func (m *SetDutPowerSupplyResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_SetDutPowerSupplyResponse.Unmarshal(m, b) |
| } |
| func (m *SetDutPowerSupplyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_SetDutPowerSupplyResponse.Marshal(b, m, deterministic) |
| } |
| func (m *SetDutPowerSupplyResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SetDutPowerSupplyResponse.Merge(m, src) |
| } |
| func (m *SetDutPowerSupplyResponse) XXX_Size() int { |
| return xxx_messageInfo_SetDutPowerSupplyResponse.Size(m) |
| } |
| func (m *SetDutPowerSupplyResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_SetDutPowerSupplyResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SetDutPowerSupplyResponse proto.InternalMessageInfo |
| |
| func (m *SetDutPowerSupplyResponse) GetStatus() SetDutPowerSupplyResponse_Status { |
| if m != nil { |
| return m.Status |
| } |
| return SetDutPowerSupplyResponse_STATUS_UNKNOWN |
| } |
| |
| func (m *SetDutPowerSupplyResponse) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type CacheForDutRequest struct { |
| // url identifies the resource to cache. |
| // Only http, https, and gs are supported. |
| Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CacheForDutRequest) Reset() { *m = CacheForDutRequest{} } |
| func (m *CacheForDutRequest) String() string { return proto.CompactTextString(m) } |
| func (*CacheForDutRequest) ProtoMessage() {} |
| func (*CacheForDutRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{4} |
| } |
| |
| func (m *CacheForDutRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CacheForDutRequest.Unmarshal(m, b) |
| } |
| func (m *CacheForDutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CacheForDutRequest.Marshal(b, m, deterministic) |
| } |
| func (m *CacheForDutRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CacheForDutRequest.Merge(m, src) |
| } |
| func (m *CacheForDutRequest) XXX_Size() int { |
| return xxx_messageInfo_CacheForDutRequest.Size(m) |
| } |
| func (m *CacheForDutRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_CacheForDutRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CacheForDutRequest proto.InternalMessageInfo |
| |
| func (m *CacheForDutRequest) GetUrl() string { |
| if m != nil { |
| return m.Url |
| } |
| return "" |
| } |
| |
| type CacheForDutResponse struct { |
| Status CacheForDutResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=tls.CacheForDutResponse_Status" json:"status,omitempty"` |
| // url is where the resource is cached at. |
| // This should be accessible to the DUT. |
| // If the host is a name, it should be resolveable by the DUT via |
| // standard name resolution facilities. |
| Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` |
| // reason provides human friendly context for any error status. |
| Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CacheForDutResponse) Reset() { *m = CacheForDutResponse{} } |
| func (m *CacheForDutResponse) String() string { return proto.CompactTextString(m) } |
| func (*CacheForDutResponse) ProtoMessage() {} |
| func (*CacheForDutResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{5} |
| } |
| |
| func (m *CacheForDutResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CacheForDutResponse.Unmarshal(m, b) |
| } |
| func (m *CacheForDutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CacheForDutResponse.Marshal(b, m, deterministic) |
| } |
| func (m *CacheForDutResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CacheForDutResponse.Merge(m, src) |
| } |
| func (m *CacheForDutResponse) XXX_Size() int { |
| return xxx_messageInfo_CacheForDutResponse.Size(m) |
| } |
| func (m *CacheForDutResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_CacheForDutResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CacheForDutResponse proto.InternalMessageInfo |
| |
| func (m *CacheForDutResponse) GetStatus() CacheForDutResponse_Status { |
| if m != nil { |
| return m.Status |
| } |
| return CacheForDutResponse_STATUS_UNKNOWN |
| } |
| |
| func (m *CacheForDutResponse) GetUrl() string { |
| if m != nil { |
| return m.Url |
| } |
| return "" |
| } |
| |
| func (m *CacheForDutResponse) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type CallServoXmlRpcRequest struct { |
| Dut string `protobuf:"bytes,1,opt,name=dut,proto3" json:"dut,omitempty"` |
| Method string `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"` |
| Args []*xmlrpc.Value `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CallServoXmlRpcRequest) Reset() { *m = CallServoXmlRpcRequest{} } |
| func (m *CallServoXmlRpcRequest) String() string { return proto.CompactTextString(m) } |
| func (*CallServoXmlRpcRequest) ProtoMessage() {} |
| func (*CallServoXmlRpcRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{6} |
| } |
| |
| func (m *CallServoXmlRpcRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CallServoXmlRpcRequest.Unmarshal(m, b) |
| } |
| func (m *CallServoXmlRpcRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CallServoXmlRpcRequest.Marshal(b, m, deterministic) |
| } |
| func (m *CallServoXmlRpcRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CallServoXmlRpcRequest.Merge(m, src) |
| } |
| func (m *CallServoXmlRpcRequest) XXX_Size() int { |
| return xxx_messageInfo_CallServoXmlRpcRequest.Size(m) |
| } |
| func (m *CallServoXmlRpcRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_CallServoXmlRpcRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CallServoXmlRpcRequest proto.InternalMessageInfo |
| |
| func (m *CallServoXmlRpcRequest) GetDut() string { |
| if m != nil { |
| return m.Dut |
| } |
| return "" |
| } |
| |
| func (m *CallServoXmlRpcRequest) GetMethod() string { |
| if m != nil { |
| return m.Method |
| } |
| return "" |
| } |
| |
| func (m *CallServoXmlRpcRequest) GetArgs() []*xmlrpc.Value { |
| if m != nil { |
| return m.Args |
| } |
| return nil |
| } |
| |
| type CallServoXmlRpcResponse struct { |
| Status CallServoXmlRpcResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=tls.CallServoXmlRpcResponse_Status" json:"status,omitempty"` |
| Value *xmlrpc.Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` |
| // fault indicates that the servo XML-RPC returned a fault. |
| // The fault value is stored in the value field. |
| Fault bool `protobuf:"varint,3,opt,name=fault,proto3" json:"fault,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *CallServoXmlRpcResponse) Reset() { *m = CallServoXmlRpcResponse{} } |
| func (m *CallServoXmlRpcResponse) String() string { return proto.CompactTextString(m) } |
| func (*CallServoXmlRpcResponse) ProtoMessage() {} |
| func (*CallServoXmlRpcResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_aaa1c187e104f1c4, []int{7} |
| } |
| |
| func (m *CallServoXmlRpcResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_CallServoXmlRpcResponse.Unmarshal(m, b) |
| } |
| func (m *CallServoXmlRpcResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_CallServoXmlRpcResponse.Marshal(b, m, deterministic) |
| } |
| func (m *CallServoXmlRpcResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_CallServoXmlRpcResponse.Merge(m, src) |
| } |
| func (m *CallServoXmlRpcResponse) XXX_Size() int { |
| return xxx_messageInfo_CallServoXmlRpcResponse.Size(m) |
| } |
| func (m *CallServoXmlRpcResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_CallServoXmlRpcResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_CallServoXmlRpcResponse proto.InternalMessageInfo |
| |
| func (m *CallServoXmlRpcResponse) GetStatus() CallServoXmlRpcResponse_Status { |
| if m != nil { |
| return m.Status |
| } |
| return CallServoXmlRpcResponse_STATUS_UNKNOWN |
| } |
| |
| func (m *CallServoXmlRpcResponse) GetValue() *xmlrpc.Value { |
| if m != nil { |
| return m.Value |
| } |
| return nil |
| } |
| |
| func (m *CallServoXmlRpcResponse) GetFault() bool { |
| if m != nil { |
| return m.Fault |
| } |
| return false |
| } |
| |
| func init() { |
| proto.RegisterEnum("tls.OpenDutPortResponse_Status", OpenDutPortResponse_Status_name, OpenDutPortResponse_Status_value) |
| proto.RegisterEnum("tls.SetDutPowerSupplyRequest_State", SetDutPowerSupplyRequest_State_name, SetDutPowerSupplyRequest_State_value) |
| proto.RegisterEnum("tls.SetDutPowerSupplyResponse_Status", SetDutPowerSupplyResponse_Status_name, SetDutPowerSupplyResponse_Status_value) |
| proto.RegisterEnum("tls.CacheForDutResponse_Status", CacheForDutResponse_Status_name, CacheForDutResponse_Status_value) |
| proto.RegisterEnum("tls.CallServoXmlRpcResponse_Status", CallServoXmlRpcResponse_Status_name, CallServoXmlRpcResponse_Status_value) |
| proto.RegisterType((*OpenDutPortRequest)(nil), "tls.OpenDutPortRequest") |
| proto.RegisterType((*OpenDutPortResponse)(nil), "tls.OpenDutPortResponse") |
| proto.RegisterType((*SetDutPowerSupplyRequest)(nil), "tls.SetDutPowerSupplyRequest") |
| proto.RegisterType((*SetDutPowerSupplyResponse)(nil), "tls.SetDutPowerSupplyResponse") |
| proto.RegisterType((*CacheForDutRequest)(nil), "tls.CacheForDutRequest") |
| proto.RegisterType((*CacheForDutResponse)(nil), "tls.CacheForDutResponse") |
| proto.RegisterType((*CallServoXmlRpcRequest)(nil), "tls.CallServoXmlRpcRequest") |
| proto.RegisterType((*CallServoXmlRpcResponse)(nil), "tls.CallServoXmlRpcResponse") |
| } |
| |
| func init() { proto.RegisterFile("tls/wiring.proto", fileDescriptor_aaa1c187e104f1c4) } |
| |
| var fileDescriptor_aaa1c187e104f1c4 = []byte{ |
| // 728 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xdd, 0x4e, 0xdb, 0x48, |
| 0x14, 0x5e, 0xdb, 0x49, 0x80, 0xc3, 0x02, 0xc3, 0x04, 0x85, 0x90, 0xfd, 0x63, 0x8d, 0x76, 0xc5, |
| 0xcd, 0xc6, 0xab, 0xec, 0x05, 0x5a, 0x55, 0x95, 0x9a, 0x1f, 0x47, 0x20, 0x88, 0x4d, 0xc7, 0x36, |
| 0x54, 0xed, 0x85, 0xe5, 0x26, 0x43, 0x48, 0xe5, 0xc4, 0xee, 0x78, 0x0c, 0xed, 0x5d, 0xd5, 0x87, |
| 0xe8, 0x75, 0x1f, 0xa1, 0x2f, 0xd4, 0xbb, 0xbe, 0x42, 0xef, 0xab, 0x8c, 0x9d, 0x62, 0xf2, 0x27, |
| 0x55, 0x5c, 0x25, 0xe7, 0xcc, 0x99, 0xf3, 0xf3, 0x7d, 0xdf, 0x1c, 0x03, 0xe2, 0x7e, 0xa4, 0xdd, |
| 0x0e, 0xd8, 0x60, 0xd4, 0xaf, 0x86, 0x2c, 0xe0, 0x01, 0x56, 0xb8, 0x1f, 0x55, 0x8a, 0x6f, 0x86, |
| 0x3e, 0x0b, 0xbb, 0x5a, 0xf2, 0x93, 0x9c, 0xa8, 0x75, 0xc0, 0x66, 0x48, 0x47, 0xad, 0x98, 0x9f, |
| 0x07, 0x8c, 0x13, 0xfa, 0x3a, 0xa6, 0x11, 0xc7, 0x08, 0x94, 0x5e, 0xcc, 0xcb, 0xd2, 0xbe, 0x74, |
| 0xb8, 0x46, 0xc6, 0x7f, 0xf1, 0x1e, 0xac, 0xf6, 0x62, 0xee, 0x86, 0x01, 0xe3, 0x65, 0x79, 0x5f, |
| 0x3a, 0xcc, 0x93, 0x95, 0x5e, 0x72, 0x47, 0xfd, 0x2c, 0x41, 0xf1, 0x5e, 0x8e, 0x28, 0x0c, 0x46, |
| 0x11, 0xc5, 0x47, 0x50, 0x88, 0xb8, 0xc7, 0xe3, 0x48, 0xe4, 0xd9, 0xac, 0xfd, 0x51, 0xe5, 0x7e, |
| 0x54, 0x9d, 0x13, 0x59, 0xb5, 0x44, 0x18, 0x49, 0xc3, 0x71, 0x19, 0x56, 0xbc, 0x5e, 0x8f, 0xd1, |
| 0x28, 0x12, 0xa5, 0xd6, 0xc8, 0xc4, 0xc4, 0x25, 0x28, 0x30, 0xea, 0x45, 0xc1, 0xa8, 0xac, 0x88, |
| 0x83, 0xd4, 0x52, 0x5f, 0x40, 0x21, 0xc9, 0x81, 0x31, 0x6c, 0x5a, 0x76, 0xdd, 0x76, 0x2c, 0xd7, |
| 0x31, 0x4e, 0x0d, 0xf3, 0xd2, 0x40, 0x3f, 0xe1, 0x0d, 0x58, 0x4b, 0x7d, 0xe6, 0x29, 0x92, 0x32, |
| 0x21, 0x8d, 0x7a, 0xcb, 0x6d, 0x39, 0x36, 0x92, 0x71, 0x05, 0x4a, 0xa9, 0xaf, 0xe5, 0xd8, 0xae, |
| 0x63, 0x10, 0xbd, 0xde, 0x3c, 0xae, 0x37, 0xce, 0x74, 0xa4, 0xa8, 0x1f, 0x25, 0x28, 0x5b, 0x94, |
| 0x8b, 0xa6, 0x6f, 0x29, 0xb3, 0xe2, 0x30, 0xf4, 0xdf, 0x2e, 0x46, 0xea, 0x7f, 0xc8, 0x8f, 0xe7, |
| 0xa0, 0xa2, 0xf7, 0xcd, 0xda, 0x81, 0x98, 0x7a, 0xd1, 0x7d, 0x31, 0x3a, 0x25, 0xc9, 0x0d, 0xf5, |
| 0x08, 0xf2, 0xc2, 0xc6, 0xdb, 0xb0, 0x31, 0x6e, 0x47, 0xcf, 0x0c, 0xf1, 0x33, 0xac, 0x26, 0x2e, |
| 0xd3, 0x40, 0xd2, 0x64, 0x24, 0xdd, 0x35, 0xdb, 0x6d, 0x24, 0xab, 0x5f, 0x25, 0xd8, 0x9b, 0x53, |
| 0x22, 0x25, 0xe2, 0xf1, 0x14, 0x11, 0x7f, 0x2d, 0x6a, 0x69, 0x3e, 0x1d, 0x77, 0xa0, 0xcb, 0xf7, |
| 0x40, 0x7f, 0x27, 0x3d, 0x14, 0xf5, 0x12, 0xe0, 0x8c, 0x8f, 0xe8, 0x4f, 0x1d, 0xdd, 0xb2, 0x91, |
| 0x32, 0x19, 0xdf, 0xb1, 0x5c, 0xc3, 0x74, 0xc9, 0x79, 0x07, 0xe5, 0xf0, 0x0e, 0xa0, 0xd4, 0x45, |
| 0xce, 0x3b, 0xae, 0x4e, 0x88, 0x49, 0x50, 0x5e, 0xfd, 0x1b, 0x70, 0xd3, 0xeb, 0x5e, 0xd3, 0x76, |
| 0xc0, 0x5a, 0x71, 0x56, 0xbd, 0x31, 0xf3, 0x27, 0x9c, 0xc4, 0xcc, 0x57, 0xbf, 0x48, 0x50, 0xbc, |
| 0x17, 0xb8, 0x54, 0xa2, 0x73, 0x22, 0xa7, 0x31, 0x49, 0x4b, 0xc8, 0xdf, 0x4b, 0x2c, 0x94, 0xe6, |
| 0xab, 0x1f, 0x01, 0xa9, 0x08, 0x5b, 0xa9, 0xd9, 0x34, 0x0d, 0xfb, 0xc4, 0x70, 0x74, 0x24, 0x67, |
| 0x46, 0x37, 0x4c, 0xdb, 0x6d, 0x9b, 0x8e, 0xd1, 0x42, 0x4a, 0x26, 0x9b, 0x7d, 0xd2, 0xd1, 0x4d, |
| 0xc7, 0x46, 0x39, 0x95, 0x42, 0xa9, 0xe9, 0xf9, 0xbe, 0x45, 0xd9, 0x4d, 0xf0, 0x6c, 0xe8, 0x93, |
| 0xb0, 0xbb, 0x58, 0xa6, 0x25, 0x28, 0x0c, 0x29, 0xbf, 0x0e, 0x7a, 0x13, 0x56, 0x13, 0x0b, 0xff, |
| 0x09, 0x39, 0x8f, 0xf5, 0xa3, 0xb2, 0xb2, 0xaf, 0x1c, 0xae, 0xd7, 0x36, 0xaa, 0xe9, 0xb6, 0xb8, |
| 0xf0, 0xfc, 0x98, 0x12, 0x71, 0xa4, 0x7e, 0x90, 0x61, 0x77, 0xa6, 0x4e, 0x8a, 0xe8, 0xa3, 0x29, |
| 0x44, 0x0f, 0x52, 0x44, 0xe7, 0x46, 0x4f, 0xa3, 0x7a, 0x00, 0xf9, 0x9b, 0x71, 0x1d, 0xd1, 0xd2, |
| 0x4c, 0xf1, 0xe4, 0x0c, 0xef, 0x40, 0xfe, 0xca, 0x8b, 0x7d, 0x2e, 0x70, 0x5e, 0x25, 0x89, 0xa1, |
| 0xbe, 0x7f, 0xb0, 0x18, 0xb3, 0x30, 0xbb, 0x1d, 0xdd, 0x3e, 0x36, 0xc7, 0x30, 0xdf, 0x31, 0x62, |
| 0x98, 0xae, 0xa5, 0x93, 0x0b, 0x13, 0xe5, 0x32, 0xba, 0x15, 0x9e, 0x89, 0x1c, 0x6b, 0x9f, 0x64, |
| 0x28, 0x5c, 0x8a, 0xbd, 0x8b, 0x9f, 0xc0, 0x7a, 0x66, 0xd3, 0xe1, 0xdd, 0xd9, 0xdd, 0x27, 0x88, |
| 0xa9, 0x94, 0x17, 0x2d, 0x45, 0x4c, 0x60, 0x7b, 0xe6, 0x89, 0xe2, 0xdf, 0x96, 0x6e, 0x93, 0xca, |
| 0xef, 0xcb, 0x5f, 0x36, 0x6e, 0xc0, 0x7a, 0x46, 0xdc, 0x69, 0x57, 0xb3, 0x2f, 0x28, 0xed, 0x6a, |
| 0xce, 0x3b, 0xf8, 0x57, 0xc2, 0x67, 0xb0, 0x35, 0x45, 0x27, 0xfe, 0x65, 0x3e, 0xc9, 0x49, 0xae, |
| 0x5f, 0x97, 0x29, 0xa0, 0xa1, 0x3d, 0xff, 0xa7, 0x1f, 0x54, 0xbb, 0xd7, 0x2c, 0x18, 0x0e, 0xe2, |
| 0x61, 0x35, 0x60, 0x7d, 0x6d, 0x62, 0x04, 0x91, 0x36, 0x18, 0x5d, 0x31, 0x4f, 0x13, 0x5f, 0x2a, |
| 0xad, 0x1f, 0x68, 0xdc, 0x8f, 0x5e, 0x16, 0x84, 0xf5, 0xdf, 0xb7, 0x00, 0x00, 0x00, 0xff, 0xff, |
| 0xc3, 0x60, 0xc8, 0x50, 0xe5, 0x06, 0x00, 0x00, |
| } |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ context.Context |
| var _ grpc.ClientConn |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the grpc package it is being compiled against. |
| const _ = grpc.SupportPackageIsVersion4 |
| |
| // WiringClient is the client API for Wiring service. |
| // |
| // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. |
| type WiringClient interface { |
| // Open a port on the DUT for the caller. |
| // The TLE attempts to keep this port open for the duration of the |
| // RTD's runtime. |
| // This RPC can be called repeatedly for the same RTD, DUT, and port. |
| // On subsequent calls, the implementation should attempt to return the same address. |
| // If the implementation lost and cannot reobtain the previous |
| // address, it should return a new address. |
| OpenDutPort(ctx context.Context, in *OpenDutPortRequest, opts ...grpc.CallOption) (*OpenDutPortResponse, error) |
| // SetDutPowerSupply sets the connected power state for the DUT. It is |
| // the caller's responsibility to wait for the effects of the call |
| // to propagate, e.g. waiting in between calls to set the power OFF |
| // and ON. |
| SetDutPowerSupply(ctx context.Context, in *SetDutPowerSupplyRequest, opts ...grpc.CallOption) (*SetDutPowerSupplyResponse, error) |
| // CacheForDut caches some data to be accesible for the DUT. |
| // This will be made available to the DUT via a returned URL. |
| // The service will periodically return STATUS_CONTINUE messages to keep the stream alive. |
| // Implementations should use a reasonable interval (e.g., one minute) |
| // to ensure the stream does not time out. |
| // The client should continue streaming replies until getting success or failure. |
| // |
| // Experimental |
| CacheForDut(ctx context.Context, in *CacheForDutRequest, opts ...grpc.CallOption) (Wiring_CacheForDutClient, error) |
| // CallServoXmlRpc performs an XML-RPC call against the servo connected to a DUT. |
| // |
| // This RPC mirrors the XML-RPC specification (http://xmlrpc.com/spec.md). |
| // |
| // Experimental |
| CallServoXmlRpc(ctx context.Context, in *CallServoXmlRpcRequest, opts ...grpc.CallOption) (*CallServoXmlRpcResponse, error) |
| } |
| |
| type wiringClient struct { |
| cc *grpc.ClientConn |
| } |
| |
| func NewWiringClient(cc *grpc.ClientConn) WiringClient { |
| return &wiringClient{cc} |
| } |
| |
| func (c *wiringClient) OpenDutPort(ctx context.Context, in *OpenDutPortRequest, opts ...grpc.CallOption) (*OpenDutPortResponse, error) { |
| out := new(OpenDutPortResponse) |
| err := c.cc.Invoke(ctx, "/tls.Wiring/OpenDutPort", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *wiringClient) SetDutPowerSupply(ctx context.Context, in *SetDutPowerSupplyRequest, opts ...grpc.CallOption) (*SetDutPowerSupplyResponse, error) { |
| out := new(SetDutPowerSupplyResponse) |
| err := c.cc.Invoke(ctx, "/tls.Wiring/SetDutPowerSupply", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *wiringClient) CacheForDut(ctx context.Context, in *CacheForDutRequest, opts ...grpc.CallOption) (Wiring_CacheForDutClient, error) { |
| stream, err := c.cc.NewStream(ctx, &_Wiring_serviceDesc.Streams[0], "/tls.Wiring/CacheForDut", opts...) |
| if err != nil { |
| return nil, err |
| } |
| x := &wiringCacheForDutClient{stream} |
| if err := x.ClientStream.SendMsg(in); err != nil { |
| return nil, err |
| } |
| if err := x.ClientStream.CloseSend(); err != nil { |
| return nil, err |
| } |
| return x, nil |
| } |
| |
| type Wiring_CacheForDutClient interface { |
| Recv() (*CacheForDutResponse, error) |
| grpc.ClientStream |
| } |
| |
| type wiringCacheForDutClient struct { |
| grpc.ClientStream |
| } |
| |
| func (x *wiringCacheForDutClient) Recv() (*CacheForDutResponse, error) { |
| m := new(CacheForDutResponse) |
| if err := x.ClientStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| func (c *wiringClient) CallServoXmlRpc(ctx context.Context, in *CallServoXmlRpcRequest, opts ...grpc.CallOption) (*CallServoXmlRpcResponse, error) { |
| out := new(CallServoXmlRpcResponse) |
| err := c.cc.Invoke(ctx, "/tls.Wiring/CallServoXmlRpc", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| // WiringServer is the server API for Wiring service. |
| type WiringServer interface { |
| // Open a port on the DUT for the caller. |
| // The TLE attempts to keep this port open for the duration of the |
| // RTD's runtime. |
| // This RPC can be called repeatedly for the same RTD, DUT, and port. |
| // On subsequent calls, the implementation should attempt to return the same address. |
| // If the implementation lost and cannot reobtain the previous |
| // address, it should return a new address. |
| OpenDutPort(context.Context, *OpenDutPortRequest) (*OpenDutPortResponse, error) |
| // SetDutPowerSupply sets the connected power state for the DUT. It is |
| // the caller's responsibility to wait for the effects of the call |
| // to propagate, e.g. waiting in between calls to set the power OFF |
| // and ON. |
| SetDutPowerSupply(context.Context, *SetDutPowerSupplyRequest) (*SetDutPowerSupplyResponse, error) |
| // CacheForDut caches some data to be accesible for the DUT. |
| // This will be made available to the DUT via a returned URL. |
| // The service will periodically return STATUS_CONTINUE messages to keep the stream alive. |
| // Implementations should use a reasonable interval (e.g., one minute) |
| // to ensure the stream does not time out. |
| // The client should continue streaming replies until getting success or failure. |
| // |
| // Experimental |
| CacheForDut(*CacheForDutRequest, Wiring_CacheForDutServer) error |
| // CallServoXmlRpc performs an XML-RPC call against the servo connected to a DUT. |
| // |
| // This RPC mirrors the XML-RPC specification (http://xmlrpc.com/spec.md). |
| // |
| // Experimental |
| CallServoXmlRpc(context.Context, *CallServoXmlRpcRequest) (*CallServoXmlRpcResponse, error) |
| } |
| |
| // UnimplementedWiringServer can be embedded to have forward compatible implementations. |
| type UnimplementedWiringServer struct { |
| } |
| |
| func (*UnimplementedWiringServer) OpenDutPort(ctx context.Context, req *OpenDutPortRequest) (*OpenDutPortResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method OpenDutPort not implemented") |
| } |
| func (*UnimplementedWiringServer) SetDutPowerSupply(ctx context.Context, req *SetDutPowerSupplyRequest) (*SetDutPowerSupplyResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method SetDutPowerSupply not implemented") |
| } |
| func (*UnimplementedWiringServer) CacheForDut(req *CacheForDutRequest, srv Wiring_CacheForDutServer) error { |
| return status.Errorf(codes.Unimplemented, "method CacheForDut not implemented") |
| } |
| func (*UnimplementedWiringServer) CallServoXmlRpc(ctx context.Context, req *CallServoXmlRpcRequest) (*CallServoXmlRpcResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method CallServoXmlRpc not implemented") |
| } |
| |
| func RegisterWiringServer(s *grpc.Server, srv WiringServer) { |
| s.RegisterService(&_Wiring_serviceDesc, srv) |
| } |
| |
| func _Wiring_OpenDutPort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(OpenDutPortRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(WiringServer).OpenDutPort(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/tls.Wiring/OpenDutPort", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(WiringServer).OpenDutPort(ctx, req.(*OpenDutPortRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _Wiring_SetDutPowerSupply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(SetDutPowerSupplyRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(WiringServer).SetDutPowerSupply(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/tls.Wiring/SetDutPowerSupply", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(WiringServer).SetDutPowerSupply(ctx, req.(*SetDutPowerSupplyRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _Wiring_CacheForDut_Handler(srv interface{}, stream grpc.ServerStream) error { |
| m := new(CacheForDutRequest) |
| if err := stream.RecvMsg(m); err != nil { |
| return err |
| } |
| return srv.(WiringServer).CacheForDut(m, &wiringCacheForDutServer{stream}) |
| } |
| |
| type Wiring_CacheForDutServer interface { |
| Send(*CacheForDutResponse) error |
| grpc.ServerStream |
| } |
| |
| type wiringCacheForDutServer struct { |
| grpc.ServerStream |
| } |
| |
| func (x *wiringCacheForDutServer) Send(m *CacheForDutResponse) error { |
| return x.ServerStream.SendMsg(m) |
| } |
| |
| func _Wiring_CallServoXmlRpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(CallServoXmlRpcRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(WiringServer).CallServoXmlRpc(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/tls.Wiring/CallServoXmlRpc", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(WiringServer).CallServoXmlRpc(ctx, req.(*CallServoXmlRpcRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| var _Wiring_serviceDesc = grpc.ServiceDesc{ |
| ServiceName: "tls.Wiring", |
| HandlerType: (*WiringServer)(nil), |
| Methods: []grpc.MethodDesc{ |
| { |
| MethodName: "OpenDutPort", |
| Handler: _Wiring_OpenDutPort_Handler, |
| }, |
| { |
| MethodName: "SetDutPowerSupply", |
| Handler: _Wiring_SetDutPowerSupply_Handler, |
| }, |
| { |
| MethodName: "CallServoXmlRpc", |
| Handler: _Wiring_CallServoXmlRpc_Handler, |
| }, |
| }, |
| Streams: []grpc.StreamDesc{ |
| { |
| StreamName: "CacheForDut", |
| Handler: _Wiring_CacheForDut_Handler, |
| ServerStreams: true, |
| }, |
| }, |
| Metadata: "tls/wiring.proto", |
| } |