marathon

package module
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 26, 2016 License: Apache-2.0 Imports: 18 Imported by: 0

README

Build Status GoDoc

Go-Marathon

Go-marathon is a API library for working with Marathon. It currently supports

  • Application and group deployment
  • Helper filters for pulling the status, configuration and tasks
  • Multiple Endpoint support for HA deployments
  • Marathon Event Subscriptions and Event Streams

Note: the library is still under active development; users should expect frequent (possibly breaking) API changes for the time being.

It requires Go version 1.5 or higher.

Code Examples

There is also an examples directory in the source which shows hints and snippets of code of how to use it — which is probably the best place to start.

You can use examples/docker-compose.yml in order to start a test cluster.

Creating a client
import (
	marathon "github.com/gambol99/go-marathon"
)

marathonURL := "http://10.241.1.71:8080"
config := marathon.NewDefaultConfig()
config.URL = marathonURL
client, err := marathon.NewClient(config)
if err != nil {
	log.Fatalf("Failed to create a client for marathon, error: %s", err)
}

applications, err := client.Applications()
...

Note, you can also specify multiple endpoint for Marathon (i.e. you have setup Marathon in HA mode and having multiple running)

marathonURL := "http://10.241.1.71:8080,10.241.1.72:8080,10.241.1.73:8080"

The first one specified will be used, if that goes offline the member is marked as "unavailable" and a background process will continue to ping the member until it's back online.

Listing the applications
applications, err := client.Applications()
if err != nil {
	log.Fatalf("Failed to list applications")
}

log.Printf("Found %d applications running", len(applications.Apps))
for _, application := range applications.Apps {
	log.Printf("Application: %s", application)
	details, err := client.Application(application.ID)
	assert(err)
	if details.Tasks != nil && len(details.Tasks) > 0 {
		for _, task := range details.Tasks {
			log.Printf("task: %s", task)
		}
		// check the health of the application
		health, err := client.ApplicationOK(details.ID)
		log.Printf("Application: %s, healthy: %t", details.ID, health)
	}
}
Creating a new application
log.Printf("Deploying a new application")
application := marathon.NewDockerApplication()
application.Name("/product/name/frontend")
application.CPU(0.1).Memory(64).Storage(0.0).Count(2)
application.Arg("/usr/sbin/apache2ctl", "-D", "FOREGROUND")
application.AddEnv("NAME", "frontend_http")
application.AddEnv("SERVICE_80_NAME", "test_http")
application.AddLabel("environment", "staging")
application.AddLabel("security", "none")
// add the docker container
application.Container.Docker.Container("quay.io/gambol99/apache-php:latest").Expose(80, 443)
application.CheckHTTP("/health", 10, 5)

if _, err := client.CreateApplication(application); err != nil {
	log.Fatalf("Failed to create application: %s, error: %s", application, err)
} else {
	log.Printf("Created the application: %s", application)
}

Note: Applications may also be defined by means of initializing a marathon.Application struct instance directly. However, go-marathon's DSL as shown above provides a more concise way to achieve the same.

Scaling application

Change the number of application instances to 4

log.Printf("Scale to 4 instances")
if err := client.ScaleApplicationInstances(application.ID, 4); err != nil {
	log.Fatalf("Failed to delete the application: %s, error: %s", application, err)
} else {
	client.WaitOnApplication(application.ID, 30 * time.Second)
	log.Printf("Successfully scaled the application")
}
Subscription & Events

Request to listen to events related to applications — namely status updates, health checks changes and failures. There are two different event transports controlled by EventsTransport setting with the following possible values: EventsTransportSSE and EventsTransportCallback (default value). See Event Stream and Event Subscriptions for details.

Event Stream

Only available in Marathon >= 0.9.0. Does not require any special configuration or prerequisites.

// Configure client
config := marathon.NewDefaultConfig()
config.URL = marathonURL
config.EventsTransport = marathon.EventsTransportSSE

client, err := marathon.NewClient(config)
if err != nil {
	log.Fatalf("Failed to create a client for marathon, error: %s", err)
}

// Register for events
events := make(marathon.EventsChannel, 5)
err = client.AddEventsListener(events, marathon.EVENTS_APPLICATIONS)
if err != nil {
	log.Fatalf("Failed to register for events, %s", err)
}

timer := time.After(60 * time.Second)
done := false

// Receive events from channel for 60 seconds
for {
	if done {
		break
	}
	select {
	case <-timer:
		log.Printf("Exiting the loop")
		done = true
	case event := <-events:
		log.Printf("Recieved event: %s", event)
	}
}

// Unsubscribe from Marathon events
client.RemoveEventsListener(events)
Event Subscriptions

Requires to start a built-in web server accessible by Marathon to connect and push events to. Consider the following additional settings:

  • EventsInterface — the interface we should be listening on for events. Default "eth0".
  • EventsPort — built-in web server port. Default 10001.
  • CallbackURL — custom callback URL. Default "".
// Configure client
config := marathon.NewDefaultConfig()
config.URL = marathonURL
config.EventsInterface = marathonInterface
config.EventsPort = marathonPort

client, err := marathon.NewClient(config)
if err != nil {
	log.Fatalf("Failed to create a client for marathon, error: %s", err)
}

// Register for events
events := make(marathon.EventsChannel, 5)
err = client.AddEventsListener(events, marathon.EVENTS_APPLICATIONS)
if err != nil {
	log.Fatalf("Failed to register for events, %s", err)
}

timer := time.After(60 * time.Second)
done := false

// Receive events from channel for 60 seconds
for {
	if done {
		break
	}
	select {
	case <-timer:
		log.Printf("Exiting the loop")
		done = true
	case event := <-events:
		log.Printf("Recieved event: %s", event)
	}
}

// Unsubscribe from Marathon events
client.RemoveEventsListener(events)

A full list of the events:

const (
	EVENT_API_REQUEST = 1 << iota
	EVENT_STATUS_UPDATE
	EVENT_FRAMEWORK_MESSAGE
	EVENT_SUBSCRIPTION
	EVENT_UNSUBSCRIBED
	EVENT_STREAM_ATTACHED
	EVENT_STREAM_DETACHED
	EVENT_ADD_HEALTH_CHECK
	EVENT_REMOVE_HEALTH_CHECK
	EVENT_FAILED_HEALTH_CHECK
	EVENT_CHANGED_HEALTH_CHECK
	EVENT_GROUP_CHANGE_SUCCESS
	EVENT_GROUP_CHANGE_FAILED
	EVENT_DEPLOYMENT_SUCCESS
	EVENT_DEPLOYMENT_FAILED
	EVENT_DEPLOYMENT_INFO
	EVENT_DEPLOYMENT_STEP_SUCCESS
	EVENT_DEPLOYMENT_STEP_FAILED
	EVENT_APP_TERMINATED
)

const (
	EVENTS_APPLICATIONS  = EVENT_STATUS_UPDATE | EVENT_CHANGED_HEALTH_CHECK | EVENT_FAILED_HEALTH_CHECK | EVENT_APP_TERMINATED
	EVENTS_SUBSCRIPTIONS = EVENT_SUBSCRIPTION | EVENT_UNSUBSCRIBED | EVENT_STREAM_ATTACHED | EVENT_STREAM_DETACHED
)

Contributing

  • Fork it
  • Create your feature branch (git checkout -b my-new-feature)
  • Commit your changes (git commit -am 'Add some feature')
  • Push to the branch (git push origin my-new-feature)
  • Create new Pull Request
  • If applicable, update the README.md

Documentation

Index

Constants

View Source 
const (
	// ErrCodeBadRequest specifies a 400 Bad Request error.
	ErrCodeBadRequest = iota
	// ErrCodeUnauthorized specifies a 401 Unauthorized error.
	ErrCodeUnauthorized
	// ErrCodeForbidden specifies a 403 Forbidden error.
	ErrCodeForbidden
	// ErrCodeNotFound specifies a 404 Not Found error.
	ErrCodeNotFound
	// ErrCodeDuplicateID specifies a PUT 409 Conflict error.
	ErrCodeDuplicateID
	// ErrCodeAppLocked specifies a POST 409 Conflict error.
	ErrCodeAppLocked
	// ErrCodeInvalidBean specifies a 422 UnprocessableEntity error.
	ErrCodeInvalidBean
	// ErrCodeServer specifies a 500+ Server error.
	ErrCodeServer
	// ErrCodeUnknown specifies an unknown error.
	ErrCodeUnknown
)
View Source 
const (
	EVENT_API_REQUEST = 1 << iota
	EVENT_STATUS_UPDATE
	EVENT_FRAMEWORK_MESSAGE
	EVENT_SUBSCRIPTION
	EVENT_UNSUBSCRIBED
	EVENT_STREAM_ATTACHED
	EVENT_STREAM_DETACHED
	EVENT_ADD_HEALTH_CHECK
	EVENT_REMOVE_HEALTH_CHECK
	EVENT_FAILED_HEALTH_CHECK
	EVENT_CHANGED_HEALTH_CHECK
	EVENT_GROUP_CHANGE_SUCCESS
	EVENT_GROUP_CHANGE_FAILED
	EVENT_DEPLOYMENT_SUCCESS
	EVENT_DEPLOYMENT_FAILED
	EVENT_DEPLOYMENT_INFO
	EVENT_DEPLOYMENT_STEP_SUCCESS
	EVENT_DEPLOYMENT_STEP_FAILED
	EVENT_APP_TERMINATED
)
View Source 
const (
	EVENTS_APPLICATIONS  = EVENT_STATUS_UPDATE | EVENT_CHANGED_HEALTH_CHECK | EVENT_FAILED_HEALTH_CHECK | EVENT_APP_TERMINATED
	EVENTS_SUBSCRIPTIONS = EVENT_SUBSCRIPTION | EVENT_UNSUBSCRIBED | EVENT_STREAM_ATTACHED | EVENT_STREAM_DETACHED
)

Variables

View Source 
var (
	// ErrInvalidEndpoint is thrown when the marathon url specified was invalid
	ErrInvalidEndpoint = errors.New("invalid Marathon endpoint specified")
	// ErrInvalidResponse is thrown when marathon responds with invalid or error response
	ErrInvalidResponse = errors.New("invalid response from Marathon")
	// ErrMarathonDown is thrown when all the marathon endpoints are down
	ErrMarathonDown = errors.New("all the Marathon hosts are presently down")
	// ErrTimeoutError is thrown when the operation has timed out
	ErrTimeoutError = errors.New("the operation has timed out")
)
View Source 
var (
	// ErrNoApplicationContainer is thrown when a container has been specified yet
	ErrNoApplicationContainer = errors.New("you have not specified a docker container yet")
)
View Source 
var (
	Events map[string]int
)

Functions

This section is empty.

Types

type APIError 

type APIError struct {
	// ErrCode specifies the nature of the error.
	ErrCode int
	// contains filtered or unexported fields
}

APIError represents a generic API error.

func NewAPIError 

func NewAPIError(code int, content []byte) (*APIError, error)

NewAPIError creates a new APIError instance from the given response code and content.

func (*APIError) Error 

func (e *APIError) Error() string

type AllTasksOpts 

type AllTasksOpts struct {
	Status string `url:"status,omitempty"`
}

AllTasksOpts contains a payload for AllTasks method 

status:		Return only those tasks whose status matches this parameter.
		If not specified, all tasks are returned. Possible values: running, staging. Default: none.

type Application 

type Application struct {
	ID                    string              `json:"id,omitempty"`
	Cmd                   string              `json:"cmd,omitempty"`
	Args                  []string            `json:"args"`
	Constraints           [][]string          `json:"constraints"`
	Container             *Container          `json:"container,omitempty"`
	CPUs                  float64             `json:"cpus,omitempty"`
	Disk                  float64             `json:"disk,omitempty"`
	Env                   map[string]string   `json:"env"`
	Executor              string              `json:"executor,omitempty"`
	HealthChecks          []*HealthCheck      `json:"healthChecks"`
	Instances             int                 `json:"instances,omitempty"`
	Mem                   float64             `json:"mem,omitempty"`
	Tasks                 []*Task             `json:"tasks,omitempty"`
	Ports                 []int               `json:"ports"`
	RequirePorts          bool                `json:"requirePorts,omitempty"`
	BackoffSeconds        float64             `json:"backoffSeconds,omitempty"`
	BackoffFactor         float64             `json:"backoffFactor,omitempty"`
	MaxLaunchDelaySeconds float64             `json:"maxLaunchDelaySeconds,omitempty"`
	Deployments           []map[string]string `json:"deployments,omitempty"`
	Dependencies          []string            `json:"dependencies"`
	TasksRunning          int                 `json:"tasksRunning,omitempty"`
	TasksStaged           int                 `json:"tasksStaged,omitempty"`
	TasksHealthy          int                 `json:"tasksHealthy,omitempty"`
	TasksUnhealthy        int                 `json:"tasksUnhealthy,omitempty"`
	User                  string              `json:"user,omitempty"`
	UpgradeStrategy       *UpgradeStrategy    `json:"upgradeStrategy,omitempty"`
	Uris                  []string            `json:"uris"`
	Version               string              `json:"version,omitempty"`
	VersionInfo           *VersionInfo        `json:"versionInfo,omitempty"`
	Labels                map[string]string   `json:"labels,omitempty"`
	AcceptedResourceRoles []string            `json:"acceptedResourceRoles,omitempty"`
	LastTaskFailure       *LastTaskFailure    `json:"lastTaskFailure,omitempty"`
}

Application is the definition for an application in marathon

func NewDockerApplication 

func NewDockerApplication() *Application

NewDockerApplication creates a default docker application

func (*Application) AddEnv 

func (r *Application) AddEnv(name, value string) *Application

AddEnv adds an environment variable to the application 

name:	the name of the variable
value:	go figure, the value associated to the above

func (*Application) AddLabel 

func (r *Application) AddLabel(name, value string) *Application

AddLabel adds a label to the application 

name:	the name of the label
value:	go figure, the value associated to the above

func (*Application) AllTaskRunning 

func (r *Application) AllTaskRunning() bool

AllTaskRunning checks to see if all the application tasks are running, i.e. the instances is equal to the number of running tasks

func (*Application) Arg 

func (r *Application) Arg(arguments ...string) *Application

Arg adds one or more arguments to the applications 

arguments:	the argument(s) you are adding

func (*Application) CPU 

func (r *Application) CPU(cpu float64) *Application

CPU set the amount of CPU shares per instance which is assigned to the application 

cpu:	the CPU shared (check Docker docs) per instance

func (*Application) CheckHTTP 

func (r *Application) CheckHTTP(uri string, port, interval int) (*Application, error)

CheckHTTP adds a HTTP check to an application 

port: 		the port the check should be checking
interval:	the interval in seconds the check should be performed

func (*Application) CheckTCP 

func (r *Application) CheckTCP(port, interval int) (*Application, error)

CheckTCP adds a TCP check to an application; note the port mapping must already exist, or an error will thrown 

port: 		the port the check should, err, check
interval:	the interval in seconds the check should be performed

func (*Application) Count 

func (r *Application) Count(count int) *Application

Count sets the number of instances of the application to run 

count:	the number of instances to run

func (*Application) DependsOn 

func (r *Application) DependsOn(names ...string) *Application

DependsOn adds one or more dependencies for this application. Note, if you want to wait for an application dependency to actually be UP, i.e. not just deployed, you need a health check on the dependant app. 

names:	the application id(s) this application depends on

func (*Application) DeploymentIDs 

func (r *Application) DeploymentIDs() []*DeploymentID

DeploymentIDs retrieves the application deployments IDs

func (*Application) HasHealthChecks 

func (r *Application) HasHealthChecks() bool

HasHealthChecks is a helper method, used to check if an application has healtchecks

func (*Application) Memory 

func (r *Application) Memory(memory float64) *Application

Memory sets he amount of memory the application can consume per instance 

memory:	the amount of MB to assign

func (*Application) Name 

func (r *Application) Name(id string) *Application

Name set the name of the application i.e. the identifier for this application

func (*Application) Storage 

func (r *Application) Storage(disk float64) *Application

Storage sets the amount of disk space the application is assigned, which for docker application I don't believe is relevant 

disk:	the disk space in MB

type ApplicationVersion 

type ApplicationVersion struct {
	Version string `json:"version"`
}

ApplicationVersion is the application version response from marathon

type ApplicationVersions 

type ApplicationVersions struct {
	Versions []string `json:"versions"`
}

ApplicationVersions is a collection of application versions for a specific app in marathon

type Applications 

type Applications struct {
	Apps []Application `json:"apps"`
}

Applications is a collection of applications

type Cluster 

type Cluster interface {
	URL() string
	// retrieve a member from the cluster
	GetMember() (string, error)
	// make the last member as down
	MarkDown()
	// the size of the cluster
	Size() int
	// the members which are available
	Active() []string
	// the members which are NOT available
	NonActive() []string
}

Cluster is the interface for the marathon cluster impl

type Command 

type Command struct {
	Value string `json:"value"`
}

Command is the command health check type

type Config 

type Config struct {
	// the url for marathon
	URL string
	// events transport: EventsTransportCallback or EventsTransportSSE
	EventsTransport EventsTransport
	// event handler port
	EventsPort int
	// the interface we should be listening on for events
	EventsInterface string
	// the timeout for requests
	RequestTimeout int
	// http basic auth
	HTTPBasicAuthUser string
	// http basic password
	HTTPBasicPassword string
	// custom callback url
	CallbackURL string
	// the output for debug log messages
	LogOutput io.Writer
}

Config holds the settings and options for the client

func NewDefaultConfig 

func NewDefaultConfig() Config

NewDefaultConfig create a default client config

type Container 

type Container struct {
	Type    string    `json:"type,omitempty"`
	Docker  *Docker   `json:"docker,omitempty"`
	Volumes []*Volume `json:"volumes,omitempty"`
}

Container is the definition for a container type in marathon

func NewDockerContainer 

func NewDockerContainer() *Container

NewDockerContainer creates a default docker container for you

func (*Container) Volume 

func (container *Container) Volume(hostPath, containerPath, mode string) *Container

Volume attachs a volume to the container 

host_path:			the path on the docker host to map
container_path:		the path inside the container to map the host volume
mode:				the mode to map the container

type Deployment 

type Deployment struct {
	ID             string              `json:"id"`
	Version        string              `json:"version"`
	CurrentStep    int                 `json:"currentStep"`
	TotalSteps     int                 `json:"totalSteps"`
	AffectedApps   []string            `json:"affectedApps"`
	Steps          [][]*DeploymentStep `json:"steps"`
	CurrentActions []*DeploymentStep   `json:"currentActions"`
}

Deployment is a marathon deployment definition

type DeploymentID 

type DeploymentID struct {
	DeploymentID string `json:"deploymentId"`
	Version      string `json:"version"`
}

DeploymentID is the identifier for a application deployment

type DeploymentPlan 

type DeploymentPlan struct {
	ID       string `json:"id"`
	Version  string `json:"version"`
	Original struct {
		Apps         []*Application `json:"apps"`
		Dependencies []string       `json:"dependencies"`
		Groups       []*Group       `json:"groups"`
		ID           string         `json:"id"`
		Version      string         `json:"version"`
	} `json:"original"`
	Steps  []*DeploymentStep `json:"steps"`
	Target struct {
		Apps         []*Application `json:"apps"`
		Dependencies []string       `json:"dependencies"`
		Groups       []*Group       `json:"groups"`
		ID           string         `json:"id"`
		Version      string         `json:"version"`
	} `json:"target"`
}

DeploymentPlan is a collection of steps for application deployment

type DeploymentStep 

type DeploymentStep struct {
	Action string `json:"action"`
	App    string `json:"app"`
}

DeploymentStep is a step in the application deployment plan

type Docker 

type Docker struct {
	ForcePullImage bool           `json:"forcePullImage,omitempty"`
	Image          string         `json:"image,omitempty"`
	Network        string         `json:"network,omitempty"`
	Parameters     []*Parameters  `json:"parameters,omitempty"`
	PortMappings   []*PortMapping `json:"portMappings,omitempty"`
	Privileged     bool           `json:"privileged,omitempty"`
}

Docker is the docker definition from a marathon application

func (*Docker) Bridged 

func (docker *Docker) Bridged() *Docker

Bridged sets the networking mode to bridged

func (*Docker) Container 

func (docker *Docker) Container(image string) *Docker

Container sets the image of the container 

image:			the image name you are using

func (*Docker) Expose 

func (docker *Docker) Expose(ports ...int) *Docker

Expose sets the container to expose the following TCP ports 

ports:			the TCP ports the container is exposing

func (*Docker) ExposePort 

func (docker *Docker) ExposePort(containerPort, hostPort, servicePort int, protocol string) *Docker

ExposePort exposes an port in the container 

containerPort:			the container port which is being exposed
hostPort:						the host port we should expose it on
servicePort:				check the marathon documentation
protocol:						the protocol to use TCP, UDP

func (*Docker) ExposeUDP 

func (docker *Docker) ExposeUDP(ports ...int) *Docker

ExposeUDP sets the container to expose the following UDP ports 

ports:			the UDP ports the container is exposing

func (*Docker) Parameter 

func (docker *Docker) Parameter(key string, value string) *Docker

Parameter adds a parameter to the docker execution line when creating the container 

key:			the name of the option to add
value:		the value of the option

func (*Docker) ServicePortIndex 

func (docker *Docker) ServicePortIndex(port int) (int, error)

ServicePortIndex finds the service port index of the exposed port 

port:			the port you are looking for

type Event 

type Event struct {
	ID    int
	Name  string
	Event interface{}
}

Event is the definition for a event in marathon

func GetEvent 

func GetEvent(eventType string) (*Event, error)

GetEvent returns allocated empty event object which corresponds to provided event type 

eventType:			the type of Marathon event

func (*Event) String 

func (event *Event) String() string

type EventAPIRequest 

type EventAPIRequest struct {
	EventType     string       `json:"eventType"`
	ClientIp      string       `json:"clientIp"`
	Timestamp     string       `json:"timestamp"`
	Uri           string       `json:"uri"`
	AppDefinition *Application `json:"appDefinition"`
}

type EventAddHealthCheck 

type EventAddHealthCheck struct {
	AppId       string `json:"appId"`
	EventType   string `json:"eventType"`
	HealthCheck struct {
		GracePeriodSeconds     float64 `json:"gracePeriodSeconds"`
		IntervalSeconds        float64 `json:"intervalSeconds"`
		MaxConsecutiveFailures float64 `json:"maxConsecutiveFailures"`
		Path                   string  `json:"path"`
		PortIndex              float64 `json:"portIndex"`
		Protocol               string  `json:"protocol"`
		TimeoutSeconds         float64 `json:"timeoutSeconds"`
	} `json:"healthCheck"`
	Timestamp string `json:"timestamp"`
}

type EventAppTerminated 

type EventAppTerminated struct {
	EventType string `json:"eventType"`
	Timestamp string `json:"timestamp,omitempty"`
	AppID     string `json:"appId"`
}

type EventDeploymentFailed 

type EventDeploymentFailed struct {
	ID        string `json:"id"`
	EventType string `json:"eventType"`
	Timestamp string `json:"timestamp"`
}

type EventDeploymentInfo 

type EventDeploymentInfo struct {
	EventType   string          `json:"eventType"`
	CurrentStep *DeploymentStep `json:"currentStep"`
	Timestamp   string          `json:"timestamp"`
	Plan        *DeploymentPlan `json:"plan"`
}

type EventDeploymentStepFailure 

type EventDeploymentStepFailure struct {
	EventType   string          `json:"eventType"`
	CurrentStep *DeploymentStep `json:"currentStep"`
	Timestamp   string          `json:"timestamp"`
	Plan        *DeploymentPlan `json:"plan"`
}

type EventDeploymentStepSuccess 

type EventDeploymentStepSuccess struct {
	EventType   string          `json:"eventType"`
	CurrentStep *DeploymentStep `json:"currentStep"`
	Timestamp   string          `json:"timestamp"`
	Plan        *DeploymentPlan `json:"plan"`
}

type EventDeploymentSuccess 

type EventDeploymentSuccess struct {
	ID        string `json:"id"`
	EventType string `json:"eventType"`
	Timestamp string `json:"timestamp"`
}

type EventFailedHealthCheck 

type EventFailedHealthCheck struct {
	AppId       string `json:"appId"`
	EventType   string `json:"eventType"`
	HealthCheck struct {
		GracePeriodSeconds     float64 `json:"gracePeriodSeconds"`
		IntervalSeconds        float64 `json:"intervalSeconds"`
		MaxConsecutiveFailures float64 `json:"maxConsecutiveFailures"`
		Path                   string  `json:"path"`
		PortIndex              float64 `json:"portIndex"`
		Protocol               string  `json:"protocol"`
		TimeoutSeconds         float64 `json:"timeoutSeconds"`
	} `json:"healthCheck"`
	Timestamp string `json:"timestamp"`
}

type EventFrameworkMessage 

type EventFrameworkMessage struct {
	EventType  string `json:"eventType"`
	ExecutorId string `json:"executorId"`
	Message    string `json:"message"`
	SlaveId    string `json:"slaveId"`
	Timestamp  string `json:"timestamp"`
}

type EventGroupChangeFailed 

type EventGroupChangeFailed struct {
	EventType string `json:"eventType"`
	GroupId   string `json:"groupId"`
	Timestamp string `json:"timestamp"`
	Version   string `json:"version"`
	Reason    string `json:"reason"`
}

type EventGroupChangeSuccess 

type EventGroupChangeSuccess struct {
	EventType string `json:"eventType"`
	GroupId   string `json:"groupId"`
	Timestamp string `json:"timestamp"`
	Version   string `json:"version"`
}

type EventHealthCheckChanged 

type EventHealthCheckChanged struct {
	EventType string `json:"eventType"`
	Timestamp string `json:"timestamp,omitempty"`
	AppID     string `json:"appId"`
	TaskID    string `json:"taskId"`
	Version   string `json:"version,omitempty"`
	Alive     bool   `json:"alive"`
}

type EventRemoveHealthCheck 

type EventRemoveHealthCheck struct {
	AppId       string `json:"appId"`
	EventType   string `json:"eventType"`
	HealthCheck struct {
		GracePeriodSeconds     float64 `json:"gracePeriodSeconds"`
		IntervalSeconds        float64 `json:"intervalSeconds"`
		MaxConsecutiveFailures float64 `json:"maxConsecutiveFailures"`
		Path                   string  `json:"path"`
		PortIndex              float64 `json:"portIndex"`
		Protocol               string  `json:"protocol"`
		TimeoutSeconds         float64 `json:"timeoutSeconds"`
	} `json:"healthCheck"`
	Timestamp string `json:"timestamp"`
}

type EventStatusUpdate 

type EventStatusUpdate struct {
	EventType  string `json:"eventType"`
	Timestamp  string `json:"timestamp,omitempty"`
	SlaveID    string `json:"slaveId,omitempty"`
	TaskID     string `json:"taskId"`
	TaskStatus string `json:"taskStatus"`
	AppID      string `json:"appId"`
	Host       string `json:"host"`
	Ports      []int  `json:"ports,omitempty"`
	Version    string `json:"version,omitempty"`
}

type EventStreamAttached 

type EventStreamAttached struct {
	RemoteAddress string `json:"remoteAddress"`
	EventType     string `json:"eventType"`
	Timestamp     string `json:"timestamp"`
}

EventStreamAttached describes 'event_stream_attached' Marathon event

type EventStreamDetached 

type EventStreamDetached struct {
	RemoteAddress string `json:"remoteAddress"`
	EventType     string `json:"eventType"`
	Timestamp     string `json:"timestamp"`
}

EventStreamDetached describes 'event_stream_detached' Marathon event

type EventSubscription 

type EventSubscription struct {
	CallbackUrl string `json:"callbackUrl"`
	ClientIp    string `json:"clientIp"`
	EventType   string `json:"eventType"`
	Timestamp   string `json:"timestamp"`
}

EventSubscription describes 'subscribe_event' Marathon event

type EventType 

type EventType struct {
	EventType string `json:"eventType"`
}

EventType is a wrapper for a marathon event

type EventUnsubscription 

type EventUnsubscription struct {
	CallbackUrl string `json:"callbackUrl"`
	ClientIp    string `json:"clientIp"`
	EventType   string `json:"eventType"`
	Timestamp   string `json:"timestamp"`
}

EventUnsubscription describes 'unsubscribe_event' Marathon event

type EventsChannel 

type EventsChannel chan *Event

EventsChannel is a channel to receive events upon

type EventsTransport 

type EventsTransport int

EventsTransport describes which transport should be used to deliver Marathon events 

const (
	// EventsTransportCallback activates callback events transport
	EventsTransportCallback EventsTransport = 1 << iota

	// EventsTransportSSE activates stream events transport
	EventsTransportSSE
)

type Group 

type Group struct {
	ID           string         `json:"id"`
	Apps         []*Application `json:"apps"`
	Dependencies []string       `json:"dependencies"`
	Groups       []*Group       `json:"groups"`
}

Group is a marathon application group

func NewApplicationGroup 

func NewApplicationGroup(name string) *Group

NewApplicationGroup create a new application group 

name:			the name of the group

func (*Group) App 

func (r *Group) App(application *Application) *Group

App add a application to the group in question 

application:	a pointer to the Application

func (*Group) Name 

func (r *Group) Name(name string) *Group

Name sets the name of the group 

name:	the name of the group

type Groups 

type Groups struct {
	ID           string         `json:"id"`
	Apps         []*Application `json:"apps"`
	Dependencies []string       `json:"dependencies"`
	Groups       []*Group       `json:"groups"`
}

Groups is a collection of marathon application groups

type HealthCheck 

type HealthCheck struct {
	Command                *Command `json:"command,omitempty"`
	Protocol               string   `json:"protocol,omitempty"`
	Path                   string   `json:"path,omitempty"`
	GracePeriodSeconds     int      `json:"gracePeriodSeconds,omitempty"`
	IntervalSeconds        int      `json:"intervalSeconds,omitempty"`
	PortIndex              int      `json:"portIndex,omitempty"`
	MaxConsecutiveFailures int      `json:"maxConsecutiveFailures"`
	TimeoutSeconds         int      `json:"timeoutSeconds,omitempty"`
}

HealthCheck is the definition for an application health check

func NewDefaultHealthCheck 

func NewDefaultHealthCheck() *HealthCheck

NewDefaultHealthCheck creates a default application health check

type HealthCheckResult 

type HealthCheckResult struct {
	Alive               bool   `json:"alive"`
	ConsecutiveFailures int    `json:"consecutiveFailures"`
	FirstSuccess        string `json:"firstSuccess"`
	LastFailure         string `json:"lastFailure"`
	LastSuccess         string `json:"lastSuccess"`
	TaskID              string `json:"taskId"`
}

HealthCheckResult is the health check result

type Info 

type Info struct {
	EventSubscriber struct {
		HTTPEndpoints []string `json:"http_endpoints"`
		Type          string   `json:"type"`
	} `json:"event_subscriber"`
	FrameworkID string `json:"frameworkId"`
	HTTPConfig  struct {
		AssetsPath interface{} `json:"assets_path"`
		HTTPPort   float64     `json:"http_port"`
		HTTPSPort  float64     `json:"https_port"`
	} `json:"http_config"`
	Leader         string `json:"leader"`
	MarathonConfig struct {
		Checkpoint                 bool    `json:"checkpoint"`
		Executor                   string  `json:"executor"`
		FailoverTimeout            float64 `json:"failover_timeout"`
		Ha                         bool    `json:"ha"`
		Hostname                   string  `json:"hostname"`
		LocalPortMax               float64 `json:"local_port_max"`
		LocalPortMin               float64 `json:"local_port_min"`
		Master                     string  `json:"master"`
		MesosRole                  string  `json:"mesos_role"`
		MesosUser                  string  `json:"mesos_user"`
		ReconciliationInitialDelay float64 `json:"reconciliation_initial_delay"`
		ReconciliationInterval     float64 `json:"reconciliation_interval"`
		TaskLaunchTimeout          float64 `json:"task_launch_timeout"`
	} `json:"marathon_config"`
	Name            string `json:"name"`
	Version         string `json:"version"`
	ZookeeperConfig struct {
		Zk              string `json:"zk"`
		ZkFutureTimeout struct {
			Duration float64 `json:"duration"`
		} `json:"zk_future_timeout"`
		ZkHosts   string  `json:"zk_hosts"`
		ZkPath    string  `json:"zk_path"`
		ZkState   string  `json:"zk_state"`
		ZkTimeout float64 `json:"zk_timeout"`
	} `json:"zookeeper_config"`
}

Info is the detailed stats returned from marathon info

type KillApplicationTasksOpts 

type KillApplicationTasksOpts struct {
	Host  string `url:"host,omitempty"`
	Scale bool   `url:"scale,omitempty"`
}

KillApplicationTasksOpts contains a payload for KillApplicationTasks method 

host:		kill only those tasks on a specific host (optional)
scale:		Scale the app down (i.e. decrement its instances setting by the number of tasks killed) after killing the specified tasks

type KillTaskOpts 

type KillTaskOpts struct {
	Scale bool `url:"scale,omitempty"`
}

KillTaskOpts contains a payload for task killing methods 

scale:		Scale the app down

type LastTaskFailure 

type LastTaskFailure struct {
	AppID     string `json:"appId,omitempty"`
	Host      string `json:"host,omitempty"`
	Message   string `json:"message,omitempty"`
	State     string `json:"state,omitempty"`
	TaskID    string `json:"taskId,omitempty"`
	Timestamp string `json:"timestamp,omitempty"`
	Version   string `json:"version,omitempty"`
}

LastTaskFailure provides details on the last error experienced by an application

type Marathon 

type Marathon interface {

	// get a listing of the application ids
	ListApplications(url.Values) ([]string, error)
	// a list of application versions
	ApplicationVersions(name string) (*ApplicationVersions, error)
	// check a application version exists
	HasApplicationVersion(name, version string) (bool, error)
	// change an application to a different version
	SetApplicationVersion(name string, version *ApplicationVersion) (*DeploymentID, error)
	// check if an application is ok
	ApplicationOK(name string) (bool, error)
	// create an application in marathon
	CreateApplication(application *Application) (*Application, error)
	// delete an application
	DeleteApplication(name string) (*DeploymentID, error)
	// update an application in marathon
	UpdateApplication(application *Application) (*DeploymentID, error)
	// a list of deployments on a application
	ApplicationDeployments(name string) ([]*DeploymentID, error)
	// scale a application
	ScaleApplicationInstances(name string, instances int, force bool) (*DeploymentID, error)
	// restart an application
	RestartApplication(name string, force bool) (*DeploymentID, error)
	// get a list of applications from marathon
	Applications(url.Values) (*Applications, error)
	// get a specific application
	Application(name string) (*Application, error)
	// wait of application
	WaitOnApplication(name string, timeout time.Duration) error

	// get a list of tasks for a specific application
	Tasks(application string) (*Tasks, error)
	// get a list of all tasks
	AllTasks(opts *AllTasksOpts) (*Tasks, error)
	// get the endpoints for a service on a application
	TaskEndpoints(name string, port int, healthCheck bool) ([]string, error)
	// kill all the tasks for any application
	KillApplicationTasks(applicationID string, opts *KillApplicationTasksOpts) (*Tasks, error)
	// kill a single task
	KillTask(taskID string, opts *KillTaskOpts) (*Task, error)
	// kill the given array of tasks
	KillTasks(taskIDs []string, opts *KillTaskOpts) error

	// list all the groups in the system
	Groups() (*Groups, error)
	// retrieve a specific group from marathon
	Group(name string) (*Group, error)
	// create a group deployment
	CreateGroup(group *Group) error
	// delete a group
	DeleteGroup(name string) (*DeploymentID, error)
	// update a groups
	UpdateGroup(id string, group *Group) (*DeploymentID, error)
	// check if a group exists
	HasGroup(name string) (bool, error)
	// wait for an group to be deployed
	WaitOnGroup(name string, timeout time.Duration) error

	// get a list of the deployments
	Deployments() ([]*Deployment, error)
	// delete a deployment
	DeleteDeployment(id string, force bool) (*DeploymentID, error)
	// check to see if a deployment exists
	HasDeployment(id string) (bool, error)
	// wait of a deployment to finish
	WaitOnDeployment(id string, timeout time.Duration) error

	// a list of current subscriptions
	Subscriptions() (*Subscriptions, error)
	// add a events listener
	AddEventsListener(channel EventsChannel, filter int) error
	// remove a events listener
	RemoveEventsListener(channel EventsChannel)
	// remove our self from subscriptions
	Unsubscribe(string) error

	// get the marathon url
	GetMarathonURL() string
	// ping the marathon
	Ping() (bool, error)
	// grab the marathon server info
	Info() (*Info, error)
	// retrieve the leader info
	Leader() (string, error)
	// cause the current leader to abdicate
	AbdicateLeader() (string, error)
}

Marathon is the interface to the marathon API

func NewClient 

func NewClient(config Config) (Marathon, error)

NewClient creates a new marathon client 

config:			the configuration to use

type Parameters 

type Parameters struct {
	Key   string `json:"key,omitempty"`
	Value string `json:"value,omitempty"`
}

Parameters is the parameters to pass to the docker client when creating the container

type PortMapping 

type PortMapping struct {
	ContainerPort int    `json:"containerPort,omitempty"`
	HostPort      int    `json:"hostPort"`
	ServicePort   int    `json:"servicePort,omitempty"`
	Protocol      string `json:"protocol"`
}

PortMapping is the portmapping structure between container and mesos

type Subscriptions 

type Subscriptions struct {
	CallbackURLs []string `json:"callbackUrls"`
}

Subscriptions is a collection to urls that marathon is implementing a callback on

type Task 

type Task struct {
	ID                 string               `json:"id"`
	AppID              string               `json:"appId"`
	Host               string               `json:"host"`
	HealthCheckResults []*HealthCheckResult `json:"healthCheckResults"`
	Ports              []int                `json:"ports"`
	ServicePorts       []int                `json:"servicePorts"`
	StagedAt           string               `json:"stagedAt"`
	StartedAt          string               `json:"startedAt"`
	Version            string               `json:"version"`
}

Task is the definition for a marathon task

func (*Task) HasHealthCheckResults 

func (r *Task) HasHealthCheckResults() bool

HasHealthCheckResults checks if the task has any health checks

type Tasks 

type Tasks struct {
	Tasks []Task `json:"tasks"`
}

Tasks is a collection of marathon tasks

type UpgradeStrategy 

type UpgradeStrategy struct {
	MinimumHealthCapacity float64 `json:"minimumHealthCapacity"`
	MaximumOverCapacity   float64 `json:"maximumOverCapacity"`
}

UpgradeStrategy is upgrade strategy applied to a application

type VersionInfo 

type VersionInfo struct {
	LastScalingAt      string `json:"lastScalingAt,omitempty"`
	LastConfigChangeAt string `json:"lastConfigChangeAt,omitempty"`
}

VersionInfo is the application versioning details from marathon

type Volume 

type Volume struct {
	ContainerPath string `json:"containerPath,omitempty"`
	HostPath      string `json:"hostPath,omitempty"`
	Mode          string `json:"mode,omitempty"`
}

Volume is the docker volume details associated to the container

Source Files

View all Source files

Directories

Path Synopsis
examples
applications
events_callback_transport
events_sse_transport
glog
groups
multiple_endpoints
tasks

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.