_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36400 | SAMLACS | train | func (s *Server) SAMLACS(w http.ResponseWriter, r *http.Request) {
if s.ServiceProvider == nil {
http.NotFound(w, r)
return
}
assertion, err := s.ServiceProvider.Parse(w, r)
if err != nil {
if err, ok := err.(*saml.InvalidResponseError); ok {
reporter.Report(r.Context(), err.PrivateErr)
}
http.Error(w... | go | {
"resource": ""
} |
q36401 | SSLEndpointDelete | train | func (c *Client) SSLEndpointDelete(appIdentity string, sslEndpointIdentity string) error {
return c.Delete("/apps/" + appIdentity + "/ssl-endpoints/" + sslEndpointIdentity)
} | go | {
"resource": ""
} |
q36402 | SSLEndpointInfo | train | func (c *Client) SSLEndpointInfo(appIdentity string, sslEndpointIdentity string) (*SSLEndpoint, error) {
var sslEndpoint SSLEndpoint
return &sslEndpoint, c.Get(&sslEndpoint, "/apps/"+appIdentity+"/ssl-endpoints/"+sslEndpointIdentity)
} | go | {
"resource": ""
} |
q36403 | SSLEndpointList | train | func (c *Client) SSLEndpointList(appIdentity string, lr *ListRange) ([]SSLEndpoint, error) {
req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/ssl-endpoints", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var sslEndpointsRes []SSLEndpoint
return sslEndpointsRes, c.DoRe... | go | {
"resource": ""
} |
q36404 | SSLEndpointUpdate | train | func (c *Client) SSLEndpointUpdate(appIdentity string, sslEndpointIdentity string, options *SSLEndpointUpdateOpts) (*SSLEndpoint, error) {
var sslEndpointRes SSLEndpoint
return &sslEndpointRes, c.Patch(&sslEndpointRes, "/apps/"+appIdentity+"/ssl-endpoints/"+sslEndpointIdentity, options)
} | go | {
"resource": ""
} |
q36405 | GetFormation | train | func (h *Server) GetFormation(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
app, err := h.findApp(r)
if err != nil {
return err
}
formation, err := h.ListScale(ctx, app)
if err != nil {
return err
}
var resp []*Formation
for name, proc := range formation {
resp = append(resp, &For... | go | {
"resource": ""
} |
q36406 | WithDefaults | train | func (r *Range) WithDefaults(d Range) Range {
if r == nil {
return d
}
// Make a copy.
c := *r
if c.Max == nil {
c.Max = d.Max
}
if c.Sort == nil {
c.Sort = d.Sort
}
if c.Order == nil {
c.Order = d.Order
}
return c
} | go | {
"resource": ""
} |
q36407 | PlanInfo | train | func (c *Client) PlanInfo(addonServiceIdentity string, planIdentity string) (*Plan, error) {
var plan Plan
return &plan, c.Get(&plan, "/addon-services/"+addonServiceIdentity+"/plans/"+planIdentity)
} | go | {
"resource": ""
} |
q36408 | PlanList | train | func (c *Client) PlanList(addonServiceIdentity string, lr *ListRange) ([]Plan, error) {
req, err := c.NewRequest("GET", "/addon-services/"+addonServiceIdentity+"/plans", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var plansRes []Plan
return plansRes, c.DoReq(req, &plansRe... | go | {
"resource": ""
} |
q36409 | Hash | train | func (r *Request) Hash() string {
h := fnv.New64()
h.Write([]byte(fmt.Sprintf("%s.%s", r.StackId, r.RequestId)))
return base62.Encode(h.Sum64())
} | go | {
"resource": ""
} |
q36410 | NewResponseFromRequest | train | func NewResponseFromRequest(req Request) Response {
return Response{
StackId: req.StackId,
RequestId: req.RequestId,
LogicalResourceId: req.LogicalResourceId,
}
} | go | {
"resource": ""
} |
q36411 | SendResponse | train | func SendResponse(req Request, response Response) error {
return SendResponseWithClient(http.DefaultClient, req, response)
} | go | {
"resource": ""
} |
q36412 | SendResponseWithClient | train | func SendResponseWithClient(client interface {
Do(*http.Request) (*http.Response, error)
}, req Request, response Response) error {
c := ResponseClient{client}
return c.SendResponse(req, response)
} | go | {
"resource": ""
} |
q36413 | SendResponse | train | func (c *ResponseClient) SendResponse(req Request, response Response) error {
raw, err := json.Marshal(response)
if err != nil {
return err
}
r, err := http.NewRequest("PUT", req.ResponseURL, bytes.NewReader(raw))
if err != nil {
return err
}
resp, err := c.client.Do(r)
if err != nil {
return err
}
de... | go | {
"resource": ""
} |
q36414 | WithTimeout | train | func WithTimeout(p Provisioner, timeout time.Duration, grace time.Duration) Provisioner {
return &timeoutProvisioner{
Provisioner: p,
timeout: timeout,
grace: grace,
}
} | go | {
"resource": ""
} |
q36415 | Eq | train | func (i *IntValue) Eq(other *IntValue) bool {
if i == nil {
return other == nil
}
if other == nil {
return i == nil
}
return *i == *other
} | go | {
"resource": ""
} |
q36416 | SampleEvery | train | func SampleEvery(stats Stats, t time.Duration) {
c := time.Tick(t)
for _ = range c {
r := newRuntimeSample()
r.drain(stats)
}
} | go | {
"resource": ""
} |
q36417 | newRuntimeSample | train | func newRuntimeSample() *runtimeSample {
r := &runtimeSample{MemStats: &runtime.MemStats{}}
runtime.ReadMemStats(r.MemStats)
r.NumGoroutine = runtime.NumGoroutine()
return r
} | go | {
"resource": ""
} |
q36418 | drain | train | func (r *runtimeSample) drain(stats Stats) {
stats.Gauge("runtime.NumGoroutine", float32(r.NumGoroutine), 1.0, nil)
stats.Gauge("runtime.MemStats.Alloc", float32(r.MemStats.Alloc), 1.0, nil)
stats.Gauge("runtime.MemStats.Frees", float32(r.MemStats.Frees), 1.0, nil)
stats.Gauge("runtime.MemStats.HeapAlloc", float32(... | go | {
"resource": ""
} |
q36419 | AppTransferCreate | train | func (c *Client) AppTransferCreate(app string, recipient string) (*AppTransfer, error) {
params := struct {
App string `json:"app"`
Recipient string `json:"recipient"`
}{
App: app,
Recipient: recipient,
}
var appTransferRes AppTransfer
return &appTransferRes, c.Post(&appTransferRes, "/account/a... | go | {
"resource": ""
} |
q36420 | AppTransferInfo | train | func (c *Client) AppTransferInfo(appTransferIdentity string) (*AppTransfer, error) {
var appTransfer AppTransfer
return &appTransfer, c.Get(&appTransfer, "/account/app-transfers/"+appTransferIdentity)
} | go | {
"resource": ""
} |
q36421 | AppTransferList | train | func (c *Client) AppTransferList(lr *ListRange) ([]AppTransfer, error) {
req, err := c.NewRequest("GET", "/account/app-transfers", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var appTransfersRes []AppTransfer
return appTransfersRes, c.DoReq(req, &appTransfersRes)
} | go | {
"resource": ""
} |
q36422 | AppTransferUpdate | train | func (c *Client) AppTransferUpdate(appTransferIdentity string, state string) (*AppTransfer, error) {
params := struct {
State string `json:"state"`
}{
State: state,
}
var appTransferRes AppTransfer
return &appTransferRes, c.Patch(&appTransferRes, "/account/app-transfers/"+appTransferIdentity, params)
} | go | {
"resource": ""
} |
q36423 | DockerDaemon | train | func DockerDaemon(c *dockerutil.Client) *DockerDaemonRegistry {
e := multiExtractor(
newFileExtractor(c),
newCMDExtractor(c),
)
return &DockerDaemonRegistry{
docker: c,
extractor: e,
}
} | go | {
"resource": ""
} |
q36424 | multiExtractor | train | func multiExtractor(extractors ...empire.ProcfileExtractor) empire.ProcfileExtractor {
return empire.ProcfileExtractorFunc(func(ctx context.Context, image image.Image, w *jsonmessage.Stream) ([]byte, error) {
for _, extractor := range extractors {
p, err := extractor.ExtractProcfile(ctx, image, w)
// Yay!
... | go | {
"resource": ""
} |
q36425 | ExtractProcfile | train | func (e *fileExtractor) ExtractProcfile(ctx context.Context, img image.Image, w *jsonmessage.Stream) ([]byte, error) {
c, err := e.createContainer(ctx, img)
if err != nil {
return nil, err
}
defer e.removeContainer(ctx, c.ID)
pfile, err := e.procfile(ctx, c.ID)
if err != nil {
return nil, err
}
b, err :=... | go | {
"resource": ""
} |
q36426 | procfile | train | func (e *fileExtractor) procfile(ctx context.Context, id string) (string, error) {
p := ""
c, err := e.client.InspectContainer(id)
if err != nil {
return "", err
}
if c.Config != nil {
p = c.Config.WorkingDir
}
return path.Join(p, empire.Procfile), nil
} | go | {
"resource": ""
} |
q36427 | createContainer | train | func (e *fileExtractor) createContainer(ctx context.Context, img image.Image) (*docker.Container, error) {
return e.client.CreateContainer(ctx, docker.CreateContainerOptions{
Config: &docker.Config{
Image: img.String(),
},
})
} | go | {
"resource": ""
} |
q36428 | removeContainer | train | func (e *fileExtractor) removeContainer(ctx context.Context, containerID string) error {
return e.client.RemoveContainer(ctx, docker.RemoveContainerOptions{
ID: containerID,
})
} | go | {
"resource": ""
} |
q36429 | copyFile | train | func (e *fileExtractor) copyFile(ctx context.Context, containerID, path string) ([]byte, error) {
var buf bytes.Buffer
if err := e.client.CopyFromContainer(ctx, docker.CopyFromContainerOptions{
Container: containerID,
Resource: path,
OutputStream: &buf,
}); err != nil {
return nil, err
}
// Open th... | go | {
"resource": ""
} |
q36430 | firstFile | train | func firstFile(tr *tar.Reader) ([]byte, error) {
if _, err := tr.Next(); err != nil {
return nil, err
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q36431 | ReleaseInfo | train | func (c *Client) ReleaseInfo(appIdentity string, releaseIdentity string) (*Release, error) {
var release Release
return &release, c.Get(&release, "/apps/"+appIdentity+"/releases/"+releaseIdentity)
} | go | {
"resource": ""
} |
q36432 | ReleaseList | train | func (c *Client) ReleaseList(appIdentity string, lr *ListRange) ([]Release, error) {
req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/releases", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var releasesRes []Release
return releasesRes, c.DoReq(req, &releasesRes)
} | go | {
"resource": ""
} |
q36433 | ReleaseCreate | train | func (c *Client) ReleaseCreate(appIdentity string, slug string, options *ReleaseCreateOpts) (*Release, error) {
params := struct {
Slug string `json:"slug"`
Description *string `json:"description,omitempty"`
}{
Slug: slug,
}
if options != nil {
params.Description = options.Description
}
var releas... | go | {
"resource": ""
} |
q36434 | ReleaseRollback | train | func (c *Client) ReleaseRollback(appIdentity, release, message string) (*Release, error) {
params := struct {
Release string `json:"release"`
}{
Release: release,
}
rh := RequestHeaders{CommitMessage: message}
var releaseRes Release
return &releaseRes, c.PostWithHeaders(&releaseRes, "/apps/"+appIdentity+"/rel... | go | {
"resource": ""
} |
q36435 | NewStream | train | func NewStream(w io.Writer) *Stream {
return &Stream{
Writer: w,
enc: json.NewEncoder(w),
}
} | go | {
"resource": ""
} |
q36436 | Encode | train | func (w *Stream) Encode(m JSONMessage) error {
return w.enc.Encode(m)
} | go | {
"resource": ""
} |
q36437 | Unauthorized | train | func Unauthorized(reason error) *ErrorResource {
if reason == nil {
return ErrUnauthorized
}
return &ErrorResource{
Status: http.StatusUnauthorized,
ID: "unauthorized",
Message: reason.Error(),
}
} | go | {
"resource": ""
} |
q36438 | SAMLUnauthorized | train | func SAMLUnauthorized(loginURL string) func(error) *ErrorResource {
return func(reason error) *ErrorResource {
if reason == nil {
reason = errors.New("Request not authenticated, API token is missing, invalid or expired")
}
return &ErrorResource{
Status: http.StatusUnauthorized,
ID: "saml_unauthor... | go | {
"resource": ""
} |
q36439 | errHandler | train | func errHandler(err error) handlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
return err
}
} | go | {
"resource": ""
} |
q36440 | KeyCreate | train | func (c *Client) KeyCreate(publicKey string) (*Key, error) {
params := struct {
PublicKey string `json:"public_key"`
}{
PublicKey: publicKey,
}
var keyRes Key
return &keyRes, c.Post(&keyRes, "/account/keys", params)
} | go | {
"resource": ""
} |
q36441 | KeyInfo | train | func (c *Client) KeyInfo(keyIdentity string) (*Key, error) {
var key Key
return &key, c.Get(&key, "/account/keys/"+keyIdentity)
} | go | {
"resource": ""
} |
q36442 | KeyList | train | func (c *Client) KeyList(lr *ListRange) ([]Key, error) {
req, err := c.NewRequest("GET", "/account/keys", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var keysRes []Key
return keysRes, c.DoReq(req, &keysRes)
} | go | {
"resource": ""
} |
q36443 | PrependAuthenticator | train | func (a *Auth) PrependAuthenticator(name string, authenticator Authenticator) *Auth {
c := a.copy()
strategy := &Strategy{
Name: name,
Authenticator: authenticator,
}
c.Strategies = append([]*Strategy{strategy}, c.Strategies...)
return c
} | go | {
"resource": ""
} |
q36444 | Authenticate | train | func (a *Auth) Authenticate(ctx context.Context, username, password, otp string, strategies ...string) (context.Context, error) {
// Default to using all strategies to authenticate.
authenticator := a.Strategies.AuthenticatorFor(strategies...)
return a.authenticate(ctx, authenticator, username, password, otp)
} | go | {
"resource": ""
} |
q36445 | Authenticate | train | func (fn AuthenticatorFunc) Authenticate(username, password, otp string) (*Session, error) {
return fn(username, password, otp)
} | go | {
"resource": ""
} |
q36446 | StaticAuthenticator | train | func StaticAuthenticator(username, password, otp string, user *empire.User) Authenticator {
return AuthenticatorFunc(func(givenUsername, givenPassword, givenOtp string) (*Session, error) {
if givenUsername != username {
return nil, ErrForbidden
}
if givenPassword != password {
return nil, ErrForbidden
}... | go | {
"resource": ""
} |
q36447 | Anyone | train | func Anyone(user *empire.User) Authenticator {
return AuthenticatorFunc(func(username, password, otp string) (*Session, error) {
return NewSession(user), nil
})
} | go | {
"resource": ""
} |
q36448 | WithMaxSessionDuration | train | func WithMaxSessionDuration(auth Authenticator, exp func() time.Time) Authenticator {
return AuthenticatorFunc(func(username, password, otp string) (*Session, error) {
session, err := auth.Authenticate(username, password, otp)
if err != nil {
return session, err
}
t := exp()
if exp := session.ExpiresAt; ... | go | {
"resource": ""
} |
q36449 | WithSession | train | func WithSession(ctx context.Context, session *Session) context.Context {
return context.WithValue(ctx, sessionKey, session)
} | go | {
"resource": ""
} |
q36450 | UserFromContext | train | func UserFromContext(ctx context.Context) *empire.User {
session := SessionFromContext(ctx)
return session.User
} | go | {
"resource": ""
} |
q36451 | SessionFromContext | train | func SessionFromContext(ctx context.Context) *Session {
session, ok := ctx.Value(sessionKey).(*Session)
if !ok {
panic("expected user to be authenticated")
}
return session
} | go | {
"resource": ""
} |
q36452 | ImageFromTemplate | train | func ImageFromTemplate(t *template.Template) ImageBuilder {
return ImageBuilderFunc(func(ctx context.Context, _ io.Writer, event events.Deployment) (image.Image, error) {
buf := new(bytes.Buffer)
if err := t.Execute(buf, event); err != nil {
return image.Image{}, err
}
return image.Decode(buf.String())
})... | go | {
"resource": ""
} |
q36453 | newPostgresLocker | train | func newPostgresLocker(db *sql.DB) sync.Locker {
key := crc32.ChecksumIEEE([]byte("migrations"))
return &postgresLocker{
key: key,
db: db,
}
} | go | {
"resource": ""
} |
q36454 | NewMigrator | train | func NewMigrator(db *sql.DB) *Migrator {
return &Migrator{
db: db,
Locker: new(sync.Mutex),
}
} | go | {
"resource": ""
} |
q36455 | NewPostgresMigrator | train | func NewPostgresMigrator(db *sql.DB) *Migrator {
m := NewMigrator(db)
m.Locker = newPostgresLocker(db)
return m
} | go | {
"resource": ""
} |
q36456 | Exec | train | func (m *Migrator) Exec(dir MigrationDirection, migrations ...Migration) error {
m.Lock()
defer m.Unlock()
_, err := m.db.Exec(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version integer primary key not null)", m.table()))
if err != nil {
return err
}
var tx *sql.Tx
if m.TransactionMode == SingleTransaction ... | go | {
"resource": ""
} |
q36457 | runMigration | train | func (m *Migrator) runMigration(tx *sql.Tx, dir MigrationDirection, migration Migration) error {
shouldMigrate, err := m.shouldMigrate(tx, migration.ID, dir)
if err != nil {
return err
}
if !shouldMigrate {
return nil
}
var migrate func(tx *sql.Tx) error
switch dir {
case Up:
migrate = migration.Up
def... | go | {
"resource": ""
} |
q36458 | Exec | train | func Exec(db *sql.DB, dir MigrationDirection, migrations ...Migration) error {
return NewMigrator(db).Exec(dir, migrations...)
} | go | {
"resource": ""
} |
q36459 | sortMigrations | train | func sortMigrations(dir MigrationDirection, migrations []Migration) []Migration {
var m ByID
for _, migration := range migrations {
m = append(m, migration)
}
switch dir {
case Up:
sort.Sort(ByID(m))
default:
sort.Sort(sort.Reverse(ByID(m)))
}
return m
} | go | {
"resource": ""
} |
q36460 | NewCustomResourceProvisioner | train | func NewCustomResourceProvisioner(empire *empire.Empire, config client.ConfigProvider) *CustomResourceProvisioner {
db := empire.DB.DB.DB()
p := &CustomResourceProvisioner{
SQSDispatcher: newSQSDispatcher(config),
Provisioners: make(map[string]customresources.Provisioner),
sendResponse: customresources.SendRe... | go | {
"resource": ""
} |
q36461 | add | train | func (c *CustomResourceProvisioner) add(resourceName string, p customresources.Provisioner) {
// Wrap the provisioner with timeouts.
p = customresources.WithTimeout(p, ProvisioningTimeout, ProvisioningGraceTimeout)
c.Provisioners[resourceName] = withMetrics(p)
} | go | {
"resource": ""
} |
q36462 | Handle | train | func (c *CustomResourceProvisioner) Handle(ctx context.Context, message *sqs.Message) error {
var m Message
err := json.Unmarshal([]byte(*message.Body), &m)
if err != nil {
return fmt.Errorf("error unmarshalling sqs message body: %v", err)
}
var req customresources.Request
err = json.Unmarshal([]byte(m.Message... | go | {
"resource": ""
} |
q36463 | requiresReplacement | train | func requiresReplacement(n, o properties) (bool, error) {
a, err := n.ReplacementHash()
if err != nil {
return false, err
}
b, err := o.ReplacementHash()
if err != nil {
return false, err
}
return a != b, nil
} | go | {
"resource": ""
} |
q36464 | taskFromInstance | train | func taskFromInstance(i *twelvefactor.Task) *Task {
version := i.Process.Env["EMPIRE_RELEASE"]
if version == "" {
version = "v0"
}
return &Task{
Name: fmt.Sprintf("%s.%s.%s", version, i.Process.Type, i.ID),
Type: string(i.Process.Type),
Host: Host{ID: i.Host.ID},
Command: Command(i.Process.Comma... | go | {
"resource": ""
} |
q36465 | RecordToCloudWatch | train | func RecordToCloudWatch(group string, config client.ConfigProvider) empire.RunRecorder {
c := cloudwatchlogs.New(config)
g := cloudwatch.NewGroup(group, c)
return func() (io.Writer, error) {
stream := uuid.New()
w, err := g.Create(stream)
if err != nil {
return nil, err
}
url := fmt.Sprintf("https://co... | go | {
"resource": ""
} |
q36466 | RecordTo | train | func RecordTo(w io.Writer) empire.RunRecorder {
return func() (io.Writer, error) {
return w, nil
}
} | go | {
"resource": ""
} |
q36467 | NewAdvisoryLock | train | func NewAdvisoryLock(db *sql.DB, key uint32) (*AdvisoryLock, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
return &AdvisoryLock{
tx: tx,
key: key,
}, nil
} | go | {
"resource": ""
} |
q36468 | Lock | train | func (l *AdvisoryLock) Lock() error {
l.mu.Lock()
defer l.mu.Unlock()
if l.commited {
panic("lock called on commited lock")
}
if l.LockTimeout != 0 {
_, err := l.tx.Exec(fmt.Sprintf("SET LOCAL lock_timeout = %d", int(l.LockTimeout.Seconds()*1000)))
if err != nil {
return fmt.Errorf("error setting lock t... | go | {
"resource": ""
} |
q36469 | Unlock | train | func (l *AdvisoryLock) Unlock() error {
l.mu.Lock()
defer l.mu.Unlock()
if l.commited {
panic("unlock called on commited lock")
}
if l.c == 0 {
panic("unlock of unlocked advisory lock")
}
_, err := l.tx.Exec(fmt.Sprintf("SELECT pg_advisory_unlock($1) /* %s */", l.Context), l.key)
if err != nil {
return... | go | {
"resource": ""
} |
q36470 | suggest | train | func suggest(s string) (a []string) {
var g Suggestions
for _, c := range commands {
if d := editDistance(s, c.Name()); d < 4 {
if c.Runnable() {
g = append(g, Suggestion{c.Name(), d})
} else {
g = append(g, Suggestion{strconv.Quote("help " + c.Name()), d})
}
}
}
sort.Sort(g)
for i, s := range... | go | {
"resource": ""
} |
q36471 | SessionFromAssertion | train | func SessionFromAssertion(assertion *saml.Assertion) *auth.Session {
login := assertion.Subject.NameID.Value
user := &empire.User{
Name: login,
}
session := auth.NewSession(user)
session.ExpiresAt = &assertion.AuthnStatement.SessionNotOnOrAfter
return session
} | go | {
"resource": ""
} |
q36472 | MustParseCommand | train | func MustParseCommand(command string) Command {
c, err := ParseCommand(command)
if err != nil {
panic(err)
}
return c
} | go | {
"resource": ""
} |
q36473 | IsValid | train | func (p *Process) IsValid() error {
// Ensure that processes marked as NoService can't be scaled up.
if p.NoService {
if p.Quantity != 0 {
return errors.New("non-service processes cannot be scaled up")
}
}
return nil
} | go | {
"resource": ""
} |
q36474 | Constraints | train | func (p *Process) Constraints() Constraints {
return Constraints{
Memory: p.Memory,
CPUShare: p.CPUShare,
Nproc: p.Nproc,
}
} | go | {
"resource": ""
} |
q36475 | IsValid | train | func (f Formation) IsValid() error {
for n, p := range f {
if err := p.IsValid(); err != nil {
return fmt.Errorf("process %s is not valid: %v", n, err)
}
}
return nil
} | go | {
"resource": ""
} |
q36476 | Merge | train | func (f Formation) Merge(other Formation) Formation {
new := make(Formation)
for name, p := range f {
if existing, found := other[name]; found {
// If the existing Formation already had a process
// configuration for this process type, copy over the
// instance count.
p.Quantity = existing.Quantity
... | go | {
"resource": ""
} |
q36477 | New | train | func New(db *DB) *Empire {
e := &Empire{
LogsStreamer: logsDisabled,
EventStream: NullEventStream,
DB: db,
db: db.DB,
}
e.apps = &appsService{Empire: e}
e.configs = &configsService{Empire: e}
e.deployer = &deployerService{Empire: e}
e.domains = &domainsService{Empire: e}
e.slugs = &slugsService{Empire... | go | {
"resource": ""
} |
q36478 | AppsFind | train | func (e *Empire) AppsFind(q AppsQuery) (*App, error) {
return appsFind(e.db, q)
} | go | {
"resource": ""
} |
q36479 | Apps | train | func (e *Empire) Apps(q AppsQuery) ([]*App, error) {
return apps(e.db, q)
} | go | {
"resource": ""
} |
q36480 | Create | train | func (e *Empire) Create(ctx context.Context, opts CreateOpts) (*App, error) {
if err := opts.Validate(e); err != nil {
return nil, err
}
a, err := appsCreate(e.db, &App{Name: opts.Name})
if err != nil {
return a, err
}
return a, e.PublishEvent(opts.Event())
} | go | {
"resource": ""
} |
q36481 | Destroy | train | func (e *Empire) Destroy(ctx context.Context, opts DestroyOpts) error {
if err := opts.Validate(e); err != nil {
return err
}
tx := e.db.Begin()
if err := e.apps.Destroy(ctx, tx, opts.App); err != nil {
tx.Rollback()
return err
}
if err := tx.Commit().Error; err != nil {
return err
}
return e.Publis... | go | {
"resource": ""
} |
q36482 | Config | train | func (e *Empire) Config(app *App) (*Config, error) {
tx := e.db.Begin()
c, err := e.configs.Config(tx, app)
if err != nil {
tx.Rollback()
return c, err
}
if err := tx.Commit().Error; err != nil {
return c, err
}
return c, nil
} | go | {
"resource": ""
} |
q36483 | SetMaintenanceMode | train | func (e *Empire) SetMaintenanceMode(ctx context.Context, opts SetMaintenanceModeOpts) error {
if err := opts.Validate(e); err != nil {
return err
}
tx := e.db.Begin()
app := opts.App
app.Maintenance = opts.Maintenance
if err := appsUpdate(tx, app); err != nil {
tx.Rollback()
return err
}
if err := e.... | go | {
"resource": ""
} |
q36484 | Set | train | func (e *Empire) Set(ctx context.Context, opts SetOpts) (*Config, error) {
if err := opts.Validate(e); err != nil {
return nil, err
}
tx := e.db.Begin()
c, err := e.configs.Set(ctx, tx, opts)
if err != nil {
tx.Rollback()
return c, err
}
if err := tx.Commit().Error; err != nil {
return c, err
}
ret... | go | {
"resource": ""
} |
q36485 | DomainsFind | train | func (e *Empire) DomainsFind(q DomainsQuery) (*Domain, error) {
return domainsFind(e.db, q)
} | go | {
"resource": ""
} |
q36486 | Domains | train | func (e *Empire) Domains(q DomainsQuery) ([]*Domain, error) {
return domains(e.db, q)
} | go | {
"resource": ""
} |
q36487 | DomainsCreate | train | func (e *Empire) DomainsCreate(ctx context.Context, domain *Domain) (*Domain, error) {
tx := e.db.Begin()
d, err := e.domains.DomainsCreate(ctx, tx, domain)
if err != nil {
tx.Rollback()
return d, err
}
if err := tx.Commit().Error; err != nil {
return d, err
}
return d, nil
} | go | {
"resource": ""
} |
q36488 | Tasks | train | func (e *Empire) Tasks(ctx context.Context, app *App) ([]*Task, error) {
return e.tasks.Tasks(ctx, app)
} | go | {
"resource": ""
} |
q36489 | Restart | train | func (e *Empire) Restart(ctx context.Context, opts RestartOpts) error {
if err := opts.Validate(e); err != nil {
return err
}
if err := e.apps.Restart(ctx, e.db, opts); err != nil {
return err
}
return e.PublishEvent(opts.Event())
} | go | {
"resource": ""
} |
q36490 | Run | train | func (e *Empire) Run(ctx context.Context, opts RunOpts) error {
event := opts.Event()
if err := opts.Validate(e); err != nil {
return err
}
if e.RunRecorder != nil && (opts.Stdout != nil || opts.Stderr != nil) {
w, err := e.RunRecorder()
if err != nil {
return err
}
// Add the log url to the event, ... | go | {
"resource": ""
} |
q36491 | Releases | train | func (e *Empire) Releases(q ReleasesQuery) ([]*Release, error) {
return releases(e.db, q)
} | go | {
"resource": ""
} |
q36492 | ReleasesFind | train | func (e *Empire) ReleasesFind(q ReleasesQuery) (*Release, error) {
return releasesFind(e.db, q)
} | go | {
"resource": ""
} |
q36493 | Rollback | train | func (e *Empire) Rollback(ctx context.Context, opts RollbackOpts) (*Release, error) {
if err := opts.Validate(e); err != nil {
return nil, err
}
tx := e.db.Begin()
r, err := e.releases.Rollback(ctx, tx, opts)
if err != nil {
tx.Rollback()
return r, err
}
if err := tx.Commit().Error; err != nil {
retur... | go | {
"resource": ""
} |
q36494 | Deploy | train | func (e *Empire) Deploy(ctx context.Context, opts DeployOpts) (*Release, error) {
if err := opts.Validate(e); err != nil {
return nil, err
}
r, err := e.deployer.Deploy(ctx, opts)
if err != nil {
return r, err
}
event := opts.Event()
event.Release = r.Version
event.Environment = e.Environment
// Deals wi... | go | {
"resource": ""
} |
q36495 | Scale | train | func (e *Empire) Scale(ctx context.Context, opts ScaleOpts) ([]*Process, error) {
if err := opts.Validate(e); err != nil {
return nil, err
}
tx := e.db.Begin()
ps, err := e.apps.Scale(ctx, tx, opts)
if err != nil {
tx.Rollback()
return ps, err
}
return ps, tx.Commit().Error
} | go | {
"resource": ""
} |
q36496 | ListScale | train | func (e *Empire) ListScale(ctx context.Context, app *App) (Formation, error) {
return currentFormation(e.db, app)
} | go | {
"resource": ""
} |
q36497 | StreamLogs | train | func (e *Empire) StreamLogs(app *App, w io.Writer, duration time.Duration) error {
if err := e.LogsStreamer.StreamLogs(app, w, duration); err != nil {
return fmt.Errorf("error streaming logs: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q36498 | CertsAttach | train | func (e *Empire) CertsAttach(ctx context.Context, opts CertsAttachOpts) error {
tx := e.db.Begin()
if err := e.certs.CertsAttach(ctx, tx, opts); err != nil {
tx.Rollback()
return err
}
return tx.Commit().Error
} | go | {
"resource": ""
} |
q36499 | ecsWithCaching | train | func ecsWithCaching(ecs *ECS) *cachingECSClient {
return &cachingECSClient{
ecsClient: ecs,
taskDefinitions: cache.New(defaultExpiration, defaultPurge),
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.