strive.pb.go

// Code generated by protoc-gen-gogo.
// source: strive.proto
// DO NOT EDIT!

/*
	Package strive is a generated protocol buffer package.

	It is generated from these files:
		strive.proto

	It has these top-level messages:
		Range
		Ranges
		Value
		Variable
		Resource
		Host
		PortBinding
		ContainerInfo
		TaskDescription
		HostResource
		Task
		ClusterState
		UpdateState
		FetchState
		StartTask
		StopTask
		OpAcknowledged
		TaskStatusChange
		HostStatusChange
		ListTasks
		CurrentTasks
		Error
		GenericError
		StopError
		CheckTasks
		CheckedTaskList
*/
package strive

import proto "github.com/gogo/protobuf/proto"
import math "math"

// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto/gogo.pb"
import tai64n "github.com/vektra/tai64n"

import io "io"
import fmt "fmt"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"

import strings "strings"
import reflect "reflect"

import bytes "bytes"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = math.Inf

type HostStatus int32

const (
	HostStatus_UNKNOWN  HostStatus = 0
	HostStatus_ONLINE   HostStatus = 1
	HostStatus_DISABLED HostStatus = 2
	HostStatus_OFFLINE  HostStatus = 3
)

var HostStatus_name = map[int32]string{
	0: "UNKNOWN",
	1: "ONLINE",
	2: "DISABLED",
	3: "OFFLINE",
}
var HostStatus_value = map[string]int32{
	"UNKNOWN":  0,
	"ONLINE":   1,
	"DISABLED": 2,
	"OFFLINE":  3,
}

func (x HostStatus) Enum() *HostStatus {
	p := new(HostStatus)
	*p = x
	return p
}
func (x HostStatus) String() string {
	return proto.EnumName(HostStatus_name, int32(x))
}
func (x *HostStatus) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(HostStatus_value, data, "HostStatus")
	if err != nil {
		return err
	}
	*x = HostStatus(value)
	return nil
}

type TaskStatus int32

const (
	TaskStatus_CREATED  TaskStatus = 0
	TaskStatus_RUNNING  TaskStatus = 1
	TaskStatus_FINISHED TaskStatus = 2
	TaskStatus_FAILED   TaskStatus = 3
	TaskStatus_ERROR    TaskStatus = 4
	TaskStatus_LOST     TaskStatus = 5
)

var TaskStatus_name = map[int32]string{
	0: "CREATED",
	1: "RUNNING",
	2: "FINISHED",
	3: "FAILED",
	4: "ERROR",
	5: "LOST",
}
var TaskStatus_value = map[string]int32{
	"CREATED":  0,
	"RUNNING":  1,
	"FINISHED": 2,
	"FAILED":   3,
	"ERROR":    4,
	"LOST":     5,
}

func (x TaskStatus) Enum() *TaskStatus {
	p := new(TaskStatus)
	*p = x
	return p
}
func (x TaskStatus) String() string {
	return proto.EnumName(TaskStatus_name, int32(x))
}
func (x *TaskStatus) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TaskStatus_value, data, "TaskStatus")
	if err != nil {
		return err
	}
	*x = TaskStatus(value)
	return nil
}

type Value_ValueType int32

const (
	Value_INT    Value_ValueType = 0
	Value_STRING Value_ValueType = 1
	Value_BYTES  Value_ValueType = 2
	Value_BOOL   Value_ValueType = 3
	Value_RANGES Value_ValueType = 4
	Value_LIST   Value_ValueType = 5
	Value_MAP    Value_ValueType = 6
)

var Value_ValueType_name = map[int32]string{
	0: "INT",
	1: "STRING",
	2: "BYTES",
	3: "BOOL",
	4: "RANGES",
	5: "LIST",
	6: "MAP",
}
var Value_ValueType_value = map[string]int32{
	"INT":    0,
	"STRING": 1,
	"BYTES":  2,
	"BOOL":   3,
	"RANGES": 4,
	"LIST":   5,
	"MAP":    6,
}

func (x Value_ValueType) Enum() *Value_ValueType {
	p := new(Value_ValueType)
	*p = x
	return p
}
func (x Value_ValueType) String() string {
	return proto.EnumName(Value_ValueType_name, int32(x))
}
func (x *Value_ValueType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Value_ValueType_value, data, "Value_ValueType")
	if err != nil {
		return err
	}
	*x = Value_ValueType(value)
	return nil
}

type Resource_ResourceType int32

const (
	Resource_CPU    Resource_ResourceType = 0
	Resource_MEMORY Resource_ResourceType = 1
	Resource_PORT   Resource_ResourceType = 2
	Resource_VOLUME Resource_ResourceType = 3
	Resource_CUSTOM Resource_ResourceType = 4
)

var Resource_ResourceType_name = map[int32]string{
	0: "CPU",
	1: "MEMORY",
	2: "PORT",
	3: "VOLUME",
	4: "CUSTOM",
}
var Resource_ResourceType_value = map[string]int32{
	"CPU":    0,
	"MEMORY": 1,
	"PORT":   2,
	"VOLUME": 3,
	"CUSTOM": 4,
}

func (x Resource_ResourceType) Enum() *Resource_ResourceType {
	p := new(Resource_ResourceType)
	*p = x
	return p
}
func (x Resource_ResourceType) String() string {
	return proto.EnumName(Resource_ResourceType_name, int32(x))
}
func (x *Resource_ResourceType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Resource_ResourceType_value, data, "Resource_ResourceType")
	if err != nil {
		return err
	}
	*x = Resource_ResourceType(value)
	return nil
}

type PortBinding_Protocol int32

const (
	PortBinding_TCP PortBinding_Protocol = 0
	PortBinding_UDP PortBinding_Protocol = 1
)

var PortBinding_Protocol_name = map[int32]string{
	0: "TCP",
	1: "UDP",
}
var PortBinding_Protocol_value = map[string]int32{
	"TCP": 0,
	"UDP": 1,
}

func (x PortBinding_Protocol) Enum() *PortBinding_Protocol {
	p := new(PortBinding_Protocol)
	*p = x
	return p
}
func (x PortBinding_Protocol) String() string {
	return proto.EnumName(PortBinding_Protocol_name, int32(x))
}
func (x *PortBinding_Protocol) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(PortBinding_Protocol_value, data, "PortBinding_Protocol")
	if err != nil {
		return err
	}
	*x = PortBinding_Protocol(value)
	return nil
}

type ContainerInfo_ContainerMode int32

const (
	ContainerInfo_DOCKER ContainerInfo_ContainerMode = 0
)

var ContainerInfo_ContainerMode_name = map[int32]string{
	0: "DOCKER",
}
var ContainerInfo_ContainerMode_value = map[string]int32{
	"DOCKER": 0,
}

func (x ContainerInfo_ContainerMode) Enum() *ContainerInfo_ContainerMode {
	p := new(ContainerInfo_ContainerMode)
	*p = x
	return p
}
func (x ContainerInfo_ContainerMode) String() string {
	return proto.EnumName(ContainerInfo_ContainerMode_name, int32(x))
}
func (x *ContainerInfo_ContainerMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ContainerInfo_ContainerMode_value, data, "ContainerInfo_ContainerMode")
	if err != nil {
		return err
	}
	*x = ContainerInfo_ContainerMode(value)
	return nil
}

type Error_ErrorCode int32

const (
	Error_UNKNOWN         Error_ErrorCode = 0
	Error_UNKNOWN_TASK    Error_ErrorCode = 1
	Error_UNKNOWN_MESSAGE Error_ErrorCode = 2
)

var Error_ErrorCode_name = map[int32]string{
	0: "UNKNOWN",
	1: "UNKNOWN_TASK",
	2: "UNKNOWN_MESSAGE",
}
var Error_ErrorCode_value = map[string]int32{
	"UNKNOWN":         0,
	"UNKNOWN_TASK":    1,
	"UNKNOWN_MESSAGE": 2,
}

func (x Error_ErrorCode) Enum() *Error_ErrorCode {
	p := new(Error_ErrorCode)
	*p = x
	return p
}
func (x Error_ErrorCode) String() string {
	return proto.EnumName(Error_ErrorCode_name, int32(x))
}
func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
	if err != nil {
		return err
	}
	*x = Error_ErrorCode(value)
	return nil
}

type Range struct {
	Start            *int64 `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
	End              *int64 `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Range) Reset()      { *m = Range{} }
func (*Range) ProtoMessage() {}

func (m *Range) GetStart() int64 {
	if m != nil && m.Start != nil {
		return *m.Start
	}
	return 0
}

func (m *Range) GetEnd() int64 {
	if m != nil && m.End != nil {
		return *m.End
	}
	return 0
}

type Ranges struct {
	Ranges           []*Range `protobuf:"bytes,1,rep,name=ranges" json:"ranges,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *Ranges) Reset()      { *m = Ranges{} }
func (*Ranges) ProtoMessage() {}

func (m *Ranges) GetRanges() []*Range {
	if m != nil {
		return m.Ranges
	}
	return nil
}

type Value struct {
	ValueType        *Value_ValueType `protobuf:"varint,1,req,name=value_type,enum=strive.Value_ValueType" json:"value_type,omitempty"`
	IntVal           *int64           `protobuf:"varint,2,opt,name=int_val" json:"int_val,omitempty"`
	StrVal           *string          `protobuf:"bytes,3,opt,name=str_val" json:"str_val,omitempty"`
	BytesVal         []byte           `protobuf:"bytes,4,opt,name=bytes_val" json:"bytes_val,omitempty"`
	BoolVal          *bool            `protobuf:"varint,5,opt,name=bool_val" json:"bool_val,omitempty"`
	RangeVal         *Ranges          `protobuf:"bytes,6,opt,name=range_val" json:"range_val,omitempty"`
	ListVal          []*Value         `protobuf:"bytes,7,rep,name=list_val" json:"list_val,omitempty"`
	MapVal           []*Variable      `protobuf:"bytes,8,rep,name=map_val" json:"map_val,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *Value) Reset()      { *m = Value{} }
func (*Value) ProtoMessage() {}

func (m *Value) GetValueType() Value_ValueType {
	if m != nil && m.ValueType != nil {
		return *m.ValueType
	}
	return Value_INT
}

func (m *Value) GetIntVal() int64 {
	if m != nil && m.IntVal != nil {
		return *m.IntVal
	}
	return 0
}

func (m *Value) GetStrVal() string {
	if m != nil && m.StrVal != nil {
		return *m.StrVal
	}
	return ""
}

func (m *Value) GetBytesVal() []byte {
	if m != nil {
		return m.BytesVal
	}
	return nil
}

func (m *Value) GetBoolVal() bool {
	if m != nil && m.BoolVal != nil {
		return *m.BoolVal
	}
	return false
}

func (m *Value) GetRangeVal() *Ranges {
	if m != nil {
		return m.RangeVal
	}
	return nil
}

func (m *Value) GetListVal() []*Value {
	if m != nil {
		return m.ListVal
	}
	return nil
}

func (m *Value) GetMapVal() []*Variable {
	if m != nil {
		return m.MapVal
	}
	return nil
}

type Variable struct {
	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Value            *Value  `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *Variable) Reset()      { *m = Variable{} }
func (*Variable) ProtoMessage() {}

func (m *Variable) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *Variable) GetValue() *Value {
	if m != nil {
		return m.Value
	}
	return nil
}

type Resource struct {
	Type             *Resource_ResourceType `protobuf:"varint,1,req,name=type,enum=strive.Resource_ResourceType" json:"type,omitempty"`
	CustomType       *string                `protobuf:"bytes,2,opt,name=custom_type" json:"custom_type,omitempty"`
	Value            *Value                 `protobuf:"bytes,3,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte                 `json:"-"`
}

func (m *Resource) Reset()      { *m = Resource{} }
func (*Resource) ProtoMessage() {}

func (m *Resource) GetType() Resource_ResourceType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Resource_CPU
}

func (m *Resource) GetCustomType() string {
	if m != nil && m.CustomType != nil {
		return *m.CustomType
	}
	return ""
}

func (m *Resource) GetValue() *Value {
	if m != nil {
		return m.Value
	}
	return nil
}

type Host struct {
	HostId           *string        `protobuf:"bytes,1,req,name=host_id" json:"host_id,omitempty"`
	Name             *string        `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
	Resources        []*Resource    `protobuf:"bytes,3,rep,name=resources" json:"resources,omitempty"`
	Status           *HostStatus    `protobuf:"varint,4,req,name=status,enum=strive.HostStatus,def=0" json:"status,omitempty"`
	LastHeartbeat    *tai64n.TAI64N `protobuf:"bytes,5,req,name=last_heartbeat" json:"last_heartbeat,omitempty"`
	XXX_unrecognized []byte         `json:"-"`
}

func (m *Host) Reset()      { *m = Host{} }
func (*Host) ProtoMessage() {}

const Default_Host_Status HostStatus = HostStatus_UNKNOWN

func (m *Host) GetHostId() string {
	if m != nil && m.HostId != nil {
		return *m.HostId
	}
	return ""
}

func (m *Host) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *Host) GetResources() []*Resource {
	if m != nil {
		return m.Resources
	}
	return nil
}

func (m *Host) GetStatus() HostStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Default_Host_Status
}

func (m *Host) GetLastHeartbeat() *tai64n.TAI64N {
	if m != nil {
		return m.LastHeartbeat
	}
	return nil
}

type PortBinding struct {
	Host             *int64                `protobuf:"varint,1,req,name=host" json:"host,omitempty"`
	Container        *int64                `protobuf:"varint,2,req,name=container" json:"container,omitempty"`
	Protocol         *PortBinding_Protocol `protobuf:"varint,3,req,name=protocol,enum=strive.PortBinding_Protocol,def=0" json:"protocol,omitempty"`
	XXX_unrecognized []byte                `json:"-"`
}

func (m *PortBinding) Reset()      { *m = PortBinding{} }
func (*PortBinding) ProtoMessage() {}

const Default_PortBinding_Protocol PortBinding_Protocol = PortBinding_TCP

func (m *PortBinding) GetHost() int64 {
	if m != nil && m.Host != nil {
		return *m.Host
	}
	return 0
}

func (m *PortBinding) GetContainer() int64 {
	if m != nil && m.Container != nil {
		return *m.Container
	}
	return 0
}

func (m *PortBinding) GetProtocol() PortBinding_Protocol {
	if m != nil && m.Protocol != nil {
		return *m.Protocol
	}
	return Default_PortBinding_Protocol
}

type ContainerInfo struct {
	Mode             *ContainerInfo_ContainerMode `protobuf:"varint,1,req,name=mode,enum=strive.ContainerInfo_ContainerMode" json:"mode,omitempty"`
	Image            *string                      `protobuf:"bytes,2,req,name=image" json:"image,omitempty"`
	Ports            []*PortBinding               `protobuf:"bytes,3,rep,name=ports" json:"ports,omitempty"`
	XXX_unrecognized []byte                       `json:"-"`
}

func (m *ContainerInfo) Reset()      { *m = ContainerInfo{} }
func (*ContainerInfo) ProtoMessage() {}

func (m *ContainerInfo) GetMode() ContainerInfo_ContainerMode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return ContainerInfo_DOCKER
}

func (m *ContainerInfo) GetImage() string {
	if m != nil && m.Image != nil {
		return *m.Image
	}
	return ""
}

func (m *ContainerInfo) GetPorts() []*PortBinding {
	if m != nil {
		return m.Ports
	}
	return nil
}

type TaskDescription struct {
	Command          *string        `protobuf:"bytes,1,opt,name=command" json:"command,omitempty"`
	Exec             []string       `protobuf:"bytes,2,rep,name=exec" json:"exec,omitempty"`
	Env              []*Variable    `protobuf:"bytes,3,rep,name=env" json:"env,omitempty"`
	Urls             []string       `protobuf:"bytes,4,rep,name=urls" json:"urls,omitempty"`
	Config           []*Variable    `protobuf:"bytes,5,rep,name=config" json:"config,omitempty"`
	Metadata         []*Variable    `protobuf:"bytes,6,rep,name=metadata" json:"metadata,omitempty"`
	Labels           []string       `protobuf:"bytes,7,rep,name=labels" json:"labels,omitempty"`
	Container        *ContainerInfo `protobuf:"bytes,8,opt,name=container" json:"container,omitempty"`
	XXX_unrecognized []byte         `json:"-"`
}

func (m *TaskDescription) Reset()      { *m = TaskDescription{} }
func (*TaskDescription) ProtoMessage() {}

func (m *TaskDescription) GetCommand() string {
	if m != nil && m.Command != nil {
		return *m.Command
	}
	return ""
}

func (m *TaskDescription) GetExec() []string {
	if m != nil {
		return m.Exec
	}
	return nil
}

func (m *TaskDescription) GetEnv() []*Variable {
	if m != nil {
		return m.Env
	}
	return nil
}

func (m *TaskDescription) GetUrls() []string {
	if m != nil {
		return m.Urls
	}
	return nil
}

func (m *TaskDescription) GetConfig() []*Variable {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *TaskDescription) GetMetadata() []*Variable {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *TaskDescription) GetLabels() []string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *TaskDescription) GetContainer() *ContainerInfo {
	if m != nil {
		return m.Container
	}
	return nil
}

type HostResource struct {
	HostId           *string     `protobuf:"bytes,1,req,name=host_id" json:"host_id,omitempty"`
	Resources        []*Resource `protobuf:"bytes,2,rep,name=resources" json:"resources,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *HostResource) Reset()      { *m = HostResource{} }
func (*HostResource) ProtoMessage() {}

func (m *HostResource) GetHostId() string {
	if m != nil && m.HostId != nil {
		return *m.HostId
	}
	return ""
}

func (m *HostResource) GetResources() []*Resource {
	if m != nil {
		return m.Resources
	}
	return nil
}

type Task struct {
	TaskId           *string          `protobuf:"bytes,1,req,name=task_id" json:"task_id,omitempty"`
	HostId           *string          `protobuf:"bytes,2,opt,name=host_id" json:"host_id,omitempty"`
	SchedulerId      *string          `protobuf:"bytes,3,opt,name=scheduler_id" json:"scheduler_id,omitempty"`
	Description      *TaskDescription `protobuf:"bytes,4,req,name=description" json:"description,omitempty"`
	Resources        []*HostResource  `protobuf:"bytes,5,rep,name=resources" json:"resources,omitempty"`
	Status           *TaskStatus      `protobuf:"varint,6,req,name=status,enum=strive.TaskStatus,def=0" json:"status,omitempty"`
	LastUpdate       *tai64n.TAI64N   `protobuf:"bytes,7,req,name=last_update" json:"last_update,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *Task) Reset()      { *m = Task{} }
func (*Task) ProtoMessage() {}

const Default_Task_Status TaskStatus = TaskStatus_CREATED

func (m *Task) GetTaskId() string {
	if m != nil && m.TaskId != nil {
		return *m.TaskId
	}
	return ""
}

func (m *Task) GetHostId() string {
	if m != nil && m.HostId != nil {
		return *m.HostId
	}
	return ""
}

func (m *Task) GetSchedulerId() string {
	if m != nil && m.SchedulerId != nil {
		return *m.SchedulerId
	}
	return ""
}

func (m *Task) GetDescription() *TaskDescription {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *Task) GetResources() []*HostResource {
	if m != nil {
		return m.Resources
	}
	return nil
}

func (m *Task) GetStatus() TaskStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Default_Task_Status
}

func (m *Task) GetLastUpdate() *tai64n.TAI64N {
	if m != nil {
		return m.LastUpdate
	}
	return nil
}

type ClusterState struct {
	Hosts            []*Host         `protobuf:"bytes,1,rep,name=hosts" json:"hosts,omitempty"`
	Tasks            []*Task         `protobuf:"bytes,2,rep,name=tasks" json:"tasks,omitempty"`
	Available        []*HostResource `protobuf:"bytes,3,rep,name=available" json:"available,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

func (m *ClusterState) Reset()      { *m = ClusterState{} }
func (*ClusterState) ProtoMessage() {}

func (m *ClusterState) GetHosts() []*Host {
	if m != nil {
		return m.Hosts
	}
	return nil
}

func (m *ClusterState) GetTasks() []*Task {
	if m != nil {
		return m.Tasks
	}
	return nil
}

func (m *ClusterState) GetAvailable() []*HostResource {
	if m != nil {
		return m.Available
	}
	return nil
}

type UpdateState struct {
	AddHosts         []*Host `protobuf:"bytes,1,rep,name=add_hosts" json:"add_hosts,omitempty"`
	AddTasks         []*Task `protobuf:"bytes,2,rep,name=add_tasks" json:"add_tasks,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *UpdateState) Reset()      { *m = UpdateState{} }
func (*UpdateState) ProtoMessage() {}

func (m *UpdateState) GetAddHosts() []*Host {
	if m != nil {
		return m.AddHosts
	}
	return nil
}

func (m *UpdateState) GetAddTasks() []*Task {
	if m != nil {
		return m.AddTasks
	}
	return nil
}

type FetchState struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *FetchState) Reset()      { *m = FetchState{} }
func (*FetchState) ProtoMessage() {}

type StartTask struct {
	OpId             *string `protobuf:"bytes,1,req,name=opId" json:"opId,omitempty"`
	Task             *Task   `protobuf:"bytes,2,req,name=task" json:"task,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *StartTask) Reset()      { *m = StartTask{} }
func (*StartTask) ProtoMessage() {}

func (m *StartTask) GetOpId() string {
	if m != nil && m.OpId != nil {
		return *m.OpId
	}
	return ""
}

func (m *StartTask) GetTask() *Task {
	if m != nil {
		return m.Task
	}
	return nil
}

type StopTask struct {
	OpId             *string `protobuf:"bytes,1,req,name=op_id" json:"op_id,omitempty"`
	TaskId           *string `protobuf:"bytes,2,req,name=task_id" json:"task_id,omitempty"`
	Force            *bool   `protobuf:"varint,3,opt,name=force" json:"force,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *StopTask) Reset()      { *m = StopTask{} }
func (*StopTask) ProtoMessage() {}

func (m *StopTask) GetOpId() string {
	if m != nil && m.OpId != nil {
		return *m.OpId
	}
	return ""
}

func (m *StopTask) GetTaskId() string {
	if m != nil && m.TaskId != nil {
		return *m.TaskId
	}
	return ""
}

func (m *StopTask) GetForce() bool {
	if m != nil && m.Force != nil {
		return *m.Force
	}
	return false
}

type OpAcknowledged struct {
	OpId             *string `protobuf:"bytes,1,req,name=op_id" json:"op_id,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *OpAcknowledged) Reset()      { *m = OpAcknowledged{} }
func (*OpAcknowledged) ProtoMessage() {}

func (m *OpAcknowledged) GetOpId() string {
	if m != nil && m.OpId != nil {
		return *m.OpId
	}
	return ""
}

type TaskStatusChange struct {
	TaskId           *string     `protobuf:"bytes,1,req,name=task_id" json:"task_id,omitempty"`
	Status           *TaskStatus `protobuf:"varint,2,req,name=status,enum=strive.TaskStatus" json:"status,omitempty"`
	Error            *string     `protobuf:"bytes,3,opt,name=error" json:"error,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *TaskStatusChange) Reset()      { *m = TaskStatusChange{} }
func (*TaskStatusChange) ProtoMessage() {}

func (m *TaskStatusChange) GetTaskId() string {
	if m != nil && m.TaskId != nil {
		return *m.TaskId
	}
	return ""
}

func (m *TaskStatusChange) GetStatus() TaskStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return TaskStatus_CREATED
}

func (m *TaskStatusChange) GetError() string {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ""
}

type HostStatusChange struct {
	HostId           *string     `protobuf:"bytes,1,req,name=host_id" json:"host_id,omitempty"`
	Status           *HostStatus `protobuf:"varint,2,req,name=status,enum=strive.HostStatus" json:"status,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *HostStatusChange) Reset()      { *m = HostStatusChange{} }
func (*HostStatusChange) ProtoMessage() {}

func (m *HostStatusChange) GetHostId() string {
	if m != nil && m.HostId != nil {
		return *m.HostId
	}
	return ""
}

func (m *HostStatusChange) GetStatus() HostStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return HostStatus_UNKNOWN
}

type ListTasks struct {
	OpId             *string `protobuf:"bytes,1,req,name=op_id" json:"op_id,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *ListTasks) Reset()      { *m = ListTasks{} }
func (*ListTasks) ProtoMessage() {}

func (m *ListTasks) GetOpId() string {
	if m != nil && m.OpId != nil {
		return *m.OpId
	}
	return ""
}

type CurrentTasks struct {
	OpId             *string  `protobuf:"bytes,1,req,name=op_id" json:"op_id,omitempty"`
	TaskIds          []string `protobuf:"bytes,2,rep,name=task_ids" json:"task_ids,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *CurrentTasks) Reset()      { *m = CurrentTasks{} }
func (*CurrentTasks) ProtoMessage() {}

func (m *CurrentTasks) GetOpId() string {
	if m != nil && m.OpId != nil {
		return *m.OpId
	}
	return ""
}

func (m *CurrentTasks) GetTaskIds() []string {
	if m != nil {
		return m.TaskIds
	}
	return nil
}

type Error struct {
	ErrorId          Error_ErrorCode `protobuf:"varint,1,req,name=error_id,enum=strive.Error_ErrorCode" json:"error_id"`
	Description      *string         `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

func (m *Error) Reset()      { *m = Error{} }
func (*Error) ProtoMessage() {}

func (m *Error) GetErrorId() Error_ErrorCode {
	if m != nil {
		return m.ErrorId
	}
	return Error_UNKNOWN
}

func (m *Error) GetDescription() string {
	if m != nil && m.Description != nil {
		return *m.Description
	}
	return ""
}

type GenericError struct {
	Error            *Error `protobuf:"bytes,1,req,name=error" json:"error,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *GenericError) Reset()      { *m = GenericError{} }
func (*GenericError) ProtoMessage() {}

func (m *GenericError) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type StopError struct {
	OpId             *string `protobuf:"bytes,1,req,name=op_id" json:"op_id,omitempty"`
	TaskId           *string `protobuf:"bytes,2,req,name=task_id" json:"task_id,omitempty"`
	Error            *Error  `protobuf:"bytes,3,req,name=error" json:"error,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *StopError) Reset()      { *m = StopError{} }
func (*StopError) ProtoMessage() {}

func (m *StopError) GetOpId() string {
	if m != nil && m.OpId != nil {
		return *m.OpId
	}
	return ""
}

func (m *StopError) GetTaskId() string {
	if m != nil && m.TaskId != nil {
		return *m.TaskId
	}
	return ""
}

func (m *StopError) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type CheckTasks struct {
	TaskIds          []string `protobuf:"bytes,1,rep,name=task_ids" json:"task_ids,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *CheckTasks) Reset()      { *m = CheckTasks{} }
func (*CheckTasks) ProtoMessage() {}

func (m *CheckTasks) GetTaskIds() []string {
	if m != nil {
		return m.TaskIds
	}
	return nil
}

type CheckedTaskList struct {
	HostId           *string  `protobuf:"bytes,1,req,name=host_id" json:"host_id,omitempty"`
	Missing          []string `protobuf:"bytes,2,rep,name=missing" json:"missing,omitempty"`
	Unknown          []string `protobuf:"bytes,3,rep,name=unknown" json:"unknown,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *CheckedTaskList) Reset()      { *m = CheckedTaskList{} }
func (*CheckedTaskList) ProtoMessage() {}

func (m *CheckedTaskList) GetHostId() string {
	if m != nil && m.HostId != nil {
		return *m.HostId
	}
	return ""
}

func (m *CheckedTaskList) GetMissing() []string {
	if m != nil {
		return m.Missing
	}
	return nil
}

func (m *CheckedTaskList) GetUnknown() []string {
	if m != nil {
		return m.Unknown
	}
	return nil
}

func init() {
	proto.RegisterEnum("strive.HostStatus", HostStatus_name, HostStatus_value)
	proto.RegisterEnum("strive.TaskStatus", TaskStatus_name, TaskStatus_value)
	proto.RegisterEnum("strive.Value_ValueType", Value_ValueType_name, Value_ValueType_value)
	proto.RegisterEnum("strive.Resource_ResourceType", Resource_ResourceType_name, Resource_ResourceType_value)
	proto.RegisterEnum("strive.PortBinding_Protocol", PortBinding_Protocol_name, PortBinding_Protocol_value)
	proto.RegisterEnum("strive.ContainerInfo_ContainerMode", ContainerInfo_ContainerMode_name, ContainerInfo_ContainerMode_value)
	proto.RegisterEnum("strive.Error_ErrorCode", Error_ErrorCode_name, Error_ErrorCode_value)
}
func (m *Range) 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Start = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.End = &v
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Ranges) 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 Ranges", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ranges = append(m.Ranges, &Range{})
			m.Ranges[len(m.Ranges)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Value) 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueType", wireType)
			}
			var v Value_ValueType
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (Value_ValueType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ValueType = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntVal", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IntVal = &v
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StrVal", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.StrVal = &s
			index = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesVal", 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
				}
			}
			postIndex := index + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BytesVal = append([]byte{}, data[index:postIndex]...)
			index = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolVal", 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.BoolVal = &b
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeVal", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RangeVal == nil {
				m.RangeVal = &Ranges{}
			}
			if err := m.RangeVal.Unmarshal(data[index:postIndex]); err != nil {
				return err
			}
			index = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListVal", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ListVal = append(m.ListVal, &Value{})
			m.ListVal[len(m.ListVal)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapVal", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapVal = append(m.MapVal, &Variable{})
			m.MapVal[len(m.MapVal)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Variable) 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 Name", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.Name = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &Value{}
			}
			if err := m.Value.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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Resource) 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v Resource_ResourceType
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (Resource_ResourceType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomType", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.CustomType = &s
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &Value{}
			}
			if err := m.Value.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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Host) 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 HostId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.HostId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.Name = &s
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, &Resource{})
			m.Resources[len(m.Resources)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v HostStatus
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (HostStatus(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = &v
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastHeartbeat", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastHeartbeat == nil {
				m.LastHeartbeat = &tai64n.TAI64N{}
			}
			if err := m.LastHeartbeat.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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *PortBinding) 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Host = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Container = &v
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			var v PortBinding_Protocol
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (PortBinding_Protocol(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Protocol = &v
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *ContainerInfo) 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			var v ContainerInfo_ContainerMode
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (ContainerInfo_ContainerMode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Mode = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.Image = &s
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ports = append(m.Ports, &PortBinding{})
			m.Ports[len(m.Ports)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *TaskDescription) 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 Command", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.Command = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exec", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Exec = append(m.Exec, string(data[index:postIndex]))
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Env", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Env = append(m.Env, &Variable{})
			m.Env[len(m.Env)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Urls", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Urls = append(m.Urls, string(data[index:postIndex]))
			index = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Config = append(m.Config, &Variable{})
			m.Config[len(m.Config)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata, &Variable{})
			m.Metadata[len(m.Metadata)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, string(data[index:postIndex]))
			index = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Container == nil {
				m.Container = &ContainerInfo{}
			}
			if err := m.Container.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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *HostResource) 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 HostId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.HostId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, &Resource{})
			m.Resources[len(m.Resources)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Task) 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 TaskId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.TaskId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.HostId = &s
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchedulerId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.SchedulerId = &s
			index = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Description == nil {
				m.Description = &TaskDescription{}
			}
			if err := m.Description.Unmarshal(data[index:postIndex]); err != nil {
				return err
			}
			index = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, &HostResource{})
			m.Resources[len(m.Resources)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v TaskStatus
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (TaskStatus(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = &v
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdate", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastUpdate == nil {
				m.LastUpdate = &tai64n.TAI64N{}
			}
			if err := m.LastUpdate.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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *ClusterState) 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 Hosts", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hosts = append(m.Hosts, &Host{})
			m.Hosts[len(m.Hosts)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 2:
			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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tasks = append(m.Tasks, &Task{})
			m.Tasks[len(m.Tasks)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Available", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Available = append(m.Available, &HostResource{})
			m.Available[len(m.Available)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *UpdateState) 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 AddHosts", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AddHosts = append(m.AddHosts, &Host{})
			m.AddHosts[len(m.AddHosts)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddTasks", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AddTasks = append(m.AddTasks, &Task{})
			m.AddTasks[len(m.AddTasks)-1].Unmarshal(data[index:postIndex])
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *FetchState) 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)
		switch fieldNum {
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *StartTask) 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 OpId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.OpId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &Task{}
			}
			if err := m.Task.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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *StopTask) 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 OpId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.OpId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.TaskId = &s
			index = postIndex
		case 3:
			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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *OpAcknowledged) 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 OpId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.OpId = &s
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *TaskStatusChange) 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 TaskId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.TaskId = &s
			index = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v TaskStatus
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (TaskStatus(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = &v
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.Error = &s
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *HostStatusChange) 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 HostId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.HostId = &s
			index = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v HostStatus
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				v |= (HostStatus(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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *ListTasks) 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 OpId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.OpId = &s
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *CurrentTasks) 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 OpId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.OpId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskIds", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaskIds = append(m.TaskIds, string(data[index:postIndex]))
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *Error) 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorId", wireType)
			}
			for shift := uint(0); ; shift += 7 {
				if index >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[index]
				index++
				m.ErrorId |= (Error_ErrorCode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.Description = &s
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *GenericError) 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 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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *StopError) 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 OpId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.OpId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.TaskId = &s
			index = postIndex
		case 3:
			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
				}
			}
			postIndex := index + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &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 := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *CheckTasks) 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 TaskIds", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaskIds = append(m.TaskIds, string(data[index:postIndex]))
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (m *CheckedTaskList) 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 HostId", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[index:postIndex])
			m.HostId = &s
			index = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Missing", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Missing = append(m.Missing, string(data[index:postIndex]))
			index = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unknown", 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
				}
			}
			postIndex := index + int(stringLen)
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unknown = append(m.Unknown, string(data[index:postIndex]))
			index = postIndex
		default:
			var sizeOfWire int
			for {
				sizeOfWire++
				wire >>= 7
				if wire == 0 {
					break
				}
			}
			index -= sizeOfWire
			skippy, err := github_com_gogo_protobuf_proto.Skip(data[index:])
			if err != nil {
				return err
			}
			if (index + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
			index += skippy
		}
	}
	return nil
}
func (this *Range) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Range{`,
		`Start:` + valueToStringStrive(this.Start) + `,`,
		`End:` + valueToStringStrive(this.End) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Ranges) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Ranges{`,
		`Ranges:` + strings.Replace(fmt.Sprintf("%v", this.Ranges), "Range", "Range", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Value) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Value{`,
		`ValueType:` + valueToStringStrive(this.ValueType) + `,`,
		`IntVal:` + valueToStringStrive(this.IntVal) + `,`,
		`StrVal:` + valueToStringStrive(this.StrVal) + `,`,
		`BytesVal:` + valueToStringStrive(this.BytesVal) + `,`,
		`BoolVal:` + valueToStringStrive(this.BoolVal) + `,`,
		`RangeVal:` + strings.Replace(fmt.Sprintf("%v", this.RangeVal), "Ranges", "Ranges", 1) + `,`,
		`ListVal:` + strings.Replace(fmt.Sprintf("%v", this.ListVal), "Value", "Value", 1) + `,`,
		`MapVal:` + strings.Replace(fmt.Sprintf("%v", this.MapVal), "Variable", "Variable", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Variable) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Variable{`,
		`Name:` + valueToStringStrive(this.Name) + `,`,
		`Value:` + strings.Replace(fmt.Sprintf("%v", this.Value), "Value", "Value", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Resource) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Resource{`,
		`Type:` + valueToStringStrive(this.Type) + `,`,
		`CustomType:` + valueToStringStrive(this.CustomType) + `,`,
		`Value:` + strings.Replace(fmt.Sprintf("%v", this.Value), "Value", "Value", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Host) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Host{`,
		`HostId:` + valueToStringStrive(this.HostId) + `,`,
		`Name:` + valueToStringStrive(this.Name) + `,`,
		`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Resource", "Resource", 1) + `,`,
		`Status:` + valueToStringStrive(this.Status) + `,`,
		`LastHeartbeat:` + strings.Replace(fmt.Sprintf("%v", this.LastHeartbeat), "TAI64N", "tai64n.TAI64N", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PortBinding) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PortBinding{`,
		`Host:` + valueToStringStrive(this.Host) + `,`,
		`Container:` + valueToStringStrive(this.Container) + `,`,
		`Protocol:` + valueToStringStrive(this.Protocol) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainerInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainerInfo{`,
		`Mode:` + valueToStringStrive(this.Mode) + `,`,
		`Image:` + valueToStringStrive(this.Image) + `,`,
		`Ports:` + strings.Replace(fmt.Sprintf("%v", this.Ports), "PortBinding", "PortBinding", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TaskDescription) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TaskDescription{`,
		`Command:` + valueToStringStrive(this.Command) + `,`,
		`Exec:` + fmt.Sprintf("%v", this.Exec) + `,`,
		`Env:` + strings.Replace(fmt.Sprintf("%v", this.Env), "Variable", "Variable", 1) + `,`,
		`Urls:` + fmt.Sprintf("%v", this.Urls) + `,`,
		`Config:` + strings.Replace(fmt.Sprintf("%v", this.Config), "Variable", "Variable", 1) + `,`,
		`Metadata:` + strings.Replace(fmt.Sprintf("%v", this.Metadata), "Variable", "Variable", 1) + `,`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`Container:` + strings.Replace(fmt.Sprintf("%v", this.Container), "ContainerInfo", "ContainerInfo", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HostResource) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HostResource{`,
		`HostId:` + valueToStringStrive(this.HostId) + `,`,
		`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Resource", "Resource", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Task) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Task{`,
		`TaskId:` + valueToStringStrive(this.TaskId) + `,`,
		`HostId:` + valueToStringStrive(this.HostId) + `,`,
		`SchedulerId:` + valueToStringStrive(this.SchedulerId) + `,`,
		`Description:` + strings.Replace(fmt.Sprintf("%v", this.Description), "TaskDescription", "TaskDescription", 1) + `,`,
		`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "HostResource", "HostResource", 1) + `,`,
		`Status:` + valueToStringStrive(this.Status) + `,`,
		`LastUpdate:` + strings.Replace(fmt.Sprintf("%v", this.LastUpdate), "TAI64N", "tai64n.TAI64N", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClusterState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ClusterState{`,
		`Hosts:` + strings.Replace(fmt.Sprintf("%v", this.Hosts), "Host", "Host", 1) + `,`,
		`Tasks:` + strings.Replace(fmt.Sprintf("%v", this.Tasks), "Task", "Task", 1) + `,`,
		`Available:` + strings.Replace(fmt.Sprintf("%v", this.Available), "HostResource", "HostResource", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UpdateState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UpdateState{`,
		`AddHosts:` + strings.Replace(fmt.Sprintf("%v", this.AddHosts), "Host", "Host", 1) + `,`,
		`AddTasks:` + strings.Replace(fmt.Sprintf("%v", this.AddTasks), "Task", "Task", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FetchState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FetchState{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StartTask) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StartTask{`,
		`OpId:` + valueToStringStrive(this.OpId) + `,`,
		`Task:` + strings.Replace(fmt.Sprintf("%v", this.Task), "Task", "Task", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StopTask) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StopTask{`,
		`OpId:` + valueToStringStrive(this.OpId) + `,`,
		`TaskId:` + valueToStringStrive(this.TaskId) + `,`,
		`Force:` + valueToStringStrive(this.Force) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OpAcknowledged) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OpAcknowledged{`,
		`OpId:` + valueToStringStrive(this.OpId) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TaskStatusChange) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TaskStatusChange{`,
		`TaskId:` + valueToStringStrive(this.TaskId) + `,`,
		`Status:` + valueToStringStrive(this.Status) + `,`,
		`Error:` + valueToStringStrive(this.Error) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HostStatusChange) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HostStatusChange{`,
		`HostId:` + valueToStringStrive(this.HostId) + `,`,
		`Status:` + valueToStringStrive(this.Status) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListTasks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ListTasks{`,
		`OpId:` + valueToStringStrive(this.OpId) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CurrentTasks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CurrentTasks{`,
		`OpId:` + valueToStringStrive(this.OpId) + `,`,
		`TaskIds:` + fmt.Sprintf("%v", this.TaskIds) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Error) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Error{`,
		`ErrorId:` + fmt.Sprintf("%v", this.ErrorId) + `,`,
		`Description:` + valueToStringStrive(this.Description) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GenericError) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GenericError{`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Error", "Error", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StopError) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StopError{`,
		`OpId:` + valueToStringStrive(this.OpId) + `,`,
		`TaskId:` + valueToStringStrive(this.TaskId) + `,`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Error", "Error", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CheckTasks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CheckTasks{`,
		`TaskIds:` + fmt.Sprintf("%v", this.TaskIds) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CheckedTaskList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CheckedTaskList{`,
		`HostId:` + valueToStringStrive(this.HostId) + `,`,
		`Missing:` + fmt.Sprintf("%v", this.Missing) + `,`,
		`Unknown:` + fmt.Sprintf("%v", this.Unknown) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringStrive(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Range) Size() (n int) {
	var l int
	_ = l
	if m.Start != nil {
		n += 1 + sovStrive(uint64(*m.Start))
	}
	if m.End != nil {
		n += 1 + sovStrive(uint64(*m.End))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Ranges) Size() (n int) {
	var l int
	_ = l
	if len(m.Ranges) > 0 {
		for _, e := range m.Ranges {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Value) Size() (n int) {
	var l int
	_ = l
	if m.ValueType != nil {
		n += 1 + sovStrive(uint64(*m.ValueType))
	}
	if m.IntVal != nil {
		n += 1 + sovStrive(uint64(*m.IntVal))
	}
	if m.StrVal != nil {
		l = len(*m.StrVal)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.BytesVal != nil {
		l = len(m.BytesVal)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.BoolVal != nil {
		n += 2
	}
	if m.RangeVal != nil {
		l = m.RangeVal.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.ListVal) > 0 {
		for _, e := range m.ListVal {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.MapVal) > 0 {
		for _, e := range m.MapVal {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Variable) Size() (n int) {
	var l int
	_ = l
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Resource) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovStrive(uint64(*m.Type))
	}
	if m.CustomType != nil {
		l = len(*m.CustomType)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Host) Size() (n int) {
	var l int
	_ = l
	if m.HostId != nil {
		l = len(*m.HostId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.Status != nil {
		n += 1 + sovStrive(uint64(*m.Status))
	}
	if m.LastHeartbeat != nil {
		l = m.LastHeartbeat.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PortBinding) Size() (n int) {
	var l int
	_ = l
	if m.Host != nil {
		n += 1 + sovStrive(uint64(*m.Host))
	}
	if m.Container != nil {
		n += 1 + sovStrive(uint64(*m.Container))
	}
	if m.Protocol != nil {
		n += 1 + sovStrive(uint64(*m.Protocol))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ContainerInfo) Size() (n int) {
	var l int
	_ = l
	if m.Mode != nil {
		n += 1 + sovStrive(uint64(*m.Mode))
	}
	if m.Image != nil {
		l = len(*m.Image)
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TaskDescription) Size() (n int) {
	var l int
	_ = l
	if m.Command != nil {
		l = len(*m.Command)
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.Exec) > 0 {
		for _, s := range m.Exec {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Env) > 0 {
		for _, e := range m.Env {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Urls) > 0 {
		for _, s := range m.Urls {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Config) > 0 {
		for _, e := range m.Config {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Metadata) > 0 {
		for _, e := range m.Metadata {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		for _, s := range m.Labels {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.Container != nil {
		l = m.Container.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HostResource) Size() (n int) {
	var l int
	_ = l
	if m.HostId != nil {
		l = len(*m.HostId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Task) Size() (n int) {
	var l int
	_ = l
	if m.TaskId != nil {
		l = len(*m.TaskId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.HostId != nil {
		l = len(*m.HostId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.SchedulerId != nil {
		l = len(*m.SchedulerId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Description != nil {
		l = m.Description.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.Status != nil {
		n += 1 + sovStrive(uint64(*m.Status))
	}
	if m.LastUpdate != nil {
		l = m.LastUpdate.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClusterState) Size() (n int) {
	var l int
	_ = l
	if len(m.Hosts) > 0 {
		for _, e := range m.Hosts {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Tasks) > 0 {
		for _, e := range m.Tasks {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Available) > 0 {
		for _, e := range m.Available {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateState) Size() (n int) {
	var l int
	_ = l
	if len(m.AddHosts) > 0 {
		for _, e := range m.AddHosts {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.AddTasks) > 0 {
		for _, e := range m.AddTasks {
			l = e.Size()
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FetchState) Size() (n int) {
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StartTask) Size() (n int) {
	var l int
	_ = l
	if m.OpId != nil {
		l = len(*m.OpId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StopTask) Size() (n int) {
	var l int
	_ = l
	if m.OpId != nil {
		l = len(*m.OpId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.TaskId != nil {
		l = len(*m.TaskId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Force != nil {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpAcknowledged) Size() (n int) {
	var l int
	_ = l
	if m.OpId != nil {
		l = len(*m.OpId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TaskStatusChange) Size() (n int) {
	var l int
	_ = l
	if m.TaskId != nil {
		l = len(*m.TaskId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Status != nil {
		n += 1 + sovStrive(uint64(*m.Status))
	}
	if m.Error != nil {
		l = len(*m.Error)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HostStatusChange) Size() (n int) {
	var l int
	_ = l
	if m.HostId != nil {
		l = len(*m.HostId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Status != nil {
		n += 1 + sovStrive(uint64(*m.Status))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListTasks) Size() (n int) {
	var l int
	_ = l
	if m.OpId != nil {
		l = len(*m.OpId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CurrentTasks) Size() (n int) {
	var l int
	_ = l
	if m.OpId != nil {
		l = len(*m.OpId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.TaskIds) > 0 {
		for _, s := range m.TaskIds {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Error) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovStrive(uint64(m.ErrorId))
	if m.Description != nil {
		l = len(*m.Description)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GenericError) Size() (n int) {
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StopError) Size() (n int) {
	var l int
	_ = l
	if m.OpId != nil {
		l = len(*m.OpId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.TaskId != nil {
		l = len(*m.TaskId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovStrive(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CheckTasks) Size() (n int) {
	var l int
	_ = l
	if len(m.TaskIds) > 0 {
		for _, s := range m.TaskIds {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CheckedTaskList) Size() (n int) {
	var l int
	_ = l
	if m.HostId != nil {
		l = len(*m.HostId)
		n += 1 + l + sovStrive(uint64(l))
	}
	if len(m.Missing) > 0 {
		for _, s := range m.Missing {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if len(m.Unknown) > 0 {
		for _, s := range m.Unknown {
			l = len(s)
			n += 1 + l + sovStrive(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovStrive(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozStrive(x uint64) (n int) {
	return sovStrive(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Range) 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 *Range) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Start != nil {
		data[i] = 0x8
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Start))
	}
	if m.End != nil {
		data[i] = 0x10
		i++
		i = encodeVarintStrive(data, i, uint64(*m.End))
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Ranges) 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 *Ranges) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Ranges) > 0 {
		for _, msg := range m.Ranges {
			data[i] = 0xa
			i++
			i = encodeVarintStrive(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 *Value) 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 *Value) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ValueType != nil {
		data[i] = 0x8
		i++
		i = encodeVarintStrive(data, i, uint64(*m.ValueType))
	}
	if m.IntVal != nil {
		data[i] = 0x10
		i++
		i = encodeVarintStrive(data, i, uint64(*m.IntVal))
	}
	if m.StrVal != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.StrVal)))
		i += copy(data[i:], *m.StrVal)
	}
	if m.BytesVal != nil {
		data[i] = 0x22
		i++
		i = encodeVarintStrive(data, i, uint64(len(m.BytesVal)))
		i += copy(data[i:], m.BytesVal)
	}
	if m.BoolVal != nil {
		data[i] = 0x28
		i++
		if *m.BoolVal {
			data[i] = 1
		} else {
			data[i] = 0
		}
		i++
	}
	if m.RangeVal != nil {
		data[i] = 0x32
		i++
		i = encodeVarintStrive(data, i, uint64(m.RangeVal.Size()))
		n1, err := m.RangeVal.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.ListVal) > 0 {
		for _, msg := range m.ListVal {
			data[i] = 0x3a
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.MapVal) > 0 {
		for _, msg := range m.MapVal {
			data[i] = 0x42
			i++
			i = encodeVarintStrive(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 *Variable) 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 *Variable) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Name != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.Name)))
		i += copy(data[i:], *m.Name)
	}
	if m.Value != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(m.Value.Size()))
		n2, err := m.Value.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Resource) 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 *Resource) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Type))
	}
	if m.CustomType != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.CustomType)))
		i += copy(data[i:], *m.CustomType)
	}
	if m.Value != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintStrive(data, i, uint64(m.Value.Size()))
		n3, err := m.Value.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Host) 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 *Host) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.HostId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.HostId)))
		i += copy(data[i:], *m.HostId)
	}
	if m.Name != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.Name)))
		i += copy(data[i:], *m.Name)
	}
	if len(m.Resources) > 0 {
		for _, msg := range m.Resources {
			data[i] = 0x1a
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Status != nil {
		data[i] = 0x20
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Status))
	}
	if m.LastHeartbeat != nil {
		data[i] = 0x2a
		i++
		i = encodeVarintStrive(data, i, uint64(m.LastHeartbeat.Size()))
		n4, err := m.LastHeartbeat.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PortBinding) 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 *PortBinding) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Host != nil {
		data[i] = 0x8
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Host))
	}
	if m.Container != nil {
		data[i] = 0x10
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Container))
	}
	if m.Protocol != nil {
		data[i] = 0x18
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Protocol))
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ContainerInfo) 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 *ContainerInfo) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mode != nil {
		data[i] = 0x8
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Mode))
	}
	if m.Image != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.Image)))
		i += copy(data[i:], *m.Image)
	}
	if len(m.Ports) > 0 {
		for _, msg := range m.Ports {
			data[i] = 0x1a
			i++
			i = encodeVarintStrive(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 *TaskDescription) 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 *TaskDescription) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Command != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.Command)))
		i += copy(data[i:], *m.Command)
	}
	if len(m.Exec) > 0 {
		for _, s := range m.Exec {
			data[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if len(m.Env) > 0 {
		for _, msg := range m.Env {
			data[i] = 0x1a
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Urls) > 0 {
		for _, s := range m.Urls {
			data[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if len(m.Config) > 0 {
		for _, msg := range m.Config {
			data[i] = 0x2a
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Metadata) > 0 {
		for _, msg := range m.Metadata {
			data[i] = 0x32
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Labels) > 0 {
		for _, s := range m.Labels {
			data[i] = 0x3a
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if m.Container != nil {
		data[i] = 0x42
		i++
		i = encodeVarintStrive(data, i, uint64(m.Container.Size()))
		n5, err := m.Container.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *HostResource) 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 *HostResource) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.HostId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.HostId)))
		i += copy(data[i:], *m.HostId)
	}
	if len(m.Resources) > 0 {
		for _, msg := range m.Resources {
			data[i] = 0x12
			i++
			i = encodeVarintStrive(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 *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 *Task) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TaskId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.TaskId)))
		i += copy(data[i:], *m.TaskId)
	}
	if m.HostId != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.HostId)))
		i += copy(data[i:], *m.HostId)
	}
	if m.SchedulerId != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.SchedulerId)))
		i += copy(data[i:], *m.SchedulerId)
	}
	if m.Description != nil {
		data[i] = 0x22
		i++
		i = encodeVarintStrive(data, i, uint64(m.Description.Size()))
		n6, err := m.Description.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if len(m.Resources) > 0 {
		for _, msg := range m.Resources {
			data[i] = 0x2a
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Status != nil {
		data[i] = 0x30
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Status))
	}
	if m.LastUpdate != nil {
		data[i] = 0x3a
		i++
		i = encodeVarintStrive(data, i, uint64(m.LastUpdate.Size()))
		n7, err := m.LastUpdate.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 *ClusterState) 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 *ClusterState) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hosts) > 0 {
		for _, msg := range m.Hosts {
			data[i] = 0xa
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Tasks) > 0 {
		for _, msg := range m.Tasks {
			data[i] = 0x12
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Available) > 0 {
		for _, msg := range m.Available {
			data[i] = 0x1a
			i++
			i = encodeVarintStrive(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 *UpdateState) 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 *UpdateState) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.AddHosts) > 0 {
		for _, msg := range m.AddHosts {
			data[i] = 0xa
			i++
			i = encodeVarintStrive(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.AddTasks) > 0 {
		for _, msg := range m.AddTasks {
			data[i] = 0x12
			i++
			i = encodeVarintStrive(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 *FetchState) 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 *FetchState) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StartTask) 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 *StartTask) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.OpId)))
		i += copy(data[i:], *m.OpId)
	}
	if m.Task != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(m.Task.Size()))
		n8, err := m.Task.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StopTask) 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 *StopTask) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.OpId)))
		i += copy(data[i:], *m.OpId)
	}
	if m.TaskId != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.TaskId)))
		i += copy(data[i:], *m.TaskId)
	}
	if m.Force != nil {
		data[i] = 0x18
		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 *OpAcknowledged) 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 *OpAcknowledged) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.OpId)))
		i += copy(data[i:], *m.OpId)
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TaskStatusChange) 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 *TaskStatusChange) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TaskId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.TaskId)))
		i += copy(data[i:], *m.TaskId)
	}
	if m.Status != nil {
		data[i] = 0x10
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Status))
	}
	if m.Error != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.Error)))
		i += copy(data[i:], *m.Error)
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *HostStatusChange) 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 *HostStatusChange) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.HostId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.HostId)))
		i += copy(data[i:], *m.HostId)
	}
	if m.Status != nil {
		data[i] = 0x10
		i++
		i = encodeVarintStrive(data, i, uint64(*m.Status))
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ListTasks) 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 *ListTasks) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.OpId)))
		i += copy(data[i:], *m.OpId)
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CurrentTasks) 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 *CurrentTasks) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.OpId)))
		i += copy(data[i:], *m.OpId)
	}
	if len(m.TaskIds) > 0 {
		for _, s := range m.TaskIds {
			data[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *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 *Error) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	data[i] = 0x8
	i++
	i = encodeVarintStrive(data, i, uint64(m.ErrorId))
	if m.Description != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.Description)))
		i += copy(data[i:], *m.Description)
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GenericError) 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 *GenericError) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(m.Error.Size()))
		n9, err := m.Error.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 *StopError) 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 *StopError) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.OpId)))
		i += copy(data[i:], *m.OpId)
	}
	if m.TaskId != nil {
		data[i] = 0x12
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.TaskId)))
		i += copy(data[i:], *m.TaskId)
	}
	if m.Error != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintStrive(data, i, uint64(m.Error.Size()))
		n10, err := m.Error.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 *CheckTasks) 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 *CheckTasks) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TaskIds) > 0 {
		for _, s := range m.TaskIds {
			data[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CheckedTaskList) 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 *CheckedTaskList) MarshalTo(data []byte) (n int, err error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.HostId != nil {
		data[i] = 0xa
		i++
		i = encodeVarintStrive(data, i, uint64(len(*m.HostId)))
		i += copy(data[i:], *m.HostId)
	}
	if len(m.Missing) > 0 {
		for _, s := range m.Missing {
			data[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if len(m.Unknown) > 0 {
		for _, s := range m.Unknown {
			data[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				data[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			data[i] = uint8(l)
			i++
			i += copy(data[i:], s)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeFixed64Strive(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 encodeFixed32Strive(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 encodeVarintStrive(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 (this *Range) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Range)
	if !ok {
		return fmt.Errorf("that is not of type *Range")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Range but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Rangebut is not nil && this == nil")
	}
	if this.Start != nil && that1.Start != nil {
		if *this.Start != *that1.Start {
			return fmt.Errorf("Start this(%v) Not Equal that(%v)", *this.Start, *that1.Start)
		}
	} else if this.Start != nil {
		return fmt.Errorf("this.Start == nil && that.Start != nil")
	} else if that1.Start != nil {
		return fmt.Errorf("Start this(%v) Not Equal that(%v)", this.Start, that1.Start)
	}
	if this.End != nil && that1.End != nil {
		if *this.End != *that1.End {
			return fmt.Errorf("End this(%v) Not Equal that(%v)", *this.End, *that1.End)
		}
	} else if this.End != nil {
		return fmt.Errorf("this.End == nil && that.End != nil")
	} else if that1.End != nil {
		return fmt.Errorf("End this(%v) Not Equal that(%v)", this.End, that1.End)
	}
	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 *Range) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Range)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Start != nil && that1.Start != nil {
		if *this.Start != *that1.Start {
			return false
		}
	} else if this.Start != nil {
		return false
	} else if that1.Start != nil {
		return false
	}
	if this.End != nil && that1.End != nil {
		if *this.End != *that1.End {
			return false
		}
	} else if this.End != nil {
		return false
	} else if that1.End != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Ranges) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Ranges)
	if !ok {
		return fmt.Errorf("that is not of type *Ranges")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Ranges but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Rangesbut is not nil && this == nil")
	}
	if len(this.Ranges) != len(that1.Ranges) {
		return fmt.Errorf("Ranges this(%v) Not Equal that(%v)", len(this.Ranges), len(that1.Ranges))
	}
	for i := range this.Ranges {
		if !this.Ranges[i].Equal(that1.Ranges[i]) {
			return fmt.Errorf("Ranges this[%v](%v) Not Equal that[%v](%v)", i, this.Ranges[i], i, that1.Ranges[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 *Ranges) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Ranges)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Ranges) != len(that1.Ranges) {
		return false
	}
	for i := range this.Ranges {
		if !this.Ranges[i].Equal(that1.Ranges[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Value) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Value)
	if !ok {
		return fmt.Errorf("that is not of type *Value")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Value but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Valuebut is not nil && this == nil")
	}
	if this.ValueType != nil && that1.ValueType != nil {
		if *this.ValueType != *that1.ValueType {
			return fmt.Errorf("ValueType this(%v) Not Equal that(%v)", *this.ValueType, *that1.ValueType)
		}
	} else if this.ValueType != nil {
		return fmt.Errorf("this.ValueType == nil && that.ValueType != nil")
	} else if that1.ValueType != nil {
		return fmt.Errorf("ValueType this(%v) Not Equal that(%v)", this.ValueType, that1.ValueType)
	}
	if this.IntVal != nil && that1.IntVal != nil {
		if *this.IntVal != *that1.IntVal {
			return fmt.Errorf("IntVal this(%v) Not Equal that(%v)", *this.IntVal, *that1.IntVal)
		}
	} else if this.IntVal != nil {
		return fmt.Errorf("this.IntVal == nil && that.IntVal != nil")
	} else if that1.IntVal != nil {
		return fmt.Errorf("IntVal this(%v) Not Equal that(%v)", this.IntVal, that1.IntVal)
	}
	if this.StrVal != nil && that1.StrVal != nil {
		if *this.StrVal != *that1.StrVal {
			return fmt.Errorf("StrVal this(%v) Not Equal that(%v)", *this.StrVal, *that1.StrVal)
		}
	} else if this.StrVal != nil {
		return fmt.Errorf("this.StrVal == nil && that.StrVal != nil")
	} else if that1.StrVal != nil {
		return fmt.Errorf("StrVal this(%v) Not Equal that(%v)", this.StrVal, that1.StrVal)
	}
	if !bytes.Equal(this.BytesVal, that1.BytesVal) {
		return fmt.Errorf("BytesVal this(%v) Not Equal that(%v)", this.BytesVal, that1.BytesVal)
	}
	if this.BoolVal != nil && that1.BoolVal != nil {
		if *this.BoolVal != *that1.BoolVal {
			return fmt.Errorf("BoolVal this(%v) Not Equal that(%v)", *this.BoolVal, *that1.BoolVal)
		}
	} else if this.BoolVal != nil {
		return fmt.Errorf("this.BoolVal == nil && that.BoolVal != nil")
	} else if that1.BoolVal != nil {
		return fmt.Errorf("BoolVal this(%v) Not Equal that(%v)", this.BoolVal, that1.BoolVal)
	}
	if !this.RangeVal.Equal(that1.RangeVal) {
		return fmt.Errorf("RangeVal this(%v) Not Equal that(%v)", this.RangeVal, that1.RangeVal)
	}
	if len(this.ListVal) != len(that1.ListVal) {
		return fmt.Errorf("ListVal this(%v) Not Equal that(%v)", len(this.ListVal), len(that1.ListVal))
	}
	for i := range this.ListVal {
		if !this.ListVal[i].Equal(that1.ListVal[i]) {
			return fmt.Errorf("ListVal this[%v](%v) Not Equal that[%v](%v)", i, this.ListVal[i], i, that1.ListVal[i])
		}
	}
	if len(this.MapVal) != len(that1.MapVal) {
		return fmt.Errorf("MapVal this(%v) Not Equal that(%v)", len(this.MapVal), len(that1.MapVal))
	}
	for i := range this.MapVal {
		if !this.MapVal[i].Equal(that1.MapVal[i]) {
			return fmt.Errorf("MapVal this[%v](%v) Not Equal that[%v](%v)", i, this.MapVal[i], i, that1.MapVal[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 *Value) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Value)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ValueType != nil && that1.ValueType != nil {
		if *this.ValueType != *that1.ValueType {
			return false
		}
	} else if this.ValueType != nil {
		return false
	} else if that1.ValueType != nil {
		return false
	}
	if this.IntVal != nil && that1.IntVal != nil {
		if *this.IntVal != *that1.IntVal {
			return false
		}
	} else if this.IntVal != nil {
		return false
	} else if that1.IntVal != nil {
		return false
	}
	if this.StrVal != nil && that1.StrVal != nil {
		if *this.StrVal != *that1.StrVal {
			return false
		}
	} else if this.StrVal != nil {
		return false
	} else if that1.StrVal != nil {
		return false
	}
	if !bytes.Equal(this.BytesVal, that1.BytesVal) {
		return false
	}
	if this.BoolVal != nil && that1.BoolVal != nil {
		if *this.BoolVal != *that1.BoolVal {
			return false
		}
	} else if this.BoolVal != nil {
		return false
	} else if that1.BoolVal != nil {
		return false
	}
	if !this.RangeVal.Equal(that1.RangeVal) {
		return false
	}
	if len(this.ListVal) != len(that1.ListVal) {
		return false
	}
	for i := range this.ListVal {
		if !this.ListVal[i].Equal(that1.ListVal[i]) {
			return false
		}
	}
	if len(this.MapVal) != len(that1.MapVal) {
		return false
	}
	for i := range this.MapVal {
		if !this.MapVal[i].Equal(that1.MapVal[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Variable) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Variable)
	if !ok {
		return fmt.Errorf("that is not of type *Variable")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Variable but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Variablebut is not nil && this == nil")
	}
	if this.Name != nil && that1.Name != nil {
		if *this.Name != *that1.Name {
			return fmt.Errorf("Name this(%v) Not Equal that(%v)", *this.Name, *that1.Name)
		}
	} else if this.Name != nil {
		return fmt.Errorf("this.Name == nil && that.Name != nil")
	} else if that1.Name != nil {
		return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
	}
	if !this.Value.Equal(that1.Value) {
		return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
	}
	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 *Variable) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Variable)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Name != nil && that1.Name != nil {
		if *this.Name != *that1.Name {
			return false
		}
	} else if this.Name != nil {
		return false
	} else if that1.Name != nil {
		return false
	}
	if !this.Value.Equal(that1.Value) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Resource) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Resource)
	if !ok {
		return fmt.Errorf("that is not of type *Resource")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Resource but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Resourcebut 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.CustomType != nil && that1.CustomType != nil {
		if *this.CustomType != *that1.CustomType {
			return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", *this.CustomType, *that1.CustomType)
		}
	} else if this.CustomType != nil {
		return fmt.Errorf("this.CustomType == nil && that.CustomType != nil")
	} else if that1.CustomType != nil {
		return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType)
	}
	if !this.Value.Equal(that1.Value) {
		return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
	}
	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 *Resource) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Resource)
	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.CustomType != nil && that1.CustomType != nil {
		if *this.CustomType != *that1.CustomType {
			return false
		}
	} else if this.CustomType != nil {
		return false
	} else if that1.CustomType != nil {
		return false
	}
	if !this.Value.Equal(that1.Value) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Host) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Host)
	if !ok {
		return fmt.Errorf("that is not of type *Host")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Host but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Hostbut is not nil && this == nil")
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return fmt.Errorf("HostId this(%v) Not Equal that(%v)", *this.HostId, *that1.HostId)
		}
	} else if this.HostId != nil {
		return fmt.Errorf("this.HostId == nil && that.HostId != nil")
	} else if that1.HostId != nil {
		return fmt.Errorf("HostId this(%v) Not Equal that(%v)", this.HostId, that1.HostId)
	}
	if this.Name != nil && that1.Name != nil {
		if *this.Name != *that1.Name {
			return fmt.Errorf("Name this(%v) Not Equal that(%v)", *this.Name, *that1.Name)
		}
	} else if this.Name != nil {
		return fmt.Errorf("this.Name == nil && that.Name != nil")
	} else if that1.Name != nil {
		return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
	}
	if len(this.Resources) != len(that1.Resources) {
		return fmt.Errorf("Resources this(%v) Not Equal that(%v)", len(this.Resources), len(that1.Resources))
	}
	for i := range this.Resources {
		if !this.Resources[i].Equal(that1.Resources[i]) {
			return fmt.Errorf("Resources this[%v](%v) Not Equal that[%v](%v)", i, this.Resources[i], i, that1.Resources[i])
		}
	}
	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 !this.LastHeartbeat.Equal(that1.LastHeartbeat) {
		return fmt.Errorf("LastHeartbeat this(%v) Not Equal that(%v)", this.LastHeartbeat, that1.LastHeartbeat)
	}
	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 *Host) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Host)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return false
		}
	} else if this.HostId != nil {
		return false
	} else if that1.HostId != nil {
		return false
	}
	if this.Name != nil && that1.Name != nil {
		if *this.Name != *that1.Name {
			return false
		}
	} else if this.Name != nil {
		return false
	} else if that1.Name != nil {
		return false
	}
	if len(this.Resources) != len(that1.Resources) {
		return false
	}
	for i := range this.Resources {
		if !this.Resources[i].Equal(that1.Resources[i]) {
			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 !this.LastHeartbeat.Equal(that1.LastHeartbeat) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *PortBinding) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*PortBinding)
	if !ok {
		return fmt.Errorf("that is not of type *PortBinding")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *PortBinding but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *PortBindingbut is not nil && this == nil")
	}
	if this.Host != nil && that1.Host != nil {
		if *this.Host != *that1.Host {
			return fmt.Errorf("Host this(%v) Not Equal that(%v)", *this.Host, *that1.Host)
		}
	} else if this.Host != nil {
		return fmt.Errorf("this.Host == nil && that.Host != nil")
	} else if that1.Host != nil {
		return fmt.Errorf("Host this(%v) Not Equal that(%v)", this.Host, that1.Host)
	}
	if this.Container != nil && that1.Container != nil {
		if *this.Container != *that1.Container {
			return fmt.Errorf("Container this(%v) Not Equal that(%v)", *this.Container, *that1.Container)
		}
	} else if this.Container != nil {
		return fmt.Errorf("this.Container == nil && that.Container != nil")
	} else if that1.Container != nil {
		return fmt.Errorf("Container this(%v) Not Equal that(%v)", this.Container, that1.Container)
	}
	if this.Protocol != nil && that1.Protocol != nil {
		if *this.Protocol != *that1.Protocol {
			return fmt.Errorf("Protocol this(%v) Not Equal that(%v)", *this.Protocol, *that1.Protocol)
		}
	} else if this.Protocol != nil {
		return fmt.Errorf("this.Protocol == nil && that.Protocol != nil")
	} else if that1.Protocol != nil {
		return fmt.Errorf("Protocol this(%v) Not Equal that(%v)", this.Protocol, that1.Protocol)
	}
	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 *PortBinding) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*PortBinding)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Host != nil && that1.Host != nil {
		if *this.Host != *that1.Host {
			return false
		}
	} else if this.Host != nil {
		return false
	} else if that1.Host != nil {
		return false
	}
	if this.Container != nil && that1.Container != nil {
		if *this.Container != *that1.Container {
			return false
		}
	} else if this.Container != nil {
		return false
	} else if that1.Container != nil {
		return false
	}
	if this.Protocol != nil && that1.Protocol != nil {
		if *this.Protocol != *that1.Protocol {
			return false
		}
	} else if this.Protocol != nil {
		return false
	} else if that1.Protocol != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ContainerInfo) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ContainerInfo)
	if !ok {
		return fmt.Errorf("that is not of type *ContainerInfo")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ContainerInfo but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ContainerInfobut is not nil && this == nil")
	}
	if this.Mode != nil && that1.Mode != nil {
		if *this.Mode != *that1.Mode {
			return fmt.Errorf("Mode this(%v) Not Equal that(%v)", *this.Mode, *that1.Mode)
		}
	} else if this.Mode != nil {
		return fmt.Errorf("this.Mode == nil && that.Mode != nil")
	} else if that1.Mode != nil {
		return fmt.Errorf("Mode this(%v) Not Equal that(%v)", this.Mode, that1.Mode)
	}
	if this.Image != nil && that1.Image != nil {
		if *this.Image != *that1.Image {
			return fmt.Errorf("Image this(%v) Not Equal that(%v)", *this.Image, *that1.Image)
		}
	} else if this.Image != nil {
		return fmt.Errorf("this.Image == nil && that.Image != nil")
	} else if that1.Image != nil {
		return fmt.Errorf("Image this(%v) Not Equal that(%v)", this.Image, that1.Image)
	}
	if len(this.Ports) != len(that1.Ports) {
		return fmt.Errorf("Ports this(%v) Not Equal that(%v)", len(this.Ports), len(that1.Ports))
	}
	for i := range this.Ports {
		if !this.Ports[i].Equal(that1.Ports[i]) {
			return fmt.Errorf("Ports this[%v](%v) Not Equal that[%v](%v)", i, this.Ports[i], i, that1.Ports[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 *ContainerInfo) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ContainerInfo)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Mode != nil && that1.Mode != nil {
		if *this.Mode != *that1.Mode {
			return false
		}
	} else if this.Mode != nil {
		return false
	} else if that1.Mode != nil {
		return false
	}
	if this.Image != nil && that1.Image != nil {
		if *this.Image != *that1.Image {
			return false
		}
	} else if this.Image != nil {
		return false
	} else if that1.Image != nil {
		return false
	}
	if len(this.Ports) != len(that1.Ports) {
		return false
	}
	for i := range this.Ports {
		if !this.Ports[i].Equal(that1.Ports[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *TaskDescription) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*TaskDescription)
	if !ok {
		return fmt.Errorf("that is not of type *TaskDescription")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *TaskDescription but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *TaskDescriptionbut is not nil && this == nil")
	}
	if this.Command != nil && that1.Command != nil {
		if *this.Command != *that1.Command {
			return fmt.Errorf("Command this(%v) Not Equal that(%v)", *this.Command, *that1.Command)
		}
	} else if this.Command != nil {
		return fmt.Errorf("this.Command == nil && that.Command != nil")
	} else if that1.Command != nil {
		return fmt.Errorf("Command this(%v) Not Equal that(%v)", this.Command, that1.Command)
	}
	if len(this.Exec) != len(that1.Exec) {
		return fmt.Errorf("Exec this(%v) Not Equal that(%v)", len(this.Exec), len(that1.Exec))
	}
	for i := range this.Exec {
		if this.Exec[i] != that1.Exec[i] {
			return fmt.Errorf("Exec this[%v](%v) Not Equal that[%v](%v)", i, this.Exec[i], i, that1.Exec[i])
		}
	}
	if len(this.Env) != len(that1.Env) {
		return fmt.Errorf("Env this(%v) Not Equal that(%v)", len(this.Env), len(that1.Env))
	}
	for i := range this.Env {
		if !this.Env[i].Equal(that1.Env[i]) {
			return fmt.Errorf("Env this[%v](%v) Not Equal that[%v](%v)", i, this.Env[i], i, that1.Env[i])
		}
	}
	if len(this.Urls) != len(that1.Urls) {
		return fmt.Errorf("Urls this(%v) Not Equal that(%v)", len(this.Urls), len(that1.Urls))
	}
	for i := range this.Urls {
		if this.Urls[i] != that1.Urls[i] {
			return fmt.Errorf("Urls this[%v](%v) Not Equal that[%v](%v)", i, this.Urls[i], i, that1.Urls[i])
		}
	}
	if len(this.Config) != len(that1.Config) {
		return fmt.Errorf("Config this(%v) Not Equal that(%v)", len(this.Config), len(that1.Config))
	}
	for i := range this.Config {
		if !this.Config[i].Equal(that1.Config[i]) {
			return fmt.Errorf("Config this[%v](%v) Not Equal that[%v](%v)", i, this.Config[i], i, that1.Config[i])
		}
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return fmt.Errorf("Metadata this(%v) Not Equal that(%v)", len(this.Metadata), len(that1.Metadata))
	}
	for i := range this.Metadata {
		if !this.Metadata[i].Equal(that1.Metadata[i]) {
			return fmt.Errorf("Metadata this[%v](%v) Not Equal that[%v](%v)", i, this.Metadata[i], i, that1.Metadata[i])
		}
	}
	if len(this.Labels) != len(that1.Labels) {
		return fmt.Errorf("Labels this(%v) Not Equal that(%v)", len(this.Labels), len(that1.Labels))
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return fmt.Errorf("Labels this[%v](%v) Not Equal that[%v](%v)", i, this.Labels[i], i, that1.Labels[i])
		}
	}
	if !this.Container.Equal(that1.Container) {
		return fmt.Errorf("Container this(%v) Not Equal that(%v)", this.Container, that1.Container)
	}
	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 *TaskDescription) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*TaskDescription)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Command != nil && that1.Command != nil {
		if *this.Command != *that1.Command {
			return false
		}
	} else if this.Command != nil {
		return false
	} else if that1.Command != nil {
		return false
	}
	if len(this.Exec) != len(that1.Exec) {
		return false
	}
	for i := range this.Exec {
		if this.Exec[i] != that1.Exec[i] {
			return false
		}
	}
	if len(this.Env) != len(that1.Env) {
		return false
	}
	for i := range this.Env {
		if !this.Env[i].Equal(that1.Env[i]) {
			return false
		}
	}
	if len(this.Urls) != len(that1.Urls) {
		return false
	}
	for i := range this.Urls {
		if this.Urls[i] != that1.Urls[i] {
			return false
		}
	}
	if len(this.Config) != len(that1.Config) {
		return false
	}
	for i := range this.Config {
		if !this.Config[i].Equal(that1.Config[i]) {
			return false
		}
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return false
	}
	for i := range this.Metadata {
		if !this.Metadata[i].Equal(that1.Metadata[i]) {
			return false
		}
	}
	if len(this.Labels) != len(that1.Labels) {
		return false
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return false
		}
	}
	if !this.Container.Equal(that1.Container) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *HostResource) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*HostResource)
	if !ok {
		return fmt.Errorf("that is not of type *HostResource")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *HostResource but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *HostResourcebut is not nil && this == nil")
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return fmt.Errorf("HostId this(%v) Not Equal that(%v)", *this.HostId, *that1.HostId)
		}
	} else if this.HostId != nil {
		return fmt.Errorf("this.HostId == nil && that.HostId != nil")
	} else if that1.HostId != nil {
		return fmt.Errorf("HostId this(%v) Not Equal that(%v)", this.HostId, that1.HostId)
	}
	if len(this.Resources) != len(that1.Resources) {
		return fmt.Errorf("Resources this(%v) Not Equal that(%v)", len(this.Resources), len(that1.Resources))
	}
	for i := range this.Resources {
		if !this.Resources[i].Equal(that1.Resources[i]) {
			return fmt.Errorf("Resources this[%v](%v) Not Equal that[%v](%v)", i, this.Resources[i], i, that1.Resources[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 *HostResource) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*HostResource)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return false
		}
	} else if this.HostId != nil {
		return false
	} else if that1.HostId != nil {
		return false
	}
	if len(this.Resources) != len(that1.Resources) {
		return false
	}
	for i := range this.Resources {
		if !this.Resources[i].Equal(that1.Resources[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Task) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Task)
	if !ok {
		return fmt.Errorf("that is not of type *Task")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Task but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Taskbut is not nil && this == nil")
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", *this.TaskId, *that1.TaskId)
		}
	} else if this.TaskId != nil {
		return fmt.Errorf("this.TaskId == nil && that.TaskId != nil")
	} else if that1.TaskId != nil {
		return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return fmt.Errorf("HostId this(%v) Not Equal that(%v)", *this.HostId, *that1.HostId)
		}
	} else if this.HostId != nil {
		return fmt.Errorf("this.HostId == nil && that.HostId != nil")
	} else if that1.HostId != nil {
		return fmt.Errorf("HostId this(%v) Not Equal that(%v)", this.HostId, that1.HostId)
	}
	if this.SchedulerId != nil && that1.SchedulerId != nil {
		if *this.SchedulerId != *that1.SchedulerId {
			return fmt.Errorf("SchedulerId this(%v) Not Equal that(%v)", *this.SchedulerId, *that1.SchedulerId)
		}
	} else if this.SchedulerId != nil {
		return fmt.Errorf("this.SchedulerId == nil && that.SchedulerId != nil")
	} else if that1.SchedulerId != nil {
		return fmt.Errorf("SchedulerId this(%v) Not Equal that(%v)", this.SchedulerId, that1.SchedulerId)
	}
	if !this.Description.Equal(that1.Description) {
		return fmt.Errorf("Description this(%v) Not Equal that(%v)", this.Description, that1.Description)
	}
	if len(this.Resources) != len(that1.Resources) {
		return fmt.Errorf("Resources this(%v) Not Equal that(%v)", len(this.Resources), len(that1.Resources))
	}
	for i := range this.Resources {
		if !this.Resources[i].Equal(that1.Resources[i]) {
			return fmt.Errorf("Resources this[%v](%v) Not Equal that[%v](%v)", i, this.Resources[i], i, that1.Resources[i])
		}
	}
	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 !this.LastUpdate.Equal(that1.LastUpdate) {
		return fmt.Errorf("LastUpdate this(%v) Not Equal that(%v)", this.LastUpdate, that1.LastUpdate)
	}
	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 *Task) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Task)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return false
		}
	} else if this.TaskId != nil {
		return false
	} else if that1.TaskId != nil {
		return false
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return false
		}
	} else if this.HostId != nil {
		return false
	} else if that1.HostId != nil {
		return false
	}
	if this.SchedulerId != nil && that1.SchedulerId != nil {
		if *this.SchedulerId != *that1.SchedulerId {
			return false
		}
	} else if this.SchedulerId != nil {
		return false
	} else if that1.SchedulerId != nil {
		return false
	}
	if !this.Description.Equal(that1.Description) {
		return false
	}
	if len(this.Resources) != len(that1.Resources) {
		return false
	}
	for i := range this.Resources {
		if !this.Resources[i].Equal(that1.Resources[i]) {
			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 !this.LastUpdate.Equal(that1.LastUpdate) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ClusterState) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ClusterState)
	if !ok {
		return fmt.Errorf("that is not of type *ClusterState")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ClusterState but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ClusterStatebut is not nil && this == nil")
	}
	if len(this.Hosts) != len(that1.Hosts) {
		return fmt.Errorf("Hosts this(%v) Not Equal that(%v)", len(this.Hosts), len(that1.Hosts))
	}
	for i := range this.Hosts {
		if !this.Hosts[i].Equal(that1.Hosts[i]) {
			return fmt.Errorf("Hosts this[%v](%v) Not Equal that[%v](%v)", i, this.Hosts[i], i, that1.Hosts[i])
		}
	}
	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 len(this.Available) != len(that1.Available) {
		return fmt.Errorf("Available this(%v) Not Equal that(%v)", len(this.Available), len(that1.Available))
	}
	for i := range this.Available {
		if !this.Available[i].Equal(that1.Available[i]) {
			return fmt.Errorf("Available this[%v](%v) Not Equal that[%v](%v)", i, this.Available[i], i, that1.Available[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 *ClusterState) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ClusterState)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Hosts) != len(that1.Hosts) {
		return false
	}
	for i := range this.Hosts {
		if !this.Hosts[i].Equal(that1.Hosts[i]) {
			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 len(this.Available) != len(that1.Available) {
		return false
	}
	for i := range this.Available {
		if !this.Available[i].Equal(that1.Available[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *UpdateState) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*UpdateState)
	if !ok {
		return fmt.Errorf("that is not of type *UpdateState")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *UpdateState but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *UpdateStatebut is not nil && this == nil")
	}
	if len(this.AddHosts) != len(that1.AddHosts) {
		return fmt.Errorf("AddHosts this(%v) Not Equal that(%v)", len(this.AddHosts), len(that1.AddHosts))
	}
	for i := range this.AddHosts {
		if !this.AddHosts[i].Equal(that1.AddHosts[i]) {
			return fmt.Errorf("AddHosts this[%v](%v) Not Equal that[%v](%v)", i, this.AddHosts[i], i, that1.AddHosts[i])
		}
	}
	if len(this.AddTasks) != len(that1.AddTasks) {
		return fmt.Errorf("AddTasks this(%v) Not Equal that(%v)", len(this.AddTasks), len(that1.AddTasks))
	}
	for i := range this.AddTasks {
		if !this.AddTasks[i].Equal(that1.AddTasks[i]) {
			return fmt.Errorf("AddTasks this[%v](%v) Not Equal that[%v](%v)", i, this.AddTasks[i], i, that1.AddTasks[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 *UpdateState) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*UpdateState)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.AddHosts) != len(that1.AddHosts) {
		return false
	}
	for i := range this.AddHosts {
		if !this.AddHosts[i].Equal(that1.AddHosts[i]) {
			return false
		}
	}
	if len(this.AddTasks) != len(that1.AddTasks) {
		return false
	}
	for i := range this.AddTasks {
		if !this.AddTasks[i].Equal(that1.AddTasks[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *FetchState) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*FetchState)
	if !ok {
		return fmt.Errorf("that is not of type *FetchState")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *FetchState but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *FetchStatebut is not nil && this == nil")
	}
	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 *FetchState) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*FetchState)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *StartTask) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StartTask)
	if !ok {
		return fmt.Errorf("that is not of type *StartTask")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StartTask but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StartTaskbut is not nil && this == nil")
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return fmt.Errorf("OpId this(%v) Not Equal that(%v)", *this.OpId, *that1.OpId)
		}
	} else if this.OpId != nil {
		return fmt.Errorf("this.OpId == nil && that.OpId != nil")
	} else if that1.OpId != nil {
		return fmt.Errorf("OpId this(%v) Not Equal that(%v)", this.OpId, that1.OpId)
	}
	if !this.Task.Equal(that1.Task) {
		return fmt.Errorf("Task this(%v) Not Equal that(%v)", this.Task, that1.Task)
	}
	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 *StartTask) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StartTask)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return false
		}
	} else if this.OpId != nil {
		return false
	} else if that1.OpId != nil {
		return false
	}
	if !this.Task.Equal(that1.Task) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *StopTask) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StopTask)
	if !ok {
		return fmt.Errorf("that is not of type *StopTask")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StopTask but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StopTaskbut is not nil && this == nil")
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return fmt.Errorf("OpId this(%v) Not Equal that(%v)", *this.OpId, *that1.OpId)
		}
	} else if this.OpId != nil {
		return fmt.Errorf("this.OpId == nil && that.OpId != nil")
	} else if that1.OpId != nil {
		return fmt.Errorf("OpId this(%v) Not Equal that(%v)", this.OpId, that1.OpId)
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", *this.TaskId, *that1.TaskId)
		}
	} else if this.TaskId != nil {
		return fmt.Errorf("this.TaskId == nil && that.TaskId != nil")
	} else if that1.TaskId != nil {
		return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
	}
	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 *StopTask) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StopTask)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return false
		}
	} else if this.OpId != nil {
		return false
	} else if that1.OpId != nil {
		return false
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return false
		}
	} else if this.TaskId != nil {
		return false
	} else if that1.TaskId != nil {
		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 *OpAcknowledged) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OpAcknowledged)
	if !ok {
		return fmt.Errorf("that is not of type *OpAcknowledged")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OpAcknowledged but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OpAcknowledgedbut is not nil && this == nil")
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return fmt.Errorf("OpId this(%v) Not Equal that(%v)", *this.OpId, *that1.OpId)
		}
	} else if this.OpId != nil {
		return fmt.Errorf("this.OpId == nil && that.OpId != nil")
	} else if that1.OpId != nil {
		return fmt.Errorf("OpId this(%v) Not Equal that(%v)", this.OpId, that1.OpId)
	}
	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 *OpAcknowledged) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OpAcknowledged)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return false
		}
	} else if this.OpId != nil {
		return false
	} else if that1.OpId != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *TaskStatusChange) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*TaskStatusChange)
	if !ok {
		return fmt.Errorf("that is not of type *TaskStatusChange")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *TaskStatusChange but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *TaskStatusChangebut is not nil && this == nil")
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", *this.TaskId, *that1.TaskId)
		}
	} else if this.TaskId != nil {
		return fmt.Errorf("this.TaskId == nil && that.TaskId != nil")
	} else if that1.TaskId != nil {
		return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
	}
	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 this.Error != nil && that1.Error != nil {
		if *this.Error != *that1.Error {
			return fmt.Errorf("Error this(%v) Not Equal that(%v)", *this.Error, *that1.Error)
		}
	} else if this.Error != nil {
		return fmt.Errorf("this.Error == nil && that.Error != nil")
	} else if that1.Error != nil {
		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 *TaskStatusChange) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*TaskStatusChange)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return false
		}
	} else if this.TaskId != nil {
		return false
	} else if that1.TaskId != nil {
		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 this.Error != nil && that1.Error != nil {
		if *this.Error != *that1.Error {
			return false
		}
	} else if this.Error != nil {
		return false
	} else if that1.Error != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *HostStatusChange) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*HostStatusChange)
	if !ok {
		return fmt.Errorf("that is not of type *HostStatusChange")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *HostStatusChange but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *HostStatusChangebut is not nil && this == nil")
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return fmt.Errorf("HostId this(%v) Not Equal that(%v)", *this.HostId, *that1.HostId)
		}
	} else if this.HostId != nil {
		return fmt.Errorf("this.HostId == nil && that.HostId != nil")
	} else if that1.HostId != nil {
		return fmt.Errorf("HostId this(%v) Not Equal that(%v)", this.HostId, that1.HostId)
	}
	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 *HostStatusChange) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*HostStatusChange)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return false
		}
	} else if this.HostId != nil {
		return false
	} else if that1.HostId != nil {
		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 *ListTasks) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ListTasks)
	if !ok {
		return fmt.Errorf("that is not of type *ListTasks")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ListTasks but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ListTasksbut is not nil && this == nil")
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return fmt.Errorf("OpId this(%v) Not Equal that(%v)", *this.OpId, *that1.OpId)
		}
	} else if this.OpId != nil {
		return fmt.Errorf("this.OpId == nil && that.OpId != nil")
	} else if that1.OpId != nil {
		return fmt.Errorf("OpId this(%v) Not Equal that(%v)", this.OpId, that1.OpId)
	}
	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 *ListTasks) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ListTasks)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return false
		}
	} else if this.OpId != nil {
		return false
	} else if that1.OpId != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *CurrentTasks) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*CurrentTasks)
	if !ok {
		return fmt.Errorf("that is not of type *CurrentTasks")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *CurrentTasks but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *CurrentTasksbut is not nil && this == nil")
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return fmt.Errorf("OpId this(%v) Not Equal that(%v)", *this.OpId, *that1.OpId)
		}
	} else if this.OpId != nil {
		return fmt.Errorf("this.OpId == nil && that.OpId != nil")
	} else if that1.OpId != nil {
		return fmt.Errorf("OpId this(%v) Not Equal that(%v)", this.OpId, that1.OpId)
	}
	if len(this.TaskIds) != len(that1.TaskIds) {
		return fmt.Errorf("TaskIds this(%v) Not Equal that(%v)", len(this.TaskIds), len(that1.TaskIds))
	}
	for i := range this.TaskIds {
		if this.TaskIds[i] != that1.TaskIds[i] {
			return fmt.Errorf("TaskIds this[%v](%v) Not Equal that[%v](%v)", i, this.TaskIds[i], i, that1.TaskIds[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 *CurrentTasks) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*CurrentTasks)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return false
		}
	} else if this.OpId != nil {
		return false
	} else if that1.OpId != nil {
		return false
	}
	if len(this.TaskIds) != len(that1.TaskIds) {
		return false
	}
	for i := range this.TaskIds {
		if this.TaskIds[i] != that1.TaskIds[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Error) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Error)
	if !ok {
		return fmt.Errorf("that is not of type *Error")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Error but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Errorbut is not nil && this == nil")
	}
	if this.ErrorId != that1.ErrorId {
		return fmt.Errorf("ErrorId this(%v) Not Equal that(%v)", this.ErrorId, that1.ErrorId)
	}
	if this.Description != nil && that1.Description != nil {
		if *this.Description != *that1.Description {
			return fmt.Errorf("Description this(%v) Not Equal that(%v)", *this.Description, *that1.Description)
		}
	} else if this.Description != nil {
		return fmt.Errorf("this.Description == nil && that.Description != nil")
	} else if that1.Description != nil {
		return fmt.Errorf("Description this(%v) Not Equal that(%v)", this.Description, that1.Description)
	}
	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 *Error) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Error)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ErrorId != that1.ErrorId {
		return false
	}
	if this.Description != nil && that1.Description != nil {
		if *this.Description != *that1.Description {
			return false
		}
	} else if this.Description != nil {
		return false
	} else if that1.Description != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *GenericError) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*GenericError)
	if !ok {
		return fmt.Errorf("that is not of type *GenericError")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *GenericError but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *GenericErrorbut is not nil && this == nil")
	}
	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 *GenericError) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*GenericError)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		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 *StopError) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StopError)
	if !ok {
		return fmt.Errorf("that is not of type *StopError")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StopError but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StopErrorbut is not nil && this == nil")
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return fmt.Errorf("OpId this(%v) Not Equal that(%v)", *this.OpId, *that1.OpId)
		}
	} else if this.OpId != nil {
		return fmt.Errorf("this.OpId == nil && that.OpId != nil")
	} else if that1.OpId != nil {
		return fmt.Errorf("OpId this(%v) Not Equal that(%v)", this.OpId, that1.OpId)
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", *this.TaskId, *that1.TaskId)
		}
	} else if this.TaskId != nil {
		return fmt.Errorf("this.TaskId == nil && that.TaskId != nil")
	} else if that1.TaskId != nil {
		return fmt.Errorf("TaskId this(%v) Not Equal that(%v)", this.TaskId, that1.TaskId)
	}
	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 *StopError) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StopError)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.OpId != nil && that1.OpId != nil {
		if *this.OpId != *that1.OpId {
			return false
		}
	} else if this.OpId != nil {
		return false
	} else if that1.OpId != nil {
		return false
	}
	if this.TaskId != nil && that1.TaskId != nil {
		if *this.TaskId != *that1.TaskId {
			return false
		}
	} else if this.TaskId != nil {
		return false
	} else if that1.TaskId != nil {
		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 *CheckTasks) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*CheckTasks)
	if !ok {
		return fmt.Errorf("that is not of type *CheckTasks")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *CheckTasks but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *CheckTasksbut is not nil && this == nil")
	}
	if len(this.TaskIds) != len(that1.TaskIds) {
		return fmt.Errorf("TaskIds this(%v) Not Equal that(%v)", len(this.TaskIds), len(that1.TaskIds))
	}
	for i := range this.TaskIds {
		if this.TaskIds[i] != that1.TaskIds[i] {
			return fmt.Errorf("TaskIds this[%v](%v) Not Equal that[%v](%v)", i, this.TaskIds[i], i, that1.TaskIds[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 *CheckTasks) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*CheckTasks)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.TaskIds) != len(that1.TaskIds) {
		return false
	}
	for i := range this.TaskIds {
		if this.TaskIds[i] != that1.TaskIds[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *CheckedTaskList) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*CheckedTaskList)
	if !ok {
		return fmt.Errorf("that is not of type *CheckedTaskList")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *CheckedTaskList but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *CheckedTaskListbut is not nil && this == nil")
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return fmt.Errorf("HostId this(%v) Not Equal that(%v)", *this.HostId, *that1.HostId)
		}
	} else if this.HostId != nil {
		return fmt.Errorf("this.HostId == nil && that.HostId != nil")
	} else if that1.HostId != nil {
		return fmt.Errorf("HostId this(%v) Not Equal that(%v)", this.HostId, that1.HostId)
	}
	if len(this.Missing) != len(that1.Missing) {
		return fmt.Errorf("Missing this(%v) Not Equal that(%v)", len(this.Missing), len(that1.Missing))
	}
	for i := range this.Missing {
		if this.Missing[i] != that1.Missing[i] {
			return fmt.Errorf("Missing this[%v](%v) Not Equal that[%v](%v)", i, this.Missing[i], i, that1.Missing[i])
		}
	}
	if len(this.Unknown) != len(that1.Unknown) {
		return fmt.Errorf("Unknown this(%v) Not Equal that(%v)", len(this.Unknown), len(that1.Unknown))
	}
	for i := range this.Unknown {
		if this.Unknown[i] != that1.Unknown[i] {
			return fmt.Errorf("Unknown this[%v](%v) Not Equal that[%v](%v)", i, this.Unknown[i], i, that1.Unknown[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 *CheckedTaskList) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*CheckedTaskList)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.HostId != nil && that1.HostId != nil {
		if *this.HostId != *that1.HostId {
			return false
		}
	} else if this.HostId != nil {
		return false
	} else if that1.HostId != nil {
		return false
	}
	if len(this.Missing) != len(that1.Missing) {
		return false
	}
	for i := range this.Missing {
		if this.Missing[i] != that1.Missing[i] {
			return false
		}
	}
	if len(this.Unknown) != len(that1.Unknown) {
		return false
	}
	for i := range this.Unknown {
		if this.Unknown[i] != that1.Unknown[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}