| // 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 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 { |
| // name is the resource name for the DUT. |
| // The DUT name is passed to the RTD when the RTD is started. |
| // It is not specified whether the name is the DUT hostname. |
| Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| // port is the port to open on the DUT. |
| Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"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) GetName() string { |
| if m != nil { |
| return m.Name |
| } |
| return "" |
| } |
| |
| func (m *OpenDutPortRequest) GetPort() int32 { |
| if m != nil { |
| return m.Port |
| } |
| return 0 |
| } |
| |
| type OpenDutPortResponse struct { |
| // address for which a port is forwarded to the DUT. |
| // TLEs SHOULD return an IPv4 or IPv6 address to avoid name |
| // resolution issues. |
| // IPv4 addresses MUST be in standard dotted decimal notation. |
| // IPv6 addresses MUST be formatted according to RFC4291, Section |
| // 2.2. The mixed IPv4 and IPv6 form MUST NOT be used. |
| // If TLEs return a hostname, they SHOULD ensure that the hostname |
| // can be resolved by the RTD via standard name resolution |
| // facilities. |
| Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` |
| // port on the address which is forwarded to the DUT. |
| Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,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) GetAddress() string { |
| if m != nil { |
| return m.Address |
| } |
| return "" |
| } |
| |
| func (m *OpenDutPortResponse) GetPort() int32 { |
| if m != nil { |
| return m.Port |
| } |
| return 0 |
| } |
| |
| 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.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{ |
| // 699 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xdd, 0x6e, 0xd3, 0x4a, |
| 0x10, 0x3e, 0xce, 0xdf, 0x69, 0xa7, 0xa7, 0xed, 0x76, 0x53, 0xa5, 0x39, 0xe5, 0xaf, 0xb8, 0x02, |
| 0xf5, 0x86, 0x18, 0x85, 0x8b, 0x0a, 0x01, 0x12, 0x6d, 0xe2, 0x88, 0xaa, 0xc4, 0x2e, 0x6b, 0xbb, |
| 0x45, 0xdc, 0x58, 0x26, 0xd9, 0xa6, 0x41, 0x4e, 0x6c, 0x76, 0xd7, 0x2d, 0xdc, 0x21, 0x1e, 0x82, |
| 0x6b, 0x1e, 0x81, 0x87, 0xe2, 0x15, 0xb8, 0x47, 0x59, 0xaf, 0xc1, 0x4d, 0xd2, 0x4a, 0x88, 0xab, |
| 0xf8, 0x9b, 0x9d, 0x9d, 0xf9, 0xe6, 0x9b, 0x99, 0x0d, 0x20, 0x11, 0x72, 0xe3, 0x62, 0xc8, 0x86, |
| 0xe3, 0x41, 0x23, 0x66, 0x91, 0x88, 0x70, 0x51, 0x84, 0x7c, 0xb3, 0xfa, 0x61, 0x14, 0xb2, 0xb8, |
| 0x67, 0xa4, 0x3f, 0xe9, 0x89, 0xfe, 0x14, 0xb0, 0x1d, 0xd3, 0x71, 0x3b, 0x11, 0x47, 0x11, 0x13, |
| 0x84, 0xbe, 0x4f, 0x28, 0x17, 0x18, 0x43, 0x69, 0x1c, 0x8c, 0x68, 0x5d, 0xdb, 0xd2, 0x76, 0x16, |
| 0x89, 0xfc, 0x9e, 0xd8, 0xe2, 0x88, 0x89, 0x7a, 0x61, 0x4b, 0xdb, 0x29, 0x13, 0xf9, 0xad, 0xb7, |
| 0xa0, 0x7a, 0xe9, 0x36, 0x8f, 0xa3, 0x31, 0xa7, 0xb8, 0x0e, 0xff, 0x06, 0xfd, 0x3e, 0xa3, 0x9c, |
| 0xab, 0x08, 0x19, 0x9c, 0x1b, 0xe4, 0xab, 0x06, 0x75, 0x87, 0x0a, 0x19, 0xe4, 0x82, 0x32, 0x27, |
| 0x89, 0xe3, 0xf0, 0x63, 0xc6, 0x04, 0x41, 0xb1, 0x9f, 0x08, 0x15, 0x66, 0xf2, 0x89, 0x1f, 0x43, |
| 0x99, 0x8b, 0x40, 0x50, 0x19, 0x63, 0xa5, 0xb9, 0xdd, 0x10, 0x21, 0x6f, 0x5c, 0x75, 0xbf, 0xe1, |
| 0x4c, 0x5c, 0x49, 0x7a, 0x43, 0xdf, 0x85, 0xb2, 0xc4, 0x78, 0x0d, 0x96, 0x1d, 0x77, 0xcf, 0x35, |
| 0x7d, 0xcf, 0x3a, 0xb4, 0xec, 0x13, 0x0b, 0xfd, 0x83, 0xff, 0x83, 0x85, 0xd4, 0x64, 0x5b, 0x48, |
| 0xc3, 0xcb, 0xb0, 0xa8, 0x50, 0xa7, 0x83, 0x0a, 0xfa, 0x0f, 0x0d, 0xfe, 0x9f, 0x93, 0x42, 0x95, |
| 0xfb, 0x0c, 0x2a, 0x93, 0xf8, 0x49, 0x5a, 0xed, 0x4a, 0xf3, 0xde, 0x55, 0x94, 0x52, 0x7f, 0xc9, |
| 0x29, 0xe1, 0x44, 0x5d, 0xc2, 0x35, 0xa8, 0x30, 0x1a, 0xf0, 0x68, 0x2c, 0x2b, 0x5a, 0x24, 0x0a, |
| 0xe9, 0x9f, 0x34, 0xa8, 0xa4, 0xae, 0x18, 0xc3, 0xca, 0x84, 0x8e, 0xe7, 0xe4, 0x08, 0x2b, 0x8a, |
| 0x9e, 0xe3, 0xdb, 0x87, 0x48, 0xcb, 0xb9, 0xec, 0xef, 0xb5, 0xfd, 0xb6, 0xe7, 0xa2, 0x02, 0xae, |
| 0x01, 0xce, 0xd9, 0x88, 0xf9, 0xca, 0x33, 0x1d, 0x17, 0x15, 0xb3, 0xf2, 0x3d, 0xc7, 0xb7, 0x6c, |
| 0x9f, 0x1c, 0x75, 0x51, 0x09, 0xaf, 0x03, 0x52, 0x26, 0x72, 0xd4, 0xf5, 0x4d, 0x42, 0x6c, 0x82, |
| 0xca, 0xfa, 0x7d, 0xc0, 0xad, 0xa0, 0x77, 0x46, 0x3b, 0x11, 0x6b, 0x27, 0x22, 0xd7, 0x93, 0x84, |
| 0x85, 0x59, 0x4f, 0x12, 0x16, 0xea, 0xdf, 0x35, 0xa8, 0x5e, 0x72, 0x54, 0xca, 0xec, 0x4e, 0x29, |
| 0x73, 0x47, 0x2a, 0x33, 0xc7, 0x73, 0x5a, 0x13, 0x95, 0xa2, 0xf0, 0x2b, 0x45, 0x4e, 0xa5, 0xe2, |
| 0x25, 0x95, 0xde, 0xfd, 0x89, 0x48, 0x55, 0x58, 0x55, 0xb0, 0x65, 0x5b, 0xee, 0x81, 0xe5, 0x99, |
| 0xa8, 0x90, 0x2b, 0xdd, 0xb2, 0x5d, 0xbf, 0x63, 0x7b, 0x56, 0x1b, 0x15, 0x73, 0xd1, 0xdc, 0x83, |
| 0xae, 0x69, 0x7b, 0x2e, 0x2a, 0xe9, 0x14, 0x6a, 0xad, 0x20, 0x0c, 0x1d, 0xca, 0xce, 0xa3, 0xd7, |
| 0xa3, 0x90, 0xc4, 0xbd, 0xab, 0xc7, 0xb4, 0x06, 0x95, 0x11, 0x15, 0x67, 0x51, 0x3f, 0xeb, 0x6a, |
| 0x8a, 0xf0, 0x5d, 0x28, 0x05, 0x6c, 0xc0, 0xeb, 0xc5, 0xad, 0xe2, 0xce, 0x52, 0x73, 0xb9, 0xa1, |
| 0xb6, 0xf1, 0x38, 0x08, 0x13, 0x4a, 0xe4, 0x91, 0xfe, 0xa5, 0x00, 0x1b, 0x33, 0x79, 0x94, 0xa2, |
| 0x4f, 0xa6, 0x14, 0xdd, 0x56, 0x8a, 0xce, 0xf5, 0x9e, 0x56, 0x75, 0x1b, 0xca, 0xe7, 0x93, 0x3c, |
| 0x92, 0xd2, 0x4c, 0xf2, 0xf4, 0x0c, 0xaf, 0x43, 0xf9, 0x34, 0x48, 0x42, 0x21, 0x75, 0x5e, 0x20, |
| 0x29, 0xd0, 0x3f, 0xff, 0xf5, 0x30, 0xe6, 0x65, 0xf6, 0xbb, 0xa6, 0xfb, 0xc2, 0x9e, 0xc8, 0xfc, |
| 0xbb, 0x23, 0x96, 0xed, 0x3b, 0x26, 0x39, 0xb6, 0x51, 0x29, 0x37, 0xb7, 0xd2, 0x92, 0x8d, 0x63, |
| 0xf3, 0x5b, 0x01, 0x2a, 0x27, 0xf2, 0x5d, 0xc3, 0xcf, 0x61, 0x29, 0xf7, 0xf2, 0xe0, 0x0d, 0x29, |
| 0xc3, 0xec, 0x4b, 0xb6, 0x59, 0x9f, 0x3d, 0x50, 0x4a, 0x12, 0x58, 0x9b, 0x59, 0x51, 0x7c, 0xeb, |
| 0xda, 0xd7, 0x64, 0xf3, 0xf6, 0xf5, 0x9b, 0x8d, 0xf7, 0x61, 0x29, 0x37, 0xdc, 0x8a, 0xd5, 0xec, |
| 0x06, 0x29, 0x56, 0x73, 0xf6, 0xe0, 0xa1, 0x86, 0x5f, 0xc2, 0xea, 0x54, 0x3b, 0xf1, 0x8d, 0xf9, |
| 0x4d, 0x4e, 0x63, 0xdd, 0xbc, 0x6e, 0x02, 0xf6, 0x8d, 0x37, 0x0f, 0x06, 0x51, 0xa3, 0x77, 0xc6, |
| 0xa2, 0xd1, 0x30, 0x19, 0x35, 0x22, 0x36, 0x30, 0x32, 0x10, 0x71, 0x63, 0x38, 0x3e, 0x65, 0x81, |
| 0x21, 0xff, 0x09, 0x8c, 0x41, 0x64, 0x88, 0x90, 0xbf, 0xad, 0x48, 0xf4, 0xe8, 0x67, 0x00, 0x00, |
| 0x00, 0xff, 0xff, 0x3e, 0x89, 0x6e, 0x31, 0x45, 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 and return an address which the client can |
| // use to connect to the port on the DUT. |
| // The TLE SHOULD attempt to keep this address-to-port connection open for |
| // the duration of the RTD's runtime. |
| // The connection is not restarted if it is interrupted. |
| // |
| // If the connection from a previous call with the same arguments is |
| // still open, this RPC SHOULD do nothing and return the same |
| // response. |
| // If the previous connection was closed, the implementation SHOULD |
| // attempt to rebind and return the same address. |
| // If the implementation lost and cannot reobtain the previous |
| // address, it MAY return a new address. |
| // |
| // This RPC does NOT ensure that there is a service running on the |
| // DUT for the given port. |
| // A service running on the given port MUST NOT required for this RPC |
| // to succeed. |
| // It is not specified whether this RPC will open the given port in |
| // the DUT's firewall, if the DUT has a firewall. |
| 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. |
| // |
| // EXPERIMENTAL |
| 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 and return an address which the client can |
| // use to connect to the port on the DUT. |
| // The TLE SHOULD attempt to keep this address-to-port connection open for |
| // the duration of the RTD's runtime. |
| // The connection is not restarted if it is interrupted. |
| // |
| // If the connection from a previous call with the same arguments is |
| // still open, this RPC SHOULD do nothing and return the same |
| // response. |
| // If the previous connection was closed, the implementation SHOULD |
| // attempt to rebind and return the same address. |
| // If the implementation lost and cannot reobtain the previous |
| // address, it MAY return a new address. |
| // |
| // This RPC does NOT ensure that there is a service running on the |
| // DUT for the given port. |
| // A service running on the given port MUST NOT required for this RPC |
| // to succeed. |
| // It is not specified whether this RPC will open the given port in |
| // the DUT's firewall, if the DUT has a firewall. |
| 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. |
| // |
| // EXPERIMENTAL |
| 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", |
| } |