id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25900 |
return nil, Warnings(warnings), err
}
var visibilitesToReturn []ServicePlanVisibility
for _, v := range visibilities {
visibilitesToReturn = append(visibilitesToReturn, ServicePlanVisibility(v))
}
return visibilitesToReturn, Warnings(warnings), nil
} | |
c25901 | ':' {
val, ok := params[c[1:]]
if !ok {
return "", fmt.Errorf("missing param %s", c)
}
components[i] = val
}
}
u, err := url.Parse(strings.Join(components, "/"))
if err != nil {
return "", err
}
return u.String(), nil
} | |
c25902 | mappedRoutes[route.Name] = route
}
return &Router{
routes: mappedRoutes,
resources: resources,
}
} | |
c25903 | router.resources[route.Resource]
if !ok {
return &http.Request{}, fmt.Errorf("no resource exists with the name %s", route.Resource)
}
url, err := router.urlFrom(resource, uri)
if err != nil {
return &http.Request{}, err
}
return http.NewRequest(route.Method, url, body)
} | |
c25904 | NewConnection(config.SkipSSLValidation(), config.UAADisableKeepAlives(), config.DialTimeout()),
userAgent: userAgent,
}
client.WrapConnection(NewErrorWrapper())
return &client
} | |
c25905 | translateFunc,
terminalLock: &sync.Mutex{},
Exiter: realExiter,
fileLock: &sync.Mutex{},
Interactor: realInteract,
IsTTY: config.IsTTY(),
TerminalWidth: config.TerminalWidth(),
TimezoneLocation: location,
}, nil
} | |
c25906 |
defer ui.terminalLock.Unlock()
fmt.Fprintf(ui.Out, "%s\n", ui.modifyColor(ui.TranslateText("FAILED"), color.New(color.FgRed, color.Bold)))
} | |
c25907 | ui.modifyColor(ui.TranslateText(text), color.New(color.Bold)))
} | |
c25908 | ui.terminalLock.Unlock()
fmt.Fprintf(ui.Out, "\n")
} | |
c25909 | ui.modifyColor(ui.TranslateText("OK"), color.New(color.FgGreen, color.Bold)))
} | |
c25910 |
fmt.Fprintf(ui.Out, "%s\n", ui.TranslateText(template, templateValues...))
} | |
c25911 | {
firstTemplateValues[key] = ui.modifyColor(fmt.Sprint(value), color.New(color.FgCyan, color.Bold))
}
fmt.Fprintf(ui.Out, "%s\n", ui.TranslateText(template, firstTemplateValues))
} | |
c25912 | {
fmt.Fprintf(ui.Err, "%s\n\n", ui.TranslateText(template, templateValues...))
} | |
c25913 | "%s\n", ui.TranslateText(warning))
}
if len(warnings) > 0 {
fmt.Fprintln(ui.Err)
}
} | |
c25914 | ui.translate(template, getFirstSet(templateValues))
} | |
c25915 | input.Local().Format("Mon 02 Jan 15:04:05 MST 2006")
} | |
c25916 | = append(config.ConfigFile.PluginRepositories,
PluginRepository{Name: name, URL: url})
} | |
c25917 | columnWidth {
columnWidth = width
}
}
for _, change := range changeSet {
padding := columnWidth - wordSize(ui.TranslateText(change.Header)) + 3
err := ui.DisplayChangeForPush(change.Header, padding, change.HiddenValue, change.CurrentValue, change.NewValue)
if err != nil {
return err
}
}
return ni... | |
c25918 |
instance, warnings, err := actor.CloudControllerClient.CreateServiceInstance(spaceGUID, plan.GUID, serviceInstanceName, params, tags)
allWarnings = append(allWarnings, warnings...)
if err != nil {
return ServiceInstance{}, allWarnings, err
}
return ServiceInstance(instance), allWarnings, nil
} | |
c25919 | range rs {
formattedRoutes = append(formattedRoutes, route.String())
}
return strings.Join(formattedRoutes, ", ")
} | |
c25920 | Is TCP Domain
if r.Host != "" || r.Path != "" {
return actionerror.InvalidTCPRouteSettings{Domain: r.Domain.Name}
}
}
return nil
} | |
c25921 | && !randomPort {
return actionerror.TCPRouteOptionsNotProvidedError{}
}
return r.Validate()
} | |
c25922 | routeString = fmt.Sprintf("%s.%s", r.Host, routeString)
}
if r.Path != "" {
routeString = path.Join(routeString, r.Path)
}
return routeString
} | |
c25923 | nil, allWarnings, err
}
if len(apps) == 0 {
orphanedRoutes = append(orphanedRoutes, route)
}
}
if len(orphanedRoutes) == 0 {
return nil, allWarnings, actionerror.OrphanedRoutesNotFoundError{}
}
return orphanedRoutes, allWarnings, nil
} | |
c25924 | allWarnings = append(allWarnings, warnings...)
if err != nil {
return nil, allWarnings, err
}
routes, domainWarnings, err := actor.applyDomain(ccv2Routes)
return routes, append(allWarnings, domainWarnings...), err
} | |
c25925 | }
routes, domainWarnings, err := actor.applyDomain(ccv2Routes)
return routes, append(allWarnings, domainWarnings...), err
} | |
c25926 | actor.CloudControllerClient.DeleteSpaceUnmappedRoutes(spaceGUID)
return Warnings(warnings), err
} | |
c25927 | access.
if exists {
log.Errorf("unable to find route %s in current space", route.String())
return Route{}, append(Warnings(warnings), checkRouteWarnings...), actionerror.RouteInDifferentSpaceError{Route: route.String()}
}
log.Warnf("negative existence check for route %s - returning partial route", route.S... | |
c25928 | []string{fmt.Sprint(route.Port.Value)},
})
}
ccv2Routes, warnings, err := actor.CloudControllerClient.GetRoutes(queries...)
if err != nil {
return Route{}, Warnings(warnings), err
}
if len(ccv2Routes) == 0 {
return Route{}, Warnings(warnings), actionerror.RouteNotFoundError{
Host: route.Host,
... | |
c25929 | ccv3.Checksum{Value: r.SHA1},
SizeInBytes: r.Size,
}
} | |
c25930 |
Mode: r.Mode,
SHA1: r.Checksum.Value,
Size: r.SizeInBytes,
}
} | |
c25931 | }
defer fileReader.Close()
hash := sha1.New()
_, err = io.Copy(hash, fileReader)
if err != nil {
return nil, err
}
resource.Mode = DefaultArchiveFilePermissions
resource.SHA1 = fmt.Sprintf("%x", hash.Sum(nil))
resource.Size = archivedFile.FileInfo().Size()
}
resources = append(res... | |
c25932 | }
if relPath == "." {
return nil
}
resource := Resource{
Filename: filepath.ToSlash(relPath),
}
switch {
case info.IsDir():
// If the file is a directory
resource.Mode = DefaultFolderPermissions
case info.Mode()&os.ModeSymlink == os.ModeSymlink:
// If the file is a Symlink we just set t... | |
c25933 | application.State,
}
if application.Buildpack.IsSet {
ccApp.Buildpack = &application.Buildpack.Value
}
if application.Command.IsSet {
ccApp.Command = &application.Command.Value
}
if application.DiskQuota.IsSet {
ccApp.DiskQuota = &application.DiskQuota.Value
}
if application.DockerCreden... | |
c25934 |
response := cloudcontroller.Response{
DecodeJSONResponseInto: &updatedApp,
}
err = client.connection.Make(request, &response)
return updatedApp, response.Warnings, err
} | |
c25935 |
}
var app Application
response := cloudcontroller.Response{
DecodeJSONResponseInto: &app,
}
err = client.connection.Make(request, &response)
return app, response.Warnings, err
} | |
c25936 | := item.(Application); ok {
fullAppsList = append(fullAppsList, app)
} else {
return ccerror.UnknownObjectInListError{
Expected: Application{},
Unexpected: item,
}
}
return nil
})
return fullAppsList, warnings, err
} | |
c25937 |
}
var restagedApp Application
response := cloudcontroller.Response{
DecodeJSONResponseInto: &restagedApp,
}
err = client.connection.Make(request, &response)
return restagedApp, response.Warnings, err
} | |
c25938 | return app.Buildpacks
case len(buildpack) > 0:
return []string{buildpack}
default:
return nil
}
} | |
c25939 | == config.DesiredApplication.StackGUID {
v2App.StackGUID = ""
}
return v2App
} | |
c25940 | runtime.GOARCH,
runtime.GOOS,
)
client := Client{
userAgent: userAgent,
connection: NewConnection(config.SkipSSLValidation, config.DialTimeout),
}
return &client
} | |
c25941 | log.Errorln("Looking up applications:", err)
return nil, warnings, err
}
nameToApp := actor.generateAppNameToApplicationMapping(applications)
var updatedPushPlans []PushPlan
for _, pushPlan := range pushPlans {
app := nameToApp[pushPlan.Application.Name]
pushPlan.Application.GUID = app.GUID
pushPlan.App... | |
c25942 | {
return *pq.messages[i].Timestamp < *pq.messages[j].Timestamp
} | |
c25943 | List of PushPlanFuncs is defined in NewActor
for _, updatePlan := range actor.PushPlanFuncs {
var err error
plan, err = updatePlan(plan, overrides, manifestApplication)
if err != nil {
return nil, err
}
}
pushPlans = append(pushPlans, plan)
}
return pushPlans, nil
} | |
c25944 | URIParams: map[string]string{
"buildpack_guid": buildpackGUID,
},
})
if err != nil {
return "", nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return JobURL(response.ResourceLocationURL), response.Warnings, err
} | |
c25945 | unmatches []sharedaction.V3Resource
for _, resource := range resources {
if _, ok := mapChecksumToResource[resource.Checksum.Value]; !ok {
unmatches = append(unmatches, resource)
}
}
return matches, unmatches, Warnings(warnings), err
} | |
c25946 | if err != nil {
return err
}
user.GUID = ccUser.Metadata.GUID
return nil
} | |
c25947 | User
response := cloudcontroller.Response{
DecodeJSONResponseInto: &user,
}
err = client.connection.Make(request, &response)
if err != nil {
return User{}, response.Warnings, err
}
return user, response.Warnings, nil
} | |
c25948 | NewConnection(config.ConnectionConfig),
}
for _, wrapper := range config.Wrappers {
client.connection = wrapper.Wrap(client.connection)
}
return &client
} | |
c25949 |
var serviceInstanceSharedFrom ServiceInstanceSharedFrom
response := cloudcontroller.Response{
DecodeJSONResponseInto: &serviceInstanceSharedFrom,
}
err = client.connection.Make(request, &response)
return serviceInstanceSharedFrom, response.Warnings, err
} | |
c25950 | {
fullFeatureFlagList = append(fullFeatureFlagList, featureFlag)
} else {
return ccerror.UnknownObjectInListError{
Expected: FeatureFlag{},
Unexpected: item,
}
}
return nil
})
return fullFeatureFlagList, warnings, err
} | |
c25951 | translatableerror.ArgumentCombinationError{Args: []string{
"--disable-pseudo-tty", "-T", "--force-pseudo-tty", "--request-pseudo-tty", "-t",
}}
}
return option, nil
} | |
c25952 |
if quota.Name == quotaName {
return SpaceQuota(quota), Warnings(warnings), nil
}
}
return SpaceQuota{}, Warnings(warnings), actionerror.SpaceQuotaNotFoundByNameError{Name: quotaName}
} | |
c25953 | := actor.CloudControllerClient.SetSpaceQuota(spaceGUID, quotaGUID)
return Warnings(warnings), err
} | |
c25954 |
}
domain, warnings, err = actor.GetPrivateDomain(domainGUID)
allWarnings = append(allWarnings, warnings...)
switch err.(type) {
case nil:
return domain, allWarnings, nil
default:
return Domain{}, allWarnings, err
}
} | |
c25955 | {
domains = append(domains, Domain(domain))
actor.saveDomain(domain)
}
privateDomains, warnings, err := actor.CloudControllerClient.GetOrganizationPrivateDomains(
orgGUID,
ccv2.Filter{
Type: constant.NameFilter,
Operator: constant.InOperator,
Values: domainNames,
})
allWarnings = append(al... | |
c25956 |
if isResourceNotFoundError(err) {
return Domain{}, Warnings(warnings), actionerror.DomainNotFoundError{GUID: domainGUID}
}
actor.saveDomain(domain)
return Domain(domain), Warnings(warnings), err
} | |
c25957 |
}
domains, warnings, err = actor.CloudControllerClient.GetOrganizationPrivateDomains(orgGUID)
allWarnings = append(allWarnings, warnings...)
if err != nil {
return []Domain{}, allWarnings, err
}
for _, domain := range domains {
allDomains = append(allDomains, Domain(domain))
}
return allDomains, allWarn... | |
c25958 | time.Now().Add(-instance.Uptime)
} | |
c25959 |
pluginClient.WrapConnection(wrapper.NewRequestLogger(ui.RequestLoggerTerminalDisplay()))
}
if location != nil {
pluginClient.WrapConnection(wrapper.NewRequestLogger(ui.RequestLoggerFileWriter(location)))
}
pluginClient.WrapConnection(wrapper.NewRetryRequest(config.RequestRetryCount()))
return pluginClient
} | |
c25960 | info.UAALink(),
"authorization_endpoint": bootstrapURL,
}
client.router = internal.NewRouter(internal.APIRoutes, resources)
client.Info = info
client.config.SetUAAEndpoint(info.UAALink())
return nil
} | |
c25961 | cmd.RelatedCommands = relatedCommands
continue
}
if fieldTag.Get("description") != "" {
cmd.Flags = append(cmd.Flags, CommandFlag{
Short: fieldTag.Get("short"),
Long: fieldTag.Get("long"),
Description: fieldTag.Get("description"),
Default: fieldTag.Get("default"),
})
... | |
c25962 | = CommandInfo{
Name: commandName,
Description: fieldTag.Get("description"),
Alias: fieldTag.Get("alias"),
}
}
return infos
} | |
c25963 | err
}
r.FilePath = ccResource.FilePath
r.SizeInBytes = ccResource.SizeInBytes
r.Checksum = ccResource.Checksum
mode, err := strconv.ParseUint(ccResource.Mode, 8, 32)
if err != nil {
return err
}
r.Mode = os.FileMode(mode)
return nil
} | |
c25964 | "", nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return JobURL(response.ResourceLocationURL), response.Warnings, err
} | |
c25965 | map[string]string{"app_guid": appGUID},
Body: bytes.NewReader(rawManifest),
})
if err != nil {
return "", nil, err
}
request.Header.Set("Content-Type", "application/x-yaml")
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return JobURL(response.ResourceLoca... | |
c25966 |
rawTranslation, err := loadAssetFromResources(locale)
if err != nil {
rawTranslation, err = loadAssetFromResources(defaultLocale)
if err != nil {
return nil, err
}
}
return generateTranslationFunc(rawTranslation)
} | |
c25967 | allUsers = append(allUsers, User{
GUID: resource.Metadata.GUID,
CreatedAt: resource.Metadata.CreatedAt,
Username: resource.Entity.Username,
})
}
if userPagesResponse.NextURL == nil {
break
}
nextURL = *userPagesResponse.NextURL
}
return allUsers
} | |
c25968 | := err.(ccerror.UnknownHTTPSourceError); ok && unknownSourceErr.StatusCode == http.StatusNotFound {
return Info{}, nil, ccerror.APINotFoundError{URL: client.cloudControllerURL}
}
return rootResponse, response.Warnings, err
} | |
c25969 | || a.StackName != "" {
if a.hasAutodetectedBuildpack() {
ccApp.setAutodetectedBuildpackLifecycle(a)
} else {
ccApp.setBuildpackLifecycle(a)
}
}
}
return json.Marshal(ccApp)
} | |
c25970 |
var fullAppsList []Application
warnings, err := client.paginate(request, Application{}, func(item interface{}) error {
if app, ok := item.(Application); ok {
fullAppsList = append(fullAppsList, app)
} else {
return ccerror.UnknownObjectInListError{
Expected: Application{},
Unexpected: item,
}... | |
c25971 | var responseApp Application
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseApp,
}
err = client.connection.Make(request, &response)
return responseApp, response.Warnings, err
} | |
c25972 | nil, err
}
var responseApp Application
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseApp,
}
err = client.connection.Make(request, &response)
return responseApp, response.Warnings, err
} | |
c25973 | application.Buildpack.Value
}
return application.DetectedBuildpack.Value
} | |
c25974 | application.Command.Value
}
return application.DetectedStartCommand.Value
} | |
c25975 | return application.StagingFailedDescription
}
return application.StagingFailedReason
} | |
c25976 | warnings, err := actor.CloudControllerClient.CreateApplication(ccv2.Application(application))
return Application(app), Warnings(warnings), err
} | |
c25977 |
return Application{}, Warnings(warnings), actionerror.ApplicationNotFoundError{GUID: guid}
}
return Application(app), Warnings(warnings), err
} | |
c25978 |
if err != nil {
return Application{}, Warnings(warnings), err
}
if len(app) == 0 {
return Application{}, Warnings(warnings), actionerror.ApplicationNotFoundError{
Name: name,
}
}
return Application(app[0]), Warnings(warnings), nil
} | |
c25979 |
for _, app := range apps {
allApplications = append(allApplications, Application(app))
}
return allApplications, Warnings(warnings), nil
} | |
c25980 | string
if healthCheckType == constant.ApplicationHealthCheckHTTP {
healthCheckEndpoint = httpEndpoint
}
updatedApp, apiWarnings, err := actor.CloudControllerClient.UpdateApplication(ccv2.Application{
GUID: app.GUID,
HealthCheckType: healthCheckType,
HealthCheckHTTPEndpoint... | |
c25981 |
GUID: app.GUID,
State: constant.ApplicationStarted,
})
for _, warning := range warnings {
allWarnings <- warning
}
if err != nil {
errs <- err
return
}
actor.waitForApplicationStageAndStart(Application(updatedApp), client, appState, allWarnings, errs)
}()
return messages, logErrs, appS... | |
c25982 | app.GUID,
})
for _, warning := range warnings {
allWarnings <- warning
}
if err != nil {
errs <- err
return
}
actor.waitForApplicationStageAndStart(Application(restagedApp), client, appState, allWarnings, errs)
}()
return messages, logErrs, appState, allWarnings, errs
} | |
c25983 |
}
var routerGroups []RouterGroup
var response = Response{
Result: &routerGroups,
}
err = client.connection.Make(request, &response)
if err != nil {
return RouterGroup{}, err
}
for _, routerGroup := range routerGroups {
if routerGroup.Name == name {
return routerGroup, nil
}
}
return RouterGrou... | |
c25984 |
GUID string `json:"guid"`
} `json:"package"`
}
ccBuild.Package.GUID = b.PackageGUID
return json.Marshal(ccBuild)
} | |
c25985 | return err
}
b.GUID = ccBuild.GUID
b.CreatedAt = ccBuild.CreatedAt
b.Error = ccBuild.Error
b.PackageGUID = ccBuild.Package.GUID
b.State = ccBuild.State
b.DropletGUID = ccBuild.Droplet.GUID
return nil
} | |
c25986 | cloudcontroller.Response{
DecodeJSONResponseInto: &responseBuild,
}
err = client.connection.Make(request, &response)
return responseBuild, response.Warnings, err
} | |
c25987 |
var responseBuild Build
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseBuild,
}
err = client.connection.Make(request, &response)
return responseBuild, response.Warnings, err
} | |
c25988 | v3Warnings, apiErr := actor.CloudControllerClient.GetApplicationEnvironment(app.GUID)
warnings = append(warnings, v3Warnings...)
return EnvironmentVariableGroups(ccEnvGroups), warnings, apiErr
} | |
c25989 | apiErr := actor.CloudControllerClient.UpdateApplicationEnvironmentVariables(
app.GUID,
ccv3.EnvironmentVariables{
envPair.Key: {Value: envPair.Value, IsSet: true},
})
warnings = append(warnings, v3Warnings...)
return warnings, apiErr
} | |
c25990 | = append(warnings, getWarnings...)
if getErr != nil {
return warnings, getErr
}
if _, ok := envGroups.EnvironmentVariables[environmentVariableName]; !ok {
return warnings, actionerror.EnvironmentVariableNotSetError{EnvironmentVariableName: environmentVariableName}
}
_, patchWarnings, patchErr := actor.Cloud... | |
c25991 |
interactivePrompt := ui.Interactor.NewInteraction(ui.TranslateText(template, templateValues...))
interactivePrompt.SetIn(ui.In)
interactivePrompt.SetOut(ui.OutForInteration)
err := interactivePrompt.Resolve(&response)
if isInterrupt(err) {
ui.Exiter.Exit(sigIntExitCode)
}
return response, err
} | |
c25992 | interactivePrompt.SetIn(ui.In)
interactivePrompt.SetOut(ui.OutForInteration)
err := interactivePrompt.Resolve(interact.Required(&password))
if isInterrupt(err) {
ui.Exiter.Exit(sigIntExitCode)
}
return string(password), err
} | |
c25993 | err
}
if value == "enter to skip" {
return "", nil
}
i, err := strconv.Atoi(value)
if err != nil {
if contains(choices, value) {
return value, nil
}
return "", InvalidChoiceError{Choice: value}
}
if i > len(choices) || i <= 0 {
return "", ErrInvalidIndex
}
return choices[i-1], nil
} | |
c25994 |
err := interactivePrompt.Resolve(interact.Required(&value))
if isInterrupt(err) {
ui.Exiter.Exit(sigIntExitCode)
}
return value, err
} | |
c25995 | != nil {
return err
}
route.GUID = ccRoute.Metadata.GUID
route.Host = ccRoute.Entity.Host
route.Path = ccRoute.Entity.Path
route.Port = ccRoute.Entity.Port
route.DomainGUID = ccRoute.Entity.DomainGUID
route.SpaceGUID = ccRoute.Entity.SpaceGUID
return nil
} | |
c25996 | response cloudcontroller.Response
err = client.connection.Make(request, &response)
if _, ok := err.(ccerror.ResourceNotFoundError); ok {
return false, response.Warnings, nil
}
return response.HTTPResponse.StatusCode == http.StatusNoContent, response.Warnings, err
} | |
c25997 | },
})
if err != nil {
return nil, err
}
var response cloudcontroller.Response
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c25998 | nil, err
}
var response cloudcontroller.Response
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c25999 |
}
var route Route
response := cloudcontroller.Response{
DecodeJSONResponseInto: &route,
}
err = client.connection.Make(request, &response)
return route, response.Warnings, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.