_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36500 | DescribeTaskDefinition | train | func (c *cachingECSClient) DescribeTaskDefinition(input *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error) {
if _, err := arn.Parse(*input.TaskDefinition); err != nil {
return c.ecsClient.DescribeTaskDefinition(input)
}
if v, ok := c.taskDefinitions.Get(*input.TaskDefinition); ok {
ret... | go | {
"resource": ""
} |
q36501 | WaitUntilTasksNotPending | train | func (c *ECS) WaitUntilTasksNotPending(input *ecs.DescribeTasksInput) error {
waiterCfg := awswaiter.Config{
Operation: "DescribeTasks",
Delay: 6,
MaxAttempts: 100,
Acceptors: []awswaiter.WaitAcceptor{
{
State: "failure",
Matcher: "pathAny",
Argument: "failures[].reason",
Expecte... | go | {
"resource": ""
} |
q36502 | OAuthTokenCreate | train | func (c *Client) OAuthTokenCreate(grant OAuthTokenCreateGrant, client OAuthTokenCreateClient, refreshToken OAuthTokenCreateRefreshToken) (*OAuthToken, error) {
params := struct {
Grant OAuthTokenCreateGrant `json:"grant"`
Client OAuthTokenCreateClient `json:"client"`
RefreshToken OAuthT... | go | {
"resource": ""
} |
q36503 | AppFeatureInfo | train | func (c *Client) AppFeatureInfo(appIdentity string, appFeatureIdentity string) (*AppFeature, error) {
var appFeature AppFeature
return &appFeature, c.Get(&appFeature, "/apps/"+appIdentity+"/features/"+appFeatureIdentity)
} | go | {
"resource": ""
} |
q36504 | AppFeatureList | train | func (c *Client) AppFeatureList(appIdentity string, lr *ListRange) ([]AppFeature, error) {
req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/features", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var appFeaturesRes []AppFeature
return appFeaturesRes, c.DoReq(req, &ap... | go | {
"resource": ""
} |
q36505 | AppFeatureUpdate | train | func (c *Client) AppFeatureUpdate(appIdentity string, appFeatureIdentity string, enabled bool) (*AppFeature, error) {
params := struct {
Enabled bool `json:"enabled"`
}{
Enabled: enabled,
}
var appFeatureRes AppFeature
return &appFeatureRes, c.Patch(&appFeatureRes, "/apps/"+appIdentity+"/features/"+appFeatureI... | go | {
"resource": ""
} |
q36506 | WithRequest | train | func WithRequest(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ctx = httpx.WithRequest(ctx, r)
// Add the request to the context.
reporter.AddRequest(ctx, r)
// Add the request id
reporter.AddContext(ctx, "request_id", httpx.Requ... | go | {
"resource": ""
} |
q36507 | NewTemplate | train | func NewTemplate() *Template {
return &Template{
Conditions: make(map[string]interface{}),
Outputs: make(map[string]Output),
Parameters: make(map[string]Parameter),
Resources: make(map[string]Resource),
}
} | go | {
"resource": ""
} |
q36508 | AddResource | train | func (t *Template) AddResource(resource NamedResource) {
if _, ok := t.Resources[resource.Name]; ok {
panic(fmt.Sprintf("%s is already defined in the template", resource.Name))
}
t.Resources[resource.Name] = resource.Resource
} | go | {
"resource": ""
} |
q36509 | Parse | train | func Parse(arn string) (*ARN, error) {
p := strings.SplitN(arn, delimiter, 6)
// Ensure that we have all the components that make up an ARN.
if len(p) < 6 {
return nil, ErrInvalidARN
}
a := &ARN{
ARN: p[0],
AWS: p[1],
Service: p[2],
Region: p[3],
Account: p[4],
Resource: p[5],
}
//... | go | {
"resource": ""
} |
q36510 | String | train | func (a *ARN) String() string {
return strings.Join(
[]string{a.ARN, a.AWS, a.Service, a.Region, a.Account, a.Resource},
delimiter,
)
} | go | {
"resource": ""
} |
q36511 | SplitResource | train | func SplitResource(r string) (resource, id string, err error) {
p := strings.Split(r, "/")
if len(p) != 2 {
err = ErrInvalidResource
return
}
resource = p[0]
id = p[1]
return
} | go | {
"resource": ""
} |
q36512 | ResourceID | train | func ResourceID(arn string) (string, error) {
a, err := Parse(arn)
if err != nil {
return "", err
}
_, id, err := SplitResource(a.Resource)
return id, err
} | go | {
"resource": ""
} |
q36513 | LogRequests | train | func LogRequests(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
logger.Info(ctx, "request.start",
"method", r.Method,
"path", r.URL.Path,
"user_agent", r.Header.Get("User-Agent"),
"remote_ip", realip.RealIP(r),
)
h.ServeHTTP... | go | {
"resource": ""
} |
q36514 | PrefixRequestID | train | func PrefixRequestID(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if l, ok := logger.FromContext(ctx); ok {
if l, ok := l.(log15.Logger); ok {
ctx = logger.WithLogger(ctx, l.New("request_id", httpx.RequestID(ctx)))
}
}
h.Se... | go | {
"resource": ""
} |
q36515 | NewDogstatsd | train | func NewDogstatsd(addr string) (*Dogstatsd, error) {
c, err := statsd.New(addr)
if err != nil {
return nil, err
}
return &Dogstatsd{
Client: c,
}, nil
} | go | {
"resource": ""
} |
q36516 | CollaboratorCreate | train | func (c *Client) CollaboratorCreate(appIdentity string, user string, options *CollaboratorCreateOpts) (*Collaborator, error) {
params := struct {
User string `json:"user"`
Silent *bool `json:"silent,omitempty"`
}{
User: user,
}
if options != nil {
params.Silent = options.Silent
}
var collaboratorRes Co... | go | {
"resource": ""
} |
q36517 | CollaboratorDelete | train | func (c *Client) CollaboratorDelete(appIdentity string, collaboratorIdentity string) error {
return c.Delete("/apps/" + appIdentity + "/collaborators/" + collaboratorIdentity)
} | go | {
"resource": ""
} |
q36518 | CollaboratorInfo | train | func (c *Client) CollaboratorInfo(appIdentity string, collaboratorIdentity string) (*Collaborator, error) {
var collaborator Collaborator
return &collaborator, c.Get(&collaborator, "/apps/"+appIdentity+"/collaborators/"+collaboratorIdentity)
} | go | {
"resource": ""
} |
q36519 | CollaboratorList | train | func (c *Client) CollaboratorList(appIdentity string, lr *ListRange) ([]Collaborator, error) {
req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/collaborators", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var collaboratorsRes []Collaborator
return collaboratorsRes, c... | go | {
"resource": ""
} |
q36520 | SlugInfo | train | func (c *Client) SlugInfo(appIdentity string, slugIdentity string) (*Slug, error) {
var slug Slug
return &slug, c.Get(&slug, "/apps/"+appIdentity+"/slugs/"+slugIdentity)
} | go | {
"resource": ""
} |
q36521 | SlugCreate | train | func (c *Client) SlugCreate(appIdentity string, processTypes map[string]string, options *SlugCreateOpts) (*Slug, error) {
params := struct {
ProcessTypes map[string]string `json:"process_types"`
BuildpackProvidedDescription *string `json:"buildpack_provided_description,omitempty"`
Commi... | go | {
"resource": ""
} |
q36522 | NewDockerClient | train | func NewDockerClient(host, certPath string) (*docker.Client, error) {
if certPath != "" {
cert := certPath + "/cert.pem"
key := certPath + "/key.pem"
ca := certPath + "/ca.pem"
return docker.NewTLSClient(host, cert, key, ca)
}
return docker.NewClient(host)
} | go | {
"resource": ""
} |
q36523 | NewClient | train | func NewClient(authProvider dockerauth.AuthProvider, host, certPath string) (*Client, error) {
c, err := NewDockerClient(host, certPath)
if err != nil {
return nil, err
}
return newClient(authProvider, c)
} | go | {
"resource": ""
} |
q36524 | PullImage | train | func (c *Client) PullImage(ctx context.Context, opts docker.PullImageOptions) error {
// This is to workaround an issue in the Docker API, where it doesn't
// respect the registry param. We have to put the registry in the
// repository field.
if opts.Registry != "" {
opts.Repository = fmt.Sprintf("%s/%s", opts.Re... | go | {
"resource": ""
} |
q36525 | AddonServiceInfo | train | func (c *Client) AddonServiceInfo(addonServiceIdentity string) (*AddonService, error) {
var addonService AddonService
return &addonService, c.Get(&addonService, "/addon-services/"+addonServiceIdentity)
} | go | {
"resource": ""
} |
q36526 | AddonServiceList | train | func (c *Client) AddonServiceList(lr *ListRange) ([]AddonService, error) {
req, err := c.NewRequest("GET", "/addon-services", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var addonServicesRes []AddonService
return addonServicesRes, c.DoReq(req, &addonServicesRes)
} | go | {
"resource": ""
} |
q36527 | ParsePort | train | func ParsePort(s string) (p Port, err error) {
if strings.Contains(s, ":") {
return portFromHostContainer(s)
}
var port int
port, err = toPort(s)
if err != nil {
return
}
p.Host = port
p.Container = port
return
} | go | {
"resource": ""
} |
q36528 | Parse | train | func Parse(r io.Reader) (Procfile, error) {
raw, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return ParseProcfile(raw)
} | go | {
"resource": ""
} |
q36529 | ParseProcfile | train | func ParseProcfile(b []byte) (Procfile, error) {
p, err := parseStandardProcfile(b)
if err != nil {
p, err = parseExtendedProcfile(b)
}
return p, err
} | go | {
"resource": ""
} |
q36530 | OAuthClientCreate | train | func (c *Client) OAuthClientCreate(name string, redirectUri string) (*OAuthClient, error) {
params := struct {
Name string `json:"name"`
RedirectUri string `json:"redirect_uri"`
}{
Name: name,
RedirectUri: redirectUri,
}
var oauthClientRes OAuthClient
return &oauthClientRes, c.Post(&oauthClie... | go | {
"resource": ""
} |
q36531 | OAuthClientInfo | train | func (c *Client) OAuthClientInfo(oauthClientIdentity string) (*OAuthClient, error) {
var oauthClient OAuthClient
return &oauthClient, c.Get(&oauthClient, "/oauth/clients/"+oauthClientIdentity)
} | go | {
"resource": ""
} |
q36532 | OAuthClientList | train | func (c *Client) OAuthClientList(lr *ListRange) ([]OAuthClient, error) {
req, err := c.NewRequest("GET", "/oauth/clients", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var oauthClientsRes []OAuthClient
return oauthClientsRes, c.DoReq(req, &oauthClientsRes)
} | go | {
"resource": ""
} |
q36533 | OAuthClientUpdate | train | func (c *Client) OAuthClientUpdate(oauthClientIdentity string, options *OAuthClientUpdateOpts) (*OAuthClient, error) {
var oauthClientRes OAuthClient
return &oauthClientRes, c.Patch(&oauthClientRes, "/oauth/clients/"+oauthClientIdentity, options)
} | go | {
"resource": ""
} |
q36534 | LogSessionCreate | train | func (c *Client) LogSessionCreate(appIdentity string, options *LogSessionCreateOpts) (*LogSession, error) {
var logSessionRes LogSession
return &logSessionRes, c.Post(&logSessionRes, "/apps/"+appIdentity+"/log-sessions", options)
} | go | {
"resource": ""
} |
q36535 | newDeployer | train | func newDeployer(e *empire.Empire, options Options) github.Deployer {
ed := github.NewEmpireDeployer(e)
ed.ImageBuilder = options.GitHub.Deployments.ImageBuilder
var d github.Deployer = ed
// Enables the Tugboat integration, which will send logs to a Tugboat
// instance.
if url := options.GitHub.Deployments.Tug... | go | {
"resource": ""
} |
q36536 | OrganizationMemberCreateOrUpdate | train | func (c *Client) OrganizationMemberCreateOrUpdate(organizationIdentity string, email string, role string) (*OrganizationMember, error) {
params := struct {
Email string `json:"email"`
Role string `json:"role"`
}{
Email: email,
Role: role,
}
var organizationMemberRes OrganizationMember
return &organizatio... | go | {
"resource": ""
} |
q36537 | OrganizationMemberDelete | train | func (c *Client) OrganizationMemberDelete(organizationIdentity string, organizationMemberIdentity string) error {
return c.Delete("/organizations/" + organizationIdentity + "/members/" + organizationIdentity)
} | go | {
"resource": ""
} |
q36538 | OrganizationMemberList | train | func (c *Client) OrganizationMemberList(organizationIdentity string, lr *ListRange) ([]OrganizationMember, error) {
req, err := c.NewRequest("GET", "/organizations/"+organizationIdentity+"/members", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var organizationMembersRes []O... | go | {
"resource": ""
} |
q36539 | NewScheduler | train | func NewScheduler(db *sql.DB, config client.ConfigProvider) *Scheduler {
return &Scheduler{
cloudformation: cloudformation.New(config),
ecs: ecsWithCaching(&ECS{ecs.New(config)}),
s3: s3.New(config),
ec2: ec2.New(config),
db: db,
after: time.After,
}
... | go | {
"resource": ""
} |
q36540 | createTemplate | train | func (s *Scheduler) createTemplate(ctx context.Context, app *twelvefactor.Manifest, stackTags []*cloudformation.Tag) (*cloudformationTemplate, error) {
data := &TemplateData{
Manifest: app,
StackTags: stackTags,
}
buf := new(bytes.Buffer)
if err := s.Template.Execute(buf, data); err != nil {
return nil, err... | go | {
"resource": ""
} |
q36541 | createStack | train | func (s *Scheduler) createStack(ctx context.Context, input *createStackInput, output chan stackOperationOutput, ss twelvefactor.StatusStream) error {
waiter := s.waitFor(ctx, createStack, ss)
submitted := make(chan error)
fn := func() error {
_, err := s.cloudformation.CreateStack(&cloudformation.CreateStackInput... | go | {
"resource": ""
} |
q36542 | updateStack | train | func (s *Scheduler) updateStack(ctx context.Context, input *updateStackInput, output chan stackOperationOutput, ss twelvefactor.StatusStream) error {
waiter := s.waitFor(ctx, updateStack, ss)
locked := make(chan struct{})
submitted := make(chan error, 1)
fn := func() error {
close(locked)
err := s.executeStack... | go | {
"resource": ""
} |
q36543 | waitUntilStackOperationComplete | train | func (s *Scheduler) waitUntilStackOperationComplete(lock *pglock.AdvisoryLock, wait func() error) error {
errCh := make(chan error)
go func() { errCh <- wait() }()
var err error
select {
case <-s.after(stackOperationTimeout):
err = errors.New("timed out waiting for stack operation to complete")
case err = <-er... | go | {
"resource": ""
} |
q36544 | executeStackUpdate | train | func (s *Scheduler) executeStackUpdate(input *updateStackInput) error {
stack, err := s.stack(input.StackName)
if err != nil {
return err
}
i := &cloudformation.UpdateStackInput{
StackName: input.StackName,
Parameters: updateParameters(input.Parameters, stack, input.Template),
Tags: input.Tags,
}
... | go | {
"resource": ""
} |
q36545 | stack | train | func (s *Scheduler) stack(stackName *string) (*cloudformation.Stack, error) {
resp, err := s.cloudformation.DescribeStacks(&cloudformation.DescribeStacksInput{
StackName: stackName,
})
if err != nil {
return nil, err
}
return resp.Stacks[0], nil
} | go | {
"resource": ""
} |
q36546 | Remove | train | func (s *Scheduler) Remove(ctx context.Context, appID string) error {
tx, err := s.db.Begin()
if err != nil {
return err
}
err = s.remove(ctx, tx, appID)
if err != nil {
tx.Rollback()
return err
}
return tx.Commit()
} | go | {
"resource": ""
} |
q36547 | remove | train | func (s *Scheduler) remove(_ context.Context, tx *sql.Tx, appID string) error {
stackName, err := s.stackName(appID)
// if there's no stack entry in the db for this app, nothing to remove
if err == errNoStack {
return nil
}
if err != nil {
return err
}
_, err = tx.Exec(`DELETE FROM stacks WHERE app_id = $1... | go | {
"resource": ""
} |
q36548 | tasks | train | func (s *Scheduler) tasks(app string) ([]*ecs.Task, error) {
services, err := s.Services(app)
if err != nil {
return nil, err
}
var arns []*string
// Find all of the tasks started by the ECS services.
for process, serviceArn := range services {
id, err := arn.ResourceID(serviceArn)
if err != nil {
retu... | go | {
"resource": ""
} |
q36549 | Stop | train | func (s *Scheduler) Stop(ctx context.Context, taskID string) error {
_, err := s.ecs.StopTask(&ecs.StopTaskInput{
Cluster: aws.String(s.Cluster),
Task: aws.String(taskID),
})
return err
} | go | {
"resource": ""
} |
q36550 | Run | train | func (m *Scheduler) Run(ctx context.Context, app *twelvefactor.Manifest) error {
for _, process := range app.Processes {
var attached bool
if process.Stdout != nil || process.Stderr != nil {
attached = true
}
t, ok := m.Template.(interface {
ContainerDefinition(*twelvefactor.Manifest, *twelvefactor.Proc... | go | {
"resource": ""
} |
q36551 | attach | train | func (m *Scheduler) attach(ctx context.Context, task *ecs.Task, stdin io.Reader, stdout, stderr io.Writer) error {
if a, _ := arn.Parse(aws.StringValue(task.TaskArn)); a != nil {
fmt.Fprintf(stderr, "Attaching to %s...\r\n", a.Resource)
}
descContainerInstanceResp, err := m.ecs.DescribeContainerInstances(&ecs.Des... | go | {
"resource": ""
} |
q36552 | stackName | train | func (s *Scheduler) stackName(appID string) (string, error) {
var stackName string
err := s.db.QueryRow(`SELECT stack_name FROM stacks WHERE app_id = $1`, appID).Scan(&stackName)
if err == sql.ErrNoRows {
return "", errNoStack
}
return stackName, err
} | go | {
"resource": ""
} |
q36553 | waitFor | train | func (s *Scheduler) waitFor(ctx context.Context, op stackOperation, ss twelvefactor.StatusStream) func(*cloudformation.DescribeStacksInput) error {
waiter := waiters[op]
wait := waiter.wait(s.cloudformation)
return func(input *cloudformation.DescribeStacksInput) error {
tags := []string{
fmt.Sprintf("stack:%s"... | go | {
"resource": ""
} |
q36554 | extractProcessData | train | func extractProcessData(value string) map[string]string {
data := make(map[string]string)
pairs := strings.Split(value, ",")
for _, p := range pairs {
parts := strings.Split(p, "=")
data[parts[0]] = parts[1]
}
return data
} | go | {
"resource": ""
} |
q36555 | taskDefinitionToProcess | train | func taskDefinitionToProcess(td *ecs.TaskDefinition) (*twelvefactor.Process, error) {
// If this task definition has no container definitions, then something
// funky is up.
if len(td.ContainerDefinitions) == 0 {
return nil, errors.New("task definition had no container definitions")
}
container := td.ContainerD... | go | {
"resource": ""
} |
q36556 | chunkStrings | train | func chunkStrings(s []*string, size int) [][]*string {
var chunks [][]*string
for len(s) > 0 {
end := size
if len(s) < size {
end = len(s)
}
chunks = append(chunks, s[0:end])
s = s[end:]
}
return chunks
} | go | {
"resource": ""
} |
q36557 | updateParameters | train | func updateParameters(provided []*cloudformation.Parameter, stack *cloudformation.Stack, template *cloudformationTemplate) []*cloudformation.Parameter {
parameters := provided[:]
// This tracks the names of the parameters that have pre-existing values
// on the stack.
existingParams := make(map[string]bool)
for _... | go | {
"resource": ""
} |
q36558 | stackLockKey | train | func stackLockKey(stackName string) uint32 {
return crc32.ChecksumIEEE([]byte(fmt.Sprintf("stack_%s", stackName)))
} | go | {
"resource": ""
} |
q36559 | newAdvisoryLock | train | func newAdvisoryLock(db *sql.DB, stackName string) (*pglock.AdvisoryLock, error) {
l, err := pglock.NewAdvisoryLock(db, stackLockKey(stackName))
if err != nil {
return l, err
}
l.LockTimeout = lockTimeout
l.Context = fmt.Sprintf("stack %s", stackName)
return l, nil
} | go | {
"resource": ""
} |
q36560 | output | train | func output(stack *cloudformation.Stack, key string) (output *cloudformation.Output) {
for _, o := range stack.Outputs {
if *o.OutputKey == key {
output = o
}
}
return
} | go | {
"resource": ""
} |
q36561 | deploymentsToWatch | train | func deploymentsToWatch(stack *cloudformation.Stack) (map[string]*ecsDeployment, error) {
deployments := output(stack, deploymentsOutput)
services := output(stack, servicesOutput)
if deployments == nil {
return nil, fmt.Errorf("deployments output missing from stack")
}
if services == nil {
return nil, fmt.Erro... | go | {
"resource": ""
} |
q36562 | Start | train | func (q *SQSDispatcher) Start(handle func(context.Context, *sqs.Message) error) {
var wg sync.WaitGroup
for i := 0; i < q.NumWorkers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
q.start(handle)
}()
}
wg.Wait()
} | go | {
"resource": ""
} |
q36563 | start | train | func (q *SQSDispatcher) start(handle func(context.Context, *sqs.Message) error) {
var wg sync.WaitGroup
for {
select {
case <-q.stopped:
wg.Wait()
return
default:
ctx := q.Context
resp, err := q.sqs.ReceiveMessage(&sqs.ReceiveMessageInput{
QueueUrl: aws.String(q.QueueURL),
WaitTimeSe... | go | {
"resource": ""
} |
q36564 | extendMessageVisibilityTimeout | train | func (q *SQSDispatcher) extendMessageVisibilityTimeout(receiptHandle *string) (<-chan time.Time, error) {
visibilityTimeout := int64(float64(q.VisibilityHeartbeat) / float64(time.Second))
_, err := q.sqs.ChangeMessageVisibility(&sqs.ChangeMessageVisibilityInput{
QueueUrl: aws.String(q.QueueURL),
Receipt... | go | {
"resource": ""
} |
q36565 | AppCreate | train | func (c *Client) AppCreate(options *AppCreateOpts) (*App, error) {
var appRes App
return &appRes, c.Post(&appRes, "/apps", options)
} | go | {
"resource": ""
} |
q36566 | AppInfo | train | func (c *Client) AppInfo(appIdentity string) (*App, error) {
var app App
return &app, c.Get(&app, "/apps/"+appIdentity)
} | go | {
"resource": ""
} |
q36567 | AppList | train | func (c *Client) AppList(lr *ListRange) ([]App, error) {
req, err := c.NewRequest("GET", "/apps", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var appsRes []App
return appsRes, c.DoReq(req, &appsRes)
} | go | {
"resource": ""
} |
q36568 | AppUpdate | train | func (c *Client) AppUpdate(appIdentity string, options *AppUpdateOpts, message string) (*App, error) {
rh := RequestHeaders{CommitMessage: message}
var appRes App
return &appRes, c.PatchWithHeaders(&appRes, "/apps/"+appIdentity, options, rh.Headers())
} | go | {
"resource": ""
} |
q36569 | Decode | train | func Decode(in string) (image Image, err error) {
repo, tag := parseRepositoryTag(in)
image.Registry, image.Repository = splitRepository(repo)
if strings.Contains(tag, ":") {
image.Digest = tag
} else {
image.Tag = tag
}
if image.Repository == "" {
err = ErrInvalidImage
return
}
return
} | go | {
"resource": ""
} |
q36570 | Encode | train | func Encode(image Image) string {
repo := image.Repository
if image.Registry != "" {
repo = fmt.Sprintf("%s/%s", image.Registry, repo)
}
if image.Digest != "" {
return fmt.Sprintf("%s@%s", repo, image.Digest)
} else if image.Tag != "" {
return fmt.Sprintf("%s:%s", repo, image.Tag)
}
return repo
} | go | {
"resource": ""
} |
q36571 | splitRepository | train | func splitRepository(fullRepo string) (registry string, path string) {
parts := strings.Split(fullRepo, "/")
if len(parts) < 2 {
return "", parts[0]
}
if len(parts) == 2 {
return "", strings.Join(parts, "/")
}
return parts[0], strings.Join(parts[1:], "/")
} | go | {
"resource": ""
} |
q36572 | createRelease | train | func (s *deployerService) createRelease(ctx context.Context, db *gorm.DB, ss twelvefactor.StatusStream, opts DeployOpts) (*Release, error) {
app, img := opts.App, opts.Image
// If no app is specified, attempt to find the app that relates to this
// images repository, or create it if not found.
if app == nil {
va... | go | {
"resource": ""
} |
q36573 | Deploy | train | func (s *deployerService) Deploy(ctx context.Context, opts DeployOpts) (*Release, error) {
w := opts.Output
var stream twelvefactor.StatusStream
if opts.Stream {
stream = w
}
r, err := s.createInTransaction(ctx, stream, opts)
if err != nil {
return r, w.Error(err)
}
if err := w.Status(fmt.Sprintf("Create... | go | {
"resource": ""
} |
q36574 | Publish | train | func (w *DeploymentStream) Publish(status twelvefactor.Status) error {
return w.Status(status.Message)
} | go | {
"resource": ""
} |
q36575 | Status | train | func (w *DeploymentStream) Status(message string) error {
m := jsonmessage.JSONMessage{Status: fmt.Sprintf("Status: %s", message)}
return w.Encode(m)
} | go | {
"resource": ""
} |
q36576 | OAuthAuthorizationCreate | train | func (c *Client) OAuthAuthorizationCreate(scope []string, options *OAuthAuthorizationCreateOpts) (*OAuthAuthorization, error) {
params := struct {
Scope []string `json:"scope"`
Client *string `json:"client,omitempty"`
Description *string `json:"description,omitempty"`
ExpiresIn *int `json:"e... | go | {
"resource": ""
} |
q36577 | OAuthAuthorizationInfo | train | func (c *Client) OAuthAuthorizationInfo(oauthAuthorizationIdentity string) (*OAuthAuthorization, error) {
var oauthAuthorization OAuthAuthorization
return &oauthAuthorization, c.Get(&oauthAuthorization, "/oauth/authorizations/"+oauthAuthorizationIdentity)
} | go | {
"resource": ""
} |
q36578 | OAuthAuthorizationList | train | func (c *Client) OAuthAuthorizationList(lr *ListRange) ([]OAuthAuthorization, error) {
req, err := c.NewRequest("GET", "/oauth/authorizations", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var oauthAuthorizationsRes []OAuthAuthorization
return oauthAuthorizationsRes, c.DoR... | go | {
"resource": ""
} |
q36579 | ExpiresIn | train | func (t *AccessToken) ExpiresIn() time.Duration {
if t.ExpiresAt == nil {
return 0
}
return t.ExpiresAt.Sub(time.Now())
} | go | {
"resource": ""
} |
q36580 | IsValid | train | func (t *AccessToken) IsValid() error {
if err := t.User.IsValid(); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q36581 | Authenticate | train | func (a *accessTokenAuthenticator) Authenticate(_ string, token string, _ string) (*auth.Session, error) {
at, err := a.findAccessToken(token)
if err != nil {
return nil, err
}
if at == nil {
return nil, auth.ErrForbidden
}
session := &auth.Session{
User: at.User,
ExpiresAt: at.ExpiresAt,
}
retu... | go | {
"resource": ""
} |
q36582 | AccessTokensCreate | train | func (s *Server) AccessTokensCreate(token *AccessToken) (*AccessToken, error) {
signed, err := signToken(s.Secret, token)
if err != nil {
return token, err
}
token.Token = signed
return token, token.IsValid()
} | go | {
"resource": ""
} |
q36583 | signToken | train | func signToken(secret []byte, token *AccessToken) (string, error) {
t := accessTokenToJwt(token)
return t.SignedString(secret)
} | go | {
"resource": ""
} |
q36584 | parseToken | train | func parseToken(secret []byte, token string) (*AccessToken, error) {
t, err := jwtParse(secret, token)
if err != nil {
return nil, err
}
if !t.Valid {
return nil, nil
}
return jwtToAccessToken(t)
} | go | {
"resource": ""
} |
q36585 | jwtToAccessToken | train | func jwtToAccessToken(t *jwt.Token) (*AccessToken, error) {
var token AccessToken
if t.Claims["exp"] != nil {
exp := time.Unix(int64(t.Claims["exp"].(float64)), 0).UTC()
token.ExpiresAt = &exp
}
if u, ok := t.Claims["User"].(map[string]interface{}); ok {
var user empire.User
if n, ok := u["Name"].(string... | go | {
"resource": ""
} |
q36586 | DomainCreate | train | func (c *Client) DomainCreate(appIdentity string, hostname string) (*Domain, error) {
params := struct {
Hostname string `json:"hostname"`
}{
Hostname: hostname,
}
var domainRes Domain
return &domainRes, c.Post(&domainRes, "/apps/"+appIdentity+"/domains", params)
} | go | {
"resource": ""
} |
q36587 | DomainDelete | train | func (c *Client) DomainDelete(appIdentity string, domainIdentity string) error {
return c.Delete("/apps/" + appIdentity + "/domains/" + domainIdentity)
} | go | {
"resource": ""
} |
q36588 | DomainInfo | train | func (c *Client) DomainInfo(appIdentity string, domainIdentity string) (*Domain, error) {
var domain Domain
return &domain, c.Get(&domain, "/apps/"+appIdentity+"/domains/"+domainIdentity)
} | go | {
"resource": ""
} |
q36589 | DomainList | train | func (c *Client) DomainList(appIdentity string, lr *ListRange) ([]Domain, error) {
req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/domains", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var domainsRes []Domain
return domainsRes, c.DoReq(req, &domainsRes)
} | go | {
"resource": ""
} |
q36590 | StreamingResponseWriter | train | func StreamingResponseWriter(w http.ResponseWriter) *ResponseWriter {
fw, err := newFlushWriter(w)
if err != nil {
panic(err)
}
return &ResponseWriter{
ResponseWriter: w,
w: fw,
}
} | go | {
"resource": ""
} |
q36591 | Write | train | func (w *ResponseWriter) Write(p []byte) (int, error) {
return w.w.Write(p)
} | go | {
"resource": ""
} |
q36592 | Heartbeat | train | func Heartbeat(outStream io.Writer, interval time.Duration) chan struct{} {
stop := make(chan struct{})
t := time.NewTicker(interval)
go func() {
for {
select {
case <-t.C:
fmt.Fprintf(outStream, "\x00")
continue
case <-stop:
t.Stop()
return
}
}
}()
return stop
} | go | {
"resource": ""
} |
q36593 | taskDefinitionResourceType | train | func taskDefinitionResourceType(app *twelvefactor.Manifest) string {
check := []string{
"EMPIRE_X_TASK_DEFINITION_TYPE",
"ECS_TASK_DEFINITION", // For backwards compatibility.
}
for _, n := range check {
if v, ok := app.Env[n]; ok {
if v == "custom" {
return "Custom::ECSTaskDefinition"
}
}
}
//... | go | {
"resource": ""
} |
q36594 | Validate | train | func (t *EmpireTemplate) Validate() error {
r := func(n string) error {
return errors.New(fmt.Sprintf("%s is required", n))
}
if t.VpcId == "" {
return r("VpcId")
}
if t.Cluster == "" {
return r("Cluster")
}
if t.ServiceRole == "" {
return r("ServiceRole")
}
if t.HostedZone == nil {
return r("Hosted... | go | {
"resource": ""
} |
q36595 | Execute | train | func (t *EmpireTemplate) Execute(w io.Writer, data interface{}) error {
v, err := t.Build(data.(*TemplateData))
if err != nil {
return err
}
if t.NoCompress {
raw, err := json.MarshalIndent(v, "", " ")
if err != nil {
return err
}
_, err = io.Copy(w, bytes.NewReader(raw))
return err
}
return js... | go | {
"resource": ""
} |
q36596 | Build | train | func (t *EmpireTemplate) Build(data *TemplateData) (*troposphere.Template, error) {
app := data.Manifest
tmpl := troposphere.NewTemplate()
tmpl.Parameters["DNS"] = troposphere.Parameter{
Type: "String",
Description: "When set to `true`, CNAME's will be altered",
Default: "true",
}
tmpl.Parameter... | go | {
"resource": ""
} |
q36597 | serviceRoleArn | train | func (t *EmpireTemplate) serviceRoleArn() interface{} {
if _, err := arn.Parse(t.ServiceRole); err == nil {
return t.ServiceRole
}
return Join("", "arn:aws:iam::", Ref("AWS::AccountId"), ":role/", t.ServiceRole)
} | go | {
"resource": ""
} |
q36598 | ContainerDefinition | train | func (t *EmpireTemplate) ContainerDefinition(app *twelvefactor.Manifest, p *twelvefactor.Process) *ecs.ContainerDefinition {
command := []*string{}
for _, s := range p.Command {
ss := s
command = append(command, &ss)
}
labels := make(map[string]*string)
for k, v := range twelvefactor.Labels(app, p) {
labels... | go | {
"resource": ""
} |
q36599 | HostedZone | train | func HostedZone(config client.ConfigProvider, hostedZoneID string) (*route53.HostedZone, error) {
r := route53.New(config)
zid := fixHostedZoneIDPrefix(hostedZoneID)
out, err := r.GetHostedZone(&route53.GetHostedZoneInput{Id: zid})
if err != nil {
return nil, err
}
return out.HostedZone, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.