Adding dep files and dependencies.

vendor/github.com/mesos/mesos-go/api/v0/mesosutil/constants.go

@@ -0,0 +1,6 @@
+package mesosutil
+
+const (
+	// MesosVersion indicates the supported mesos version.
+	MesosVersion = "0.24.0"
+)

vendor/github.com/mesos/mesos-go/api/v0/mesosutil/mesosprotoutil.go

@@ -0,0 +1,229 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mesosutil
+
+import (
+	"github.com/gogo/protobuf/proto"
+	mesos "github.com/mesos/mesos-go/api/v0/mesosproto"
+)
+
+func NewValueRange(begin, end uint64) *mesos.Value_Range {
+	return &mesos.Value_Range{Begin: proto.Uint64(begin), End: proto.Uint64(end)}
+}
+
+func FilterResources(resources []*mesos.Resource, filter func(*mesos.Resource) bool) (result []*mesos.Resource) {
+	for _, resource := range resources {
+		if filter(resource) {
+			result = append(result, resource)
+		}
+	}
+	return result
+}
+
+func AddResourceRevocable(resource *mesos.Resource) *mesos.Resource {
+	resource.Revocable = &mesos.Resource_RevocableInfo{}
+	return resource
+}
+
+func NewScalarResourceWithRevocable(name string, value float64) *mesos.Resource {
+	return AddResourceRevocable(NewScalarResource(name, value))
+}
+
+func AddResourceReservation(resource *mesos.Resource, principal string, role string) *mesos.Resource {
+	resource.Reservation = &mesos.Resource_ReservationInfo{Principal: proto.String(principal)}
+	resource.Role = proto.String(role)
+	return resource
+}
+
+func NewScalarResourceWithReservation(name string, value float64, principal string, role string) *mesos.Resource {
+	return AddResourceReservation(NewScalarResource(name, value), principal, role)
+}
+
+func NewRangesResourceWithReservation(name string, ranges []*mesos.Value_Range, principal string, role string) *mesos.Resource {
+	return AddResourceReservation(NewRangesResource(name, ranges), principal, role)
+}
+
+func NewSetResourceWithReservation(name string, items []string, principal string, role string) *mesos.Resource {
+	return AddResourceReservation(NewSetResource(name, items), principal, role)
+}
+
+func NewVolumeResourceWithReservation(val float64, containerPath string, persistenceId string, mode *mesos.Volume_Mode, principal string, role string) *mesos.Resource {
+	return AddResourceReservation(NewVolumeResource(val, containerPath, persistenceId, mode), principal, role)
+}
+
+func NewScalarResource(name string, val float64) *mesos.Resource {
+	return &mesos.Resource{
+		Name:   proto.String(name),
+		Type:   mesos.Value_SCALAR.Enum(),
+		Scalar: &mesos.Value_Scalar{Value: proto.Float64(val)},
+	}
+}
+
+func NewRangesResource(name string, ranges []*mesos.Value_Range) *mesos.Resource {
+	return &mesos.Resource{
+		Name:   proto.String(name),
+		Type:   mesos.Value_RANGES.Enum(),
+		Ranges: &mesos.Value_Ranges{Range: ranges},
+	}
+}
+
+func NewSetResource(name string, items []string) *mesos.Resource {
+	return &mesos.Resource{
+		Name: proto.String(name),
+		Type: mesos.Value_SET.Enum(),
+		Set:  &mesos.Value_Set{Item: items},
+	}
+}
+
+func NewVolumeResource(val float64, containerPath string, persistenceId string, mode *mesos.Volume_Mode) *mesos.Resource {
+	resource := NewScalarResource("disk", val)
+	resource.Disk = &mesos.Resource_DiskInfo{
+		Persistence: &mesos.Resource_DiskInfo_Persistence{Id: proto.String(persistenceId)},
+		Volume:      &mesos.Volume{ContainerPath: proto.String(containerPath), Mode: mode},
+	}
+	return resource
+}
+
+func NewFrameworkID(id string) *mesos.FrameworkID {
+	return &mesos.FrameworkID{Value: proto.String(id)}
+}
+
+func NewFrameworkInfo(user, name string, frameworkId *mesos.FrameworkID) *mesos.FrameworkInfo {
+	return &mesos.FrameworkInfo{
+		User: proto.String(user),
+		Name: proto.String(name),
+		Id:   frameworkId,
+	}
+}
+
+func NewMasterInfo(id string, ip, port uint32) *mesos.MasterInfo {
+	return &mesos.MasterInfo{
+		Id:   proto.String(id),
+		Ip:   proto.Uint32(ip),
+		Port: proto.Uint32(port),
+	}
+}
+
+func NewOfferID(id string) *mesos.OfferID {
+	return &mesos.OfferID{Value: proto.String(id)}
+}
+
+func NewOffer(offerId *mesos.OfferID, frameworkId *mesos.FrameworkID, slaveId *mesos.SlaveID, hostname string) *mesos.Offer {
+	return &mesos.Offer{
+		Id:          offerId,
+		FrameworkId: frameworkId,
+		SlaveId:     slaveId,
+		Hostname:    proto.String(hostname),
+	}
+}
+
+func FilterOffersResources(offers []*mesos.Offer, filter func(*mesos.Resource) bool) (result []*mesos.Resource) {
+	for _, offer := range offers {
+		result = FilterResources(offer.Resources, filter)
+	}
+	return result
+}
+
+func NewSlaveID(id string) *mesos.SlaveID {
+	return &mesos.SlaveID{Value: proto.String(id)}
+}
+
+func NewTaskID(id string) *mesos.TaskID {
+	return &mesos.TaskID{Value: proto.String(id)}
+}
+
+func NewTaskInfo(
+	name string,
+	taskId *mesos.TaskID,
+	slaveId *mesos.SlaveID,
+	resources []*mesos.Resource,
+) *mesos.TaskInfo {
+	return &mesos.TaskInfo{
+		Name:      proto.String(name),
+		TaskId:    taskId,
+		SlaveId:   slaveId,
+		Resources: resources,
+	}
+}
+
+func NewTaskStatus(taskId *mesos.TaskID, state mesos.TaskState) *mesos.TaskStatus {
+	return &mesos.TaskStatus{
+		TaskId: taskId,
+		State:  mesos.TaskState(state).Enum(),
+	}
+}
+
+func NewStatusUpdate(frameworkId *mesos.FrameworkID, taskStatus *mesos.TaskStatus, timestamp float64, uuid []byte) *mesos.StatusUpdate {
+	return &mesos.StatusUpdate{
+		FrameworkId: frameworkId,
+		Status:      taskStatus,
+		Timestamp:   proto.Float64(timestamp),
+		Uuid:        uuid,
+	}
+}
+
+func NewCommandInfo(command string) *mesos.CommandInfo {
+	return &mesos.CommandInfo{Value: proto.String(command)}
+}
+
+func NewExecutorID(id string) *mesos.ExecutorID {
+	return &mesos.ExecutorID{Value: proto.String(id)}
+}
+
+func NewExecutorInfo(execId *mesos.ExecutorID, command *mesos.CommandInfo) *mesos.ExecutorInfo {
+	return &mesos.ExecutorInfo{
+		ExecutorId: execId,
+		Command:    command,
+	}
+}
+
+func NewCreateOperation(volumes []*mesos.Resource) *mesos.Offer_Operation {
+	return &mesos.Offer_Operation{
+		Type:   mesos.Offer_Operation_CREATE.Enum(),
+		Create: &mesos.Offer_Operation_Create{Volumes: volumes},
+	}
+}
+
+func NewDestroyOperation(volumes []*mesos.Resource) *mesos.Offer_Operation {
+	return &mesos.Offer_Operation{
+		Type:    mesos.Offer_Operation_DESTROY.Enum(),
+		Destroy: &mesos.Offer_Operation_Destroy{Volumes: volumes},
+	}
+}
+
+func NewReserveOperation(resources []*mesos.Resource) *mesos.Offer_Operation {
+	return &mesos.Offer_Operation{
+		Type:    mesos.Offer_Operation_RESERVE.Enum(),
+		Reserve: &mesos.Offer_Operation_Reserve{Resources: resources},
+	}
+}
+
+func NewUnreserveOperation(resources []*mesos.Resource) *mesos.Offer_Operation {
+	return &mesos.Offer_Operation{
+		Type:      mesos.Offer_Operation_UNRESERVE.Enum(),
+		Unreserve: &mesos.Offer_Operation_Unreserve{Resources: resources},
+	}
+}
+
+func NewLaunchOperation(tasks []*mesos.TaskInfo) *mesos.Offer_Operation {
+	return &mesos.Offer_Operation{
+		Type:   mesos.Offer_Operation_LAUNCH.Enum(),
+		Launch: &mesos.Offer_Operation_Launch{TaskInfos: tasks},
+	}
+}

vendor/github.com/mesos/mesos-go/api/v0/mesosutil/node.go

@@ -0,0 +1,29 @@
+package mesosutil
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+
+	log "github.com/golang/glog"
+)
+
+//TODO(jdef) copied from kubernetes/pkg/util/node.go
+func GetHostname(hostnameOverride string) string {
+	hostname := hostnameOverride
+	if hostname == "" {
+		// Note: We use exec here instead of os.Hostname() because we
+		// want the FQDN, and this is the easiest way to get it.
+		fqdn, err := exec.Command("hostname", "-f").Output()
+		if err != nil || len(fqdn) == 0 {
+			log.Errorf("Couldn't determine hostname fqdn, failing back to hostname: %v", err)
+			hostname, err = os.Hostname()
+			if err != nil {
+				log.Fatalf("Error getting hostname: %v", err)
+			}
+		} else {
+			hostname = string(fqdn)
+		}
+	}
+	return strings.TrimSpace(hostname)
+}

vendor/github.com/mesos/mesos-go/api/v0/mesosutil/process/process.go

@@ -0,0 +1,34 @@
+package process
+
+import (
+	"fmt"
+	"sync"
+)
+
+var (
+	pidLock sync.Mutex
+	pid     uint64
+)
+
+func nextPid() uint64 {
+	pidLock.Lock()
+	defer pidLock.Unlock()
+	pid++
+	return pid
+}
+
+//TODO(jdef) add lifecycle funcs
+//TODO(jdef) add messaging funcs
+type Process struct {
+	label string
+}
+
+func New(kind string) *Process {
+	return &Process{
+		label: fmt.Sprintf("%s(%d)", kind, nextPid()),
+	}
+}
+
+func (p *Process) Label() string {
+	return p.label
+}