traefik/vendor/github.com/mesos/mesos-go/mesosproto/scheduler.pb.go
2017-03-09 13:13:02 +01:00

7176 lines
172 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Code generated by protoc-gen-gogo.
// source: scheduler.proto
// DO NOT EDIT!
package mesosproto
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto"
import bytes "bytes"
import strings "strings"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import sort "sort"
import strconv "strconv"
import reflect "reflect"
import io "io"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Possible event types, followed by message definitions if
// applicable.
type Event_Type int32
const (
Event_SUBSCRIBED Event_Type = 1
Event_OFFERS Event_Type = 2
Event_RESCIND Event_Type = 3
Event_UPDATE Event_Type = 4
Event_MESSAGE Event_Type = 5
Event_FAILURE Event_Type = 6
Event_ERROR Event_Type = 7
// Periodic message sent by the Mesos master according to
// 'Subscribed.heartbeat_interval_seconds'. If the scheduler does
// not receive any events (including heartbeats) for an extended
// period of time (e.g., 5 x heartbeat_interval_seconds), there is
// likely a network partition. In such a case the scheduler should
// close the existing subscription connection and resubscribe
// using a backoff strategy.
Event_HEARTBEAT Event_Type = 8
)
var Event_Type_name = map[int32]string{
1: "SUBSCRIBED",
2: "OFFERS",
3: "RESCIND",
4: "UPDATE",
5: "MESSAGE",
6: "FAILURE",
7: "ERROR",
8: "HEARTBEAT",
}
var Event_Type_value = map[string]int32{
"SUBSCRIBED": 1,
"OFFERS": 2,
"RESCIND": 3,
"UPDATE": 4,
"MESSAGE": 5,
"FAILURE": 6,
"ERROR": 7,
"HEARTBEAT": 8,
}
func (x Event_Type) Enum() *Event_Type {
p := new(Event_Type)
*p = x
return p
}
func (x Event_Type) String() string {
return proto.EnumName(Event_Type_name, int32(x))
}
func (x *Event_Type) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Event_Type_value, data, "Event_Type")
if err != nil {
return err
}
*x = Event_Type(value)
return nil
}
// Possible call types, followed by message definitions if
// applicable.
type Call_Type int32
const (
Call_SUBSCRIBE Call_Type = 1
Call_TEARDOWN Call_Type = 2
Call_ACCEPT Call_Type = 3
Call_DECLINE Call_Type = 4
Call_REVIVE Call_Type = 5
Call_KILL Call_Type = 6
Call_SHUTDOWN Call_Type = 7
Call_ACKNOWLEDGE Call_Type = 8
Call_RECONCILE Call_Type = 9
Call_MESSAGE Call_Type = 10
Call_REQUEST Call_Type = 11
)
var Call_Type_name = map[int32]string{
1: "SUBSCRIBE",
2: "TEARDOWN",
3: "ACCEPT",
4: "DECLINE",
5: "REVIVE",
6: "KILL",
7: "SHUTDOWN",
8: "ACKNOWLEDGE",
9: "RECONCILE",
10: "MESSAGE",
11: "REQUEST",
}
var Call_Type_value = map[string]int32{
"SUBSCRIBE": 1,
"TEARDOWN": 2,
"ACCEPT": 3,
"DECLINE": 4,
"REVIVE": 5,
"KILL": 6,
"SHUTDOWN": 7,
"ACKNOWLEDGE": 8,
"RECONCILE": 9,
"MESSAGE": 10,
"REQUEST": 11,
}
func (x Call_Type) Enum() *Call_Type {
p := new(Call_Type)
*p = x
return p
}
func (x Call_Type) String() string {
return proto.EnumName(Call_Type_name, int32(x))
}
func (x *Call_Type) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Call_Type_value, data, "Call_Type")
if err != nil {
return err
}
*x = Call_Type(value)
return nil
}
// *
// Scheduler event API.
//
// An event is described using the standard protocol buffer "union"
// trick, see:
// https://developers.google.com/protocol-buffers/docs/techniques#union.
type Event struct {
// Type of the event, indicates which optional field below should be
// present if that type has a nested message definition.
Type *Event_Type `protobuf:"varint,1,req,name=type,enum=mesosproto.Event_Type" json:"type,omitempty"`
Subscribed *Event_Subscribed `protobuf:"bytes,2,opt,name=subscribed" json:"subscribed,omitempty"`
Offers *Event_Offers `protobuf:"bytes,3,opt,name=offers" json:"offers,omitempty"`
Rescind *Event_Rescind `protobuf:"bytes,4,opt,name=rescind" json:"rescind,omitempty"`
Update *Event_Update `protobuf:"bytes,5,opt,name=update" json:"update,omitempty"`
Message *Event_Message `protobuf:"bytes,6,opt,name=message" json:"message,omitempty"`
Failure *Event_Failure `protobuf:"bytes,7,opt,name=failure" json:"failure,omitempty"`
Error *Event_Error `protobuf:"bytes,8,opt,name=error" json:"error,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event) Reset() { *m = Event{} }
func (*Event) ProtoMessage() {}
func (m *Event) GetType() Event_Type {
if m != nil && m.Type != nil {
return *m.Type
}
return Event_SUBSCRIBED
}
func (m *Event) GetSubscribed() *Event_Subscribed {
if m != nil {
return m.Subscribed
}
return nil
}
func (m *Event) GetOffers() *Event_Offers {
if m != nil {
return m.Offers
}
return nil
}
func (m *Event) GetRescind() *Event_Rescind {
if m != nil {
return m.Rescind
}
return nil
}
func (m *Event) GetUpdate() *Event_Update {
if m != nil {
return m.Update
}
return nil
}
func (m *Event) GetMessage() *Event_Message {
if m != nil {
return m.Message
}
return nil
}
func (m *Event) GetFailure() *Event_Failure {
if m != nil {
return m.Failure
}
return nil
}
func (m *Event) GetError() *Event_Error {
if m != nil {
return m.Error
}
return nil
}
// First event received when the scheduler subscribes.
type Event_Subscribed struct {
FrameworkId *FrameworkID `protobuf:"bytes,1,req,name=framework_id" json:"framework_id,omitempty"`
// This value will be set if the master is sending heartbeats. See
// the comment above on 'HEARTBEAT' for more details.
// TODO(vinod): Implement heartbeats in the master once the master
// can send HTTP events.
HeartbeatIntervalSeconds *float64 `protobuf:"fixed64,2,opt,name=heartbeat_interval_seconds" json:"heartbeat_interval_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Subscribed) Reset() { *m = Event_Subscribed{} }
func (*Event_Subscribed) ProtoMessage() {}
func (m *Event_Subscribed) GetFrameworkId() *FrameworkID {
if m != nil {
return m.FrameworkId
}
return nil
}
func (m *Event_Subscribed) GetHeartbeatIntervalSeconds() float64 {
if m != nil && m.HeartbeatIntervalSeconds != nil {
return *m.HeartbeatIntervalSeconds
}
return 0
}
// Received whenever there are new resources that are offered to the
// scheduler. Each offer corresponds to a set of resources on a
// slave. Until the scheduler accepts or declines an offer the
// resources are considered allocated to the scheduler.
type Event_Offers struct {
Offers []*Offer `protobuf:"bytes,1,rep,name=offers" json:"offers,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Offers) Reset() { *m = Event_Offers{} }
func (*Event_Offers) ProtoMessage() {}
func (m *Event_Offers) GetOffers() []*Offer {
if m != nil {
return m.Offers
}
return nil
}
// Received when a particular offer is no longer valid (e.g., the
// slave corresponding to the offer has been removed) and hence
// needs to be rescinded. Any future calls ('Accept' / 'Decline') made
// by the scheduler regarding this offer will be invalid.
type Event_Rescind struct {
OfferId *OfferID `protobuf:"bytes,1,req,name=offer_id" json:"offer_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Rescind) Reset() { *m = Event_Rescind{} }
func (*Event_Rescind) ProtoMessage() {}
func (m *Event_Rescind) GetOfferId() *OfferID {
if m != nil {
return m.OfferId
}
return nil
}
// Received whenever there is a status update that is generated by
// the executor or slave or master. Status updates should be used by
// executors to reliably communicate the status of the tasks that
// they manage. It is crucial that a terminal update (see TaskState
// in mesos.proto) is sent by the executor as soon as the task
// terminates, in order for Mesos to release the resources allocated
// to the task. It is also the responsibility of the scheduler to
// explicitly acknowledge the receipt of a status update. See
// 'Acknowledge' in the 'Call' section below for the semantics.
type Event_Update struct {
Status *TaskStatus `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Update) Reset() { *m = Event_Update{} }
func (*Event_Update) ProtoMessage() {}
func (m *Event_Update) GetStatus() *TaskStatus {
if m != nil {
return m.Status
}
return nil
}
// Received when a custom message generated by the executor is
// forwarded by the master. Note that this message is not
// interpreted by Mesos and is only forwarded (without reliability
// guarantees) to the scheduler. It is up to the executor to retry
// if the message is dropped for any reason.
type Event_Message struct {
SlaveId *SlaveID `protobuf:"bytes,1,req,name=slave_id" json:"slave_id,omitempty"`
ExecutorId *ExecutorID `protobuf:"bytes,2,req,name=executor_id" json:"executor_id,omitempty"`
Data []byte `protobuf:"bytes,3,req,name=data" json:"data,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Message) Reset() { *m = Event_Message{} }
func (*Event_Message) ProtoMessage() {}
func (m *Event_Message) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
func (m *Event_Message) GetExecutorId() *ExecutorID {
if m != nil {
return m.ExecutorId
}
return nil
}
func (m *Event_Message) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
// Received when a slave is removed from the cluster (e.g., failed
// health checks) or when an executor is terminated. Note that, this
// event coincides with receipt of terminal UPDATE events for any
// active tasks belonging to the slave or executor and receipt of
// 'Rescind' events for any outstanding offers belonging to the
// slave. Note that there is no guaranteed order between the
// 'Failure', 'Update' and 'Rescind' events when a slave or executor
// is removed.
// TODO(vinod): Consider splitting the lost slave and terminated
// executor into separate events and ensure it's reliably generated.
type Event_Failure struct {
SlaveId *SlaveID `protobuf:"bytes,1,opt,name=slave_id" json:"slave_id,omitempty"`
// If this was just a failure of an executor on a slave then
// 'executor_id' will be set and possibly 'status' (if we were
// able to determine the exit status).
ExecutorId *ExecutorID `protobuf:"bytes,2,opt,name=executor_id" json:"executor_id,omitempty"`
Status *int32 `protobuf:"varint,3,opt,name=status" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Failure) Reset() { *m = Event_Failure{} }
func (*Event_Failure) ProtoMessage() {}
func (m *Event_Failure) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
func (m *Event_Failure) GetExecutorId() *ExecutorID {
if m != nil {
return m.ExecutorId
}
return nil
}
func (m *Event_Failure) GetStatus() int32 {
if m != nil && m.Status != nil {
return *m.Status
}
return 0
}
// Received when an invalid framework (e.g., unauthenticated,
// unauthorized) attempts to subscribe with the master. Error can
// also be received if scheduler sends invalid Calls (e.g., not
// properly initialized).
// TODO(vinod): Remove this once the old scheduler driver is no
// longer supported. With HTTP API all errors will be signaled via
// HTTP response codes.
type Event_Error struct {
Message *string `protobuf:"bytes,1,req,name=message" json:"message,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Event_Error) Reset() { *m = Event_Error{} }
func (*Event_Error) ProtoMessage() {}
func (m *Event_Error) GetMessage() string {
if m != nil && m.Message != nil {
return *m.Message
}
return ""
}
// *
// Scheduler call API.
//
// Like Event, a Call is described using the standard protocol buffer
// "union" trick (see above).
type Call struct {
// Identifies who generated this call. Master assigns a framework id
// when a new scheduler subscribes for the first time. Once assigned,
// the scheduler must set the 'framework_id' here and within its
// FrameworkInfo (in any further 'Subscribe' calls). This allows the
// master to identify a scheduler correctly across disconnections,
// failovers, etc.
FrameworkId *FrameworkID `protobuf:"bytes,1,opt,name=framework_id" json:"framework_id,omitempty"`
// Type of the call, indicates which optional field below should be
// present if that type has a nested message definition.
Type *Call_Type `protobuf:"varint,2,req,name=type,enum=mesosproto.Call_Type" json:"type,omitempty"`
Subscribe *Call_Subscribe `protobuf:"bytes,3,opt,name=subscribe" json:"subscribe,omitempty"`
Accept *Call_Accept `protobuf:"bytes,4,opt,name=accept" json:"accept,omitempty"`
Decline *Call_Decline `protobuf:"bytes,5,opt,name=decline" json:"decline,omitempty"`
Kill *Call_Kill `protobuf:"bytes,6,opt,name=kill" json:"kill,omitempty"`
Shutdown *Call_Shutdown `protobuf:"bytes,7,opt,name=shutdown" json:"shutdown,omitempty"`
Acknowledge *Call_Acknowledge `protobuf:"bytes,8,opt,name=acknowledge" json:"acknowledge,omitempty"`
Reconcile *Call_Reconcile `protobuf:"bytes,9,opt,name=reconcile" json:"reconcile,omitempty"`
Message *Call_Message `protobuf:"bytes,10,opt,name=message" json:"message,omitempty"`
Request *Call_Request `protobuf:"bytes,11,opt,name=request" json:"request,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call) Reset() { *m = Call{} }
func (*Call) ProtoMessage() {}
func (m *Call) GetFrameworkId() *FrameworkID {
if m != nil {
return m.FrameworkId
}
return nil
}
func (m *Call) GetType() Call_Type {
if m != nil && m.Type != nil {
return *m.Type
}
return Call_SUBSCRIBE
}
func (m *Call) GetSubscribe() *Call_Subscribe {
if m != nil {
return m.Subscribe
}
return nil
}
func (m *Call) GetAccept() *Call_Accept {
if m != nil {
return m.Accept
}
return nil
}
func (m *Call) GetDecline() *Call_Decline {
if m != nil {
return m.Decline
}
return nil
}
func (m *Call) GetKill() *Call_Kill {
if m != nil {
return m.Kill
}
return nil
}
func (m *Call) GetShutdown() *Call_Shutdown {
if m != nil {
return m.Shutdown
}
return nil
}
func (m *Call) GetAcknowledge() *Call_Acknowledge {
if m != nil {
return m.Acknowledge
}
return nil
}
func (m *Call) GetReconcile() *Call_Reconcile {
if m != nil {
return m.Reconcile
}
return nil
}
func (m *Call) GetMessage() *Call_Message {
if m != nil {
return m.Message
}
return nil
}
func (m *Call) GetRequest() *Call_Request {
if m != nil {
return m.Request
}
return nil
}
// Subscribes the scheduler with the master to receive events. A
// scheduler must send other calls only after it has received the
// SUBCRIBED event.
type Call_Subscribe struct {
// See the comments below on 'framework_id' on the semantics for
// 'framework_info.id'.
FrameworkInfo *FrameworkInfo `protobuf:"bytes,1,req,name=framework_info" json:"framework_info,omitempty"`
// 'force' field is only relevant when 'framework_info.id' is set.
// It tells the master what to do in case an instance of the
// scheduler attempts to subscribe when another instance of it is
// already connected (e.g., split brain due to network partition).
// If 'force' is true, this scheduler instance is allowed and the
// old connected scheduler instance is disconnected. If false,
// this scheduler instance is disallowed subscription in favor of
// the already connected scheduler instance.
//
// It is recommended to set this to true only when a newly elected
// scheduler instance is attempting to subscribe but not when a
// scheduler is retrying subscription (e.g., disconnection or
// master failover; see sched/sched.cpp for an example).
Force *bool `protobuf:"varint,2,opt,name=force" json:"force,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Subscribe) Reset() { *m = Call_Subscribe{} }
func (*Call_Subscribe) ProtoMessage() {}
func (m *Call_Subscribe) GetFrameworkInfo() *FrameworkInfo {
if m != nil {
return m.FrameworkInfo
}
return nil
}
func (m *Call_Subscribe) GetForce() bool {
if m != nil && m.Force != nil {
return *m.Force
}
return false
}
// Accepts an offer, performing the specified operations
// in a sequential manner.
//
// E.g. Launch a task with a newly reserved persistent volume:
//
// Accept {
// offer_ids: [ ... ]
// operations: [
// { type: RESERVE,
// reserve: { resources: [ disk(role):2 ] } }
// { type: CREATE,
// create: { volumes: [ disk(role):1+persistence ] } }
// { type: LAUNCH,
// launch: { task_infos ... disk(role):1;disk(role):1+persistence } }
// ]
// }
//
// Note that any of the offers resources not used in the 'Accept'
// call (e.g., to launch a task) are considered unused and might be
// reoffered to other frameworks. In other words, the same OfferID
// cannot be used in more than one 'Accept' call.
type Call_Accept struct {
OfferIds []*OfferID `protobuf:"bytes,1,rep,name=offer_ids" json:"offer_ids,omitempty"`
Operations []*Offer_Operation `protobuf:"bytes,2,rep,name=operations" json:"operations,omitempty"`
Filters *Filters `protobuf:"bytes,3,opt,name=filters" json:"filters,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Accept) Reset() { *m = Call_Accept{} }
func (*Call_Accept) ProtoMessage() {}
func (m *Call_Accept) GetOfferIds() []*OfferID {
if m != nil {
return m.OfferIds
}
return nil
}
func (m *Call_Accept) GetOperations() []*Offer_Operation {
if m != nil {
return m.Operations
}
return nil
}
func (m *Call_Accept) GetFilters() *Filters {
if m != nil {
return m.Filters
}
return nil
}
// Declines an offer, signaling the master to potentially reoffer
// the resources to a different framework. Note that this is same
// as sending an Accept call with no operations. See comments on
// top of 'Accept' for semantics.
type Call_Decline struct {
OfferIds []*OfferID `protobuf:"bytes,1,rep,name=offer_ids" json:"offer_ids,omitempty"`
Filters *Filters `protobuf:"bytes,2,opt,name=filters" json:"filters,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Decline) Reset() { *m = Call_Decline{} }
func (*Call_Decline) ProtoMessage() {}
func (m *Call_Decline) GetOfferIds() []*OfferID {
if m != nil {
return m.OfferIds
}
return nil
}
func (m *Call_Decline) GetFilters() *Filters {
if m != nil {
return m.Filters
}
return nil
}
// Kills a specific task. If the scheduler has a custom executor,
// the kill is forwarded to the executor and it is up to the
// executor to kill the task and send a TASK_KILLED (or TASK_FAILED)
// update. Note that Mesos releases the resources for a task once it
// receives a terminal update (See TaskState in mesos.proto) for it.
// If the task is unknown to the master, a TASK_LOST update is
// generated.
type Call_Kill struct {
TaskId *TaskID `protobuf:"bytes,1,req,name=task_id" json:"task_id,omitempty"`
SlaveId *SlaveID `protobuf:"bytes,2,opt,name=slave_id" json:"slave_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Kill) Reset() { *m = Call_Kill{} }
func (*Call_Kill) ProtoMessage() {}
func (m *Call_Kill) GetTaskId() *TaskID {
if m != nil {
return m.TaskId
}
return nil
}
func (m *Call_Kill) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
// Shuts down a custom executor. When the executor gets a shutdown
// event, it is expected to kill all its tasks (and send TASK_KILLED
// updates) and terminate. If the executor doesnt terminate within
// a certain timeout (configurable via
// '--executor_shutdown_grace_period' slave flag), the slave will
// forcefully destroy the container (executor and its tasks) and
// transition its active tasks to TASK_LOST.
type Call_Shutdown struct {
ExecutorId *ExecutorID `protobuf:"bytes,1,req,name=executor_id" json:"executor_id,omitempty"`
SlaveId *SlaveID `protobuf:"bytes,2,req,name=slave_id" json:"slave_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Shutdown) Reset() { *m = Call_Shutdown{} }
func (*Call_Shutdown) ProtoMessage() {}
func (m *Call_Shutdown) GetExecutorId() *ExecutorID {
if m != nil {
return m.ExecutorId
}
return nil
}
func (m *Call_Shutdown) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
// Acknowledges the receipt of status update. Schedulers are
// responsible for explicitly acknowledging the receipt of status
// updates that have 'Update.status().uuid()' field set. Such status
// updates are retried by the slave until they are acknowledged by
// the scheduler.
type Call_Acknowledge struct {
SlaveId *SlaveID `protobuf:"bytes,1,req,name=slave_id" json:"slave_id,omitempty"`
TaskId *TaskID `protobuf:"bytes,2,req,name=task_id" json:"task_id,omitempty"`
Uuid []byte `protobuf:"bytes,3,req,name=uuid" json:"uuid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Acknowledge) Reset() { *m = Call_Acknowledge{} }
func (*Call_Acknowledge) ProtoMessage() {}
func (m *Call_Acknowledge) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
func (m *Call_Acknowledge) GetTaskId() *TaskID {
if m != nil {
return m.TaskId
}
return nil
}
func (m *Call_Acknowledge) GetUuid() []byte {
if m != nil {
return m.Uuid
}
return nil
}
// Allows the scheduler to query the status for non-terminal tasks.
// This causes the master to send back the latest task status for
// each task in 'tasks', if possible. Tasks that are no longer known
// will result in a TASK_LOST update. If 'statuses' is empty, then
// the master will send the latest status for each task currently
// known.
type Call_Reconcile struct {
Tasks []*Call_Reconcile_Task `protobuf:"bytes,1,rep,name=tasks" json:"tasks,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Reconcile) Reset() { *m = Call_Reconcile{} }
func (*Call_Reconcile) ProtoMessage() {}
func (m *Call_Reconcile) GetTasks() []*Call_Reconcile_Task {
if m != nil {
return m.Tasks
}
return nil
}
// TODO(vinod): Support arbitrary queries than just state of tasks.
type Call_Reconcile_Task struct {
TaskId *TaskID `protobuf:"bytes,1,req,name=task_id" json:"task_id,omitempty"`
SlaveId *SlaveID `protobuf:"bytes,2,opt,name=slave_id" json:"slave_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Reconcile_Task) Reset() { *m = Call_Reconcile_Task{} }
func (*Call_Reconcile_Task) ProtoMessage() {}
func (m *Call_Reconcile_Task) GetTaskId() *TaskID {
if m != nil {
return m.TaskId
}
return nil
}
func (m *Call_Reconcile_Task) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
// Sends arbitrary binary data to the executor. Note that Mesos
// neither interprets this data nor makes any guarantees about the
// delivery of this message to the executor.
type Call_Message struct {
SlaveId *SlaveID `protobuf:"bytes,1,req,name=slave_id" json:"slave_id,omitempty"`
ExecutorId *ExecutorID `protobuf:"bytes,2,req,name=executor_id" json:"executor_id,omitempty"`
Data []byte `protobuf:"bytes,3,req,name=data" json:"data,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Message) Reset() { *m = Call_Message{} }
func (*Call_Message) ProtoMessage() {}
func (m *Call_Message) GetSlaveId() *SlaveID {
if m != nil {
return m.SlaveId
}
return nil
}
func (m *Call_Message) GetExecutorId() *ExecutorID {
if m != nil {
return m.ExecutorId
}
return nil
}
func (m *Call_Message) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
// Requests a specific set of resources from Mesos's allocator. If
// the allocator has support for this, corresponding offers will be
// sent asynchronously via the OFFERS event(s).
//
// NOTE: The built-in hierarchical allocator doesn't have support
// for this call and hence simply ignores it.
type Call_Request struct {
Requests []*Request `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Call_Request) Reset() { *m = Call_Request{} }
func (*Call_Request) ProtoMessage() {}
func (m *Call_Request) GetRequests() []*Request {
if m != nil {
return m.Requests
}
return nil
}
func init() {
proto.RegisterEnum("mesosproto.Event_Type", Event_Type_name, Event_Type_value)
proto.RegisterEnum("mesosproto.Call_Type", Call_Type_name, Call_Type_value)
}
func (this *Event) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event)
if !ok {
return fmt.Errorf("that is not of type *Event")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Eventbut is not nil && this == nil")
}
if this.Type != nil && that1.Type != nil {
if *this.Type != *that1.Type {
return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
}
} else if this.Type != nil {
return fmt.Errorf("this.Type == nil && that.Type != nil")
} else if that1.Type != nil {
return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
}
if !this.Subscribed.Equal(that1.Subscribed) {
return fmt.Errorf("Subscribed this(%v) Not Equal that(%v)", this.Subscribed, that1.Subscribed)
}
if !this.Offers.Equal(that1.Offers) {
return fmt.Errorf("Offers this(%v) Not Equal that(%v)", this.Offers, that1.Offers)
}
if !this.Rescind.Equal(that1.Rescind) {
return fmt.Errorf("Rescind this(%v) Not Equal that(%v)", this.Rescind, that1.Rescind)
}
if !this.Update.Equal(that1.Update) {
return fmt.Errorf("Update this(%v) Not Equal that(%v)", this.Update, that1.Update)
}
if !this.Message.Equal(that1.Message) {
return fmt.Errorf("Message this(%v) Not Equal that(%v)", this.Message, that1.Message)
}
if !this.Failure.Equal(that1.Failure) {
return fmt.Errorf("Failure this(%v) Not Equal that(%v)", this.Failure, that1.Failure)
}
if !this.Error.Equal(that1.Error) {
return fmt.Errorf("Error this(%v) Not Equal that(%v)", this.Error, that1.Error)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if this.Type != nil && that1.Type != nil {
if *this.Type != *that1.Type {
return false
}
} else if this.Type != nil {
return false
} else if that1.Type != nil {
return false
}
if !this.Subscribed.Equal(that1.Subscribed) {
return false
}
if !this.Offers.Equal(that1.Offers) {
return false
}
if !this.Rescind.Equal(that1.Rescind) {
return false
}
if !this.Update.Equal(that1.Update) {
return false
}
if !this.Message.Equal(that1.Message) {
return false
}
if !this.Failure.Equal(that1.Failure) {
return false
}
if !this.Error.Equal(that1.Error) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Subscribed) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Subscribed)
if !ok {
return fmt.Errorf("that is not of type *Event_Subscribed")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Subscribed but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Subscribedbut is not nil && this == nil")
}
if !this.FrameworkId.Equal(that1.FrameworkId) {
return fmt.Errorf("FrameworkId this(%v) Not Equal that(%v)", this.FrameworkId, that1.FrameworkId)
}
if this.HeartbeatIntervalSeconds != nil && that1.HeartbeatIntervalSeconds != nil {
if *this.HeartbeatIntervalSeconds != *that1.HeartbeatIntervalSeconds {
return fmt.Errorf("HeartbeatIntervalSeconds this(%v) Not Equal that(%v)", *this.HeartbeatIntervalSeconds, *that1.HeartbeatIntervalSeconds)
}
} else if this.HeartbeatIntervalSeconds != nil {
return fmt.Errorf("this.HeartbeatIntervalSeconds == nil && that.HeartbeatIntervalSeconds != nil")
} else if that1.HeartbeatIntervalSeconds != nil {
return fmt.Errorf("HeartbeatIntervalSeconds this(%v) Not Equal that(%v)", this.HeartbeatIntervalSeconds, that1.HeartbeatIntervalSeconds)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Subscribed) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Subscribed)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.FrameworkId.Equal(that1.FrameworkId) {
return false
}
if this.HeartbeatIntervalSeconds != nil && that1.HeartbeatIntervalSeconds != nil {
if *this.HeartbeatIntervalSeconds != *that1.HeartbeatIntervalSeconds {
return false
}
} else if this.HeartbeatIntervalSeconds != nil {
return false
} else if that1.HeartbeatIntervalSeconds != nil {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Offers) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Offers)
if !ok {
return fmt.Errorf("that is not of type *Event_Offers")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Offers but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Offersbut is not nil && this == nil")
}
if len(this.Offers) != len(that1.Offers) {
return fmt.Errorf("Offers this(%v) Not Equal that(%v)", len(this.Offers), len(that1.Offers))
}
for i := range this.Offers {
if !this.Offers[i].Equal(that1.Offers[i]) {
return fmt.Errorf("Offers this[%v](%v) Not Equal that[%v](%v)", i, this.Offers[i], i, that1.Offers[i])
}
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Offers) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Offers)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if len(this.Offers) != len(that1.Offers) {
return false
}
for i := range this.Offers {
if !this.Offers[i].Equal(that1.Offers[i]) {
return false
}
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Rescind) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Rescind)
if !ok {
return fmt.Errorf("that is not of type *Event_Rescind")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Rescind but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Rescindbut is not nil && this == nil")
}
if !this.OfferId.Equal(that1.OfferId) {
return fmt.Errorf("OfferId this(%v) Not Equal that(%v)", this.OfferId, that1.OfferId)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Rescind) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Rescind)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.OfferId.Equal(that1.OfferId) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Update) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Update)
if !ok {
return fmt.Errorf("that is not of type *Event_Update")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Update but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Updatebut is not nil && this == nil")
}
if !this.Status.Equal(that1.Status) {
return fmt.Errorf("Status this(%v) Not Equal that(%v)", this.Status, that1.Status)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Update) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Update)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.Status.Equal(that1.Status) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Message) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Message)
if !ok {
return fmt.Errorf("that is not of type *Event_Message")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Message but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Messagebut is not nil && this == nil")
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return fmt.Errorf("ExecutorId this(%v) Not Equal that(%v)", this.ExecutorId, that1.ExecutorId)
}
if !bytes.Equal(this.Data, that1.Data) {
return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Message) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Message)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return false
}
if !bytes.Equal(this.Data, that1.Data) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Failure) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Failure)
if !ok {
return fmt.Errorf("that is not of type *Event_Failure")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Failure but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Failurebut is not nil && this == nil")
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return fmt.Errorf("ExecutorId this(%v) Not Equal that(%v)", this.ExecutorId, that1.ExecutorId)
}
if this.Status != nil && that1.Status != nil {
if *this.Status != *that1.Status {
return fmt.Errorf("Status this(%v) Not Equal that(%v)", *this.Status, *that1.Status)
}
} else if this.Status != nil {
return fmt.Errorf("this.Status == nil && that.Status != nil")
} else if that1.Status != nil {
return fmt.Errorf("Status this(%v) Not Equal that(%v)", this.Status, that1.Status)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Failure) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Failure)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return false
}
if this.Status != nil && that1.Status != nil {
if *this.Status != *that1.Status {
return false
}
} else if this.Status != nil {
return false
} else if that1.Status != nil {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event_Error) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Event_Error)
if !ok {
return fmt.Errorf("that is not of type *Event_Error")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Event_Error but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Event_Errorbut is not nil && this == nil")
}
if this.Message != nil && that1.Message != nil {
if *this.Message != *that1.Message {
return fmt.Errorf("Message this(%v) Not Equal that(%v)", *this.Message, *that1.Message)
}
} else if this.Message != nil {
return fmt.Errorf("this.Message == nil && that.Message != nil")
} else if that1.Message != nil {
return fmt.Errorf("Message this(%v) Not Equal that(%v)", this.Message, that1.Message)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Event_Error) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Event_Error)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if this.Message != nil && that1.Message != nil {
if *this.Message != *that1.Message {
return false
}
} else if this.Message != nil {
return false
} else if that1.Message != nil {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call)
if !ok {
return fmt.Errorf("that is not of type *Call")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Callbut is not nil && this == nil")
}
if !this.FrameworkId.Equal(that1.FrameworkId) {
return fmt.Errorf("FrameworkId this(%v) Not Equal that(%v)", this.FrameworkId, that1.FrameworkId)
}
if this.Type != nil && that1.Type != nil {
if *this.Type != *that1.Type {
return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
}
} else if this.Type != nil {
return fmt.Errorf("this.Type == nil && that.Type != nil")
} else if that1.Type != nil {
return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
}
if !this.Subscribe.Equal(that1.Subscribe) {
return fmt.Errorf("Subscribe this(%v) Not Equal that(%v)", this.Subscribe, that1.Subscribe)
}
if !this.Accept.Equal(that1.Accept) {
return fmt.Errorf("Accept this(%v) Not Equal that(%v)", this.Accept, that1.Accept)
}
if !this.Decline.Equal(that1.Decline) {
return fmt.Errorf("Decline this(%v) Not Equal that(%v)", this.Decline, that1.Decline)
}
if !this.Kill.Equal(that1.Kill) {
return fmt.Errorf("Kill this(%v) Not Equal that(%v)", this.Kill, that1.Kill)
}
if !this.Shutdown.Equal(that1.Shutdown) {
return fmt.Errorf("Shutdown this(%v) Not Equal that(%v)", this.Shutdown, that1.Shutdown)
}
if !this.Acknowledge.Equal(that1.Acknowledge) {
return fmt.Errorf("Acknowledge this(%v) Not Equal that(%v)", this.Acknowledge, that1.Acknowledge)
}
if !this.Reconcile.Equal(that1.Reconcile) {
return fmt.Errorf("Reconcile this(%v) Not Equal that(%v)", this.Reconcile, that1.Reconcile)
}
if !this.Message.Equal(that1.Message) {
return fmt.Errorf("Message this(%v) Not Equal that(%v)", this.Message, that1.Message)
}
if !this.Request.Equal(that1.Request) {
return fmt.Errorf("Request this(%v) Not Equal that(%v)", this.Request, that1.Request)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.FrameworkId.Equal(that1.FrameworkId) {
return false
}
if this.Type != nil && that1.Type != nil {
if *this.Type != *that1.Type {
return false
}
} else if this.Type != nil {
return false
} else if that1.Type != nil {
return false
}
if !this.Subscribe.Equal(that1.Subscribe) {
return false
}
if !this.Accept.Equal(that1.Accept) {
return false
}
if !this.Decline.Equal(that1.Decline) {
return false
}
if !this.Kill.Equal(that1.Kill) {
return false
}
if !this.Shutdown.Equal(that1.Shutdown) {
return false
}
if !this.Acknowledge.Equal(that1.Acknowledge) {
return false
}
if !this.Reconcile.Equal(that1.Reconcile) {
return false
}
if !this.Message.Equal(that1.Message) {
return false
}
if !this.Request.Equal(that1.Request) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Subscribe) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Subscribe)
if !ok {
return fmt.Errorf("that is not of type *Call_Subscribe")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Subscribe but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Subscribebut is not nil && this == nil")
}
if !this.FrameworkInfo.Equal(that1.FrameworkInfo) {
return fmt.Errorf("FrameworkInfo this(%v) Not Equal that(%v)", this.FrameworkInfo, that1.FrameworkInfo)
}
if this.Force != nil && that1.Force != nil {
if *this.Force != *that1.Force {
return fmt.Errorf("Force this(%v) Not Equal that(%v)", *this.Force, *that1.Force)
}
} else if this.Force != nil {
return fmt.Errorf("this.Force == nil && that.Force != nil")
} else if that1.Force != nil {
return fmt.Errorf("Force this(%v) Not Equal that(%v)", this.Force, that1.Force)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Subscribe) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Subscribe)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.FrameworkInfo.Equal(that1.FrameworkInfo) {
return false
}
if this.Force != nil && that1.Force != nil {
if *this.Force != *that1.Force {
return false
}
} else if this.Force != nil {
return false
} else if that1.Force != nil {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Accept) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Accept)
if !ok {
return fmt.Errorf("that is not of type *Call_Accept")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Accept but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Acceptbut is not nil && this == nil")
}
if len(this.OfferIds) != len(that1.OfferIds) {
return fmt.Errorf("OfferIds this(%v) Not Equal that(%v)", len(this.OfferIds), len(that1.OfferIds))
}
for i := range this.OfferIds {
if !this.OfferIds[i].Equal(that1.OfferIds[i]) {
return fmt.Errorf("OfferIds this[%v](%v) Not Equal that[%v](%v)", i, this.OfferIds[i], i, that1.OfferIds[i])
}
}
if len(this.Operations) != len(that1.Operations) {
return fmt.Errorf("Operations this(%v) Not Equal that(%v)", len(this.Operations), len(that1.Operations))
}
for i := range this.Operations {
if !this.Operations[i].Equal(that1.Operations[i]) {
return fmt.Errorf("Operations this[%v](%v) Not Equal that[%v](%v)", i, this.Operations[i], i, that1.Operations[i])
}
}
if !this.Filters.Equal(that1.Filters) {
return fmt.Errorf("Filters this(%v) Not Equal that(%v)", this.Filters, that1.Filters)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Accept) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Accept)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if len(this.OfferIds) != len(that1.OfferIds) {
return false
}
for i := range this.OfferIds {
if !this.OfferIds[i].Equal(that1.OfferIds[i]) {
return false
}
}
if len(this.Operations) != len(that1.Operations) {
return false
}
for i := range this.Operations {
if !this.Operations[i].Equal(that1.Operations[i]) {
return false
}
}
if !this.Filters.Equal(that1.Filters) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Decline) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Decline)
if !ok {
return fmt.Errorf("that is not of type *Call_Decline")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Decline but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Declinebut is not nil && this == nil")
}
if len(this.OfferIds) != len(that1.OfferIds) {
return fmt.Errorf("OfferIds this(%v) Not Equal that(%v)", len(this.OfferIds), len(that1.OfferIds))
}
for i := range this.OfferIds {
if !this.OfferIds[i].Equal(that1.OfferIds[i]) {
return fmt.Errorf("OfferIds this[%v](%v) Not Equal that[%v](%v)", i, this.OfferIds[i], i, that1.OfferIds[i])
}
}
if !this.Filters.Equal(that1.Filters) {
return fmt.Errorf("Filters this(%v) Not Equal that(%v)", this.Filters, that1.Filters)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Decline) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Decline)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if len(this.OfferIds) != len(that1.OfferIds) {
return false
}
for i := range this.OfferIds {
if !this.OfferIds[i].Equal(that1.OfferIds[i]) {
return false
}
}
if !this.Filters.Equal(that1.Filters) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Kill) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Kill)
if !ok {
return fmt.Errorf("that is not of type *Call_Kill")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Kill but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Killbut is not nil && this == nil")
}
if !this.TaskId.Equal(that1.TaskId) {
return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Kill) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Kill)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.TaskId.Equal(that1.TaskId) {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Shutdown) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Shutdown)
if !ok {
return fmt.Errorf("that is not of type *Call_Shutdown")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Shutdown but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Shutdownbut is not nil && this == nil")
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return fmt.Errorf("ExecutorId this(%v) Not Equal that(%v)", this.ExecutorId, that1.ExecutorId)
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Shutdown) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Shutdown)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Acknowledge) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Acknowledge)
if !ok {
return fmt.Errorf("that is not of type *Call_Acknowledge")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Acknowledge but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Acknowledgebut is not nil && this == nil")
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !this.TaskId.Equal(that1.TaskId) {
return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
}
if !bytes.Equal(this.Uuid, that1.Uuid) {
return fmt.Errorf("Uuid this(%v) Not Equal that(%v)", this.Uuid, that1.Uuid)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Acknowledge) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Acknowledge)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !this.TaskId.Equal(that1.TaskId) {
return false
}
if !bytes.Equal(this.Uuid, that1.Uuid) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Reconcile) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Reconcile)
if !ok {
return fmt.Errorf("that is not of type *Call_Reconcile")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Reconcile but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Reconcilebut is not nil && this == nil")
}
if len(this.Tasks) != len(that1.Tasks) {
return fmt.Errorf("Tasks this(%v) Not Equal that(%v)", len(this.Tasks), len(that1.Tasks))
}
for i := range this.Tasks {
if !this.Tasks[i].Equal(that1.Tasks[i]) {
return fmt.Errorf("Tasks this[%v](%v) Not Equal that[%v](%v)", i, this.Tasks[i], i, that1.Tasks[i])
}
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Reconcile) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Reconcile)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if len(this.Tasks) != len(that1.Tasks) {
return false
}
for i := range this.Tasks {
if !this.Tasks[i].Equal(that1.Tasks[i]) {
return false
}
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Reconcile_Task) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Reconcile_Task)
if !ok {
return fmt.Errorf("that is not of type *Call_Reconcile_Task")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Reconcile_Task but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Reconcile_Taskbut is not nil && this == nil")
}
if !this.TaskId.Equal(that1.TaskId) {
return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Reconcile_Task) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Reconcile_Task)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.TaskId.Equal(that1.TaskId) {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Message) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Message)
if !ok {
return fmt.Errorf("that is not of type *Call_Message")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Message but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Messagebut is not nil && this == nil")
}
if !this.SlaveId.Equal(that1.SlaveId) {
return fmt.Errorf("SlaveId this(%v) Not Equal that(%v)", this.SlaveId, that1.SlaveId)
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return fmt.Errorf("ExecutorId this(%v) Not Equal that(%v)", this.ExecutorId, that1.ExecutorId)
}
if !bytes.Equal(this.Data, that1.Data) {
return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Message) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Message)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if !this.SlaveId.Equal(that1.SlaveId) {
return false
}
if !this.ExecutorId.Equal(that1.ExecutorId) {
return false
}
if !bytes.Equal(this.Data, that1.Data) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Call_Request) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Call_Request)
if !ok {
return fmt.Errorf("that is not of type *Call_Request")
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Call_Request but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Call_Requestbut is not nil && this == nil")
}
if len(this.Requests) != len(that1.Requests) {
return fmt.Errorf("Requests this(%v) Not Equal that(%v)", len(this.Requests), len(that1.Requests))
}
for i := range this.Requests {
if !this.Requests[i].Equal(that1.Requests[i]) {
return fmt.Errorf("Requests this[%v](%v) Not Equal that[%v](%v)", i, this.Requests[i], i, that1.Requests[i])
}
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Call_Request) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Call_Request)
if !ok {
return false
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if len(this.Requests) != len(that1.Requests) {
return false
}
for i := range this.Requests {
if !this.Requests[i].Equal(that1.Requests[i]) {
return false
}
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Event) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 12)
s = append(s, "&mesosproto.Event{")
if this.Type != nil {
s = append(s, "Type: "+valueToGoStringScheduler(this.Type, "mesosproto.Event_Type")+",\n")
}
if this.Subscribed != nil {
s = append(s, "Subscribed: "+fmt.Sprintf("%#v", this.Subscribed)+",\n")
}
if this.Offers != nil {
s = append(s, "Offers: "+fmt.Sprintf("%#v", this.Offers)+",\n")
}
if this.Rescind != nil {
s = append(s, "Rescind: "+fmt.Sprintf("%#v", this.Rescind)+",\n")
}
if this.Update != nil {
s = append(s, "Update: "+fmt.Sprintf("%#v", this.Update)+",\n")
}
if this.Message != nil {
s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
}
if this.Failure != nil {
s = append(s, "Failure: "+fmt.Sprintf("%#v", this.Failure)+",\n")
}
if this.Error != nil {
s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Subscribed) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&mesosproto.Event_Subscribed{")
if this.FrameworkId != nil {
s = append(s, "FrameworkId: "+fmt.Sprintf("%#v", this.FrameworkId)+",\n")
}
if this.HeartbeatIntervalSeconds != nil {
s = append(s, "HeartbeatIntervalSeconds: "+valueToGoStringScheduler(this.HeartbeatIntervalSeconds, "float64")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Offers) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&mesosproto.Event_Offers{")
if this.Offers != nil {
s = append(s, "Offers: "+fmt.Sprintf("%#v", this.Offers)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Rescind) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&mesosproto.Event_Rescind{")
if this.OfferId != nil {
s = append(s, "OfferId: "+fmt.Sprintf("%#v", this.OfferId)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Update) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&mesosproto.Event_Update{")
if this.Status != nil {
s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Message) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 7)
s = append(s, "&mesosproto.Event_Message{")
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.ExecutorId != nil {
s = append(s, "ExecutorId: "+fmt.Sprintf("%#v", this.ExecutorId)+",\n")
}
if this.Data != nil {
s = append(s, "Data: "+valueToGoStringScheduler(this.Data, "byte")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Failure) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 7)
s = append(s, "&mesosproto.Event_Failure{")
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.ExecutorId != nil {
s = append(s, "ExecutorId: "+fmt.Sprintf("%#v", this.ExecutorId)+",\n")
}
if this.Status != nil {
s = append(s, "Status: "+valueToGoStringScheduler(this.Status, "int32")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Event_Error) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&mesosproto.Event_Error{")
if this.Message != nil {
s = append(s, "Message: "+valueToGoStringScheduler(this.Message, "string")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 15)
s = append(s, "&mesosproto.Call{")
if this.FrameworkId != nil {
s = append(s, "FrameworkId: "+fmt.Sprintf("%#v", this.FrameworkId)+",\n")
}
if this.Type != nil {
s = append(s, "Type: "+valueToGoStringScheduler(this.Type, "mesosproto.Call_Type")+",\n")
}
if this.Subscribe != nil {
s = append(s, "Subscribe: "+fmt.Sprintf("%#v", this.Subscribe)+",\n")
}
if this.Accept != nil {
s = append(s, "Accept: "+fmt.Sprintf("%#v", this.Accept)+",\n")
}
if this.Decline != nil {
s = append(s, "Decline: "+fmt.Sprintf("%#v", this.Decline)+",\n")
}
if this.Kill != nil {
s = append(s, "Kill: "+fmt.Sprintf("%#v", this.Kill)+",\n")
}
if this.Shutdown != nil {
s = append(s, "Shutdown: "+fmt.Sprintf("%#v", this.Shutdown)+",\n")
}
if this.Acknowledge != nil {
s = append(s, "Acknowledge: "+fmt.Sprintf("%#v", this.Acknowledge)+",\n")
}
if this.Reconcile != nil {
s = append(s, "Reconcile: "+fmt.Sprintf("%#v", this.Reconcile)+",\n")
}
if this.Message != nil {
s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
}
if this.Request != nil {
s = append(s, "Request: "+fmt.Sprintf("%#v", this.Request)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Subscribe) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&mesosproto.Call_Subscribe{")
if this.FrameworkInfo != nil {
s = append(s, "FrameworkInfo: "+fmt.Sprintf("%#v", this.FrameworkInfo)+",\n")
}
if this.Force != nil {
s = append(s, "Force: "+valueToGoStringScheduler(this.Force, "bool")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Accept) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 7)
s = append(s, "&mesosproto.Call_Accept{")
if this.OfferIds != nil {
s = append(s, "OfferIds: "+fmt.Sprintf("%#v", this.OfferIds)+",\n")
}
if this.Operations != nil {
s = append(s, "Operations: "+fmt.Sprintf("%#v", this.Operations)+",\n")
}
if this.Filters != nil {
s = append(s, "Filters: "+fmt.Sprintf("%#v", this.Filters)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Decline) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&mesosproto.Call_Decline{")
if this.OfferIds != nil {
s = append(s, "OfferIds: "+fmt.Sprintf("%#v", this.OfferIds)+",\n")
}
if this.Filters != nil {
s = append(s, "Filters: "+fmt.Sprintf("%#v", this.Filters)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Kill) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&mesosproto.Call_Kill{")
if this.TaskId != nil {
s = append(s, "TaskId: "+fmt.Sprintf("%#v", this.TaskId)+",\n")
}
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Shutdown) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&mesosproto.Call_Shutdown{")
if this.ExecutorId != nil {
s = append(s, "ExecutorId: "+fmt.Sprintf("%#v", this.ExecutorId)+",\n")
}
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Acknowledge) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 7)
s = append(s, "&mesosproto.Call_Acknowledge{")
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.TaskId != nil {
s = append(s, "TaskId: "+fmt.Sprintf("%#v", this.TaskId)+",\n")
}
if this.Uuid != nil {
s = append(s, "Uuid: "+valueToGoStringScheduler(this.Uuid, "byte")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Reconcile) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&mesosproto.Call_Reconcile{")
if this.Tasks != nil {
s = append(s, "Tasks: "+fmt.Sprintf("%#v", this.Tasks)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Reconcile_Task) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 6)
s = append(s, "&mesosproto.Call_Reconcile_Task{")
if this.TaskId != nil {
s = append(s, "TaskId: "+fmt.Sprintf("%#v", this.TaskId)+",\n")
}
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Message) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 7)
s = append(s, "&mesosproto.Call_Message{")
if this.SlaveId != nil {
s = append(s, "SlaveId: "+fmt.Sprintf("%#v", this.SlaveId)+",\n")
}
if this.ExecutorId != nil {
s = append(s, "ExecutorId: "+fmt.Sprintf("%#v", this.ExecutorId)+",\n")
}
if this.Data != nil {
s = append(s, "Data: "+valueToGoStringScheduler(this.Data, "byte")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Call_Request) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&mesosproto.Call_Request{")
if this.Requests != nil {
s = append(s, "Requests: "+fmt.Sprintf("%#v", this.Requests)+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func valueToGoStringScheduler(v interface{}, typ string) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringScheduler(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
if e == nil {
return "nil"
}
s := "map[int32]proto.Extension{"
keys := make([]int, 0, len(e))
for k := range e {
keys = append(keys, int(k))
}
sort.Ints(keys)
ss := []string{}
for _, k := range keys {
ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
}
s += strings.Join(ss, ",") + "}"
return s
}
func (m *Event) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Type == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("type")
} else {
data[i] = 0x8
i++
i = encodeVarintScheduler(data, i, uint64(*m.Type))
}
if m.Subscribed != nil {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.Subscribed.Size()))
n1, err := m.Subscribed.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n1
}
if m.Offers != nil {
data[i] = 0x1a
i++
i = encodeVarintScheduler(data, i, uint64(m.Offers.Size()))
n2, err := m.Offers.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n2
}
if m.Rescind != nil {
data[i] = 0x22
i++
i = encodeVarintScheduler(data, i, uint64(m.Rescind.Size()))
n3, err := m.Rescind.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n3
}
if m.Update != nil {
data[i] = 0x2a
i++
i = encodeVarintScheduler(data, i, uint64(m.Update.Size()))
n4, err := m.Update.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n4
}
if m.Message != nil {
data[i] = 0x32
i++
i = encodeVarintScheduler(data, i, uint64(m.Message.Size()))
n5, err := m.Message.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n5
}
if m.Failure != nil {
data[i] = 0x3a
i++
i = encodeVarintScheduler(data, i, uint64(m.Failure.Size()))
n6, err := m.Failure.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n6
}
if m.Error != nil {
data[i] = 0x42
i++
i = encodeVarintScheduler(data, i, uint64(m.Error.Size()))
n7, err := m.Error.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n7
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Subscribed) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Subscribed) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.FrameworkId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.FrameworkId.Size()))
n8, err := m.FrameworkId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n8
}
if m.HeartbeatIntervalSeconds != nil {
data[i] = 0x11
i++
i = encodeFixed64Scheduler(data, i, uint64(math.Float64bits(*m.HeartbeatIntervalSeconds)))
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Offers) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Offers) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Offers) > 0 {
for _, msg := range m.Offers {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(msg.Size()))
n, err := msg.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Rescind) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Rescind) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.OfferId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("offer_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.OfferId.Size()))
n9, err := m.OfferId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n9
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Update) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Update) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Status == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("status")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.Status.Size()))
n10, err := m.Status.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n10
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Message) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Message) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.SlaveId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n11, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n11
}
if m.ExecutorId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
} else {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.ExecutorId.Size()))
n12, err := m.ExecutorId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n12
}
if m.Data == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
} else {
data[i] = 0x1a
i++
i = encodeVarintScheduler(data, i, uint64(len(m.Data)))
i += copy(data[i:], m.Data)
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Failure) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Failure) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.SlaveId != nil {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n13, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n13
}
if m.ExecutorId != nil {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.ExecutorId.Size()))
n14, err := m.ExecutorId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n14
}
if m.Status != nil {
data[i] = 0x18
i++
i = encodeVarintScheduler(data, i, uint64(*m.Status))
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Event_Error) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Event_Error) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Message == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("message")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(len(*m.Message)))
i += copy(data[i:], *m.Message)
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.FrameworkId != nil {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.FrameworkId.Size()))
n15, err := m.FrameworkId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n15
}
if m.Type == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("type")
} else {
data[i] = 0x10
i++
i = encodeVarintScheduler(data, i, uint64(*m.Type))
}
if m.Subscribe != nil {
data[i] = 0x1a
i++
i = encodeVarintScheduler(data, i, uint64(m.Subscribe.Size()))
n16, err := m.Subscribe.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n16
}
if m.Accept != nil {
data[i] = 0x22
i++
i = encodeVarintScheduler(data, i, uint64(m.Accept.Size()))
n17, err := m.Accept.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n17
}
if m.Decline != nil {
data[i] = 0x2a
i++
i = encodeVarintScheduler(data, i, uint64(m.Decline.Size()))
n18, err := m.Decline.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n18
}
if m.Kill != nil {
data[i] = 0x32
i++
i = encodeVarintScheduler(data, i, uint64(m.Kill.Size()))
n19, err := m.Kill.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n19
}
if m.Shutdown != nil {
data[i] = 0x3a
i++
i = encodeVarintScheduler(data, i, uint64(m.Shutdown.Size()))
n20, err := m.Shutdown.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n20
}
if m.Acknowledge != nil {
data[i] = 0x42
i++
i = encodeVarintScheduler(data, i, uint64(m.Acknowledge.Size()))
n21, err := m.Acknowledge.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n21
}
if m.Reconcile != nil {
data[i] = 0x4a
i++
i = encodeVarintScheduler(data, i, uint64(m.Reconcile.Size()))
n22, err := m.Reconcile.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n22
}
if m.Message != nil {
data[i] = 0x52
i++
i = encodeVarintScheduler(data, i, uint64(m.Message.Size()))
n23, err := m.Message.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n23
}
if m.Request != nil {
data[i] = 0x5a
i++
i = encodeVarintScheduler(data, i, uint64(m.Request.Size()))
n24, err := m.Request.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n24
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Subscribe) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Subscribe) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.FrameworkInfo == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_info")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.FrameworkInfo.Size()))
n25, err := m.FrameworkInfo.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n25
}
if m.Force != nil {
data[i] = 0x10
i++
if *m.Force {
data[i] = 1
} else {
data[i] = 0
}
i++
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Accept) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Accept) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.OfferIds) > 0 {
for _, msg := range m.OfferIds {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(msg.Size()))
n, err := msg.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n
}
}
if len(m.Operations) > 0 {
for _, msg := range m.Operations {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(msg.Size()))
n, err := msg.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.Filters != nil {
data[i] = 0x1a
i++
i = encodeVarintScheduler(data, i, uint64(m.Filters.Size()))
n26, err := m.Filters.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n26
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Decline) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Decline) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.OfferIds) > 0 {
for _, msg := range m.OfferIds {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(msg.Size()))
n, err := msg.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.Filters != nil {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.Filters.Size()))
n27, err := m.Filters.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n27
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Kill) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Kill) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.TaskId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("task_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.TaskId.Size()))
n28, err := m.TaskId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n28
}
if m.SlaveId != nil {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n29, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n29
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Shutdown) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Shutdown) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.ExecutorId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.ExecutorId.Size()))
n30, err := m.ExecutorId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n30
}
if m.SlaveId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
} else {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n31, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n31
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Acknowledge) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Acknowledge) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.SlaveId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n32, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n32
}
if m.TaskId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("task_id")
} else {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.TaskId.Size()))
n33, err := m.TaskId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n33
}
if m.Uuid == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("uuid")
} else {
data[i] = 0x1a
i++
i = encodeVarintScheduler(data, i, uint64(len(m.Uuid)))
i += copy(data[i:], m.Uuid)
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Reconcile) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Reconcile) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Tasks) > 0 {
for _, msg := range m.Tasks {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(msg.Size()))
n, err := msg.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Reconcile_Task) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Reconcile_Task) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.TaskId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("task_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.TaskId.Size()))
n34, err := m.TaskId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n34
}
if m.SlaveId != nil {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n35, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n35
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Message) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Message) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.SlaveId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
} else {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(m.SlaveId.Size()))
n36, err := m.SlaveId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n36
}
if m.ExecutorId == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
} else {
data[i] = 0x12
i++
i = encodeVarintScheduler(data, i, uint64(m.ExecutorId.Size()))
n37, err := m.ExecutorId.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n37
}
if m.Data == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
} else {
data[i] = 0x1a
i++
i = encodeVarintScheduler(data, i, uint64(len(m.Data)))
i += copy(data[i:], m.Data)
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Call_Request) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *Call_Request) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Requests) > 0 {
for _, msg := range m.Requests {
data[i] = 0xa
i++
i = encodeVarintScheduler(data, i, uint64(msg.Size()))
n, err := msg.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func encodeFixed64Scheduler(data []byte, offset int, v uint64) int {
data[offset] = uint8(v)
data[offset+1] = uint8(v >> 8)
data[offset+2] = uint8(v >> 16)
data[offset+3] = uint8(v >> 24)
data[offset+4] = uint8(v >> 32)
data[offset+5] = uint8(v >> 40)
data[offset+6] = uint8(v >> 48)
data[offset+7] = uint8(v >> 56)
return offset + 8
}
func encodeFixed32Scheduler(data []byte, offset int, v uint32) int {
data[offset] = uint8(v)
data[offset+1] = uint8(v >> 8)
data[offset+2] = uint8(v >> 16)
data[offset+3] = uint8(v >> 24)
return offset + 4
}
func encodeVarintScheduler(data []byte, offset int, v uint64) int {
for v >= 1<<7 {
data[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
data[offset] = uint8(v)
return offset + 1
}
func NewPopulatedEvent(r randyScheduler, easy bool) *Event {
this := &Event{}
v1 := Event_Type([]int32{1, 2, 3, 4, 5, 6, 7, 8}[r.Intn(8)])
this.Type = &v1
if r.Intn(10) != 0 {
this.Subscribed = NewPopulatedEvent_Subscribed(r, easy)
}
if r.Intn(10) != 0 {
this.Offers = NewPopulatedEvent_Offers(r, easy)
}
if r.Intn(10) != 0 {
this.Rescind = NewPopulatedEvent_Rescind(r, easy)
}
if r.Intn(10) != 0 {
this.Update = NewPopulatedEvent_Update(r, easy)
}
if r.Intn(10) != 0 {
this.Message = NewPopulatedEvent_Message(r, easy)
}
if r.Intn(10) != 0 {
this.Failure = NewPopulatedEvent_Failure(r, easy)
}
if r.Intn(10) != 0 {
this.Error = NewPopulatedEvent_Error(r, easy)
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 9)
}
return this
}
func NewPopulatedEvent_Subscribed(r randyScheduler, easy bool) *Event_Subscribed {
this := &Event_Subscribed{}
this.FrameworkId = NewPopulatedFrameworkID(r, easy)
if r.Intn(10) != 0 {
v2 := float64(r.Float64())
if r.Intn(2) == 0 {
v2 *= -1
}
this.HeartbeatIntervalSeconds = &v2
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 3)
}
return this
}
func NewPopulatedEvent_Offers(r randyScheduler, easy bool) *Event_Offers {
this := &Event_Offers{}
if r.Intn(10) != 0 {
v3 := r.Intn(10)
this.Offers = make([]*Offer, v3)
for i := 0; i < v3; i++ {
this.Offers[i] = NewPopulatedOffer(r, easy)
}
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 2)
}
return this
}
func NewPopulatedEvent_Rescind(r randyScheduler, easy bool) *Event_Rescind {
this := &Event_Rescind{}
this.OfferId = NewPopulatedOfferID(r, easy)
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 2)
}
return this
}
func NewPopulatedEvent_Update(r randyScheduler, easy bool) *Event_Update {
this := &Event_Update{}
this.Status = NewPopulatedTaskStatus(r, easy)
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 2)
}
return this
}
func NewPopulatedEvent_Message(r randyScheduler, easy bool) *Event_Message {
this := &Event_Message{}
this.SlaveId = NewPopulatedSlaveID(r, easy)
this.ExecutorId = NewPopulatedExecutorID(r, easy)
v4 := r.Intn(100)
this.Data = make([]byte, v4)
for i := 0; i < v4; i++ {
this.Data[i] = byte(r.Intn(256))
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 4)
}
return this
}
func NewPopulatedEvent_Failure(r randyScheduler, easy bool) *Event_Failure {
this := &Event_Failure{}
if r.Intn(10) != 0 {
this.SlaveId = NewPopulatedSlaveID(r, easy)
}
if r.Intn(10) != 0 {
this.ExecutorId = NewPopulatedExecutorID(r, easy)
}
if r.Intn(10) != 0 {
v5 := int32(r.Int31())
if r.Intn(2) == 0 {
v5 *= -1
}
this.Status = &v5
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 4)
}
return this
}
func NewPopulatedEvent_Error(r randyScheduler, easy bool) *Event_Error {
this := &Event_Error{}
v6 := randStringScheduler(r)
this.Message = &v6
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 2)
}
return this
}
func NewPopulatedCall(r randyScheduler, easy bool) *Call {
this := &Call{}
if r.Intn(10) != 0 {
this.FrameworkId = NewPopulatedFrameworkID(r, easy)
}
v7 := Call_Type([]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}[r.Intn(11)])
this.Type = &v7
if r.Intn(10) != 0 {
this.Subscribe = NewPopulatedCall_Subscribe(r, easy)
}
if r.Intn(10) != 0 {
this.Accept = NewPopulatedCall_Accept(r, easy)
}
if r.Intn(10) != 0 {
this.Decline = NewPopulatedCall_Decline(r, easy)
}
if r.Intn(10) != 0 {
this.Kill = NewPopulatedCall_Kill(r, easy)
}
if r.Intn(10) != 0 {
this.Shutdown = NewPopulatedCall_Shutdown(r, easy)
}
if r.Intn(10) != 0 {
this.Acknowledge = NewPopulatedCall_Acknowledge(r, easy)
}
if r.Intn(10) != 0 {
this.Reconcile = NewPopulatedCall_Reconcile(r, easy)
}
if r.Intn(10) != 0 {
this.Message = NewPopulatedCall_Message(r, easy)
}
if r.Intn(10) != 0 {
this.Request = NewPopulatedCall_Request(r, easy)
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 12)
}
return this
}
func NewPopulatedCall_Subscribe(r randyScheduler, easy bool) *Call_Subscribe {
this := &Call_Subscribe{}
this.FrameworkInfo = NewPopulatedFrameworkInfo(r, easy)
if r.Intn(10) != 0 {
v8 := bool(bool(r.Intn(2) == 0))
this.Force = &v8
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 3)
}
return this
}
func NewPopulatedCall_Accept(r randyScheduler, easy bool) *Call_Accept {
this := &Call_Accept{}
if r.Intn(10) != 0 {
v9 := r.Intn(10)
this.OfferIds = make([]*OfferID, v9)
for i := 0; i < v9; i++ {
this.OfferIds[i] = NewPopulatedOfferID(r, easy)
}
}
if r.Intn(10) != 0 {
v10 := r.Intn(10)
this.Operations = make([]*Offer_Operation, v10)
for i := 0; i < v10; i++ {
this.Operations[i] = NewPopulatedOffer_Operation(r, easy)
}
}
if r.Intn(10) != 0 {
this.Filters = NewPopulatedFilters(r, easy)
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 4)
}
return this
}
func NewPopulatedCall_Decline(r randyScheduler, easy bool) *Call_Decline {
this := &Call_Decline{}
if r.Intn(10) != 0 {
v11 := r.Intn(10)
this.OfferIds = make([]*OfferID, v11)
for i := 0; i < v11; i++ {
this.OfferIds[i] = NewPopulatedOfferID(r, easy)
}
}
if r.Intn(10) != 0 {
this.Filters = NewPopulatedFilters(r, easy)
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 3)
}
return this
}
func NewPopulatedCall_Kill(r randyScheduler, easy bool) *Call_Kill {
this := &Call_Kill{}
this.TaskId = NewPopulatedTaskID(r, easy)
if r.Intn(10) != 0 {
this.SlaveId = NewPopulatedSlaveID(r, easy)
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 3)
}
return this
}
func NewPopulatedCall_Shutdown(r randyScheduler, easy bool) *Call_Shutdown {
this := &Call_Shutdown{}
this.ExecutorId = NewPopulatedExecutorID(r, easy)
this.SlaveId = NewPopulatedSlaveID(r, easy)
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 3)
}
return this
}
func NewPopulatedCall_Acknowledge(r randyScheduler, easy bool) *Call_Acknowledge {
this := &Call_Acknowledge{}
this.SlaveId = NewPopulatedSlaveID(r, easy)
this.TaskId = NewPopulatedTaskID(r, easy)
v12 := r.Intn(100)
this.Uuid = make([]byte, v12)
for i := 0; i < v12; i++ {
this.Uuid[i] = byte(r.Intn(256))
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 4)
}
return this
}
func NewPopulatedCall_Reconcile(r randyScheduler, easy bool) *Call_Reconcile {
this := &Call_Reconcile{}
if r.Intn(10) != 0 {
v13 := r.Intn(10)
this.Tasks = make([]*Call_Reconcile_Task, v13)
for i := 0; i < v13; i++ {
this.Tasks[i] = NewPopulatedCall_Reconcile_Task(r, easy)
}
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 2)
}
return this
}
func NewPopulatedCall_Reconcile_Task(r randyScheduler, easy bool) *Call_Reconcile_Task {
this := &Call_Reconcile_Task{}
this.TaskId = NewPopulatedTaskID(r, easy)
if r.Intn(10) != 0 {
this.SlaveId = NewPopulatedSlaveID(r, easy)
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 3)
}
return this
}
func NewPopulatedCall_Message(r randyScheduler, easy bool) *Call_Message {
this := &Call_Message{}
this.SlaveId = NewPopulatedSlaveID(r, easy)
this.ExecutorId = NewPopulatedExecutorID(r, easy)
v14 := r.Intn(100)
this.Data = make([]byte, v14)
for i := 0; i < v14; i++ {
this.Data[i] = byte(r.Intn(256))
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 4)
}
return this
}
func NewPopulatedCall_Request(r randyScheduler, easy bool) *Call_Request {
this := &Call_Request{}
if r.Intn(10) != 0 {
v15 := r.Intn(10)
this.Requests = make([]*Request, v15)
for i := 0; i < v15; i++ {
this.Requests[i] = NewPopulatedRequest(r, easy)
}
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedScheduler(r, 2)
}
return this
}
type randyScheduler interface {
Float32() float32
Float64() float64
Int63() int64
Int31() int32
Uint32() uint32
Intn(n int) int
}
func randUTF8RuneScheduler(r randyScheduler) rune {
ru := r.Intn(62)
if ru < 10 {
return rune(ru + 48)
} else if ru < 36 {
return rune(ru + 55)
}
return rune(ru + 61)
}
func randStringScheduler(r randyScheduler) string {
v16 := r.Intn(100)
tmps := make([]rune, v16)
for i := 0; i < v16; i++ {
tmps[i] = randUTF8RuneScheduler(r)
}
return string(tmps)
}
func randUnrecognizedScheduler(r randyScheduler, maxFieldNumber int) (data []byte) {
l := r.Intn(5)
for i := 0; i < l; i++ {
wire := r.Intn(4)
if wire == 3 {
wire = 5
}
fieldNumber := maxFieldNumber + r.Intn(100)
data = randFieldScheduler(data, r, fieldNumber, wire)
}
return data
}
func randFieldScheduler(data []byte, r randyScheduler, fieldNumber int, wire int) []byte {
key := uint32(fieldNumber)<<3 | uint32(wire)
switch wire {
case 0:
data = encodeVarintPopulateScheduler(data, uint64(key))
v17 := r.Int63()
if r.Intn(2) == 0 {
v17 *= -1
}
data = encodeVarintPopulateScheduler(data, uint64(v17))
case 1:
data = encodeVarintPopulateScheduler(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
case 2:
data = encodeVarintPopulateScheduler(data, uint64(key))
ll := r.Intn(100)
data = encodeVarintPopulateScheduler(data, uint64(ll))
for j := 0; j < ll; j++ {
data = append(data, byte(r.Intn(256)))
}
default:
data = encodeVarintPopulateScheduler(data, uint64(key))
data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
}
return data
}
func encodeVarintPopulateScheduler(data []byte, v uint64) []byte {
for v >= 1<<7 {
data = append(data, uint8(uint64(v)&0x7f|0x80))
v >>= 7
}
data = append(data, uint8(v))
return data
}
func (m *Event) Size() (n int) {
var l int
_ = l
if m.Type != nil {
n += 1 + sovScheduler(uint64(*m.Type))
}
if m.Subscribed != nil {
l = m.Subscribed.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Offers != nil {
l = m.Offers.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Rescind != nil {
l = m.Rescind.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Update != nil {
l = m.Update.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Message != nil {
l = m.Message.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Failure != nil {
l = m.Failure.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Error != nil {
l = m.Error.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Subscribed) Size() (n int) {
var l int
_ = l
if m.FrameworkId != nil {
l = m.FrameworkId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.HeartbeatIntervalSeconds != nil {
n += 9
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Offers) Size() (n int) {
var l int
_ = l
if len(m.Offers) > 0 {
for _, e := range m.Offers {
l = e.Size()
n += 1 + l + sovScheduler(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Rescind) Size() (n int) {
var l int
_ = l
if m.OfferId != nil {
l = m.OfferId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Update) Size() (n int) {
var l int
_ = l
if m.Status != nil {
l = m.Status.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Message) Size() (n int) {
var l int
_ = l
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.ExecutorId != nil {
l = m.ExecutorId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Data != nil {
l = len(m.Data)
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Failure) Size() (n int) {
var l int
_ = l
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.ExecutorId != nil {
l = m.ExecutorId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Status != nil {
n += 1 + sovScheduler(uint64(*m.Status))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Event_Error) Size() (n int) {
var l int
_ = l
if m.Message != nil {
l = len(*m.Message)
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call) Size() (n int) {
var l int
_ = l
if m.FrameworkId != nil {
l = m.FrameworkId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Type != nil {
n += 1 + sovScheduler(uint64(*m.Type))
}
if m.Subscribe != nil {
l = m.Subscribe.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Accept != nil {
l = m.Accept.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Decline != nil {
l = m.Decline.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Kill != nil {
l = m.Kill.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Shutdown != nil {
l = m.Shutdown.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Acknowledge != nil {
l = m.Acknowledge.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Reconcile != nil {
l = m.Reconcile.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Message != nil {
l = m.Message.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Request != nil {
l = m.Request.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Subscribe) Size() (n int) {
var l int
_ = l
if m.FrameworkInfo != nil {
l = m.FrameworkInfo.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Force != nil {
n += 2
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Accept) Size() (n int) {
var l int
_ = l
if len(m.OfferIds) > 0 {
for _, e := range m.OfferIds {
l = e.Size()
n += 1 + l + sovScheduler(uint64(l))
}
}
if len(m.Operations) > 0 {
for _, e := range m.Operations {
l = e.Size()
n += 1 + l + sovScheduler(uint64(l))
}
}
if m.Filters != nil {
l = m.Filters.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Decline) Size() (n int) {
var l int
_ = l
if len(m.OfferIds) > 0 {
for _, e := range m.OfferIds {
l = e.Size()
n += 1 + l + sovScheduler(uint64(l))
}
}
if m.Filters != nil {
l = m.Filters.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Kill) Size() (n int) {
var l int
_ = l
if m.TaskId != nil {
l = m.TaskId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Shutdown) Size() (n int) {
var l int
_ = l
if m.ExecutorId != nil {
l = m.ExecutorId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Acknowledge) Size() (n int) {
var l int
_ = l
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.TaskId != nil {
l = m.TaskId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Uuid != nil {
l = len(m.Uuid)
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Reconcile) Size() (n int) {
var l int
_ = l
if len(m.Tasks) > 0 {
for _, e := range m.Tasks {
l = e.Size()
n += 1 + l + sovScheduler(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Reconcile_Task) Size() (n int) {
var l int
_ = l
if m.TaskId != nil {
l = m.TaskId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Message) Size() (n int) {
var l int
_ = l
if m.SlaveId != nil {
l = m.SlaveId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.ExecutorId != nil {
l = m.ExecutorId.Size()
n += 1 + l + sovScheduler(uint64(l))
}
if m.Data != nil {
l = len(m.Data)
n += 1 + l + sovScheduler(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Call_Request) Size() (n int) {
var l int
_ = l
if len(m.Requests) > 0 {
for _, e := range m.Requests {
l = e.Size()
n += 1 + l + sovScheduler(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovScheduler(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozScheduler(x uint64) (n int) {
return sovScheduler(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Event) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event{`,
`Type:` + valueToStringScheduler(this.Type) + `,`,
`Subscribed:` + strings.Replace(fmt.Sprintf("%v", this.Subscribed), "Event_Subscribed", "Event_Subscribed", 1) + `,`,
`Offers:` + strings.Replace(fmt.Sprintf("%v", this.Offers), "Event_Offers", "Event_Offers", 1) + `,`,
`Rescind:` + strings.Replace(fmt.Sprintf("%v", this.Rescind), "Event_Rescind", "Event_Rescind", 1) + `,`,
`Update:` + strings.Replace(fmt.Sprintf("%v", this.Update), "Event_Update", "Event_Update", 1) + `,`,
`Message:` + strings.Replace(fmt.Sprintf("%v", this.Message), "Event_Message", "Event_Message", 1) + `,`,
`Failure:` + strings.Replace(fmt.Sprintf("%v", this.Failure), "Event_Failure", "Event_Failure", 1) + `,`,
`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Event_Error", "Event_Error", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Subscribed) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Subscribed{`,
`FrameworkId:` + strings.Replace(fmt.Sprintf("%v", this.FrameworkId), "FrameworkID", "FrameworkID", 1) + `,`,
`HeartbeatIntervalSeconds:` + valueToStringScheduler(this.HeartbeatIntervalSeconds) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Offers) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Offers{`,
`Offers:` + strings.Replace(fmt.Sprintf("%v", this.Offers), "Offer", "Offer", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Rescind) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Rescind{`,
`OfferId:` + strings.Replace(fmt.Sprintf("%v", this.OfferId), "OfferID", "OfferID", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Update) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Update{`,
`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "TaskStatus", "TaskStatus", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Message) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Message{`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`ExecutorId:` + strings.Replace(fmt.Sprintf("%v", this.ExecutorId), "ExecutorID", "ExecutorID", 1) + `,`,
`Data:` + valueToStringScheduler(this.Data) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Failure) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Failure{`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`ExecutorId:` + strings.Replace(fmt.Sprintf("%v", this.ExecutorId), "ExecutorID", "ExecutorID", 1) + `,`,
`Status:` + valueToStringScheduler(this.Status) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Event_Error) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Event_Error{`,
`Message:` + valueToStringScheduler(this.Message) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call{`,
`FrameworkId:` + strings.Replace(fmt.Sprintf("%v", this.FrameworkId), "FrameworkID", "FrameworkID", 1) + `,`,
`Type:` + valueToStringScheduler(this.Type) + `,`,
`Subscribe:` + strings.Replace(fmt.Sprintf("%v", this.Subscribe), "Call_Subscribe", "Call_Subscribe", 1) + `,`,
`Accept:` + strings.Replace(fmt.Sprintf("%v", this.Accept), "Call_Accept", "Call_Accept", 1) + `,`,
`Decline:` + strings.Replace(fmt.Sprintf("%v", this.Decline), "Call_Decline", "Call_Decline", 1) + `,`,
`Kill:` + strings.Replace(fmt.Sprintf("%v", this.Kill), "Call_Kill", "Call_Kill", 1) + `,`,
`Shutdown:` + strings.Replace(fmt.Sprintf("%v", this.Shutdown), "Call_Shutdown", "Call_Shutdown", 1) + `,`,
`Acknowledge:` + strings.Replace(fmt.Sprintf("%v", this.Acknowledge), "Call_Acknowledge", "Call_Acknowledge", 1) + `,`,
`Reconcile:` + strings.Replace(fmt.Sprintf("%v", this.Reconcile), "Call_Reconcile", "Call_Reconcile", 1) + `,`,
`Message:` + strings.Replace(fmt.Sprintf("%v", this.Message), "Call_Message", "Call_Message", 1) + `,`,
`Request:` + strings.Replace(fmt.Sprintf("%v", this.Request), "Call_Request", "Call_Request", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Subscribe) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Subscribe{`,
`FrameworkInfo:` + strings.Replace(fmt.Sprintf("%v", this.FrameworkInfo), "FrameworkInfo", "FrameworkInfo", 1) + `,`,
`Force:` + valueToStringScheduler(this.Force) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Accept) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Accept{`,
`OfferIds:` + strings.Replace(fmt.Sprintf("%v", this.OfferIds), "OfferID", "OfferID", 1) + `,`,
`Operations:` + strings.Replace(fmt.Sprintf("%v", this.Operations), "Offer_Operation", "Offer_Operation", 1) + `,`,
`Filters:` + strings.Replace(fmt.Sprintf("%v", this.Filters), "Filters", "Filters", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Decline) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Decline{`,
`OfferIds:` + strings.Replace(fmt.Sprintf("%v", this.OfferIds), "OfferID", "OfferID", 1) + `,`,
`Filters:` + strings.Replace(fmt.Sprintf("%v", this.Filters), "Filters", "Filters", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Kill) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Kill{`,
`TaskId:` + strings.Replace(fmt.Sprintf("%v", this.TaskId), "TaskID", "TaskID", 1) + `,`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Shutdown) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Shutdown{`,
`ExecutorId:` + strings.Replace(fmt.Sprintf("%v", this.ExecutorId), "ExecutorID", "ExecutorID", 1) + `,`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Acknowledge) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Acknowledge{`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`TaskId:` + strings.Replace(fmt.Sprintf("%v", this.TaskId), "TaskID", "TaskID", 1) + `,`,
`Uuid:` + valueToStringScheduler(this.Uuid) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Reconcile) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Reconcile{`,
`Tasks:` + strings.Replace(fmt.Sprintf("%v", this.Tasks), "Call_Reconcile_Task", "Call_Reconcile_Task", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Reconcile_Task) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Reconcile_Task{`,
`TaskId:` + strings.Replace(fmt.Sprintf("%v", this.TaskId), "TaskID", "TaskID", 1) + `,`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Message) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Message{`,
`SlaveId:` + strings.Replace(fmt.Sprintf("%v", this.SlaveId), "SlaveID", "SlaveID", 1) + `,`,
`ExecutorId:` + strings.Replace(fmt.Sprintf("%v", this.ExecutorId), "ExecutorID", "ExecutorID", 1) + `,`,
`Data:` + valueToStringScheduler(this.Data) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Call_Request) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Call_Request{`,
`Requests:` + strings.Replace(fmt.Sprintf("%v", this.Requests), "Request", "Request", 1) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func valueToStringScheduler(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *Event) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
var v Event_Type
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
v |= (Event_Type(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Type = &v
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Subscribed", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Subscribed == nil {
m.Subscribed = &Event_Subscribed{}
}
if err := m.Subscribed.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Offers", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Offers == nil {
m.Offers = &Event_Offers{}
}
if err := m.Offers.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Rescind", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Rescind == nil {
m.Rescind = &Event_Rescind{}
}
if err := m.Rescind.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Update == nil {
m.Update = &Event_Update{}
}
if err := m.Update.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Message == nil {
m.Message = &Event_Message{}
}
if err := m.Message.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Failure == nil {
m.Failure = &Event_Failure{}
}
if err := m.Failure.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Error == nil {
m.Error = &Event_Error{}
}
if err := m.Error.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("type")
}
return nil
}
func (m *Event_Subscribed) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FrameworkId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.FrameworkId == nil {
m.FrameworkId = &FrameworkID{}
}
if err := m.FrameworkId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 1 {
return fmt.Errorf("proto: wrong wireType = %d for field HeartbeatIntervalSeconds", wireType)
}
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
iNdEx += 8
v = uint64(data[iNdEx-8])
v |= uint64(data[iNdEx-7]) << 8
v |= uint64(data[iNdEx-6]) << 16
v |= uint64(data[iNdEx-5]) << 24
v |= uint64(data[iNdEx-4]) << 32
v |= uint64(data[iNdEx-3]) << 40
v |= uint64(data[iNdEx-2]) << 48
v |= uint64(data[iNdEx-1]) << 56
v2 := float64(math.Float64frombits(v))
m.HeartbeatIntervalSeconds = &v2
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_id")
}
return nil
}
func (m *Event_Offers) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Offers", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Offers = append(m.Offers, &Offer{})
if err := m.Offers[len(m.Offers)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
return nil
}
func (m *Event_Rescind) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field OfferId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.OfferId == nil {
m.OfferId = &OfferID{}
}
if err := m.OfferId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("offer_id")
}
return nil
}
func (m *Event_Update) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Status == nil {
m.Status = &TaskStatus{}
}
if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("status")
}
return nil
}
func (m *Event_Message) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ExecutorId == nil {
m.ExecutorId = &ExecutorID{}
}
if err := m.ExecutorId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000002)
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Data = append([]byte{}, data[iNdEx:postIndex]...)
iNdEx = postIndex
hasFields[0] |= uint64(0x00000004)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
}
if hasFields[0]&uint64(0x00000002) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
}
if hasFields[0]&uint64(0x00000004) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
}
return nil
}
func (m *Event_Failure) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ExecutorId == nil {
m.ExecutorId = &ExecutorID{}
}
if err := m.ExecutorId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
}
var v int32
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
v |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Status = &v
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
return nil
}
func (m *Event_Error) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := string(data[iNdEx:postIndex])
m.Message = &s
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("message")
}
return nil
}
func (m *Call) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FrameworkId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.FrameworkId == nil {
m.FrameworkId = &FrameworkID{}
}
if err := m.FrameworkId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
var v Call_Type
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
v |= (Call_Type(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Type = &v
hasFields[0] |= uint64(0x00000001)
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Subscribe", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Subscribe == nil {
m.Subscribe = &Call_Subscribe{}
}
if err := m.Subscribe.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Accept", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Accept == nil {
m.Accept = &Call_Accept{}
}
if err := m.Accept.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Decline", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Decline == nil {
m.Decline = &Call_Decline{}
}
if err := m.Decline.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Kill", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Kill == nil {
m.Kill = &Call_Kill{}
}
if err := m.Kill.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Shutdown", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Shutdown == nil {
m.Shutdown = &Call_Shutdown{}
}
if err := m.Shutdown.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Acknowledge", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Acknowledge == nil {
m.Acknowledge = &Call_Acknowledge{}
}
if err := m.Acknowledge.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Reconcile", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Reconcile == nil {
m.Reconcile = &Call_Reconcile{}
}
if err := m.Reconcile.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 10:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Message == nil {
m.Message = &Call_Message{}
}
if err := m.Message.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 11:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Request == nil {
m.Request = &Call_Request{}
}
if err := m.Request.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("type")
}
return nil
}
func (m *Call_Subscribe) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FrameworkInfo", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.FrameworkInfo == nil {
m.FrameworkInfo = &FrameworkInfo{}
}
if err := m.FrameworkInfo.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Force", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
b := bool(v != 0)
m.Force = &b
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_info")
}
return nil
}
func (m *Call_Accept) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field OfferIds", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.OfferIds = append(m.OfferIds, &OfferID{})
if err := m.OfferIds[len(m.OfferIds)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Operations = append(m.Operations, &Offer_Operation{})
if err := m.Operations[len(m.Operations)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Filters == nil {
m.Filters = &Filters{}
}
if err := m.Filters.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
return nil
}
func (m *Call_Decline) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field OfferIds", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.OfferIds = append(m.OfferIds, &OfferID{})
if err := m.OfferIds[len(m.OfferIds)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Filters == nil {
m.Filters = &Filters{}
}
if err := m.Filters.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
return nil
}
func (m *Call_Kill) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.TaskId == nil {
m.TaskId = &TaskID{}
}
if err := m.TaskId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("task_id")
}
return nil
}
func (m *Call_Shutdown) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ExecutorId == nil {
m.ExecutorId = &ExecutorID{}
}
if err := m.ExecutorId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000002)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
}
if hasFields[0]&uint64(0x00000002) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
}
return nil
}
func (m *Call_Acknowledge) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.TaskId == nil {
m.TaskId = &TaskID{}
}
if err := m.TaskId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000002)
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Uuid = append([]byte{}, data[iNdEx:postIndex]...)
iNdEx = postIndex
hasFields[0] |= uint64(0x00000004)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
}
if hasFields[0]&uint64(0x00000002) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("task_id")
}
if hasFields[0]&uint64(0x00000004) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("uuid")
}
return nil
}
func (m *Call_Reconcile) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Tasks", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Tasks = append(m.Tasks, &Call_Reconcile_Task{})
if err := m.Tasks[len(m.Tasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
return nil
}
func (m *Call_Reconcile_Task) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.TaskId == nil {
m.TaskId = &TaskID{}
}
if err := m.TaskId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("task_id")
}
return nil
}
func (m *Call_Message) Unmarshal(data []byte) error {
var hasFields [1]uint64
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SlaveId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SlaveId == nil {
m.SlaveId = &SlaveID{}
}
if err := m.SlaveId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ExecutorId == nil {
m.ExecutorId = &ExecutorID{}
}
if err := m.ExecutorId.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000002)
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Data = append([]byte{}, data[iNdEx:postIndex]...)
iNdEx = postIndex
hasFields[0] |= uint64(0x00000004)
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("slave_id")
}
if hasFields[0]&uint64(0x00000002) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
}
if hasFields[0]&uint64(0x00000004) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
}
return nil
}
func (m *Call_Request) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthScheduler
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Requests = append(m.Requests, &Request{})
if err := m.Requests[len(m.Requests)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
var sizeOfWire int
for {
sizeOfWire++
wire >>= 7
if wire == 0 {
break
}
}
iNdEx -= sizeOfWire
skippy, err := skipScheduler(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthScheduler
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
return nil
}
func skipScheduler(data []byte) (n int, err error) {
l := len(data)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for {
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if data[iNdEx-1] < 0x80 {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthScheduler
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipScheduler(data[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
}
return iNdEx, nil
case 4:
return iNdEx, nil
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
}
panic("unreachable")
}
var (
ErrInvalidLengthScheduler = fmt.Errorf("proto: negative length found during unmarshaling")
)