id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c161700 |
err = ioutil.WriteFile(path, yamlData, 0600)
}
return err
} | |
c161701 |
err = unmarshalObject(data, obj)
}
return err
} | |
c161702 |
err = unmarshalObject(data, obj)
}
return err
} | |
c161703 | }()
data, err = ioutil.ReadAll(resp.Body)
}
return data, err
} | |
c161704 | append(formattedConditions, fmt.Sprintf("%s: %s", condition.Type, condition.Message))
}
return strings.Join(formattedConditions, ";")
} | |
c161705 | 0)
for i := 0; i < len(apps); i++ {
a := apps[i]
if _, ok := projectsMap[a.Spec.GetProject()]; ok {
items = append(items, a)
}
}
return items
} | |
c161706 | attempt < 5; attempt++ {
app, err := appIf.Patch(name, types.MergePatchType, patch)
if err != nil {
if !apierr.IsConflict(err) {
return nil, err
}
} else {
log.Infof("Requested app '%s' refresh", name)
return app, nil
}
time.Sleep(100 * time.Millisecond)
}
return nil, err
} | |
c161707 |
app, ok := next.Object.(*argoappv1.Application)
if !ok {
return nil, fmt.Errorf("Application event object failed conversion: %v", next)
}
annotations := app.GetAnnotations()
if annotations == nil {
annotations = make(map[string]string)
}
if _, ok := annotations[common.AnnotationKeyRefresh]; !ok {
... | |
c161708 | {
return projLister.AppProjects(ns).Get(spec.GetProject())
} | |
c161709 | }
// Verify the specified environment is defined in the app spec
if spec.Source.Ksonnet == nil {
return fmt.Errorf("Ksonnet environment not specified")
}
dest, err := ksonnet.Destination(getRes.Data, spec.Source.Ksonnet.Environment)
if err != nil {
return err
}
// If server and namespace are not supplied... | |
c161710 | }
if repoRes != nil {
req.Repo.Username = repoRes.Username
req.Repo.Password = repoRes.Password
req.Repo.SSHPrivateKey = repoRes.SSHPrivateKey
}
_, err := repoClient.GetFile(ctx, &req)
if err != nil {
conditions = append(conditions, argoappv1.ApplicationCondition{
Type: argoappv1.ApplicationCondition... | |
c161711 | req.Repo.SSHPrivateKey = repoRes.SSHPrivateKey
}
// Only check whether we can access the application's path,
// and not whether it actually contains any manifests.
_, err := repoClient.GenerateManifest(ctx, &req)
if err != nil {
conditions = append(conditions, argoappv1.ApplicationCondition{
Type: argoap... | |
c161712 | nil, status.Errorf(codes.InvalidArgument, "Operation unspecified")
}
if err == nil {
return a, nil
}
if !apierr.IsConflict(err) {
return nil, err
}
log.Warnf("Failed to set operation for app '%s' due to update conflict. Retrying again...", appName)
}
} | |
c161713 | {
if r.HasIdentity(name, gvk) {
return true
}
}
return false
} | |
c161714 | c.ns, name), &v1alpha1.AppProject{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.AppProject), err
} | |
c161715 | label = labels.Everything()
}
list := &v1alpha1.AppProjectList{ListMeta: obj.(*v1alpha1.AppProjectList).ListMeta}
for _, item := range obj.(*v1alpha1.AppProjectList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
} | |
c161716 | error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(appprojectsResource, c.ns, opts))
} | |
c161717 | Invokes(testing.NewDeleteAction(appprojectsResource, c.ns, name), &v1alpha1.AppProject{})
return err
} | |
c161718 | subresources...), &v1alpha1.AppProject{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.AppProject), err
} | |
c161719 |
reconcileHistogram := prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Name: "argocd_app_reconcile",
Help: "Application reconciliation performance.",
// Buckets chosen after observing a ~2100ms mean reconcile time
Buckets: []float64{0.25, .5, 1, 2, 4, 8, 16},
},
append(descAppDefaultLabels),
)... | |
c161720 | !state.Phase.Completed() {
return
}
m.syncCounter.WithLabelValues(app.Namespace, app.Name, app.Spec.GetProject(), string(state.Phase)).Inc()
} | |
c161721 | app.Name, app.Spec.GetProject(), strconv.Itoa(statusCode)).Inc()
} | |
c161722 | {
m.reconcileHistogram.WithLabelValues(app.Namespace, app.Name, app.Spec.GetProject()).Observe(duration.Seconds())
} | |
c161723 | prometheus.NewRegistry()
registry.MustRegister(NewAppCollector(appLister))
return registry
} | |
c161724 | err := parser.ParseUnverified(u.AuthToken, &claims)
if err != nil {
return nil, err
}
return &claims, nil
} | |
c161725 |
if os.IsNotExist(err) {
return nil, nil
}
err = ValidateLocalConfig(config)
if err != nil {
return nil, err
}
return &config, nil
} | |
c161726 | return err
}
return configUtil.MarshalLocalYAMLFile(configPath, config)
} | |
c161727 | return nil, err
}
return &Context{
Name: ctx.Name,
Server: *server,
User: *user,
}, nil
}
}
return nil, fmt.Errorf("Context '%s' undefined", name)
} | |
c161728 | "", err
}
return path.Join(usr.HomeDir, ".argocd"), nil
} | |
c161729 | "", err
}
return path.Join(dir, "config"), nil
} | |
c161730 | return x509.NewCertPool()
}
return rootCAs
} | |
c161731 | "CERTIFICATE", Bytes: certBytes})
keypem := pem.EncodeToMemory(pemBlockForKey(privateKey))
return certpem, keypem, nil
} | |
c161732 | if err != nil {
return nil, err
}
cert, err := tls.X509KeyPair(certpem, keypem)
if err != nil {
return nil, err
}
return &cert, nil
} | |
c161733 |
certpem = append(certpem, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certtmp})...)
}
keypem := pem.EncodeToMemory(pemBlockForKey(cert.PrivateKey))
return certpem, keypem
} | |
c161734 | := EncodeX509KeyPair(cert)
return string(certpem), string(keypem)
} | |
c161735 | errors.CheckError(err)
export(writer, *acdConfigMap)
acdRBACConfigMap, err := acdClients.configMaps.Get(common.ArgoCDRBACConfigMapName, metav1.GetOptions{})
errors.CheckError(err)
export(writer, *acdRBACConfigMap)
referencedSecrets := getReferencedSecrets(*acdConfigMap)
secrets, err := acdClients.se... | |
c161736 | nil {
referencedSecrets[cred.CASecret.Name] = true
}
if cred.CertSecret != nil {
referencedSecrets[cred.CertSecret.Name] = true
}
if cred.KeySecret != nil {
referencedSecrets[cred.KeySecret.Name] = true
}
if cred.UsernameSecret != nil {
referencedSecrets[cred.UsernameSecret.Name] = tr... | |
c161737 |
un.SetLabels(labels)
un.SetAnnotations(annotations)
data, err := yaml.Marshal(un.Object)
errors.CheckError(err)
_, err = w.Write(data)
errors.CheckError(err)
_, err = w.Write([]byte(yamlSeparator))
errors.CheckError(err)
} | |
c161738 | := db.NewDB(namespace, settings.NewSettingsManager(context.Background(), kubeclientset, namespace), kubeclientset).GetCluster(context.Background(), serverUrl)
errors.CheckError(err)
err = kube.WriteKubeConfig(cluster.RESTConfig(), namespace, output)
errors.CheckError(err)
},
}
clientConfig = cli.AddKubect... | |
c161739 | return &Server{
ns: namespace,
appclientset: appclientset,
kubeclientset: kubeclientset,
cache: cache,
db: db,
repoClientset: repoClientset,
kubectl: kubectl,
enf: enf,
projectLock: projectLock,
auditLogger: argo.NewAuditLogger(namespace, kubeclien... | |
c161740 | app.Spec.GetProject(), app.Name)
} | |
c161741 | newItems = append(newItems, a)
}
}
newItems = argoutil.FilterByProjects(newItems, q.Projects)
for i := range newItems {
app := newItems[i]
newItems[i] = app
}
appList.Items = newItems
return appList, nil
} | |
c161742 | spec
existing, getErr := s.appclientset.ArgoprojV1alpha1().Applications(s.ns).Get(a.Name, metav1.GetOptions{})
if getErr != nil {
return nil, status.Errorf(codes.Internal, "unable to check existing application details: %v", getErr)
}
if q.Upsert != nil && *q.Upsert {
if err := s.enf.EnforceErr(ctx.Value(... | |
c161743 | q.Revision != "" {
revision = q.Revision
}
settings, err := s.settingsMgr.GetSettings()
if err != nil {
return nil, err
}
helmRepos, err := s.db.ListHelmRepos(ctx)
if err != nil {
return nil, err
}
tools := make([]*appv1.ConfigManagementPlugin, len(settings.ConfigManagementPlugins))
for i := range setti... | |
c161744 | appv1.RefreshTypeHard
}
_, err = argoutil.RefreshApp(appIf, *q.Name, refreshType)
if err != nil {
return nil, err
}
a, err = argoutil.WaitForRefresh(ctx, appIf, *q.Name, nil)
if err != nil {
return nil, err
}
}
return a, nil
} | |
c161745 |
config, _, err = s.getApplicationClusterConfig(*q.Name)
if err != nil {
return nil, err
}
kubeClientset, err = kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
fieldSelector = fields.SelectorFromSet(map[string]string{
"involvedObject.name": q.ResourceName,
"involvedObjec... | |
c161746 |
if err != nil {
return nil, err
}
out, err := s.appclientset.ArgoprojV1alpha1().Applications(s.ns).Update(a)
if err == nil {
s.logEvent(a, ctx, argo.EventReasonResourceUpdated, "updated application")
}
return out, err
} | |
c161747 |
a.Spec = q.Spec
err = s.validateAndNormalizeApp(ctx, a)
if err != nil {
return nil, err
}
normalizedSpec := a.Spec.DeepCopy()
for i := 0; i < 10; i++ {
a.Spec = *normalizedSpec
_, err = s.appclientset.ArgoprojV1alpha1().Applications(s.ns).Update(a)
if err == nil {
s.logEvent(a, ctx, argo.EventReasonR... | |
c161748 | := patch.Apply(jsonApp)
if err != nil {
return nil, err
}
s.logEvent(app, ctx, argo.EventReasonResourceUpdated, fmt.Sprintf("patched application %s/%s", app.Namespace, app.Name))
err = json.Unmarshal(patchApp, &app)
if err != nil {
return nil, err
}
err = s.validateAndNormalizeApp(ctx, app)
if err != ni... | |
c161749 | an app created prior to v0.6)
patch, err := json.Marshal(map[string]interface{}{
"metadata": map[string]interface{}{
"finalizers": a.Finalizers,
},
})
if err != nil {
return nil, err
}
_, err = s.appclientset.ArgoprojV1alpha1().Applications(a.Namespace).Patch(a.Name, types.MergePatchType, patch)... | |
c161750 | return nil, err
}
err = replaceSecretValues(manifest)
if err != nil {
return nil, err
}
data, err := json.Marshal(manifest.Object)
if err != nil {
return nil, err
}
s.logEvent(a, ctx, argo.EventReasonResourceUpdated, fmt.Sprintf("patched resource %s/%s '%s'", q.Group, q.Kind, q.ResourceName))
return &Appl... | |
c161751 | force bool
if q.Force != nil {
force = *q.Force
}
err = s.kubectl.DeleteResource(config, res.GroupKindVersion(), res.Name, res.Namespace, force)
if err != nil {
return nil, err
}
s.logEvent(a, ctx, argo.EventReasonResourceDeleted, fmt.Sprintf("deleted resource %s/%s '%s'", q.Group, q.Kind, q.ResourceName))
... | |
c161752 | syncReq.Revision != a.Spec.Source.TargetRevision {
return nil, status.Errorf(codes.FailedPrecondition, "Cannot sync to %s: auto-sync currently set to %s", syncReq.Revision, a.Spec.Source.TargetRevision)
}
}
commitSHA, displayRevision, err := s.resolveRevision(ctx, a, syncReq)
if err != nil {
return nil, sta... | |
c161753 | }
gitClient, err := s.gitFactory.NewClient(repo.Repo, "", repo.Username, repo.Password, repo.SSHPrivateKey, repo.InsecureIgnoreHostKey)
if err != nil {
return "", "", err
}
commitSHA, err := gitClient.LsRemote(ambiguousRevision)
if err != nil {
return "", "", err
}
displayRevision := fmt.Sprintf("%s (%s)", ... | |
c161754 | newObj[k] = replaceListSecrets(val, secretValues)
case string:
newObj[k] = settings.ReplaceStringSecret(val, secretValues)
default:
newObj[k] = val
}
}
return newObj
} | |
c161755 | ClusterResourceWhitelist: []metav1.GroupKind{{Group: "*", Kind: "*"}},
},
}
_, err := opts.AppClientset.ArgoprojV1alpha1().AppProjects(opts.Namespace).Create(defaultProj)
if apierrors.IsAlreadyExists(err) {
return nil
}
return err
} | |
c161756 |
errors.CheckError(err)
enf.EnableLog(os.Getenv(common.EnvVarRBACDebug) == "1")
policyEnf := rbacpolicy.NewRBACPolicyEnforcer(enf, projLister)
enf.SetClaimsEnforcerFunc(policyEnf.EnforceClaims)
return &ArgoCDServer{
ArgoCDServerOpts: opts,
log: log.NewEntry(log.StandardLogger()),
settings: ... | |
c161757 |
stopCh := a.stopCh
a.stopCh = nil
if stopCh != nil {
close(stopCh)
}
} | |
c161758 | log.Infof("github secret modified. restarting")
break
}
if prevGitLabSecret != a.settings.WebhookGitLabSecret {
log.Infof("gitlab secret modified. restarting")
break
}
if prevBitBucketUUID != a.settings.WebhookBitbucketUUID {
log.Infof("bitbucket uuid modified. restarting")
break
}
var new... | |
c161759 |
}
cookie, err := httputil.MakeCookieMetadata(common.AuthCookieName, sessionResp.Token, flags...)
if err != nil {
return err
}
w.Header().Set("Set-Cookie", cookie)
}
return nil
} | |
c161760 |
a.ssoClientApp, err = oidc.NewClientApp(a.settings, a.Cache, a.DexServerAddr)
errors.CheckError(err)
mux.HandleFunc(common.LoginEndpoint, a.ssoClientApp.HandleLogin)
mux.HandleFunc(common.CallbackEndpoint, a.ssoClientApp.HandleCallback)
} | |
c161761 | > 0 {
target += "?" + req.URL.RawQuery
}
http.Redirect(w, req, target, http.StatusTemporaryRedirect)
}),
}
} | |
c161762 | fmt.Sprintf("0.0.0.0:%d", common.PortArgoCDAPIServerMetrics),
Handler: mux,
}
} | |
c161763 | for k, v := range noCacheHeaders {
w.Header().Set(k, v)
}
indexHtmlPath, err := indexFilePath(path.Join(dir, "index.html"), baseHRef)
if err != nil {
http.Error(w, fmt.Sprintf("Unable to access index.html: %v", err), http.StatusInternalServerError)
return
}
http.ServeFile(w, r, indexHtmlPath... | |
c161764 | endpoint string, opts []grpc.DialOption) {
err := register(ctx, mux, endpoint, opts)
if err != nil {
panic(err)
}
} | |
c161765 | a.sessionMgr.VerifyToken(tokenString)
if err != nil {
return ctx, status.Errorf(codes.Unauthenticated, "invalid session: %v", err)
}
// Add claims to the context to inspect for RBAC
ctx = context.WithValue(ctx, "claims", claims)
return ctx, nil
} | |
c161766 | request := http.Request{Header: header}
token, err := request.Cookie(common.AuthCookieName)
if err == nil {
return token.Value
}
}
return ""
} | |
c161767 | maxLength {
return "", fmt.Errorf("invalid cookie, longer than max length %v", maxLength)
}
return header, nil
} | |
c161768 | %v", err)
}
envSpec, ok := appSpec.Environments[environment]
if !ok {
return nil, fmt.Errorf("environment '%s' does not exist in ksonnet app", environment)
}
return &envSpec.Destination, nil
} | |
c161769 | != 2 {
return "", fmt.Errorf("unexpected version string format: %s", ksonnetVersionStr)
}
return strings.TrimSpace(parts[1]), nil
} | |
c161770 | _, err := ksApp.appYamlPath(); err != nil {
return nil, err
}
return &ksApp, nil
} | |
c161771 |
return nil, fmt.Errorf("`ks show` failed: %v", err)
}
return kube.SplitYAML(out)
} | |
c161772 | if err != nil {
return nil, err
}
data, err := ioutil.ReadFile(p)
if err != nil {
return nil, err
}
return Destination(data, environment)
} | |
c161773 | {
Data []struct {
Component string `json:"component"`
Key string `json:"param"`
Value string `json:"value"`
} `json:"data"`
}
if err := json.Unmarshal([]byte(out), &ksParams); err != nil {
return nil, err
}
var params []*v1alpha1.KsonnetParameter
for _, ksParam := range ksParams.Data {
... | |
c161774 | k.ksCmd("param", "set", component, param, value, "--env", environment)
return err
} | |
c161775 | err = yaml.Unmarshal([]byte(argoCDSettings.DexConfig), &cfg)
if err == nil {
set.DexConfig = &cfg
}
}
if oidcConfig := argoCDSettings.OIDCConfig(); oidcConfig != nil {
set.OIDCConfig = &OIDCConfig{
Name: oidcConfig.Name,
Issuer: oidcConfig.Issuer,
ClientID: oidcConfig.ClientID,
CL... | |
c161776 | (context.Context, error) {
return ctx, nil
} | |
c161777 |
return json.NewDecoder(r)
} | |
c161778 |
return json.NewEncoder(w)
} | |
c161779 |
return json.Unmarshal(data, v)
} | |
c161780 | {
continue
}
if v2 != nil {
v2 = removeFields(v1, v2)
}
result[k] = v2
}
return result
} | |
c161781 | err := json.Marshal(v)
if err != nil {
panic(err)
}
return bytes
} | |
c161782 |
return NewFilteredApplicationInformer(client, namespace, resyncPeriod, indexers, nil)
} | |
c161783 | WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.ArgoprojV1alpha1().Applications(namespace).Watch(options)
},
},
&applicationv1alpha1.Application{},
resyncPeriod,
indexers,
)
} | |
c161784 | settingsMgr,
ns: namespace,
kubeclientset: kubeclientset,
}
} | |
c161785 | return s[0 : len(s)-len(suffix)]
}
return s
} | |
c161786 | strings.HasPrefix(url, "ssh://")
} | |
c161787 |
return NewFilteredAppProjectInformer(client, namespace, resyncPeriod, indexers, nil)
} | |
c161788 |
return RegisterVersionServiceHandlerClient(ctx, mux, NewVersionServiceClient(conn))
} | |
c161789 | make([]*appv1.HelmRepository, len(s.HelmRepositories))
for i, helmRepoInfo := range s.HelmRepositories {
repo, err := db.getHelmRepo(ctx, helmRepoInfo.URL, s)
if err != nil {
return nil, err
}
repos[i] = repo
}
return repos, nil
} | |
c161790 |
return RegisterProjectServiceHandlerClient(ctx, mux, NewProjectServiceClient(conn))
} | |
c161791 |
info := &apiMeta{namespaced: api.Meta.Namespaced, watchCancel: cancel}
c.apisMeta[api.GroupKind] = info
go c.watchEvents(ctx, api, info)
}
}
return nil
} | |
c161792 | *Server {
return &Server{
db: db,
enf: enf,
cache: cache,
}
} | |
c161793 | clusters := clustersByServer[servers[i]]
clust := clusters[0]
warningMessage := ""
if len(clusters) > 1 {
warningMessage = fmt.Sprintf("There are %d credentials configured this cluster.", len(clusters))
}
if clust.ConnectionState.Status == "" {
clust.ConnectionState = s.getConnectionState(ctx, clust, ... | |
c161794 | return nil, err
}
clust, err := s.db.GetCluster(ctx, q.Server)
return redact(clust), err
} | |
c161795 | q.Cluster.Server); err != nil {
return nil, err
}
err := kube.TestConfig(q.Cluster.RESTConfig())
if err != nil {
return nil, err
}
clust, err := s.db.UpdateCluster(ctx, q.Cluster)
return redact(clust), err
} | |
c161796 | }
unstructured.RemoveNestedField(r.Object, "status")
unstructured.RemoveNestedField(r.Object, "metadata", "creationTimestamp")
jsonBytes, err = json.MarshalIndent(r.Object, "", " ")
if err != nil {
log.Fatal(err)
}
yamlBytes, err := yaml.JSONToYAML(jsonBytes)
if err != nil {
log.Fatal(err)
}
err = io... | |
c161797 | return nil, errors.New("Argo CD server address unspecified")
}
if parts := strings.Split(c.ServerAddr, ":"); len(parts) == 1 {
// If port is unspecified, assume the most likely port
c.ServerAddr += ":443"
}
// Override auth-token if specified in env variable or CLI flag
if authFromEnv := os.Getenv(EnvArgoCDAu... | |
c161798 | } else {
return nil, nil, fmt.Errorf("%s is not configured with SSO", c.ServerAddr)
}
provider, err := oidc.NewProvider(ctx, issuerURL)
if err != nil {
return nil, nil, fmt.Errorf("Failed to query provider %q: %v", issuerURL, err)
}
oauth2conf := oauth2.Config{
ClientID: clientID,
Scopes: clientScopes,
... | |
c161799 | Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
},
}, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.