empire

package
v0.9.0 Latest Latest
Warning

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

 Go to latest Published: Jun 15, 2015 License: BSD-2-Clause Imports: 34 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ExposePrivate = "private"
	ExposePublic  = "public"
)
View Source 
const (
	StatusPending = "pending"
	StatusFailed  = "failed"
	StatusSuccess = "success"
)

Deployment statuses.

View Source 
const (
	// WebPort is the default PORT to set on web processes.
	WebPort = 8080

	// WebProcessType is the process type we assume are web server processes.
	WebProcessType = "web"
)
View Source 
const DefaultTag = "latest"

DefaultTag is used when json decoding an image. If there is no tag part present, this will be used as the tag.

View Source 
const (
	UserKey key = 0
)

Variables

View Source 
var (
	ErrDomainInUse        = errors.New("Domain currently in use by another app.")
	ErrDomainAlreadyAdded = errors.New("Domain already added to this app.")
	ErrDomainNotFound     = errors.New("Domain could not be found.")
)
View Source 
var (
	// DefaultOptions is a default Options instance that can be passed when
	// intializing a new Empire.
	DefaultOptions = Options{}

	// DefaultReporter is the default reporter.Reporter to use.
	DefaultReporter = reporter.NewLogReporter()
)
View Source 
var (
	Constraints1X = Constraints{constraints.CPUShare(256), constraints.Memory(512 * MB)}
	Constraints2X = Constraints{constraints.CPUShare(512), constraints.Memory(1 * GB)}
	ConstraintsPX = Constraints{constraints.CPUShare(1024), constraints.Memory(6 * GB)}

	// NamedConstraints maps a heroku dynos size to a Constraints.
	NamedConstraints = map[string]Constraints{
		"1X": Constraints1X,
		"2X": Constraints2X,
		"PX": ConstraintsPX,
	}

	// DefaultConstraints defaults to 1X process size.
	DefaultConstraints = Constraints1X
)
View Source 
var All = ScopeFunc(func(db *gorm.DB) *gorm.DB {
	return db
})

All returns a scope that simply returns the db.

View Source 
var DefaultQuantities = ProcessQuantityMap{
	"web": 1,
}

DefaultQuantities maps a process type to the default number of instances to run.

View Source 
var ErrInvalidImage = errors.New("invalid image")

ErrInvalidImage is returned when the image does not specify a repo.

View Source 
var (
	// ErrInvalidName is used to indicate that the app name is not valid.
	ErrInvalidName = &ValidationError{
		errors.New("An app name must be alphanumeric and dashes only, 3-30 chars in length."),
	}
)
View Source 
var ErrNoPorts = errors.New("no ports avaiable")
View Source 
var NamePattern = regexp.MustCompile(`^[a-z][a-z0-9-]{2,30}$`)

NamePattern is a regex pattern that app names must conform to.

View Source 
var (
	// Procfile is the name of the Procfile file.
	Procfile = "Procfile"
)

Functions

func AppID 

func AppID(id string) func(*gorm.DB) *gorm.DB

AppID returns a scope to find an app by id.

func Migrate 

func Migrate(db, path string) ([]error, bool)

Migrate runs the migrations.

func NewAppNameFromRepo 

func NewAppNameFromRepo(repo string) string

NewAppNameFromRepo generates a new name from a Repo 

remind101/r101-api => r101-api

func SignToken 

func SignToken(secret []byte, token *AccessToken) (string, error)

SignToken jwt signs the token and adds the signature to the Token field.

func WithUser 

func WithUser(ctx context.Context, u *User) context.Context

WithUser adds a user to the context.Context.

Types

type AccessToken 

type AccessToken struct {
	Token string
	User  *User
}

AccessToken represents a token that allow access to the api.

func ParseToken 

func ParseToken(secret []byte, token string) (*AccessToken, error)

ParseToken parses a string token, verifies it, and returns an AccessToken instance.

type App 

type App struct {
	ID string

	Name string

	Repo *string

	Certificates []*Certificate

	// Valid values are empire.ExposePrivate and empire.ExposePublic.
	Exposure string

	CreatedAt *time.Time
}

App represents an app.

func (*App) BeforeCreate 

func (a *App) BeforeCreate() error

func (*App) IsValid 

func (a *App) IsValid() error

IsValid returns an error if the app isn't valid.

type AppsQuery 

type AppsQuery struct {
	// If provided, an App ID to find.
	ID *string

	// If provided, finds apps matching the given name.
	Name *string

	// If provided, finds apps with the given repo attached.
	Repo *string
}

AppsQuery is a Scope implementation for common things to filter releases by.

func (AppsQuery) Scope 

func (q AppsQuery) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type Certificate 

type Certificate struct {
	ID               string
	Name             string
	CertificateChain string
	PrivateKey       string `sql:"-"`
	CreatedAt        *time.Time
	UpdatedAt        *time.Time

	AppID string
	App   *App
}

func (*Certificate) BeforeCreate 

func (c *Certificate) BeforeCreate() error

PreInsert implements a pre insert hook for the db interface

func (*Certificate) BeforeUpdate 

func (c *Certificate) BeforeUpdate() error

PreUpdate implements a pre insert hook for the db interface

type CertificatesQuery 

type CertificatesQuery struct {
	// If provided, finds the certificate with the given id.
	ID *string

	// If provided, filters certificates belong to the given app.
	App *App
}

CertificatesQuery is a Scope implementation for common things to filter certificates by.

func (CertificatesQuery) Scope 

func (q CertificatesQuery) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type Command 

type Command string

Command represents the actual shell command that gets executed for a given ProcessType.

func (*Command) Scan 

func (c *Command) Scan(src interface{}) error

Scan implements the sql.Scanner interface.

func (Command) Value 

func (c Command) Value() (driver.Value, error)

Value implements the driver.Value interface.

type CommandMap 

type CommandMap map[ProcessType]Command

CommandMap maps a process ProcessType to a Command.

func ParseProcfile 

func ParseProcfile(b []byte) (CommandMap, error)

ParseProcfile takes a byte slice representing a YAML Procfile and parses it into a processes.CommandMap.

func (*CommandMap) Scan 

func (cm *CommandMap) Scan(src interface{}) error

Scan implements the sql.Scanner interface.

func (CommandMap) Value 

func (cm CommandMap) Value() (driver.Value, error)

Value implements the driver.Value interface.

type ComposedScope 

type ComposedScope []Scope

ComposedScope is an implementation of the Scope interface that chains the scopes together.

func (ComposedScope) Scope 

func (s ComposedScope) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type Config 

type Config struct {
	ID   string
	Vars Vars

	AppID string
	App   *App
}

Config represents a collection of environment variables.

func NewConfig 

func NewConfig(old *Config, vars Vars) *Config

NewConfig initializes a new config based on the old config, with the new variables provided.

type ConfigsQuery 

type ConfigsQuery struct {
	// If provided, returns finds the config with the given id.
	ID *string

	// If provided, filters configs for the given app.
	App *App
}

ConfigsQuery is a Scope implementation for common things to filter releases by.

func (ConfigsQuery) Scope 

func (q ConfigsQuery) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type Constraints 

type Constraints constraints.Constraints

Constraints aliases constraints.Constraints to implement the sql.Scanner interface.

func (Constraints) String 

func (c Constraints) String() string

func (*Constraints) UnmarshalJSON 

func (c *Constraints) UnmarshalJSON(b []byte) error

type ContainerRelay 

type ContainerRelay struct {
	Name      string `json:"name"`
	AttachURL string `json:"attach_url"`
	Command   string `json:"command"`
	State     string `json:"state"`
	Type      string
	Size      string
	CreatedAt time.Time `json:"created_at"`
}

type DeploymentsCreateOpts 

type DeploymentsCreateOpts struct {
	// App is the app that is being deployed to.
	App *App

	// Image is the image that's being deployed.
	Image Image

	// EventCh will receive deployment events during deployment.
	EventCh chan Event
}

DeploymentsCreateOpts represents options that can be passed when creating a new Deployment.

type DockerEvent 

type DockerEvent jsonmessage.JSONMessage

func FakeDockerPull 

func FakeDockerPull(image Image) []DockerEvent

FakeDockerPull returns a slice of events that look like a docker pull.

func (*DockerEvent) Event 

func (e *DockerEvent) Event() string

type DockerOptions 

type DockerOptions struct {
	// The unix socket to connect to the docker api.
	Socket string

	// Path to a certificate to use for TLS connections.
	CertPath string

	// A set of docker registry credentials.
	Auth *docker.AuthConfigurations
}

DockerOptions is a set of options to configure a docker api client.

type Domain 

type Domain struct {
	ID        string
	Hostname  string
	CreatedAt *time.Time

	AppID string
	App   *App
}

func (*Domain) BeforeCreate 

func (d *Domain) BeforeCreate() error

type DomainsQuery 

type DomainsQuery struct {
	// If provided, finds domains matching the given hostname.
	Hostname *string

	// If provided, filters domains belonging to the given app.
	App *App
}

DomainsQuery is a Scope implementation for common things to filter releases by.

func (DomainsQuery) Scope 

func (q DomainsQuery) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type ECSOptions 

type ECSOptions struct {
	Cluster     string
	ServiceRole string
}

ECSOptions is a set of options to configure ECS.

type ELBOptions 

type ELBOptions struct {
	// The Security Group ID to assign when creating internal load balancers.
	InternalSecurityGroupID string

	// The Security Group ID to assign when creating external load balancers.
	ExternalSecurityGroupID string

	// The Subnet IDs to assign when creating internal load balancers.
	InternalSubnetIDs []string

	// The Subnet IDs to assign when creating external load balancers.
	ExternalSubnetIDs []string

	// Zone ID of the internal zone to add cnames for each elb
	InternalZoneID string
}

ELBOptions is a set of options to configure ELB.

type Empire 

type Empire struct {
	// Reporter is an reporter.Reporter that will be used to report errors to
	// an external system.
	reporter.Reporter

	// Logger is a log15 logger that will be used for logging.
	Logger log15.Logger
	// contains filtered or unexported fields
}

Empire is a context object that contains a collection of services.

func New 

func New(options Options) (*Empire, error)

New returns a new Empire instance.

func (*Empire) AccessTokensCreate 

func (e *Empire) AccessTokensCreate(accessToken *AccessToken) (*AccessToken, error)

AccessTokensCreate creates a new AccessToken.

func (*Empire) AccessTokensFind 

func (e *Empire) AccessTokensFind(token string) (*AccessToken, error)

AccessTokensFind finds an access token.

func (*Empire) Apps 

func (e *Empire) Apps(q AppsQuery) ([]*App, error)

Apps returns all Apps.

func (*Empire) AppsCreate 

func (e *Empire) AppsCreate(app *App) (*App, error)

AppsCreate creates a new app.

func (*Empire) AppsDestroy 

func (e *Empire) AppsDestroy(ctx context.Context, app *App) error

AppsDestroy destroys the app.

func (*Empire) AppsFirst 

func (e *Empire) AppsFirst(q AppsQuery) (*App, error)

AppsFirst finds the first app matching the query.

func (*Empire) AppsScale 

func (e *Empire) AppsScale(ctx context.Context, app *App, t ProcessType, quantity int, c *Constraints) (*Process, error)

AppsScale scales an apps process.

func (*Empire) CertificatesCreate 

func (e *Empire) CertificatesCreate(ctx context.Context, cert *Certificate) (*Certificate, error)

CertificatesCreate creates a certificate.

func (*Empire) CertificatesDestroy 

func (e *Empire) CertificatesDestroy(ctx context.Context, cert *Certificate) error

CertificatesDestroy destroys a certificate.

func (*Empire) CertificatesFirst 

func (e *Empire) CertificatesFirst(ctx context.Context, q CertificatesQuery) (*Certificate, error)

CertificatesFirst returns a certificate for the given ID

func (*Empire) CertificatesUpdate 

func (e *Empire) CertificatesUpdate(ctx context.Context, cert *Certificate) (*Certificate, error)

CertificatesUpdate updates a certificate.

func (*Empire) ConfigsApply 

func (e *Empire) ConfigsApply(ctx context.Context, app *App, vars Vars) (*Config, error)

ConfigsApply applies the new config vars to the apps current Config, returning a new Config. If the app has a running release, a new release will be created and run.

func (*Empire) ConfigsCurrent 

func (e *Empire) ConfigsCurrent(app *App) (*Config, error)

ConfigsCurrent returns the current Config for a given app.

func (*Empire) DeployImage 

func (e *Empire) DeployImage(ctx context.Context, image Image, out chan Event) (*Release, error)

DeployImage deploys an image to Empire.

func (*Empire) Domains 

func (e *Empire) Domains(q DomainsQuery) ([]*Domain, error)

Domains returns all domains matching the query.

func (*Empire) DomainsCreate 

func (e *Empire) DomainsCreate(domain *Domain) (*Domain, error)

DomainsCreate adds a new Domain for an App.

func (*Empire) DomainsDestroy 

func (e *Empire) DomainsDestroy(domain *Domain) error

DomainsDestroy removes a Domain for an App.

func (*Empire) DomainsFirst 

func (e *Empire) DomainsFirst(q DomainsQuery) (*Domain, error)

DomainsFirst returns the first domain matching the query.

func (*Empire) IsHealthy 

func (e *Empire) IsHealthy() bool

IsHealthy returns true if Empire is healthy, which means it can connect to the services it depends on.

func (*Empire) JobStatesByApp 

func (e *Empire) JobStatesByApp(ctx context.Context, app *App) ([]*ProcessState, error)

JobStatesByApp returns the JobStates for the given app.

func (*Empire) ProcessesRestart 

func (e *Empire) ProcessesRestart(ctx context.Context, app *App, t ProcessType, id string) error

ProcessesRestart restarts processes matching the given prefix for the given Release. If the prefix is empty, it will match all processes for the release.

func (*Empire) ProcessesRun 

func (e *Empire) ProcessesRun(ctx context.Context, app *App, command string, opts ProcessesRunOpts) (*ContainerRelay, error)

ProcessesRun runs a one-off process for a given App and command.

func (*Empire) ReleasesFindByApp 

func (e *Empire) ReleasesFindByApp(app *App) ([]*Release, error)

ReleasesFindByApp returns all Releases for a given App.

func (*Empire) ReleasesFindByAppAndVersion 

func (e *Empire) ReleasesFindByAppAndVersion(app *App, version int) (*Release, error)

ReleasesFindByAppAndVersion finds a specific Release for a given App.

func (*Empire) ReleasesLast 

func (e *Empire) ReleasesLast(app *App) (*Release, error)

ReleasesLast returns the last release for an App.

func (*Empire) ReleasesRollback 

func (e *Empire) ReleasesRollback(ctx context.Context, app *App, version int) (*Release, error)

ReleasesRollback rolls an app back to a specific release version. Returns a new release.

func (*Empire) Reset 

func (e *Empire) Reset() error

Reset resets empire.

type Event 

type Event interface {
	// The type of event, e.g. "deploy", "error", "docker"
	Event() string
}

Event defines an interface for events within empire.

type Extractor 

type Extractor interface {
	// Extract takes a repo in the form `remind101/r101-api`, and an image
	// id, and extracts the process types from the image.
	Extract(Image) (CommandMap, error)
}

Extractor represents an object that can extract the process types from an image.

type Formation 

type Formation map[ProcessType]*Process

Formation maps a process ProcessType to a Process.

func NewFormation 

func NewFormation(f Formation, cm CommandMap) Formation

NewFormation creates a new Formation based on an existing Formation and the available processes from a CommandMap.

func (Formation) Processes 

func (f Formation) Processes() []*Process

Processes takes a Formation and returns a slice of the processes.

type Image 

type Image struct {
	ID   string
	Repo string
}

Image represents a container image, which is tied to a repository.

func (*Image) Scan 

func (i *Image) Scan(src interface{}) error

Scan implements the sql.Scanner interface.

func (Image) String 

func (i Image) String() string

func (*Image) UnmarshalJSON 

func (i *Image) UnmarshalJSON(b []byte) error

func (Image) Value 

func (i Image) Value() (driver.Value, error)

Value implements the driver.Value interface.

type Options 

type Options struct {
	Docker DockerOptions
	Runner RunnerOptions
	ECS    ECSOptions
	ELB    ELBOptions

	// AWS Configuration
	AWSConfig *aws.Config

	Secret string

	// Database connection string.
	DB string
}

Options is provided to New to configure the Empire services.

type Port 

type Port struct {
	ID    string
	AppID *string
	Port  int
}

type Process 

type Process struct {
	ID       string
	Type     ProcessType
	Quantity int
	Command  Command
	Port     int `sql:"-"`
	Constraints

	ReleaseID string
	Release   *Release
}

Process holds configuration information about a Process Type.

func NewProcess 

func NewProcess(t ProcessType, cmd Command) *Process

NewProcess returns a new Process instance.

type ProcessQuantityMap 

type ProcessQuantityMap map[ProcessType]int

ProcessQuantityMap represents a map of process types to quantities.

type ProcessState 

type ProcessState struct {
	Name        string
	Command     string
	State       string
	UpdatedAt   time.Time
	Constraints Constraints
}

ProcessState represents the state of a Process.

type ProcessType 

type ProcessType string

ProcessType represents the type of a given process/command.

func (*ProcessType) Scan 

func (p *ProcessType) Scan(src interface{}) error

Scan implements the sql.Scanner interface.

func (ProcessType) Value 

func (p ProcessType) Value() (driver.Value, error)

Value implements the driver.Value interface.

type ProcessesQuery 

type ProcessesQuery struct {
	// If provided, finds only processes belonging to the given release.
	Release *Release
}

ProcessesQuery is a Scope implementation for common things to filter processes by.

func (ProcessesQuery) Scope 

func (q ProcessesQuery) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type ProcessesRunOpts 

type ProcessesRunOpts struct {
	Attach bool
	Env    map[string]string
	Size   string
}

type ProcfileError 

type ProcfileError struct {
	Err error
}

Example instance: Procfile doesn't exist

func (*ProcfileError) Error 

func (e *ProcfileError) Error() string

type Release 

type Release struct {
	ID      string
	Version int

	AppID string
	App   *App

	ConfigID string
	Config   *Config

	SlugID string
	Slug   *Slug

	Processes []*Process

	Description string
	CreatedAt   *time.Time
}

Release is a combination of a Config and a Slug, which form a deployable release.

func (*Release) BeforeCreate 

func (r *Release) BeforeCreate() error

Set created_at before inserting.

func (*Release) Formation 

func (r *Release) Formation() Formation

type ReleasesQuery 

type ReleasesQuery struct {
	// If Provided, an app to filter by.
	App *App

	// If provided, a version to filter by.
	Version *int
}

ReleasesQuery is a Scope implementation for common things to filter releases by.

func (ReleasesQuery) Scope 

func (q ReleasesQuery) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type Resolver 

type Resolver interface {
	Resolve(Image, chan Event) (Image, error)
}

type RunnerOptions 

type RunnerOptions struct {
	API string
}

RunnerOptions is a set of options to configure the one off process runner service.

type Scope 

type Scope interface {
	Scope(*gorm.DB) *gorm.DB
}

Scope is an interface that scopes a gorm.DB. Scopes are used in ThingsFirst and ThingsAll methods on the store for filtering/querying.

func FieldEquals 

func FieldEquals(field string, v interface{}) Scope

FieldEquals returns a Scope that filters on a field.

func ForApp 

func ForApp(app *App) Scope

ForApp returns a Scope that will filter items belonging the the given app.

func ID 

func ID(id string) Scope

ID returns a Scope that will find the item by id.

func Order 

func Order(order string) Scope

Order returns a Scope that orders the results.

func Preload 

func Preload(associations ...string) Scope

Preload returns a Scope that preloads the associations.

type ScopeFunc 

type ScopeFunc func(*gorm.DB) *gorm.DB

ScopeFunc implements the Scope interface for functions.

func (ScopeFunc) Scope 

func (f ScopeFunc) Scope(db *gorm.DB) *gorm.DB

Scope implements the Scope interface.

type Slug 

type Slug struct {
	ID           string
	Image        Image
	ProcessTypes CommandMap
}

Slug represents a container image with the extracted ProcessType.

type User 

type User struct {
	Name        string `json:"name"`
	GitHubToken string `json:"-"`
}

User represents a user of Empire.

func UserFromContext 

func UserFromContext(ctx context.Context) (*User, bool)

UserFromContext returns a user from a context.Context if one is present.

func (*User) GitHubClient 

func (u *User) GitHubClient() *http.Client

GitHubClient returns an http.Client that will automatically add the GitHubToken to all requests.

type ValidationError 

type ValidationError struct {
	Err error
}

ValidationError is returned when a model is not valid.

func (*ValidationError) Error 

func (e *ValidationError) Error() string

type Variable 

type Variable string

Variable represents the name of an environment variable.

type Vars 

type Vars map[Variable]*string

Vars represents a variable -> value mapping.

func (*Vars) Scan 

func (v *Vars) Scan(src interface{}) error

Scan implements the sql.Scanner interface.

func (Vars) Value 

func (v Vars) Value() (driver.Value, error)

Value implements the driver.Value interface.

Source Files

View all Source files

Directories

Path Synopsis
Godeps
_workspace/src/code.google.com/p/go-uuid/uuid
The uuid package generates and inspects UUIDs.
 The uuid package generates and inspects UUIDs.
_workspace/src/github.com/Sirupsen/logrus
_workspace/src/github.com/Sirupsen/logrus/examples/basic
_workspace/src/github.com/Sirupsen/logrus/examples/hook
_workspace/src/github.com/Sirupsen/logrus/hooks/airbrake
_workspace/src/github.com/Sirupsen/logrus/hooks/papertrail
_workspace/src/github.com/Sirupsen/logrus/hooks/sentry
_workspace/src/github.com/Sirupsen/logrus/hooks/syslog
_workspace/src/github.com/aws/aws-sdk-go/aws
Package aws provides core functionality for making requests to AWS services.
 Package aws provides core functionality for making requests to AWS services.
_workspace/src/github.com/aws/aws-sdk-go/aws/awserr
Package awserr represents API error interface accessors for the SDK.
 Package awserr represents API error interface accessors for the SDK.
_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil
_workspace/src/github.com/aws/aws-sdk-go/aws/credentials
Package credentials provides credential retrieval and management The Credentials is the primary method of getting access to and managing credentials Values.
 Package credentials provides credential retrieval and management The Credentials is the primary method of getting access to and managing credentials Values.
_workspace/src/github.com/aws/aws-sdk-go/internal/apierr
Package apierr represents API error types.
 Package apierr represents API error types.
_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/json/jsonutil
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/jsonrpc
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/queryutil
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/restxml
_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil
_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4
_workspace/src/github.com/aws/aws-sdk-go/service/ecs
Package ecs provides a client for Amazon EC2 Container Service.
 Package ecs provides a client for Amazon EC2 Container Service.
_workspace/src/github.com/aws/aws-sdk-go/service/ecs/ecsiface
Package ecsiface provides an interface for the Amazon EC2 Container Service.
 Package ecsiface provides an interface for the Amazon EC2 Container Service.
_workspace/src/github.com/aws/aws-sdk-go/service/elb
Package elb provides a client for Elastic Load Balancing.
 Package elb provides a client for Elastic Load Balancing.
_workspace/src/github.com/aws/aws-sdk-go/service/elb/elbiface
Package elbiface provides an interface for the Elastic Load Balancing.
 Package elbiface provides an interface for the Elastic Load Balancing.
_workspace/src/github.com/aws/aws-sdk-go/service/iam
Package iam provides a client for AWS Identity and Access Management.
 Package iam provides a client for AWS Identity and Access Management.
_workspace/src/github.com/aws/aws-sdk-go/service/iam/iamiface
Package iamiface provides an interface for the AWS Identity and Access Management.
 Package iamiface provides an interface for the AWS Identity and Access Management.
_workspace/src/github.com/aws/aws-sdk-go/service/route53
Package route53 provides a client for Amazon Route 53.
 Package route53 provides a client for Amazon Route 53.
_workspace/src/github.com/aws/aws-sdk-go/service/route53/route53iface
Package route53iface provides an interface for the Amazon Route 53.
 Package route53iface provides an interface for the Amazon Route 53.
_workspace/src/github.com/bgentry/heroku-go
Package heroku is a client interface to the Heroku API.
 Package heroku is a client interface to the Heroku API.
_workspace/src/github.com/codegangsta/cli
Package cli provides a minimal framework for creating and organizing command line Go applications.
 Package cli provides a minimal framework for creating and organizing command line Go applications.
_workspace/src/github.com/dgrijalva/jwt-go
Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html See README.md for more info.
 Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html See README.md for more info.
_workspace/src/github.com/dgrijalva/jwt-go/cmd/jwt
A useful example app.
 A useful example app.
_workspace/src/github.com/docker/docker/pkg/archive
_workspace/src/github.com/docker/docker/pkg/fileutils
_workspace/src/github.com/docker/docker/pkg/ioutils
_workspace/src/github.com/docker/docker/pkg/jsonmessage
_workspace/src/github.com/docker/docker/pkg/pools
Package pools provides a collection of pools which provide various data types with buffers.
 Package pools provides a collection of pools which provide various data types with buffers.
_workspace/src/github.com/docker/docker/pkg/promise
_workspace/src/github.com/docker/docker/pkg/system
_workspace/src/github.com/docker/docker/pkg/term
_workspace/src/github.com/docker/docker/pkg/term/winconsole
_workspace/src/github.com/docker/docker/pkg/timeutils
_workspace/src/github.com/docker/docker/pkg/units
_workspace/src/github.com/ejholmes/flock
_workspace/src/github.com/fsouza/go-dockerclient
Package docker provides a client for the Docker remote API.
 Package docker provides a client for the Docker remote API.
_workspace/src/github.com/fsouza/go-dockerclient/testing
Package testing provides a fake implementation of the Docker API, useful for testing purpose.
 Package testing provides a fake implementation of the Docker API, useful for testing purpose.
_workspace/src/github.com/go-sql-driver/mysql
Go MySQL Driver - A MySQL-Driver for Go's database/sql package The driver should be used via the database/sql package: import "database/sql" import _ "github.com/go-sql-driver/mysql" db, err := sql.Open("mysql", "user:password@/dbname") See https://github.com/go-sql-driver/mysql#usage for details
 Go MySQL Driver - A MySQL-Driver for Go's database/sql package The driver should be used via the database/sql package: import "database/sql" import _ "github.com/go-sql-driver/mysql" db, err := sql.Open("mysql", "user:password@/dbname") See https://github.com/go-sql-driver/mysql#usage for details
_workspace/src/github.com/gocql/gocql
Package gocql implements a fast and robust Cassandra driver for the Go programming language.
 Package gocql implements a fast and robust Cassandra driver for the Go programming language.
_workspace/src/github.com/golang/groupcache/lru
Package lru implements an LRU cache.
 Package lru implements an LRU cache.
_workspace/src/github.com/golang/snappy/snappy
Package snappy implements the snappy block-based compression format.
 Package snappy implements the snappy block-based compression format.
_workspace/src/github.com/gorilla/context
Package context stores values shared during a request lifetime.
 Package context stores values shared during a request lifetime.
_workspace/src/github.com/gorilla/mux
Package gorilla/mux implements a request router and dispatcher.
 Package gorilla/mux implements a request router and dispatcher.
_workspace/src/github.com/inconshreveable/log15
Package log15 provides an opinionated, simple toolkit for best-practice logging that is both human and machine readable.
 Package log15 provides an opinionated, simple toolkit for best-practice logging that is both human and machine readable.
_workspace/src/github.com/inconshreveable/log15/ext
_workspace/src/github.com/inconshreveable/log15/stack
Package stack implements utilities to capture, manipulate, and format call stacks.
 Package stack implements utilities to capture, manipulate, and format call stacks.
_workspace/src/github.com/inconshreveable/log15/term
_workspace/src/github.com/jinzhu/gorm
_workspace/src/github.com/lib/pq
Package pq is a pure Go Postgres driver for the database/sql package.
 Package pq is a pure Go Postgres driver for the database/sql package.
_workspace/src/github.com/lib/pq/hstore
_workspace/src/github.com/lib/pq/listen_example
Below you will find a self-contained Go program which uses the LISTEN / NOTIFY mechanism to avoid polling the database while waiting for more work to arrive.
 Below you will find a self-contained Go program which uses the LISTEN / NOTIFY mechanism to avoid polling the database while waiting for more work to arrive.
_workspace/src/github.com/lib/pq/oid
Package oid contains OID constants as defined by the Postgres server.
 Package oid contains OID constants as defined by the Postgres server.
_workspace/src/github.com/mattes/migrate/driver
Package driver holds the driver interface.
 Package driver holds the driver interface.
_workspace/src/github.com/mattes/migrate/driver/bash
Package bash implements the Driver interface.
 Package bash implements the Driver interface.
_workspace/src/github.com/mattes/migrate/driver/cassandra
Package cassandra implements the Driver interface.
 Package cassandra implements the Driver interface.
_workspace/src/github.com/mattes/migrate/driver/mysql
Package mysql implements the Driver interface.
 Package mysql implements the Driver interface.
_workspace/src/github.com/mattes/migrate/driver/postgres
Package postgres implements the Driver interface.
 Package postgres implements the Driver interface.
_workspace/src/github.com/mattes/migrate/file
Package file contains functions for low-level migration files handling.
 Package file contains functions for low-level migration files handling.
_workspace/src/github.com/mattes/migrate/migrate
Package migrate is imported by other Go code.
 Package migrate is imported by other Go code.
_workspace/src/github.com/mattes/migrate/migrate/direction
Package direction just holds convenience constants for Up and Down migrations.
 Package direction just holds convenience constants for Up and Down migrations.
_workspace/src/github.com/mattes/migrate/pipe
Package pipe has functions for pipe channel handling.
 Package pipe has functions for pipe channel handling.
_workspace/src/github.com/mattn/go-colorable
_workspace/src/github.com/remind101/newrelic
No op implementation for non linux platforms (new relix agent sdk only support linux right now)
 No op implementation for non linux platforms (new relix agent sdk only support linux right now)
_workspace/src/github.com/remind101/pkg/httpx
package httpx provides an extra layer of convenience over package http.
 package httpx provides an extra layer of convenience over package http.
_workspace/src/github.com/remind101/pkg/httpx/middleware
_workspace/src/github.com/remind101/pkg/logger
package logger is a package that provides a structured logger that's context.Context aware.
 package logger is a package that provides a structured logger that's context.Context aware.
_workspace/src/github.com/remind101/pkg/reporter
package reporter provides a context.Context aware abstraction for shuttling errors and panics to third partys.
 package reporter provides a context.Context aware abstraction for shuttling errors and panics to third partys.
_workspace/src/github.com/remind101/pkg/reporter/hb
package hb is a Go package from sending errors to Honeybadger.
 package hb is a Go package from sending errors to Honeybadger.
_workspace/src/github.com/remind101/pkg/reporter/nr
_workspace/src/github.com/remind101/pkg/reporter/util
_workspace/src/github.com/remind101/pkg/timex
_workspace/src/github.com/remind101/pkg/trace
_workspace/src/github.com/vaughan0/go-ini
Package ini provides functions for parsing INI configuration files.
 Package ini provides functions for parsing INI configuration files.
_workspace/src/golang.org/x/net/context
Package context defines the Context type, which carries deadlines, cancelation signals, and other request-scoped values across API boundaries and between processes.
 Package context defines the Context type, which carries deadlines, cancelation signals, and other request-scoped values across API boundaries and between processes.
_workspace/src/gopkg.in/yaml.v2
Package yaml implements YAML support for the Go language.
 Package yaml implements YAML support for the Go language.
_workspace/src/speter.net/go/exp/math/dec/inf
Package inf (type inf.Dec) implements "infinite-precision" decimal arithmetic.
 Package inf (type inf.Dec) implements "infinite-precision" decimal arithmetic.
cmd
empire
pkg
arn
package arn is a Go package for parsing Amazon Resource Names.
 package arn is a Go package for parsing Amazon Resource Names.
awsutil
bytesize
package bytesize contains constants for easily switching between different byte sizes.
 package bytesize contains constants for easily switching between different byte sizes.
constraints
package constraints contains methods for decoding a compact CPU and Memory constraints format.
 package constraints contains methods for decoding a compact CPU and Memory constraints format.
ecsutil
Package ecsutil is a layer on top of Amazon ECS to provide an app aware ECS client.
 Package ecsutil is a layer on top of Amazon ECS to provide an app aware ECS client.
lb
package lb provides an abstraction around creating load balancers.
 package lb provides an abstraction around creating load balancers.
registry
service
A Go package that provides a layer of abstraction above ECS to introduce the concept of Apps, which have are a collection of services.
 A Go package that provides a layer of abstraction above ECS to introduce the concept of Apps, which have are a collection of services.
sslcert
authorization
authorization/github
heroku
middleware

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.