id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
161,800 | argoproj/argo-cd | pkg/apiclient/apiclient.go | redeemRefreshToken | func (c *client) redeemRefreshToken() (string, string, error) {
setConn, setIf, err := c.NewSettingsClient()
if err != nil {
return "", "", err
}
defer func() { _ = setConn.Close() }()
httpClient, err := c.HTTPClient()
if err != nil {
return "", "", err
}
ctx := oidc.ClientContext(context.Background(), httpClient)
acdSet, err := setIf.Get(ctx, &settings.SettingsQuery{})
if err != nil {
return "", "", err
}
oauth2conf, _, err := c.OIDCConfig(ctx, acdSet)
if err != nil {
return "", "", err
}
t := &oauth2.Token{
RefreshToken: c.RefreshToken,
}
token, err := oauth2conf.TokenSource(ctx, t).Token()
if err != nil {
return "", "", err
}
rawIDToken, ok := token.Extra("id_token").(string)
if !ok {
return "", "", errors.New("no id_token in token response")
}
refreshToken, _ := token.Extra("refresh_token").(string)
return rawIDToken, refreshToken, nil
} | go | func (c *client) redeemRefreshToken() (string, string, error) {
setConn, setIf, err := c.NewSettingsClient()
if err != nil {
return "", "", err
}
defer func() { _ = setConn.Close() }()
httpClient, err := c.HTTPClient()
if err != nil {
return "", "", err
}
ctx := oidc.ClientContext(context.Background(), httpClient)
acdSet, err := setIf.Get(ctx, &settings.SettingsQuery{})
if err != nil {
return "", "", err
}
oauth2conf, _, err := c.OIDCConfig(ctx, acdSet)
if err != nil {
return "", "", err
}
t := &oauth2.Token{
RefreshToken: c.RefreshToken,
}
token, err := oauth2conf.TokenSource(ctx, t).Token()
if err != nil {
return "", "", err
}
rawIDToken, ok := token.Extra("id_token").(string)
if !ok {
return "", "", errors.New("no id_token in token response")
}
refreshToken, _ := token.Extra("refresh_token").(string)
return rawIDToken, refreshToken, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"redeemRefreshToken",
"(",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"setConn",
",",
"setIf",
",",
"err",
":=",
"c",
".",
"NewSettingsClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"re... | // redeemRefreshToken performs the exchange of a refresh_token for a new id_token and refresh_token | [
"redeemRefreshToken",
"performs",
"the",
"exchange",
"of",
"a",
"refresh_token",
"for",
"a",
"new",
"id_token",
"and",
"refresh_token"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apiclient/apiclient.go#L288-L320 |
161,801 | argoproj/argo-cd | pkg/apiclient/apiclient.go | NewClientOrDie | func NewClientOrDie(opts *ClientOptions) Client {
client, err := NewClient(opts)
if err != nil {
log.Fatal(err)
}
return client
} | go | func NewClientOrDie(opts *ClientOptions) Client {
client, err := NewClient(opts)
if err != nil {
log.Fatal(err)
}
return client
} | [
"func",
"NewClientOrDie",
"(",
"opts",
"*",
"ClientOptions",
")",
"Client",
"{",
"client",
",",
"err",
":=",
"NewClient",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"client"... | // NewClientOrDie creates a new API client from a set of config options, or fails fatally if the new client creation fails. | [
"NewClientOrDie",
"creates",
"a",
"new",
"API",
"client",
"from",
"a",
"set",
"of",
"config",
"options",
"or",
"fails",
"fatally",
"if",
"the",
"new",
"client",
"creation",
"fails",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apiclient/apiclient.go#L323-L329 |
161,802 | argoproj/argo-cd | pkg/apiclient/apiclient.go | WatchApplicationWithRetry | func (c *client) WatchApplicationWithRetry(ctx context.Context, appName string) chan *argoappv1.ApplicationWatchEvent {
appEventsCh := make(chan *argoappv1.ApplicationWatchEvent)
cancelled := false
go func() {
defer close(appEventsCh)
for !cancelled {
conn, appIf, err := c.NewApplicationClient()
if err == nil {
var wc application.ApplicationService_WatchClient
wc, err = appIf.Watch(ctx, &application.ApplicationQuery{Name: &appName})
if err == nil {
for {
var appEvent *v1alpha1.ApplicationWatchEvent
appEvent, err = wc.Recv()
if err != nil {
break
}
appEventsCh <- appEvent
}
}
}
if err != nil {
if isCanceledContextErr(err) {
cancelled = true
} else {
if err != io.EOF {
log.Warnf("watch err: %v", err)
}
time.Sleep(1 * time.Second)
}
}
if conn != nil {
_ = conn.Close()
}
}
}()
return appEventsCh
} | go | func (c *client) WatchApplicationWithRetry(ctx context.Context, appName string) chan *argoappv1.ApplicationWatchEvent {
appEventsCh := make(chan *argoappv1.ApplicationWatchEvent)
cancelled := false
go func() {
defer close(appEventsCh)
for !cancelled {
conn, appIf, err := c.NewApplicationClient()
if err == nil {
var wc application.ApplicationService_WatchClient
wc, err = appIf.Watch(ctx, &application.ApplicationQuery{Name: &appName})
if err == nil {
for {
var appEvent *v1alpha1.ApplicationWatchEvent
appEvent, err = wc.Recv()
if err != nil {
break
}
appEventsCh <- appEvent
}
}
}
if err != nil {
if isCanceledContextErr(err) {
cancelled = true
} else {
if err != io.EOF {
log.Warnf("watch err: %v", err)
}
time.Sleep(1 * time.Second)
}
}
if conn != nil {
_ = conn.Close()
}
}
}()
return appEventsCh
} | [
"func",
"(",
"c",
"*",
"client",
")",
"WatchApplicationWithRetry",
"(",
"ctx",
"context",
".",
"Context",
",",
"appName",
"string",
")",
"chan",
"*",
"argoappv1",
".",
"ApplicationWatchEvent",
"{",
"appEventsCh",
":=",
"make",
"(",
"chan",
"*",
"argoappv1",
... | // WatchApplicationWithRetry returns a channel of watch events for an application, retrying the
// watch upon errors. Closes the returned channel when the context is cancelled. | [
"WatchApplicationWithRetry",
"returns",
"a",
"channel",
"of",
"watch",
"events",
"for",
"an",
"application",
"retrying",
"the",
"watch",
"upon",
"errors",
".",
"Closes",
"the",
"returned",
"channel",
"when",
"the",
"context",
"is",
"cancelled",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apiclient/apiclient.go#L555-L592 |
161,803 | argoproj/argo-cd | controller/metrics/transportwrapper.go | AddMetricsTransportWrapper | func AddMetricsTransportWrapper(server *MetricsServer, app *v1alpha1.Application, config *rest.Config) *rest.Config {
wrap := config.WrapTransport
config.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
if wrap != nil {
rt = wrap(rt)
}
return &metricsRoundTripper{roundTripper: rt, metricsServer: server, app: app}
}
return config
} | go | func AddMetricsTransportWrapper(server *MetricsServer, app *v1alpha1.Application, config *rest.Config) *rest.Config {
wrap := config.WrapTransport
config.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
if wrap != nil {
rt = wrap(rt)
}
return &metricsRoundTripper{roundTripper: rt, metricsServer: server, app: app}
}
return config
} | [
"func",
"AddMetricsTransportWrapper",
"(",
"server",
"*",
"MetricsServer",
",",
"app",
"*",
"v1alpha1",
".",
"Application",
",",
"config",
"*",
"rest",
".",
"Config",
")",
"*",
"rest",
".",
"Config",
"{",
"wrap",
":=",
"config",
".",
"WrapTransport",
"\n",
... | // AddMetricsTransportWrapper adds a transport wrapper which increments 'argocd_app_k8s_request_total' counter on each kubernetes request | [
"AddMetricsTransportWrapper",
"adds",
"a",
"transport",
"wrapper",
"which",
"increments",
"argocd_app_k8s_request_total",
"counter",
"on",
"each",
"kubernetes",
"request"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/controller/metrics/transportwrapper.go#L28-L37 |
161,804 | argoproj/argo-cd | util/kube/kube.go | ToUnstructured | func ToUnstructured(obj interface{}) (*unstructured.Unstructured, error) {
uObj, err := runtime.NewTestUnstructuredConverter(equality.Semantic).ToUnstructured(obj)
if err != nil {
return nil, err
}
return &unstructured.Unstructured{Object: uObj}, nil
} | go | func ToUnstructured(obj interface{}) (*unstructured.Unstructured, error) {
uObj, err := runtime.NewTestUnstructuredConverter(equality.Semantic).ToUnstructured(obj)
if err != nil {
return nil, err
}
return &unstructured.Unstructured{Object: uObj}, nil
} | [
"func",
"ToUnstructured",
"(",
"obj",
"interface",
"{",
"}",
")",
"(",
"*",
"unstructured",
".",
"Unstructured",
",",
"error",
")",
"{",
"uObj",
",",
"err",
":=",
"runtime",
".",
"NewTestUnstructuredConverter",
"(",
"equality",
".",
"Semantic",
")",
".",
"... | // ToUnstructured converts a concrete K8s API type to a un unstructured object | [
"ToUnstructured",
"converts",
"a",
"concrete",
"K8s",
"API",
"type",
"to",
"a",
"un",
"unstructured",
"object"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L118-L124 |
161,805 | argoproj/argo-cd | util/kube/kube.go | MustToUnstructured | func MustToUnstructured(obj interface{}) *unstructured.Unstructured {
uObj, err := ToUnstructured(obj)
if err != nil {
panic(err)
}
return uObj
} | go | func MustToUnstructured(obj interface{}) *unstructured.Unstructured {
uObj, err := ToUnstructured(obj)
if err != nil {
panic(err)
}
return uObj
} | [
"func",
"MustToUnstructured",
"(",
"obj",
"interface",
"{",
"}",
")",
"*",
"unstructured",
".",
"Unstructured",
"{",
"uObj",
",",
"err",
":=",
"ToUnstructured",
"(",
"obj",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
... | // MustToUnstructured converts a concrete K8s API type to a un unstructured object and panics if not successful | [
"MustToUnstructured",
"converts",
"a",
"concrete",
"K8s",
"API",
"type",
"to",
"a",
"un",
"unstructured",
"object",
"and",
"panics",
"if",
"not",
"successful"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L127-L133 |
161,806 | argoproj/argo-cd | util/kube/kube.go | GetAppInstanceLabel | func GetAppInstanceLabel(un *unstructured.Unstructured, key string) string {
if labels := un.GetLabels(); labels != nil {
return labels[key]
}
return ""
} | go | func GetAppInstanceLabel(un *unstructured.Unstructured, key string) string {
if labels := un.GetLabels(); labels != nil {
return labels[key]
}
return ""
} | [
"func",
"GetAppInstanceLabel",
"(",
"un",
"*",
"unstructured",
".",
"Unstructured",
",",
"key",
"string",
")",
"string",
"{",
"if",
"labels",
":=",
"un",
".",
"GetLabels",
"(",
")",
";",
"labels",
"!=",
"nil",
"{",
"return",
"labels",
"[",
"key",
"]",
... | // GetAppInstanceLabel returns the application instance name from labels | [
"GetAppInstanceLabel",
"returns",
"the",
"application",
"instance",
"name",
"from",
"labels"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L136-L141 |
161,807 | argoproj/argo-cd | util/kube/kube.go | UnsetLabel | func UnsetLabel(target *unstructured.Unstructured, key string) {
if labels := target.GetLabels(); labels != nil {
if _, ok := labels[key]; ok {
delete(labels, key)
if len(labels) == 0 {
unstructured.RemoveNestedField(target.Object, "metadata", "labels")
} else {
target.SetLabels(labels)
}
}
}
} | go | func UnsetLabel(target *unstructured.Unstructured, key string) {
if labels := target.GetLabels(); labels != nil {
if _, ok := labels[key]; ok {
delete(labels, key)
if len(labels) == 0 {
unstructured.RemoveNestedField(target.Object, "metadata", "labels")
} else {
target.SetLabels(labels)
}
}
}
} | [
"func",
"UnsetLabel",
"(",
"target",
"*",
"unstructured",
".",
"Unstructured",
",",
"key",
"string",
")",
"{",
"if",
"labels",
":=",
"target",
".",
"GetLabels",
"(",
")",
";",
"labels",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"labels",
"[",
"ke... | // UnsetLabel removes our app labels from an unstructured object | [
"UnsetLabel",
"removes",
"our",
"app",
"labels",
"from",
"an",
"unstructured",
"object"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L144-L155 |
161,808 | argoproj/argo-cd | util/kube/kube.go | cleanKubectlOutput | func cleanKubectlOutput(s string) string {
s = strings.TrimSpace(s)
s = strings.Replace(s, ": error validating \"STDIN\"", "", -1)
s = strings.Replace(s, ": unable to recognize \"STDIN\"", "", -1)
s = strings.Replace(s, ": error when creating \"STDIN\"", "", -1)
s = strings.Replace(s, "; if you choose to ignore these errors, turn validation off with --validate=false", "", -1)
s = strings.Replace(s, "error: error", "error", -1)
return s
} | go | func cleanKubectlOutput(s string) string {
s = strings.TrimSpace(s)
s = strings.Replace(s, ": error validating \"STDIN\"", "", -1)
s = strings.Replace(s, ": unable to recognize \"STDIN\"", "", -1)
s = strings.Replace(s, ": error when creating \"STDIN\"", "", -1)
s = strings.Replace(s, "; if you choose to ignore these errors, turn validation off with --validate=false", "", -1)
s = strings.Replace(s, "error: error", "error", -1)
return s
} | [
"func",
"cleanKubectlOutput",
"(",
"s",
"string",
")",
"string",
"{",
"s",
"=",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
"\n",
"s",
"=",
"strings",
".",
"Replace",
"(",
"s",
",",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",... | // cleanKubectlOutput makes the error output of kubectl a little better to read | [
"cleanKubectlOutput",
"makes",
"the",
"error",
"output",
"of",
"kubectl",
"a",
"little",
"better",
"to",
"read"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L270-L278 |
161,809 | argoproj/argo-cd | util/kube/kube.go | WriteKubeConfig | func WriteKubeConfig(restConfig *rest.Config, namespace, filename string) error {
kubeConfig := NewKubeConfig(restConfig, namespace)
return clientcmd.WriteToFile(*kubeConfig, filename)
} | go | func WriteKubeConfig(restConfig *rest.Config, namespace, filename string) error {
kubeConfig := NewKubeConfig(restConfig, namespace)
return clientcmd.WriteToFile(*kubeConfig, filename)
} | [
"func",
"WriteKubeConfig",
"(",
"restConfig",
"*",
"rest",
".",
"Config",
",",
"namespace",
",",
"filename",
"string",
")",
"error",
"{",
"kubeConfig",
":=",
"NewKubeConfig",
"(",
"restConfig",
",",
"namespace",
")",
"\n",
"return",
"clientcmd",
".",
"WriteToF... | // WriteKubeConfig takes a rest.Config and writes it as a kubeconfig at the specified path | [
"WriteKubeConfig",
"takes",
"a",
"rest",
".",
"Config",
"and",
"writes",
"it",
"as",
"a",
"kubeconfig",
"at",
"the",
"specified",
"path"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L281-L284 |
161,810 | argoproj/argo-cd | util/kube/kube.go | newAuthInfo | func newAuthInfo(restConfig *rest.Config) *clientcmdapi.AuthInfo {
authInfo := clientcmdapi.AuthInfo{}
haveCredentials := false
if restConfig.TLSClientConfig.CertFile != "" {
authInfo.ClientCertificate = restConfig.TLSClientConfig.CertFile
haveCredentials = true
}
if len(restConfig.TLSClientConfig.CertData) > 0 {
authInfo.ClientCertificateData = restConfig.TLSClientConfig.CertData
haveCredentials = true
}
if restConfig.TLSClientConfig.KeyFile != "" {
authInfo.ClientKey = restConfig.TLSClientConfig.KeyFile
haveCredentials = true
}
if len(restConfig.TLSClientConfig.KeyData) > 0 {
authInfo.ClientKeyData = restConfig.TLSClientConfig.KeyData
haveCredentials = true
}
if restConfig.Username != "" {
authInfo.Username = restConfig.Username
haveCredentials = true
}
if restConfig.Password != "" {
authInfo.Password = restConfig.Password
haveCredentials = true
}
if restConfig.BearerToken != "" {
authInfo.Token = restConfig.BearerToken
haveCredentials = true
}
if restConfig.ExecProvider != nil {
authInfo.Exec = restConfig.ExecProvider
haveCredentials = true
}
if restConfig.ExecProvider == nil && !haveCredentials {
// If no credentials were set (or there was no exec provider), we assume in-cluster config.
// In-cluster configs from the go-client will no longer set bearer tokens, so we set the
// well known token path. See issue #774
authInfo.TokenFile = "/var/run/secrets/kubernetes.io/serviceaccount/token"
}
return &authInfo
} | go | func newAuthInfo(restConfig *rest.Config) *clientcmdapi.AuthInfo {
authInfo := clientcmdapi.AuthInfo{}
haveCredentials := false
if restConfig.TLSClientConfig.CertFile != "" {
authInfo.ClientCertificate = restConfig.TLSClientConfig.CertFile
haveCredentials = true
}
if len(restConfig.TLSClientConfig.CertData) > 0 {
authInfo.ClientCertificateData = restConfig.TLSClientConfig.CertData
haveCredentials = true
}
if restConfig.TLSClientConfig.KeyFile != "" {
authInfo.ClientKey = restConfig.TLSClientConfig.KeyFile
haveCredentials = true
}
if len(restConfig.TLSClientConfig.KeyData) > 0 {
authInfo.ClientKeyData = restConfig.TLSClientConfig.KeyData
haveCredentials = true
}
if restConfig.Username != "" {
authInfo.Username = restConfig.Username
haveCredentials = true
}
if restConfig.Password != "" {
authInfo.Password = restConfig.Password
haveCredentials = true
}
if restConfig.BearerToken != "" {
authInfo.Token = restConfig.BearerToken
haveCredentials = true
}
if restConfig.ExecProvider != nil {
authInfo.Exec = restConfig.ExecProvider
haveCredentials = true
}
if restConfig.ExecProvider == nil && !haveCredentials {
// If no credentials were set (or there was no exec provider), we assume in-cluster config.
// In-cluster configs from the go-client will no longer set bearer tokens, so we set the
// well known token path. See issue #774
authInfo.TokenFile = "/var/run/secrets/kubernetes.io/serviceaccount/token"
}
return &authInfo
} | [
"func",
"newAuthInfo",
"(",
"restConfig",
"*",
"rest",
".",
"Config",
")",
"*",
"clientcmdapi",
".",
"AuthInfo",
"{",
"authInfo",
":=",
"clientcmdapi",
".",
"AuthInfo",
"{",
"}",
"\n",
"haveCredentials",
":=",
"false",
"\n",
"if",
"restConfig",
".",
"TLSClie... | // newAuthInfo returns an AuthInfo from a rest config, detecting if the rest.Config is an
// in-cluster config and automatically setting the token path appropriately. | [
"newAuthInfo",
"returns",
"an",
"AuthInfo",
"from",
"a",
"rest",
"config",
"detecting",
"if",
"the",
"rest",
".",
"Config",
"is",
"an",
"in",
"-",
"cluster",
"config",
"and",
"automatically",
"setting",
"the",
"token",
"path",
"appropriately",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L313-L355 |
161,811 | argoproj/argo-cd | util/kube/kube.go | SplitYAML | func SplitYAML(out string) ([]*unstructured.Unstructured, error) {
parts := diffSeparator.Split(out, -1)
var objs []*unstructured.Unstructured
var firstErr error
for _, part := range parts {
var objMap map[string]interface{}
err := yaml.Unmarshal([]byte(part), &objMap)
if err != nil {
if firstErr == nil {
firstErr = fmt.Errorf("Failed to unmarshal manifest: %v", err)
}
continue
}
if len(objMap) == 0 {
// handles case where theres no content between `---`
continue
}
var obj unstructured.Unstructured
err = yaml.Unmarshal([]byte(part), &obj)
if err != nil {
if firstErr == nil {
firstErr = fmt.Errorf("Failed to unmarshal manifest: %v", err)
}
continue
}
remObj, err := Remarshal(&obj)
if err != nil {
log.Debugf("Failed to remarshal oject: %v", err)
} else {
obj = *remObj
}
objs = append(objs, &obj)
}
return objs, firstErr
} | go | func SplitYAML(out string) ([]*unstructured.Unstructured, error) {
parts := diffSeparator.Split(out, -1)
var objs []*unstructured.Unstructured
var firstErr error
for _, part := range parts {
var objMap map[string]interface{}
err := yaml.Unmarshal([]byte(part), &objMap)
if err != nil {
if firstErr == nil {
firstErr = fmt.Errorf("Failed to unmarshal manifest: %v", err)
}
continue
}
if len(objMap) == 0 {
// handles case where theres no content between `---`
continue
}
var obj unstructured.Unstructured
err = yaml.Unmarshal([]byte(part), &obj)
if err != nil {
if firstErr == nil {
firstErr = fmt.Errorf("Failed to unmarshal manifest: %v", err)
}
continue
}
remObj, err := Remarshal(&obj)
if err != nil {
log.Debugf("Failed to remarshal oject: %v", err)
} else {
obj = *remObj
}
objs = append(objs, &obj)
}
return objs, firstErr
} | [
"func",
"SplitYAML",
"(",
"out",
"string",
")",
"(",
"[",
"]",
"*",
"unstructured",
".",
"Unstructured",
",",
"error",
")",
"{",
"parts",
":=",
"diffSeparator",
".",
"Split",
"(",
"out",
",",
"-",
"1",
")",
"\n",
"var",
"objs",
"[",
"]",
"*",
"unst... | // SplitYAML splits a YAML file into unstructured objects. Returns list of all unstructured objects
// found in the yaml. If any errors occurred, returns the first one | [
"SplitYAML",
"splits",
"a",
"YAML",
"file",
"into",
"unstructured",
"objects",
".",
"Returns",
"list",
"of",
"all",
"unstructured",
"objects",
"found",
"in",
"the",
"yaml",
".",
"If",
"any",
"errors",
"occurred",
"returns",
"the",
"first",
"one"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L361-L395 |
161,812 | argoproj/argo-cd | util/kube/kube.go | Remarshal | func Remarshal(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
data, err := json.Marshal(obj)
if err != nil {
return nil, err
}
item, err := scheme.Scheme.New(obj.GroupVersionKind())
if err != nil {
return nil, err
}
// This will drop any omitempty fields, perform resource conversion etc...
unmarshalledObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
err = json.Unmarshal(data, &unmarshalledObj)
if err != nil {
return nil, err
}
unstrBody, err := runtime.DefaultUnstructuredConverter.ToUnstructured(unmarshalledObj)
if err != nil {
return nil, err
}
// remove all default values specified by custom formatter (e.g. creationTimestamp)
unstrBody = jsonutil.RemoveMapFields(obj.Object, unstrBody)
return &unstructured.Unstructured{Object: unstrBody}, nil
} | go | func Remarshal(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
data, err := json.Marshal(obj)
if err != nil {
return nil, err
}
item, err := scheme.Scheme.New(obj.GroupVersionKind())
if err != nil {
return nil, err
}
// This will drop any omitempty fields, perform resource conversion etc...
unmarshalledObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
err = json.Unmarshal(data, &unmarshalledObj)
if err != nil {
return nil, err
}
unstrBody, err := runtime.DefaultUnstructuredConverter.ToUnstructured(unmarshalledObj)
if err != nil {
return nil, err
}
// remove all default values specified by custom formatter (e.g. creationTimestamp)
unstrBody = jsonutil.RemoveMapFields(obj.Object, unstrBody)
return &unstructured.Unstructured{Object: unstrBody}, nil
} | [
"func",
"Remarshal",
"(",
"obj",
"*",
"unstructured",
".",
"Unstructured",
")",
"(",
"*",
"unstructured",
".",
"Unstructured",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"obj",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // Remarshal checks resource kind and version and re-marshal using corresponding struct custom marshaller.
// This ensures that expected resource state is formatter same as actual resource state in kubernetes
// and allows to find differences between actual and target states more accurately. | [
"Remarshal",
"checks",
"resource",
"kind",
"and",
"version",
"and",
"re",
"-",
"marshal",
"using",
"corresponding",
"struct",
"custom",
"marshaller",
".",
"This",
"ensures",
"that",
"expected",
"resource",
"state",
"is",
"formatter",
"same",
"as",
"actual",
"res... | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L400-L422 |
161,813 | argoproj/argo-cd | util/kube/kube.go | WatchWithRetry | func WatchWithRetry(ctx context.Context, getWatch func() (watch.Interface, error)) chan struct {
*watch.Event
Error error
} {
ch := make(chan struct {
*watch.Event
Error error
})
execute := func() (bool, error) {
w, err := getWatch()
if err != nil {
return false, err
}
defer w.Stop()
for {
select {
case event, ok := <-w.ResultChan():
if ok {
ch <- struct {
*watch.Event
Error error
}{Event: &event, Error: nil}
} else {
return true, nil
}
case <-ctx.Done():
return false, nil
}
}
}
go func() {
defer close(ch)
for {
retry, err := execute()
if err != nil {
ch <- struct {
*watch.Event
Error error
}{Error: err}
}
if !retry {
return
}
time.Sleep(time.Second)
}
}()
return ch
} | go | func WatchWithRetry(ctx context.Context, getWatch func() (watch.Interface, error)) chan struct {
*watch.Event
Error error
} {
ch := make(chan struct {
*watch.Event
Error error
})
execute := func() (bool, error) {
w, err := getWatch()
if err != nil {
return false, err
}
defer w.Stop()
for {
select {
case event, ok := <-w.ResultChan():
if ok {
ch <- struct {
*watch.Event
Error error
}{Event: &event, Error: nil}
} else {
return true, nil
}
case <-ctx.Done():
return false, nil
}
}
}
go func() {
defer close(ch)
for {
retry, err := execute()
if err != nil {
ch <- struct {
*watch.Event
Error error
}{Error: err}
}
if !retry {
return
}
time.Sleep(time.Second)
}
}()
return ch
} | [
"func",
"WatchWithRetry",
"(",
"ctx",
"context",
".",
"Context",
",",
"getWatch",
"func",
"(",
")",
"(",
"watch",
".",
"Interface",
",",
"error",
")",
")",
"chan",
"struct",
"{",
"*",
"watch",
".",
"Event",
"\n",
"Error",
"error",
"\n",
"}",
"{",
"ch... | // WatchWithRetry returns channel of watch events or errors of failed to call watch API. | [
"WatchWithRetry",
"returns",
"channel",
"of",
"watch",
"events",
"or",
"errors",
"of",
"failed",
"to",
"call",
"watch",
"API",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/kube/kube.go#L425-L473 |
161,814 | argoproj/argo-cd | util/db/cluster.go | ListClusters | func (db *db) ListClusters(ctx context.Context) (*appv1.ClusterList, error) {
clusterSecrets, err := db.listClusterSecrets()
if err != nil {
return nil, err
}
clusterList := appv1.ClusterList{
Items: make([]appv1.Cluster, len(clusterSecrets)),
}
hasInClusterCredentials := false
for i, clusterSecret := range clusterSecrets {
cluster := *secretToCluster(clusterSecret)
clusterList.Items[i] = cluster
if cluster.Server == common.KubernetesInternalAPIServerAddr {
hasInClusterCredentials = true
}
}
if !hasInClusterCredentials {
clusterList.Items = append(clusterList.Items, localCluster)
}
return &clusterList, nil
} | go | func (db *db) ListClusters(ctx context.Context) (*appv1.ClusterList, error) {
clusterSecrets, err := db.listClusterSecrets()
if err != nil {
return nil, err
}
clusterList := appv1.ClusterList{
Items: make([]appv1.Cluster, len(clusterSecrets)),
}
hasInClusterCredentials := false
for i, clusterSecret := range clusterSecrets {
cluster := *secretToCluster(clusterSecret)
clusterList.Items[i] = cluster
if cluster.Server == common.KubernetesInternalAPIServerAddr {
hasInClusterCredentials = true
}
}
if !hasInClusterCredentials {
clusterList.Items = append(clusterList.Items, localCluster)
}
return &clusterList, nil
} | [
"func",
"(",
"db",
"*",
"db",
")",
"ListClusters",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"appv1",
".",
"ClusterList",
",",
"error",
")",
"{",
"clusterSecrets",
",",
"err",
":=",
"db",
".",
"listClusterSecrets",
"(",
")",
"\n",
"if",
"... | // ListClusters returns list of clusters | [
"ListClusters",
"returns",
"list",
"of",
"clusters"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L51-L71 |
161,815 | argoproj/argo-cd | util/db/cluster.go | CreateCluster | func (db *db) CreateCluster(ctx context.Context, c *appv1.Cluster) (*appv1.Cluster, error) {
secName, err := serverToSecretName(c.Server)
if err != nil {
return nil, err
}
clusterSecret := &apiv1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: secName,
Labels: map[string]string{
common.LabelKeySecretType: common.LabelValueSecretTypeCluster,
},
Annotations: map[string]string{
common.AnnotationKeyManagedBy: common.AnnotationValueManagedByArgoCD,
},
},
}
clusterSecret.Data = clusterToData(c)
clusterSecret, err = db.kubeclientset.CoreV1().Secrets(db.ns).Create(clusterSecret)
if err != nil {
if apierr.IsAlreadyExists(err) {
return nil, status.Errorf(codes.AlreadyExists, "cluster %q already exists", c.Server)
}
return nil, err
}
return secretToCluster(clusterSecret), db.settingsMgr.ResyncInformers()
} | go | func (db *db) CreateCluster(ctx context.Context, c *appv1.Cluster) (*appv1.Cluster, error) {
secName, err := serverToSecretName(c.Server)
if err != nil {
return nil, err
}
clusterSecret := &apiv1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: secName,
Labels: map[string]string{
common.LabelKeySecretType: common.LabelValueSecretTypeCluster,
},
Annotations: map[string]string{
common.AnnotationKeyManagedBy: common.AnnotationValueManagedByArgoCD,
},
},
}
clusterSecret.Data = clusterToData(c)
clusterSecret, err = db.kubeclientset.CoreV1().Secrets(db.ns).Create(clusterSecret)
if err != nil {
if apierr.IsAlreadyExists(err) {
return nil, status.Errorf(codes.AlreadyExists, "cluster %q already exists", c.Server)
}
return nil, err
}
return secretToCluster(clusterSecret), db.settingsMgr.ResyncInformers()
} | [
"func",
"(",
"db",
"*",
"db",
")",
"CreateCluster",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"*",
"appv1",
".",
"Cluster",
")",
"(",
"*",
"appv1",
".",
"Cluster",
",",
"error",
")",
"{",
"secName",
",",
"err",
":=",
"serverToSecretName",
"(",... | // CreateCluster creates a cluster | [
"CreateCluster",
"creates",
"a",
"cluster"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L74-L99 |
161,816 | argoproj/argo-cd | util/db/cluster.go | WatchClusters | func (db *db) WatchClusters(ctx context.Context, callback func(*ClusterEvent)) error {
listOpts := metav1.ListOptions{}
labelSelector := labels.NewSelector()
req, err := labels.NewRequirement(common.LabelKeySecretType, selection.Equals, []string{common.LabelValueSecretTypeCluster})
if err != nil {
return err
}
labelSelector = labelSelector.Add(*req)
listOpts.LabelSelector = labelSelector.String()
w, err := db.kubeclientset.CoreV1().Secrets(db.ns).Watch(listOpts)
if err != nil {
return err
}
localCls, err := db.GetCluster(ctx, common.KubernetesInternalAPIServerAddr)
if err != nil {
return err
}
defer w.Stop()
done := make(chan bool)
// trigger callback with event for local cluster since it always considered added
callback(&ClusterEvent{Type: watch.Added, Cluster: localCls})
go func() {
for next := range w.ResultChan() {
secret := next.Object.(*apiv1.Secret)
cluster := secretToCluster(secret)
// change local cluster event to modified or deleted, since it cannot be re-added or deleted
if cluster.Server == common.KubernetesInternalAPIServerAddr {
if next.Type == watch.Deleted {
next.Type = watch.Modified
cluster = &localCluster
} else if next.Type == watch.Added {
localCls = cluster
next.Type = watch.Modified
} else {
localCls = cluster
}
}
callback(&ClusterEvent{
Type: next.Type,
Cluster: cluster,
})
}
done <- true
}()
select {
case <-done:
case <-ctx.Done():
}
return nil
} | go | func (db *db) WatchClusters(ctx context.Context, callback func(*ClusterEvent)) error {
listOpts := metav1.ListOptions{}
labelSelector := labels.NewSelector()
req, err := labels.NewRequirement(common.LabelKeySecretType, selection.Equals, []string{common.LabelValueSecretTypeCluster})
if err != nil {
return err
}
labelSelector = labelSelector.Add(*req)
listOpts.LabelSelector = labelSelector.String()
w, err := db.kubeclientset.CoreV1().Secrets(db.ns).Watch(listOpts)
if err != nil {
return err
}
localCls, err := db.GetCluster(ctx, common.KubernetesInternalAPIServerAddr)
if err != nil {
return err
}
defer w.Stop()
done := make(chan bool)
// trigger callback with event for local cluster since it always considered added
callback(&ClusterEvent{Type: watch.Added, Cluster: localCls})
go func() {
for next := range w.ResultChan() {
secret := next.Object.(*apiv1.Secret)
cluster := secretToCluster(secret)
// change local cluster event to modified or deleted, since it cannot be re-added or deleted
if cluster.Server == common.KubernetesInternalAPIServerAddr {
if next.Type == watch.Deleted {
next.Type = watch.Modified
cluster = &localCluster
} else if next.Type == watch.Added {
localCls = cluster
next.Type = watch.Modified
} else {
localCls = cluster
}
}
callback(&ClusterEvent{
Type: next.Type,
Cluster: cluster,
})
}
done <- true
}()
select {
case <-done:
case <-ctx.Done():
}
return nil
} | [
"func",
"(",
"db",
"*",
"db",
")",
"WatchClusters",
"(",
"ctx",
"context",
".",
"Context",
",",
"callback",
"func",
"(",
"*",
"ClusterEvent",
")",
")",
"error",
"{",
"listOpts",
":=",
"metav1",
".",
"ListOptions",
"{",
"}",
"\n",
"labelSelector",
":=",
... | // WatchClusters allow watching for cluster events | [
"WatchClusters",
"allow",
"watching",
"for",
"cluster",
"events"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L108-L164 |
161,817 | argoproj/argo-cd | util/db/cluster.go | GetCluster | func (db *db) GetCluster(ctx context.Context, server string) (*appv1.Cluster, error) {
clusterSecret, err := db.getClusterSecret(server)
if err != nil {
if errorStatus, ok := status.FromError(err); ok && errorStatus.Code() == codes.NotFound && server == common.KubernetesInternalAPIServerAddr {
return &localCluster, nil
} else {
return nil, err
}
}
return secretToCluster(clusterSecret), nil
} | go | func (db *db) GetCluster(ctx context.Context, server string) (*appv1.Cluster, error) {
clusterSecret, err := db.getClusterSecret(server)
if err != nil {
if errorStatus, ok := status.FromError(err); ok && errorStatus.Code() == codes.NotFound && server == common.KubernetesInternalAPIServerAddr {
return &localCluster, nil
} else {
return nil, err
}
}
return secretToCluster(clusterSecret), nil
} | [
"func",
"(",
"db",
"*",
"db",
")",
"GetCluster",
"(",
"ctx",
"context",
".",
"Context",
",",
"server",
"string",
")",
"(",
"*",
"appv1",
".",
"Cluster",
",",
"error",
")",
"{",
"clusterSecret",
",",
"err",
":=",
"db",
".",
"getClusterSecret",
"(",
"s... | // GetCluster returns a cluster from a query | [
"GetCluster",
"returns",
"a",
"cluster",
"from",
"a",
"query"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L181-L191 |
161,818 | argoproj/argo-cd | util/db/cluster.go | UpdateCluster | func (db *db) UpdateCluster(ctx context.Context, c *appv1.Cluster) (*appv1.Cluster, error) {
clusterSecret, err := db.getClusterSecret(c.Server)
if err != nil {
return nil, err
}
clusterSecret.Data = clusterToData(c)
clusterSecret, err = db.kubeclientset.CoreV1().Secrets(db.ns).Update(clusterSecret)
if err != nil {
return nil, err
}
return secretToCluster(clusterSecret), db.settingsMgr.ResyncInformers()
} | go | func (db *db) UpdateCluster(ctx context.Context, c *appv1.Cluster) (*appv1.Cluster, error) {
clusterSecret, err := db.getClusterSecret(c.Server)
if err != nil {
return nil, err
}
clusterSecret.Data = clusterToData(c)
clusterSecret, err = db.kubeclientset.CoreV1().Secrets(db.ns).Update(clusterSecret)
if err != nil {
return nil, err
}
return secretToCluster(clusterSecret), db.settingsMgr.ResyncInformers()
} | [
"func",
"(",
"db",
"*",
"db",
")",
"UpdateCluster",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"*",
"appv1",
".",
"Cluster",
")",
"(",
"*",
"appv1",
".",
"Cluster",
",",
"error",
")",
"{",
"clusterSecret",
",",
"err",
":=",
"db",
".",
"getClu... | // UpdateCluster updates a cluster | [
"UpdateCluster",
"updates",
"a",
"cluster"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L194-L205 |
161,819 | argoproj/argo-cd | util/db/cluster.go | serverToSecretName | func serverToSecretName(server string) (string, error) {
serverURL, err := url.ParseRequestURI(server)
if err != nil {
return "", err
}
h := fnv.New32a()
_, _ = h.Write([]byte(server))
host := strings.ToLower(strings.Split(serverURL.Host, ":")[0])
return fmt.Sprintf("cluster-%s-%v", host, h.Sum32()), nil
} | go | func serverToSecretName(server string) (string, error) {
serverURL, err := url.ParseRequestURI(server)
if err != nil {
return "", err
}
h := fnv.New32a()
_, _ = h.Write([]byte(server))
host := strings.ToLower(strings.Split(serverURL.Host, ":")[0])
return fmt.Sprintf("cluster-%s-%v", host, h.Sum32()), nil
} | [
"func",
"serverToSecretName",
"(",
"server",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"serverURL",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
... | // serverToSecretName hashes server address to the secret name using a formula.
// Part of the server address is incorporated for debugging purposes | [
"serverToSecretName",
"hashes",
"server",
"address",
"to",
"the",
"secret",
"name",
"using",
"a",
"formula",
".",
"Part",
"of",
"the",
"server",
"address",
"is",
"incorporated",
"for",
"debugging",
"purposes"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L234-L243 |
161,820 | argoproj/argo-cd | util/db/cluster.go | clusterToData | func clusterToData(c *appv1.Cluster) map[string][]byte {
data := make(map[string][]byte)
data["server"] = []byte(c.Server)
if c.Name == "" {
data["name"] = []byte(c.Server)
} else {
data["name"] = []byte(c.Name)
}
configBytes, err := json.Marshal(c.Config)
if err != nil {
panic(err)
}
data["config"] = configBytes
return data
} | go | func clusterToData(c *appv1.Cluster) map[string][]byte {
data := make(map[string][]byte)
data["server"] = []byte(c.Server)
if c.Name == "" {
data["name"] = []byte(c.Server)
} else {
data["name"] = []byte(c.Name)
}
configBytes, err := json.Marshal(c.Config)
if err != nil {
panic(err)
}
data["config"] = configBytes
return data
} | [
"func",
"clusterToData",
"(",
"c",
"*",
"appv1",
".",
"Cluster",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"data",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
")",
"\n",
"data",
"[",
"\"",
"\"",
"]",
"=",
"[",
... | // clusterToData converts a cluster object to string data for serialization to a secret | [
"clusterToData",
"converts",
"a",
"cluster",
"object",
"to",
"string",
"data",
"for",
"serialization",
"to",
"a",
"secret"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L246-L260 |
161,821 | argoproj/argo-cd | util/db/cluster.go | secretToCluster | func secretToCluster(s *apiv1.Secret) *appv1.Cluster {
var config appv1.ClusterConfig
err := json.Unmarshal(s.Data["config"], &config)
if err != nil {
panic(err)
}
cluster := appv1.Cluster{
Server: string(s.Data["server"]),
Name: string(s.Data["name"]),
Config: config,
}
return &cluster
} | go | func secretToCluster(s *apiv1.Secret) *appv1.Cluster {
var config appv1.ClusterConfig
err := json.Unmarshal(s.Data["config"], &config)
if err != nil {
panic(err)
}
cluster := appv1.Cluster{
Server: string(s.Data["server"]),
Name: string(s.Data["name"]),
Config: config,
}
return &cluster
} | [
"func",
"secretToCluster",
"(",
"s",
"*",
"apiv1",
".",
"Secret",
")",
"*",
"appv1",
".",
"Cluster",
"{",
"var",
"config",
"appv1",
".",
"ClusterConfig",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"s",
".",
"Data",
"[",
"\"",
"\"",
"]",
",",
... | // secretToCluster converts a secret into a repository object | [
"secretToCluster",
"converts",
"a",
"secret",
"into",
"a",
"repository",
"object"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/db/cluster.go#L263-L275 |
161,822 | argoproj/argo-cd | util/password/password.go | hashPasswordWithHashers | func hashPasswordWithHashers(password string, hashers []PasswordHasher) (string, error) {
// Even though good hashers will disallow blank passwords, let's be explicit that ALL BLANK PASSWORDS ARE INVALID. Full stop.
if password == "" {
return "", fmt.Errorf("blank passwords are not allowed")
}
return hashers[0].HashPassword(password)
} | go | func hashPasswordWithHashers(password string, hashers []PasswordHasher) (string, error) {
// Even though good hashers will disallow blank passwords, let's be explicit that ALL BLANK PASSWORDS ARE INVALID. Full stop.
if password == "" {
return "", fmt.Errorf("blank passwords are not allowed")
}
return hashers[0].HashPassword(password)
} | [
"func",
"hashPasswordWithHashers",
"(",
"password",
"string",
",",
"hashers",
"[",
"]",
"PasswordHasher",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Even though good hashers will disallow blank passwords, let's be explicit that ALL BLANK PASSWORDS ARE INVALID. Full stop.",
... | // HashPasswordWithHashers hashes an entered password using the first hasher in the provided list of hashers. | [
"HashPasswordWithHashers",
"hashes",
"an",
"entered",
"password",
"using",
"the",
"first",
"hasher",
"in",
"the",
"provided",
"list",
"of",
"hashers",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/password/password.go#L33-L39 |
161,823 | argoproj/argo-cd | server/repository/repository.go | NewServer | func NewServer(
repoClientset reposerver.Clientset,
db db.ArgoDB,
enf *rbac.Enforcer,
cache *cache.Cache,
) *Server {
return &Server{
db: db,
repoClientset: repoClientset,
enf: enf,
cache: cache,
}
} | go | func NewServer(
repoClientset reposerver.Clientset,
db db.ArgoDB,
enf *rbac.Enforcer,
cache *cache.Cache,
) *Server {
return &Server{
db: db,
repoClientset: repoClientset,
enf: enf,
cache: cache,
}
} | [
"func",
"NewServer",
"(",
"repoClientset",
"reposerver",
".",
"Clientset",
",",
"db",
"db",
".",
"ArgoDB",
",",
"enf",
"*",
"rbac",
".",
"Enforcer",
",",
"cache",
"*",
"cache",
".",
"Cache",
",",
")",
"*",
"Server",
"{",
"return",
"&",
"Server",
"{",
... | // NewServer returns a new instance of the Repository service | [
"NewServer",
"returns",
"a",
"new",
"instance",
"of",
"the",
"Repository",
"service"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/repository/repository.go#L37-L49 |
161,824 | argoproj/argo-cd | server/repository/repository.go | List | func (s *Server) List(ctx context.Context, q *RepoQuery) (*appsv1.RepositoryList, error) {
urls, err := s.db.ListRepoURLs(ctx)
if err != nil {
return nil, err
}
items := make([]appsv1.Repository, 0)
for _, url := range urls {
if s.enf.Enforce(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionGet, url) {
items = append(items, appsv1.Repository{Repo: url})
}
}
err = util.RunAllAsync(len(items), func(i int) error {
items[i].ConnectionState = s.getConnectionState(ctx, items[i].Repo)
return nil
})
if err != nil {
return nil, err
}
return &appsv1.RepositoryList{Items: items}, nil
} | go | func (s *Server) List(ctx context.Context, q *RepoQuery) (*appsv1.RepositoryList, error) {
urls, err := s.db.ListRepoURLs(ctx)
if err != nil {
return nil, err
}
items := make([]appsv1.Repository, 0)
for _, url := range urls {
if s.enf.Enforce(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionGet, url) {
items = append(items, appsv1.Repository{Repo: url})
}
}
err = util.RunAllAsync(len(items), func(i int) error {
items[i].ConnectionState = s.getConnectionState(ctx, items[i].Repo)
return nil
})
if err != nil {
return nil, err
}
return &appsv1.RepositoryList{Items: items}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"List",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"*",
"RepoQuery",
")",
"(",
"*",
"appsv1",
".",
"RepositoryList",
",",
"error",
")",
"{",
"urls",
",",
"err",
":=",
"s",
".",
"db",
".",
"ListRepoURLs",
... | // List returns list of repositories | [
"List",
"returns",
"list",
"of",
"repositories"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/repository/repository.go#L76-L95 |
161,825 | argoproj/argo-cd | server/repository/repository.go | ListApps | func (s *Server) ListApps(ctx context.Context, q *RepoAppsQuery) (*RepoAppsResponse, error) {
if err := s.enf.EnforceErr(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionGet, q.Repo); err != nil {
return nil, err
}
repo, err := s.db.GetRepository(ctx, q.Repo)
if err != nil {
if errStatus, ok := status.FromError(err); ok && errStatus.Code() == codes.NotFound {
repo = &appsv1.Repository{
Repo: q.Repo,
}
} else {
return nil, err
}
}
// Test the repo
conn, repoClient, err := s.repoClientset.NewRepoServerClient()
if err != nil {
return nil, err
}
defer util.Close(conn)
revision := q.Revision
if revision == "" {
revision = "HEAD"
}
paths, err := s.listAppsPaths(ctx, repoClient, repo, revision, "")
if err != nil {
return nil, err
}
items := make([]*AppInfo, 0)
for appFilePath, appType := range paths {
items = append(items, &AppInfo{Path: path.Dir(appFilePath), Type: string(appType)})
}
return &RepoAppsResponse{Items: items}, nil
} | go | func (s *Server) ListApps(ctx context.Context, q *RepoAppsQuery) (*RepoAppsResponse, error) {
if err := s.enf.EnforceErr(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionGet, q.Repo); err != nil {
return nil, err
}
repo, err := s.db.GetRepository(ctx, q.Repo)
if err != nil {
if errStatus, ok := status.FromError(err); ok && errStatus.Code() == codes.NotFound {
repo = &appsv1.Repository{
Repo: q.Repo,
}
} else {
return nil, err
}
}
// Test the repo
conn, repoClient, err := s.repoClientset.NewRepoServerClient()
if err != nil {
return nil, err
}
defer util.Close(conn)
revision := q.Revision
if revision == "" {
revision = "HEAD"
}
paths, err := s.listAppsPaths(ctx, repoClient, repo, revision, "")
if err != nil {
return nil, err
}
items := make([]*AppInfo, 0)
for appFilePath, appType := range paths {
items = append(items, &AppInfo{Path: path.Dir(appFilePath), Type: string(appType)})
}
return &RepoAppsResponse{Items: items}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"ListApps",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"*",
"RepoAppsQuery",
")",
"(",
"*",
"RepoAppsResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"s",
".",
"enf",
".",
"EnforceErr",
"(",
"ctx",
"... | // ListApps returns list of apps in the repo | [
"ListApps",
"returns",
"list",
"of",
"apps",
"in",
"the",
"repo"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/repository/repository.go#L161-L197 |
161,826 | argoproj/argo-cd | server/repository/repository.go | Create | func (s *Server) Create(ctx context.Context, q *RepoCreateRequest) (*appsv1.Repository, error) {
if err := s.enf.EnforceErr(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionCreate, q.Repo.Repo); err != nil {
return nil, err
}
r := q.Repo
err := git.TestRepo(r.Repo, r.Username, r.Password, r.SSHPrivateKey, r.InsecureIgnoreHostKey)
if err != nil {
return nil, err
}
r.ConnectionState = appsv1.ConnectionState{Status: appsv1.ConnectionStatusSuccessful}
repo, err := s.db.CreateRepository(ctx, r)
if status.Convert(err).Code() == codes.AlreadyExists {
// act idempotent if existing spec matches new spec
existing, getErr := s.db.GetRepository(ctx, r.Repo)
if getErr != nil {
return nil, status.Errorf(codes.Internal, "unable to check existing repository details: %v", getErr)
}
// repository ConnectionState may differ, so make consistent before testing
existing.ConnectionState = r.ConnectionState
if reflect.DeepEqual(existing, r) {
repo, err = existing, nil
} else if q.Upsert {
return s.Update(ctx, &RepoUpdateRequest{Repo: r})
} else {
return nil, status.Errorf(codes.InvalidArgument, "existing repository spec is different; use upsert flag to force update")
}
}
return &appsv1.Repository{Repo: repo.Repo}, err
} | go | func (s *Server) Create(ctx context.Context, q *RepoCreateRequest) (*appsv1.Repository, error) {
if err := s.enf.EnforceErr(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionCreate, q.Repo.Repo); err != nil {
return nil, err
}
r := q.Repo
err := git.TestRepo(r.Repo, r.Username, r.Password, r.SSHPrivateKey, r.InsecureIgnoreHostKey)
if err != nil {
return nil, err
}
r.ConnectionState = appsv1.ConnectionState{Status: appsv1.ConnectionStatusSuccessful}
repo, err := s.db.CreateRepository(ctx, r)
if status.Convert(err).Code() == codes.AlreadyExists {
// act idempotent if existing spec matches new spec
existing, getErr := s.db.GetRepository(ctx, r.Repo)
if getErr != nil {
return nil, status.Errorf(codes.Internal, "unable to check existing repository details: %v", getErr)
}
// repository ConnectionState may differ, so make consistent before testing
existing.ConnectionState = r.ConnectionState
if reflect.DeepEqual(existing, r) {
repo, err = existing, nil
} else if q.Upsert {
return s.Update(ctx, &RepoUpdateRequest{Repo: r})
} else {
return nil, status.Errorf(codes.InvalidArgument, "existing repository spec is different; use upsert flag to force update")
}
}
return &appsv1.Repository{Repo: repo.Repo}, err
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"*",
"RepoCreateRequest",
")",
"(",
"*",
"appsv1",
".",
"Repository",
",",
"error",
")",
"{",
"if",
"err",
":=",
"s",
".",
"enf",
".",
"EnforceErr",
"(... | // Create creates a repository | [
"Create",
"creates",
"a",
"repository"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/repository/repository.go#L233-L263 |
161,827 | argoproj/argo-cd | server/repository/repository.go | Update | func (s *Server) Update(ctx context.Context, q *RepoUpdateRequest) (*appsv1.Repository, error) {
if err := s.enf.EnforceErr(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionUpdate, q.Repo.Repo); err != nil {
return nil, err
}
_, err := s.db.UpdateRepository(ctx, q.Repo)
return &appsv1.Repository{Repo: q.Repo.Repo}, err
} | go | func (s *Server) Update(ctx context.Context, q *RepoUpdateRequest) (*appsv1.Repository, error) {
if err := s.enf.EnforceErr(ctx.Value("claims"), rbacpolicy.ResourceRepositories, rbacpolicy.ActionUpdate, q.Repo.Repo); err != nil {
return nil, err
}
_, err := s.db.UpdateRepository(ctx, q.Repo)
return &appsv1.Repository{Repo: q.Repo.Repo}, err
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"*",
"RepoUpdateRequest",
")",
"(",
"*",
"appsv1",
".",
"Repository",
",",
"error",
")",
"{",
"if",
"err",
":=",
"s",
".",
"enf",
".",
"EnforceErr",
"(... | // Update updates a repository | [
"Update",
"updates",
"a",
"repository"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/repository/repository.go#L266-L272 |
161,828 | argoproj/argo-cd | util/stats/stats.go | StartStatsTicker | func StartStatsTicker(d time.Duration) {
ticker := time.NewTicker(d)
go func() {
for {
<-ticker.C
LogStats()
}
}()
} | go | func StartStatsTicker(d time.Duration) {
ticker := time.NewTicker(d)
go func() {
for {
<-ticker.C
LogStats()
}
}()
} | [
"func",
"StartStatsTicker",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"d",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"<-",
"ticker",
".",
"C",
"\n",
"LogStats",
"(",
")",
"\n",
"}",
"\n"... | // StartStatsTicker starts a goroutine which dumps stats at a specified interval | [
"StartStatsTicker",
"starts",
"a",
"goroutine",
"which",
"dumps",
"stats",
"at",
"a",
"specified",
"interval"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/stats/stats.go#L15-L23 |
161,829 | argoproj/argo-cd | util/stats/stats.go | RegisterStackDumper | func RegisterStackDumper() {
go func() {
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGUSR1)
for {
<-sigs
LogStack()
}
}()
} | go | func RegisterStackDumper() {
go func() {
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGUSR1)
for {
<-sigs
LogStack()
}
}()
} | [
"func",
"RegisterStackDumper",
"(",
")",
"{",
"go",
"func",
"(",
")",
"{",
"sigs",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"sigs",
",",
"syscall",
".",
"SIGUSR1",
")",
"\n",
"for",
"{",
"... | // RegisterStackDumper spawns a goroutine which dumps stack trace upon a SIGUSR1 | [
"RegisterStackDumper",
"spawns",
"a",
"goroutine",
"which",
"dumps",
"stack",
"trace",
"upon",
"a",
"SIGUSR1"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/stats/stats.go#L26-L35 |
161,830 | argoproj/argo-cd | util/stats/stats.go | RegisterHeapDumper | func RegisterHeapDumper(filePath string) {
go func() {
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGUSR2)
for {
<-sigs
runtime.GC()
if _, err := os.Stat(filePath); err == nil {
err = os.Remove(filePath)
if err != nil {
log.Warnf("could not delete heap profile file: %v", err)
return
}
}
f, err := os.Create(filePath)
if err != nil {
log.Warnf("could not create heap profile file: %v", err)
return
}
if err := pprof.WriteHeapProfile(f); err != nil {
log.Warnf("could not write heap profile: %v", err)
return
} else {
log.Infof("dumped heap profile to %s", filePath)
}
}
}()
} | go | func RegisterHeapDumper(filePath string) {
go func() {
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGUSR2)
for {
<-sigs
runtime.GC()
if _, err := os.Stat(filePath); err == nil {
err = os.Remove(filePath)
if err != nil {
log.Warnf("could not delete heap profile file: %v", err)
return
}
}
f, err := os.Create(filePath)
if err != nil {
log.Warnf("could not create heap profile file: %v", err)
return
}
if err := pprof.WriteHeapProfile(f); err != nil {
log.Warnf("could not write heap profile: %v", err)
return
} else {
log.Infof("dumped heap profile to %s", filePath)
}
}
}()
} | [
"func",
"RegisterHeapDumper",
"(",
"filePath",
"string",
")",
"{",
"go",
"func",
"(",
")",
"{",
"sigs",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"sigs",
",",
"syscall",
".",
"SIGUSR2",
")",
... | // RegisterHeapDumper spawns a goroutine which dumps heap profile upon a SIGUSR2 | [
"RegisterHeapDumper",
"spawns",
"a",
"goroutine",
"which",
"dumps",
"heap",
"profile",
"upon",
"a",
"SIGUSR2"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/stats/stats.go#L38-L66 |
161,831 | argoproj/argo-cd | util/stats/stats.go | LogStats | func LogStats() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
log.Infof("Alloc=%v TotalAlloc=%v Sys=%v NumGC=%v Goroutines=%d",
m.Alloc/1024, m.TotalAlloc/1024, m.Sys/1024, m.NumGC, runtime.NumGoroutine())
} | go | func LogStats() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
log.Infof("Alloc=%v TotalAlloc=%v Sys=%v NumGC=%v Goroutines=%d",
m.Alloc/1024, m.TotalAlloc/1024, m.Sys/1024, m.NumGC, runtime.NumGoroutine())
} | [
"func",
"LogStats",
"(",
")",
"{",
"var",
"m",
"runtime",
".",
"MemStats",
"\n",
"runtime",
".",
"ReadMemStats",
"(",
"&",
"m",
")",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"m",
".",
"Alloc",
"/",
"1024",
",",
"m",
".",
"TotalAlloc",
"/"... | // LogStats logs runtime statistics | [
"LogStats",
"logs",
"runtime",
"statistics"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/stats/stats.go#L69-L75 |
161,832 | argoproj/argo-cd | util/stats/stats.go | LogStack | func LogStack() {
buf := make([]byte, 1<<20)
stacklen := runtime.Stack(buf, true)
log.Infof("*** goroutine dump...\n%s\n*** end\n", buf[:stacklen])
} | go | func LogStack() {
buf := make([]byte, 1<<20)
stacklen := runtime.Stack(buf, true)
log.Infof("*** goroutine dump...\n%s\n*** end\n", buf[:stacklen])
} | [
"func",
"LogStack",
"(",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
"<<",
"20",
")",
"\n",
"stacklen",
":=",
"runtime",
".",
"Stack",
"(",
"buf",
",",
"true",
")",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\\n",
"\\n",
"\\n",
... | // LogStack will log the current stack | [
"LogStack",
"will",
"log",
"the",
"current",
"stack"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/stats/stats.go#L78-L82 |
161,833 | argoproj/argo-cd | controller/state.go | NewAppStateManager | func NewAppStateManager(
db db.ArgoDB,
appclientset appclientset.Interface,
repoClientset reposerver.Clientset,
namespace string,
kubectl kubeutil.Kubectl,
settings *settings.ArgoCDSettings,
liveStateCache statecache.LiveStateCache,
projInformer cache.SharedIndexInformer,
metricsServer *metrics.MetricsServer,
) AppStateManager {
return &appStateManager{
liveStateCache: liveStateCache,
db: db,
appclientset: appclientset,
kubectl: kubectl,
repoClientset: repoClientset,
namespace: namespace,
settings: settings,
projInformer: projInformer,
metricsServer: metricsServer,
}
} | go | func NewAppStateManager(
db db.ArgoDB,
appclientset appclientset.Interface,
repoClientset reposerver.Clientset,
namespace string,
kubectl kubeutil.Kubectl,
settings *settings.ArgoCDSettings,
liveStateCache statecache.LiveStateCache,
projInformer cache.SharedIndexInformer,
metricsServer *metrics.MetricsServer,
) AppStateManager {
return &appStateManager{
liveStateCache: liveStateCache,
db: db,
appclientset: appclientset,
kubectl: kubectl,
repoClientset: repoClientset,
namespace: namespace,
settings: settings,
projInformer: projInformer,
metricsServer: metricsServer,
}
} | [
"func",
"NewAppStateManager",
"(",
"db",
"db",
".",
"ArgoDB",
",",
"appclientset",
"appclientset",
".",
"Interface",
",",
"repoClientset",
"reposerver",
".",
"Clientset",
",",
"namespace",
"string",
",",
"kubectl",
"kubeutil",
".",
"Kubectl",
",",
"settings",
"*... | // NewAppStateManager creates new instance of Ksonnet app comparator | [
"NewAppStateManager",
"creates",
"new",
"instance",
"of",
"Ksonnet",
"app",
"comparator"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/controller/state.go#L378-L400 |
161,834 | argoproj/argo-cd | server/application/application.pb.gw.go | RegisterApplicationServiceHandler | func RegisterApplicationServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterApplicationServiceHandlerClient(ctx, mux, NewApplicationServiceClient(conn))
} | go | func RegisterApplicationServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterApplicationServiceHandlerClient(ctx, mux, NewApplicationServiceClient(conn))
} | [
"func",
"RegisterApplicationServiceHandler",
"(",
"ctx",
"context",
".",
"Context",
",",
"mux",
"*",
"runtime",
".",
"ServeMux",
",",
"conn",
"*",
"grpc",
".",
"ClientConn",
")",
"error",
"{",
"return",
"RegisterApplicationServiceHandlerClient",
"(",
"ctx",
",",
... | // RegisterApplicationServiceHandler registers the http handlers for service ApplicationService to "mux".
// The handlers forward requests to the grpc endpoint over "conn". | [
"RegisterApplicationServiceHandler",
"registers",
"the",
"http",
"handlers",
"for",
"service",
"ApplicationService",
"to",
"mux",
".",
"The",
"handlers",
"forward",
"requests",
"to",
"the",
"grpc",
"endpoint",
"over",
"conn",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/application/application.pb.gw.go#L734-L736 |
161,835 | argoproj/argo-cd | util/git/client.go | Init | func (m *nativeGitClient) Init() error {
_, err := git.PlainOpen(m.root)
if err == nil {
return nil
}
if err != git.ErrRepositoryNotExists {
return err
}
log.Infof("Initializing %s to %s", m.repoURL, m.root)
_, err = exec.Command("rm", "-rf", m.root).Output()
if err != nil {
return fmt.Errorf("unable to clean repo at %s: %v", m.root, err)
}
err = os.MkdirAll(m.root, 0755)
if err != nil {
return err
}
repo, err := git.PlainInit(m.root, false)
if err != nil {
return err
}
_, err = repo.CreateRemote(&config.RemoteConfig{
Name: git.DefaultRemoteName,
URLs: []string{m.repoURL},
})
return err
} | go | func (m *nativeGitClient) Init() error {
_, err := git.PlainOpen(m.root)
if err == nil {
return nil
}
if err != git.ErrRepositoryNotExists {
return err
}
log.Infof("Initializing %s to %s", m.repoURL, m.root)
_, err = exec.Command("rm", "-rf", m.root).Output()
if err != nil {
return fmt.Errorf("unable to clean repo at %s: %v", m.root, err)
}
err = os.MkdirAll(m.root, 0755)
if err != nil {
return err
}
repo, err := git.PlainInit(m.root, false)
if err != nil {
return err
}
_, err = repo.CreateRemote(&config.RemoteConfig{
Name: git.DefaultRemoteName,
URLs: []string{m.repoURL},
})
return err
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"Init",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"git",
".",
"PlainOpen",
"(",
"m",
".",
"root",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",... | // Init initializes a local git repository and sets the remote origin | [
"Init",
"initializes",
"a",
"local",
"git",
"repository",
"and",
"sets",
"the",
"remote",
"origin"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L86-L112 |
161,836 | argoproj/argo-cd | util/git/client.go | Fetch | func (m *nativeGitClient) Fetch() error {
log.Debugf("Fetching repo %s at %s", m.repoURL, m.root)
// Two techniques are used for fetching the remote depending if the remote is SSH vs. HTTPS
// If http, we fork/exec the git CLI since the go-git client does not properly support git
// providers such as AWS CodeCommit and Azure DevOps.
if _, ok := m.auth.(*ssh2.PublicKeys); ok {
return m.goGitFetch()
}
_, err := m.runCredentialedCmd("git", "fetch", "origin", "--tags", "--force")
return err
} | go | func (m *nativeGitClient) Fetch() error {
log.Debugf("Fetching repo %s at %s", m.repoURL, m.root)
// Two techniques are used for fetching the remote depending if the remote is SSH vs. HTTPS
// If http, we fork/exec the git CLI since the go-git client does not properly support git
// providers such as AWS CodeCommit and Azure DevOps.
if _, ok := m.auth.(*ssh2.PublicKeys); ok {
return m.goGitFetch()
}
_, err := m.runCredentialedCmd("git", "fetch", "origin", "--tags", "--force")
return err
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"Fetch",
"(",
")",
"error",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"m",
".",
"repoURL",
",",
"m",
".",
"root",
")",
"\n",
"// Two techniques are used for fetching the remote depending if the remote is SSH ... | // Fetch fetches latest updates from origin | [
"Fetch",
"fetches",
"latest",
"updates",
"from",
"origin"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L115-L125 |
161,837 | argoproj/argo-cd | util/git/client.go | goGitFetch | func (m *nativeGitClient) goGitFetch() error {
repo, err := git.PlainOpen(m.root)
if err != nil {
return err
}
log.Debug("git fetch origin --tags --force")
err = repo.Fetch(&git.FetchOptions{
RemoteName: git.DefaultRemoteName,
Auth: m.auth,
Tags: git.AllTags,
Force: true,
})
if err == git.NoErrAlreadyUpToDate {
return nil
}
return err
} | go | func (m *nativeGitClient) goGitFetch() error {
repo, err := git.PlainOpen(m.root)
if err != nil {
return err
}
log.Debug("git fetch origin --tags --force")
err = repo.Fetch(&git.FetchOptions{
RemoteName: git.DefaultRemoteName,
Auth: m.auth,
Tags: git.AllTags,
Force: true,
})
if err == git.NoErrAlreadyUpToDate {
return nil
}
return err
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"goGitFetch",
"(",
")",
"error",
"{",
"repo",
",",
"err",
":=",
"git",
".",
"PlainOpen",
"(",
"m",
".",
"root",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"log",
".... | // goGitFetch fetches the remote using go-git | [
"goGitFetch",
"fetches",
"the",
"remote",
"using",
"go",
"-",
"git"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L128-L145 |
161,838 | argoproj/argo-cd | util/git/client.go | LsFiles | func (m *nativeGitClient) LsFiles(path string) ([]string, error) {
out, err := m.runCmd("git", "ls-files", "--full-name", "-z", "--", path)
if err != nil {
return nil, err
}
// remove last element, which is blank regardless of whether we're using nullbyte or newline
ss := strings.Split(out, "\000")
return ss[:len(ss)-1], nil
} | go | func (m *nativeGitClient) LsFiles(path string) ([]string, error) {
out, err := m.runCmd("git", "ls-files", "--full-name", "-z", "--", path)
if err != nil {
return nil, err
}
// remove last element, which is blank regardless of whether we're using nullbyte or newline
ss := strings.Split(out, "\000")
return ss[:len(ss)-1], nil
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"LsFiles",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"m",
".",
"runCmd",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
... | // LsFiles lists the local working tree, including only files that are under source control | [
"LsFiles",
"lists",
"the",
"local",
"working",
"tree",
"including",
"only",
"files",
"that",
"are",
"under",
"source",
"control"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L148-L156 |
161,839 | argoproj/argo-cd | util/git/client.go | Checkout | func (m *nativeGitClient) Checkout(revision string) error {
if revision == "" || revision == "HEAD" {
revision = "origin/HEAD"
}
if _, err := m.runCmd("git", "checkout", "--force", revision); err != nil {
return err
}
if _, err := m.runCmd("git", "clean", "-fdx"); err != nil {
return err
}
return nil
} | go | func (m *nativeGitClient) Checkout(revision string) error {
if revision == "" || revision == "HEAD" {
revision = "origin/HEAD"
}
if _, err := m.runCmd("git", "checkout", "--force", revision); err != nil {
return err
}
if _, err := m.runCmd("git", "clean", "-fdx"); err != nil {
return err
}
return nil
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"Checkout",
"(",
"revision",
"string",
")",
"error",
"{",
"if",
"revision",
"==",
"\"",
"\"",
"||",
"revision",
"==",
"\"",
"\"",
"{",
"revision",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"_",
",",
"err... | // Checkout checkout specified git sha | [
"Checkout",
"checkout",
"specified",
"git",
"sha"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L159-L170 |
161,840 | argoproj/argo-cd | util/git/client.go | LsRemote | func (m *nativeGitClient) LsRemote(revision string) (string, error) {
if IsCommitSHA(revision) {
return revision, nil
}
repo, err := git.Init(memory.NewStorage(), nil)
if err != nil {
return "", err
}
remote, err := repo.CreateRemote(&config.RemoteConfig{
Name: git.DefaultRemoteName,
URLs: []string{m.repoURL},
})
if err != nil {
return "", err
}
refs, err := remote.List(&git.ListOptions{Auth: m.auth})
if err != nil {
return "", err
}
if revision == "" {
revision = "HEAD"
}
// refToHash keeps a maps of remote refs to their hash
// (e.g. refs/heads/master -> a67038ae2e9cb9b9b16423702f98b41e36601001)
refToHash := make(map[string]string)
// refToResolve remembers ref name of the supplied revision if we determine the revision is a
// symbolic reference (like HEAD), in which case we will resolve it from the refToHash map
refToResolve := ""
for _, ref := range refs {
refName := ref.Name().String()
if refName != "HEAD" && !strings.HasPrefix(refName, "refs/heads/") && !strings.HasPrefix(refName, "refs/tags/") {
// ignore things like 'refs/pull/' 'refs/reviewable'
continue
}
hash := ref.Hash().String()
if ref.Type() == plumbing.HashReference {
refToHash[refName] = hash
}
//log.Debugf("%s\t%s", hash, refName)
if ref.Name().Short() == revision {
if ref.Type() == plumbing.HashReference {
log.Debugf("revision '%s' resolved to '%s'", revision, hash)
return hash, nil
}
if ref.Type() == plumbing.SymbolicReference {
refToResolve = ref.Target().String()
}
}
}
if refToResolve != "" {
// If refToResolve is non-empty, we are resolving symbolic reference (e.g. HEAD).
// It should exist in our refToHash map
if hash, ok := refToHash[refToResolve]; ok {
log.Debugf("symbolic reference '%s' (%s) resolved to '%s'", revision, refToResolve, hash)
return hash, nil
}
}
// We support the ability to use a truncated commit-SHA (e.g. first 7 characters of a SHA)
if IsTruncatedCommitSHA(revision) {
log.Debugf("revision '%s' assumed to be commit sha", revision)
return revision, nil
}
// If we get here, revision string had non hexadecimal characters (indicating its a branch, tag,
// or symbolic ref) and we were unable to resolve it to a commit SHA.
return "", fmt.Errorf("Unable to resolve '%s' to a commit SHA", revision)
} | go | func (m *nativeGitClient) LsRemote(revision string) (string, error) {
if IsCommitSHA(revision) {
return revision, nil
}
repo, err := git.Init(memory.NewStorage(), nil)
if err != nil {
return "", err
}
remote, err := repo.CreateRemote(&config.RemoteConfig{
Name: git.DefaultRemoteName,
URLs: []string{m.repoURL},
})
if err != nil {
return "", err
}
refs, err := remote.List(&git.ListOptions{Auth: m.auth})
if err != nil {
return "", err
}
if revision == "" {
revision = "HEAD"
}
// refToHash keeps a maps of remote refs to their hash
// (e.g. refs/heads/master -> a67038ae2e9cb9b9b16423702f98b41e36601001)
refToHash := make(map[string]string)
// refToResolve remembers ref name of the supplied revision if we determine the revision is a
// symbolic reference (like HEAD), in which case we will resolve it from the refToHash map
refToResolve := ""
for _, ref := range refs {
refName := ref.Name().String()
if refName != "HEAD" && !strings.HasPrefix(refName, "refs/heads/") && !strings.HasPrefix(refName, "refs/tags/") {
// ignore things like 'refs/pull/' 'refs/reviewable'
continue
}
hash := ref.Hash().String()
if ref.Type() == plumbing.HashReference {
refToHash[refName] = hash
}
//log.Debugf("%s\t%s", hash, refName)
if ref.Name().Short() == revision {
if ref.Type() == plumbing.HashReference {
log.Debugf("revision '%s' resolved to '%s'", revision, hash)
return hash, nil
}
if ref.Type() == plumbing.SymbolicReference {
refToResolve = ref.Target().String()
}
}
}
if refToResolve != "" {
// If refToResolve is non-empty, we are resolving symbolic reference (e.g. HEAD).
// It should exist in our refToHash map
if hash, ok := refToHash[refToResolve]; ok {
log.Debugf("symbolic reference '%s' (%s) resolved to '%s'", revision, refToResolve, hash)
return hash, nil
}
}
// We support the ability to use a truncated commit-SHA (e.g. first 7 characters of a SHA)
if IsTruncatedCommitSHA(revision) {
log.Debugf("revision '%s' assumed to be commit sha", revision)
return revision, nil
}
// If we get here, revision string had non hexadecimal characters (indicating its a branch, tag,
// or symbolic ref) and we were unable to resolve it to a commit SHA.
return "", fmt.Errorf("Unable to resolve '%s' to a commit SHA", revision)
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"LsRemote",
"(",
"revision",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"IsCommitSHA",
"(",
"revision",
")",
"{",
"return",
"revision",
",",
"nil",
"\n",
"}",
"\n",
"repo",
",",
"err",
"... | // LsRemote resolves the commit SHA of a specific branch, tag, or HEAD. If the supplied revision
// does not resolve, and "looks" like a 7+ hexadecimal commit SHA, it return the revision string.
// Otherwise, it returns an error indicating that the revision could not be resolved. This method
// runs with in-memory storage and is safe to run concurrently, or to be run without a git
// repository locally cloned. | [
"LsRemote",
"resolves",
"the",
"commit",
"SHA",
"of",
"a",
"specific",
"branch",
"tag",
"or",
"HEAD",
".",
"If",
"the",
"supplied",
"revision",
"does",
"not",
"resolve",
"and",
"looks",
"like",
"a",
"7",
"+",
"hexadecimal",
"commit",
"SHA",
"it",
"return",... | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L177-L242 |
161,841 | argoproj/argo-cd | util/git/client.go | CommitSHA | func (m *nativeGitClient) CommitSHA() (string, error) {
out, err := m.runCmd("git", "rev-parse", "HEAD")
if err != nil {
return "", err
}
return strings.TrimSpace(out), nil
} | go | func (m *nativeGitClient) CommitSHA() (string, error) {
out, err := m.runCmd("git", "rev-parse", "HEAD")
if err != nil {
return "", err
}
return strings.TrimSpace(out), nil
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"CommitSHA",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"m",
".",
"runCmd",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // CommitSHA returns current commit sha from `git rev-parse HEAD` | [
"CommitSHA",
"returns",
"current",
"commit",
"sha",
"from",
"git",
"rev",
"-",
"parse",
"HEAD"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L245-L251 |
161,842 | argoproj/argo-cd | util/git/client.go | runCmd | func (m *nativeGitClient) runCmd(command string, args ...string) (string, error) {
cmd := exec.Command(command, args...)
return m.runCmdOutput(cmd)
} | go | func (m *nativeGitClient) runCmd(command string, args ...string) (string, error) {
cmd := exec.Command(command, args...)
return m.runCmdOutput(cmd)
} | [
"func",
"(",
"m",
"*",
"nativeGitClient",
")",
"runCmd",
"(",
"command",
"string",
",",
"args",
"...",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"command",
",",
"args",
"...",
")",
"\n",
"return",... | // runCmd is a convenience function to run a command in a given directory and return its output | [
"runCmd",
"is",
"a",
"convenience",
"function",
"to",
"run",
"a",
"command",
"in",
"a",
"given",
"directory",
"and",
"return",
"its",
"output"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/git/client.go#L254-L257 |
161,843 | argoproj/argo-cd | pkg/client/clientset/versioned/typed/application/v1alpha1/application.go | newApplications | func newApplications(c *ArgoprojV1alpha1Client, namespace string) *applications {
return &applications{
client: c.RESTClient(),
ns: namespace,
}
} | go | func newApplications(c *ArgoprojV1alpha1Client, namespace string) *applications {
return &applications{
client: c.RESTClient(),
ns: namespace,
}
} | [
"func",
"newApplications",
"(",
"c",
"*",
"ArgoprojV1alpha1Client",
",",
"namespace",
"string",
")",
"*",
"applications",
"{",
"return",
"&",
"applications",
"{",
"client",
":",
"c",
".",
"RESTClient",
"(",
")",
",",
"ns",
":",
"namespace",
",",
"}",
"\n",... | // newApplications returns a Applications | [
"newApplications",
"returns",
"a",
"Applications"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/client/clientset/versioned/typed/application/v1alpha1/application.go#L40-L45 |
161,844 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationCommand | func NewApplicationCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "app",
Short: "Manage applications",
Example: appExample,
Run: func(c *cobra.Command, args []string) {
c.HelpFunc()(c, args)
os.Exit(1)
},
}
command.AddCommand(NewApplicationCreateCommand(clientOpts))
command.AddCommand(NewApplicationGetCommand(clientOpts))
command.AddCommand(NewApplicationDiffCommand(clientOpts))
command.AddCommand(NewApplicationSetCommand(clientOpts))
command.AddCommand(NewApplicationUnsetCommand(clientOpts))
command.AddCommand(NewApplicationSyncCommand(clientOpts))
command.AddCommand(NewApplicationHistoryCommand(clientOpts))
command.AddCommand(NewApplicationRollbackCommand(clientOpts))
command.AddCommand(NewApplicationListCommand(clientOpts))
command.AddCommand(NewApplicationDeleteCommand(clientOpts))
command.AddCommand(NewApplicationWaitCommand(clientOpts))
command.AddCommand(NewApplicationManifestsCommand(clientOpts))
command.AddCommand(NewApplicationTerminateOpCommand(clientOpts))
command.AddCommand(NewApplicationEditCommand(clientOpts))
command.AddCommand(NewApplicationPatchCommand(clientOpts))
command.AddCommand(NewApplicationPatchResourceCommand(clientOpts))
command.AddCommand(NewApplicationResourceActionsCommand(clientOpts))
return command
} | go | func NewApplicationCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "app",
Short: "Manage applications",
Example: appExample,
Run: func(c *cobra.Command, args []string) {
c.HelpFunc()(c, args)
os.Exit(1)
},
}
command.AddCommand(NewApplicationCreateCommand(clientOpts))
command.AddCommand(NewApplicationGetCommand(clientOpts))
command.AddCommand(NewApplicationDiffCommand(clientOpts))
command.AddCommand(NewApplicationSetCommand(clientOpts))
command.AddCommand(NewApplicationUnsetCommand(clientOpts))
command.AddCommand(NewApplicationSyncCommand(clientOpts))
command.AddCommand(NewApplicationHistoryCommand(clientOpts))
command.AddCommand(NewApplicationRollbackCommand(clientOpts))
command.AddCommand(NewApplicationListCommand(clientOpts))
command.AddCommand(NewApplicationDeleteCommand(clientOpts))
command.AddCommand(NewApplicationWaitCommand(clientOpts))
command.AddCommand(NewApplicationManifestsCommand(clientOpts))
command.AddCommand(NewApplicationTerminateOpCommand(clientOpts))
command.AddCommand(NewApplicationEditCommand(clientOpts))
command.AddCommand(NewApplicationPatchCommand(clientOpts))
command.AddCommand(NewApplicationPatchResourceCommand(clientOpts))
command.AddCommand(NewApplicationResourceActionsCommand(clientOpts))
return command
} | [
"func",
"NewApplicationCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
... | // NewApplicationCommand returns a new instance of an `argocd app` command | [
"NewApplicationCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L62-L90 |
161,845 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationCreateCommand | func NewApplicationCreateCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
appOpts appOptions
fileURL string
appName string
upsert bool
)
var command = &cobra.Command{
Use: "create APPNAME",
Short: "Create an application from a git location",
Run: func(c *cobra.Command, args []string) {
var app argoappv1.Application
argocdClient := argocdclient.NewClientOrDie(clientOpts)
if fileURL != "" {
parsedURL, err := url.ParseRequestURI(fileURL)
if err != nil || !(parsedURL.Scheme == "http" || parsedURL.Scheme == "https") {
err = config.UnmarshalLocalFile(fileURL, &app)
} else {
err = config.UnmarshalRemoteFile(fileURL, &app)
}
errors.CheckError(err)
if len(args) == 1 && args[0] != app.Name {
log.Fatalf("app name '%s' does not match app spec metadata.name '%s'", args[0], app.Name)
}
if appName != "" && appName != app.Name {
log.Fatalf("--name argument '%s' does not match app spec metadata.name '%s'", appName, app.Name)
}
} else {
if len(args) == 1 {
if appName != "" && appName != args[0] {
log.Fatalf("--name argument '%s' does not match app name %s", appName, args[0])
}
appName = args[0]
}
app = argoappv1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: appName,
},
}
setAppOptions(c.Flags(), &app, &appOpts)
setParameterOverrides(&app, appOpts.parameters)
}
if app.Name == "" {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, appIf := argocdClient.NewApplicationClientOrDie()
defer util.Close(conn)
appCreateRequest := application.ApplicationCreateRequest{
Application: app,
Upsert: &upsert,
}
created, err := appIf.Create(context.Background(), &appCreateRequest)
errors.CheckError(err)
fmt.Printf("application '%s' created\n", created.ObjectMeta.Name)
},
}
command.Flags().StringVarP(&fileURL, "file", "f", "", "Filename or URL to Kubernetes manifests for the app")
command.Flags().StringVar(&appName, "name", "", "A name for the app, ignored if a file is set (DEPRECATED)")
command.Flags().BoolVar(&upsert, "upsert", false, "Allows to override application with the same name even if supplied application spec is different from existing spec")
addAppFlags(command, &appOpts)
return command
} | go | func NewApplicationCreateCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
appOpts appOptions
fileURL string
appName string
upsert bool
)
var command = &cobra.Command{
Use: "create APPNAME",
Short: "Create an application from a git location",
Run: func(c *cobra.Command, args []string) {
var app argoappv1.Application
argocdClient := argocdclient.NewClientOrDie(clientOpts)
if fileURL != "" {
parsedURL, err := url.ParseRequestURI(fileURL)
if err != nil || !(parsedURL.Scheme == "http" || parsedURL.Scheme == "https") {
err = config.UnmarshalLocalFile(fileURL, &app)
} else {
err = config.UnmarshalRemoteFile(fileURL, &app)
}
errors.CheckError(err)
if len(args) == 1 && args[0] != app.Name {
log.Fatalf("app name '%s' does not match app spec metadata.name '%s'", args[0], app.Name)
}
if appName != "" && appName != app.Name {
log.Fatalf("--name argument '%s' does not match app spec metadata.name '%s'", appName, app.Name)
}
} else {
if len(args) == 1 {
if appName != "" && appName != args[0] {
log.Fatalf("--name argument '%s' does not match app name %s", appName, args[0])
}
appName = args[0]
}
app = argoappv1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: appName,
},
}
setAppOptions(c.Flags(), &app, &appOpts)
setParameterOverrides(&app, appOpts.parameters)
}
if app.Name == "" {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, appIf := argocdClient.NewApplicationClientOrDie()
defer util.Close(conn)
appCreateRequest := application.ApplicationCreateRequest{
Application: app,
Upsert: &upsert,
}
created, err := appIf.Create(context.Background(), &appCreateRequest)
errors.CheckError(err)
fmt.Printf("application '%s' created\n", created.ObjectMeta.Name)
},
}
command.Flags().StringVarP(&fileURL, "file", "f", "", "Filename or URL to Kubernetes manifests for the app")
command.Flags().StringVar(&appName, "name", "", "A name for the app, ignored if a file is set (DEPRECATED)")
command.Flags().BoolVar(&upsert, "upsert", false, "Allows to override application with the same name even if supplied application spec is different from existing spec")
addAppFlags(command, &appOpts)
return command
} | [
"func",
"NewApplicationCreateCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"appOpts",
"appOptions",
"\n",
"fileURL",
"string",
"\n",
"appName",
"string",
"\n",
"upsert",
"bool",
"\n",
... | // NewApplicationCreateCommand returns a new instance of an `argocd app create` command | [
"NewApplicationCreateCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"create",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L93-L155 |
161,846 | argoproj/argo-cd | cmd/argocd/commands/app.go | appURL | func appURL(acdClient argocdclient.Client, appName string) string {
var scheme string
opts := acdClient.ClientOptions()
server := opts.ServerAddr
if opts.PlainText {
scheme = "http"
} else {
scheme = "https"
if strings.HasSuffix(opts.ServerAddr, ":443") {
server = server[0 : len(server)-4]
}
}
return fmt.Sprintf("%s://%s/applications/%s", scheme, server, appName)
} | go | func appURL(acdClient argocdclient.Client, appName string) string {
var scheme string
opts := acdClient.ClientOptions()
server := opts.ServerAddr
if opts.PlainText {
scheme = "http"
} else {
scheme = "https"
if strings.HasSuffix(opts.ServerAddr, ":443") {
server = server[0 : len(server)-4]
}
}
return fmt.Sprintf("%s://%s/applications/%s", scheme, server, appName)
} | [
"func",
"appURL",
"(",
"acdClient",
"argocdclient",
".",
"Client",
",",
"appName",
"string",
")",
"string",
"{",
"var",
"scheme",
"string",
"\n",
"opts",
":=",
"acdClient",
".",
"ClientOptions",
"(",
")",
"\n",
"server",
":=",
"opts",
".",
"ServerAddr",
"\... | // appURL returns the URL of an application | [
"appURL",
"returns",
"the",
"URL",
"of",
"an",
"application"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L298-L311 |
161,847 | argoproj/argo-cd | cmd/argocd/commands/app.go | printParams | func printParams(app *argoappv1.Application, appIf application.ApplicationServiceClient) {
paramLenLimit := 80
fmt.Println()
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
if app.Spec.Source.Ksonnet != nil {
fmt.Println()
fmt.Fprintf(w, "COMPONENT\tNAME\tVALUE\n")
for _, p := range app.Spec.Source.Ksonnet.Parameters {
fmt.Fprintf(w, "%s\t%s\t%s\n", p.Component, p.Name, truncateString(p.Value, paramLenLimit))
}
} else if app.Spec.Source.Helm != nil {
fmt.Println()
fmt.Fprintf(w, "NAME\tVALUE\n")
for _, p := range app.Spec.Source.Helm.Parameters {
fmt.Fprintf(w, "%s\t%s\n", p.Name, truncateString(p.Value, paramLenLimit))
}
}
_ = w.Flush()
} | go | func printParams(app *argoappv1.Application, appIf application.ApplicationServiceClient) {
paramLenLimit := 80
fmt.Println()
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
if app.Spec.Source.Ksonnet != nil {
fmt.Println()
fmt.Fprintf(w, "COMPONENT\tNAME\tVALUE\n")
for _, p := range app.Spec.Source.Ksonnet.Parameters {
fmt.Fprintf(w, "%s\t%s\t%s\n", p.Component, p.Name, truncateString(p.Value, paramLenLimit))
}
} else if app.Spec.Source.Helm != nil {
fmt.Println()
fmt.Fprintf(w, "NAME\tVALUE\n")
for _, p := range app.Spec.Source.Helm.Parameters {
fmt.Fprintf(w, "%s\t%s\n", p.Name, truncateString(p.Value, paramLenLimit))
}
}
_ = w.Flush()
} | [
"func",
"printParams",
"(",
"app",
"*",
"argoappv1",
".",
"Application",
",",
"appIf",
"application",
".",
"ApplicationServiceClient",
")",
"{",
"paramLenLimit",
":=",
"80",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"w",
":=",
"tabwriter",
".",
"NewWriter... | // printParams prints parameters and overrides | [
"printParams",
"prints",
"parameters",
"and",
"overrides"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L325-L343 |
161,848 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationSetCommand | func NewApplicationSetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
appOpts appOptions
)
var command = &cobra.Command{
Use: "set APPNAME",
Short: "Set application parameters",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
ctx := context.Background()
appName := args[0]
argocdClient := argocdclient.NewClientOrDie(clientOpts)
conn, appIf := argocdClient.NewApplicationClientOrDie()
defer util.Close(conn)
app, err := appIf.Get(ctx, &application.ApplicationQuery{Name: &appName})
errors.CheckError(err)
visited := setAppOptions(c.Flags(), app, &appOpts)
if visited == 0 {
log.Error("Please set at least one option to update")
c.HelpFunc()(c, args)
os.Exit(1)
}
setParameterOverrides(app, appOpts.parameters)
_, err = appIf.UpdateSpec(ctx, &application.ApplicationUpdateSpecRequest{
Name: &app.Name,
Spec: app.Spec,
})
errors.CheckError(err)
},
}
addAppFlags(command, &appOpts)
return command
} | go | func NewApplicationSetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
appOpts appOptions
)
var command = &cobra.Command{
Use: "set APPNAME",
Short: "Set application parameters",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
ctx := context.Background()
appName := args[0]
argocdClient := argocdclient.NewClientOrDie(clientOpts)
conn, appIf := argocdClient.NewApplicationClientOrDie()
defer util.Close(conn)
app, err := appIf.Get(ctx, &application.ApplicationQuery{Name: &appName})
errors.CheckError(err)
visited := setAppOptions(c.Flags(), app, &appOpts)
if visited == 0 {
log.Error("Please set at least one option to update")
c.HelpFunc()(c, args)
os.Exit(1)
}
setParameterOverrides(app, appOpts.parameters)
_, err = appIf.UpdateSpec(ctx, &application.ApplicationUpdateSpecRequest{
Name: &app.Name,
Spec: app.Spec,
})
errors.CheckError(err)
},
}
addAppFlags(command, &appOpts)
return command
} | [
"func",
"NewApplicationSetCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"appOpts",
"appOptions",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
... | // NewApplicationSetCommand returns a new instance of an `argocd app set` command | [
"NewApplicationSetCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"set",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L346-L381 |
161,849 | argoproj/argo-cd | cmd/argocd/commands/app.go | targetObjects | func targetObjects(resources []*argoappv1.ResourceDiff) ([]*unstructured.Unstructured, error) {
objs := make([]*unstructured.Unstructured, len(resources))
for i, resState := range resources {
obj, err := resState.TargetObject()
if err != nil {
return nil, err
}
objs[i] = obj
}
return objs, nil
} | go | func targetObjects(resources []*argoappv1.ResourceDiff) ([]*unstructured.Unstructured, error) {
objs := make([]*unstructured.Unstructured, len(resources))
for i, resState := range resources {
obj, err := resState.TargetObject()
if err != nil {
return nil, err
}
objs[i] = obj
}
return objs, nil
} | [
"func",
"targetObjects",
"(",
"resources",
"[",
"]",
"*",
"argoappv1",
".",
"ResourceDiff",
")",
"(",
"[",
"]",
"*",
"unstructured",
".",
"Unstructured",
",",
"error",
")",
"{",
"objs",
":=",
"make",
"(",
"[",
"]",
"*",
"unstructured",
".",
"Unstructured... | // targetObjects deserializes the list of target states into unstructured objects | [
"targetObjects",
"deserializes",
"the",
"list",
"of",
"target",
"states",
"into",
"unstructured",
"objects"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L580-L590 |
161,850 | argoproj/argo-cd | cmd/argocd/commands/app.go | liveObjects | func liveObjects(resources []*argoappv1.ResourceDiff) ([]*unstructured.Unstructured, error) {
objs := make([]*unstructured.Unstructured, len(resources))
for i, resState := range resources {
obj, err := resState.LiveObject()
if err != nil {
return nil, err
}
objs[i] = obj
}
return objs, nil
} | go | func liveObjects(resources []*argoappv1.ResourceDiff) ([]*unstructured.Unstructured, error) {
objs := make([]*unstructured.Unstructured, len(resources))
for i, resState := range resources {
obj, err := resState.LiveObject()
if err != nil {
return nil, err
}
objs[i] = obj
}
return objs, nil
} | [
"func",
"liveObjects",
"(",
"resources",
"[",
"]",
"*",
"argoappv1",
".",
"ResourceDiff",
")",
"(",
"[",
"]",
"*",
"unstructured",
".",
"Unstructured",
",",
"error",
")",
"{",
"objs",
":=",
"make",
"(",
"[",
"]",
"*",
"unstructured",
".",
"Unstructured",... | // liveObjects deserializes the list of live states into unstructured objects | [
"liveObjects",
"deserializes",
"the",
"list",
"of",
"live",
"states",
"into",
"unstructured",
"objects"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L593-L603 |
161,851 | argoproj/argo-cd | cmd/argocd/commands/app.go | IsNamespaced | func (p *resourceInfoProvider) IsNamespaced(server string, obj *unstructured.Unstructured) (bool, error) {
key := kube.GetResourceKey(obj)
return p.namespacedByGk[key.GroupKind()], nil
} | go | func (p *resourceInfoProvider) IsNamespaced(server string, obj *unstructured.Unstructured) (bool, error) {
key := kube.GetResourceKey(obj)
return p.namespacedByGk[key.GroupKind()], nil
} | [
"func",
"(",
"p",
"*",
"resourceInfoProvider",
")",
"IsNamespaced",
"(",
"server",
"string",
",",
"obj",
"*",
"unstructured",
".",
"Unstructured",
")",
"(",
"bool",
",",
"error",
")",
"{",
"key",
":=",
"kube",
".",
"GetResourceKey",
"(",
"obj",
")",
"\n"... | // Infer if obj is namespaced or not from corresponding live objects list. If corresponding live object has namespace then target object is also namespaced.
// If live object is missing then it does not matter if target is namespaced or not. | [
"Infer",
"if",
"obj",
"is",
"namespaced",
"or",
"not",
"from",
"corresponding",
"live",
"objects",
"list",
".",
"If",
"corresponding",
"live",
"object",
"has",
"namespace",
"then",
"target",
"object",
"is",
"also",
"namespaced",
".",
"If",
"live",
"object",
... | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L629-L632 |
161,852 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationDeleteCommand | func NewApplicationDeleteCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
cascade bool
)
var command = &cobra.Command{
Use: "delete APPNAME",
Short: "Delete an application",
Run: func(c *cobra.Command, args []string) {
if len(args) == 0 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
for _, appName := range args {
appDeleteReq := application.ApplicationDeleteRequest{
Name: &appName,
}
if c.Flag("cascade").Changed {
appDeleteReq.Cascade = &cascade
}
_, err := appIf.Delete(context.Background(), &appDeleteReq)
errors.CheckError(err)
}
},
}
command.Flags().BoolVar(&cascade, "cascade", true, "Perform a cascaded deletion of all application resources")
return command
} | go | func NewApplicationDeleteCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
cascade bool
)
var command = &cobra.Command{
Use: "delete APPNAME",
Short: "Delete an application",
Run: func(c *cobra.Command, args []string) {
if len(args) == 0 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
for _, appName := range args {
appDeleteReq := application.ApplicationDeleteRequest{
Name: &appName,
}
if c.Flag("cascade").Changed {
appDeleteReq.Cascade = &cascade
}
_, err := appIf.Delete(context.Background(), &appDeleteReq)
errors.CheckError(err)
}
},
}
command.Flags().BoolVar(&cascade, "cascade", true, "Perform a cascaded deletion of all application resources")
return command
} | [
"func",
"NewApplicationDeleteCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"cascade",
"bool",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":... | // NewApplicationDeleteCommand returns a new instance of an `argocd app delete` command | [
"NewApplicationDeleteCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"delete",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L845-L873 |
161,853 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationListCommand | func NewApplicationListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
output string
)
var command = &cobra.Command{
Use: "list",
Short: "List applications",
Run: func(c *cobra.Command, args []string) {
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
apps, err := appIf.List(context.Background(), &application.ApplicationQuery{})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
var fmtStr string
headers := []interface{}{"NAME", "CLUSTER", "NAMESPACE", "PROJECT", "STATUS", "HEALTH", "SYNCPOLICY", "CONDITIONS"}
if output == "wide" {
fmtStr = "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"
headers = append(headers, "REPO", "PATH", "TARGET")
} else {
fmtStr = "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"
}
fmt.Fprintf(w, fmtStr, headers...)
for _, app := range apps.Items {
vals := []interface{}{
app.Name,
app.Spec.Destination.Server,
app.Spec.Destination.Namespace,
app.Spec.GetProject(),
app.Status.Sync.Status,
app.Status.Health.Status,
formatSyncPolicy(app),
formatConditionsSummary(app),
}
if output == "wide" {
vals = append(vals, app.Spec.Source.RepoURL, app.Spec.Source.Path, app.Spec.Source.TargetRevision)
}
fmt.Fprintf(w, fmtStr, vals...)
}
_ = w.Flush()
},
}
command.Flags().StringVarP(&output, "output", "o", "", "Output format. One of: wide")
return command
} | go | func NewApplicationListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
output string
)
var command = &cobra.Command{
Use: "list",
Short: "List applications",
Run: func(c *cobra.Command, args []string) {
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
apps, err := appIf.List(context.Background(), &application.ApplicationQuery{})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
var fmtStr string
headers := []interface{}{"NAME", "CLUSTER", "NAMESPACE", "PROJECT", "STATUS", "HEALTH", "SYNCPOLICY", "CONDITIONS"}
if output == "wide" {
fmtStr = "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"
headers = append(headers, "REPO", "PATH", "TARGET")
} else {
fmtStr = "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"
}
fmt.Fprintf(w, fmtStr, headers...)
for _, app := range apps.Items {
vals := []interface{}{
app.Name,
app.Spec.Destination.Server,
app.Spec.Destination.Namespace,
app.Spec.GetProject(),
app.Status.Sync.Status,
app.Status.Health.Status,
formatSyncPolicy(app),
formatConditionsSummary(app),
}
if output == "wide" {
vals = append(vals, app.Spec.Source.RepoURL, app.Spec.Source.Path, app.Spec.Source.TargetRevision)
}
fmt.Fprintf(w, fmtStr, vals...)
}
_ = w.Flush()
},
}
command.Flags().StringVarP(&output, "output", "o", "", "Output format. One of: wide")
return command
} | [
"func",
"NewApplicationListCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"output",
"string",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":"... | // NewApplicationListCommand returns a new instance of an `argocd app list` command | [
"NewApplicationListCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"list",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L876-L919 |
161,854 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationWaitCommand | func NewApplicationWaitCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
watchSync bool
watchHealth bool
watchSuspended bool
watchOperations bool
timeout uint
resources []string
)
var command = &cobra.Command{
Use: "wait APPNAME",
Short: "Wait for an application to reach a synced and healthy state",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
if !watchSync && !watchHealth && !watchOperations && !watchSuspended {
watchSync = true
watchHealth = true
watchOperations = true
watchSuspended = false
}
selectedResources := parseSelectedResources(resources)
appName := args[0]
acdClient := argocdclient.NewClientOrDie(clientOpts)
_, err := waitOnApplicationStatus(acdClient, appName, timeout, watchSync, watchHealth, watchOperations, watchSuspended, selectedResources)
errors.CheckError(err)
},
}
command.Flags().BoolVar(&watchSync, "sync", false, "Wait for sync")
command.Flags().BoolVar(&watchHealth, "health", false, "Wait for health")
command.Flags().BoolVar(&watchSuspended, "suspended", false, "Wait for suspended")
command.Flags().StringArrayVar(&resources, "resource", []string{}, fmt.Sprintf("Sync only specific resources as GROUP%sKIND%sNAME. Fields may be blank. This option may be specified repeatedly", resourceFieldDelimiter, resourceFieldDelimiter))
command.Flags().BoolVar(&watchOperations, "operation", false, "Wait for pending operations")
command.Flags().UintVar(&timeout, "timeout", defaultCheckTimeoutSeconds, "Time out after this many seconds")
return command
} | go | func NewApplicationWaitCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
watchSync bool
watchHealth bool
watchSuspended bool
watchOperations bool
timeout uint
resources []string
)
var command = &cobra.Command{
Use: "wait APPNAME",
Short: "Wait for an application to reach a synced and healthy state",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
if !watchSync && !watchHealth && !watchOperations && !watchSuspended {
watchSync = true
watchHealth = true
watchOperations = true
watchSuspended = false
}
selectedResources := parseSelectedResources(resources)
appName := args[0]
acdClient := argocdclient.NewClientOrDie(clientOpts)
_, err := waitOnApplicationStatus(acdClient, appName, timeout, watchSync, watchHealth, watchOperations, watchSuspended, selectedResources)
errors.CheckError(err)
},
}
command.Flags().BoolVar(&watchSync, "sync", false, "Wait for sync")
command.Flags().BoolVar(&watchHealth, "health", false, "Wait for health")
command.Flags().BoolVar(&watchSuspended, "suspended", false, "Wait for suspended")
command.Flags().StringArrayVar(&resources, "resource", []string{}, fmt.Sprintf("Sync only specific resources as GROUP%sKIND%sNAME. Fields may be blank. This option may be specified repeatedly", resourceFieldDelimiter, resourceFieldDelimiter))
command.Flags().BoolVar(&watchOperations, "operation", false, "Wait for pending operations")
command.Flags().UintVar(&timeout, "timeout", defaultCheckTimeoutSeconds, "Time out after this many seconds")
return command
} | [
"func",
"NewApplicationWaitCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"watchSync",
"bool",
"\n",
"watchHealth",
"bool",
"\n",
"watchSuspended",
"bool",
"\n",
"watchOperations",
"bool"... | // NewApplicationWaitCommand returns a new instance of an `argocd app wait` command | [
"NewApplicationWaitCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"wait",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L999-L1036 |
161,855 | argoproj/argo-cd | cmd/argocd/commands/app.go | printAppResources | func printAppResources(w io.Writer, app *argoappv1.Application, showOperation bool) {
messages := make(map[string]string)
opState := app.Status.OperationState
var syncRes *argoappv1.SyncOperationResult
if showOperation {
fmt.Fprintf(w, "GROUP\tKIND\tNAMESPACE\tNAME\tSTATUS\tHEALTH\tHOOK\tMESSAGE\n")
if opState != nil {
if opState.SyncResult != nil {
syncRes = opState.SyncResult
}
}
if syncRes != nil {
for _, res := range syncRes.Resources {
if !res.IsHook() {
messages[fmt.Sprintf("%s/%s/%s/%s", res.Group, res.Kind, res.Namespace, res.Name)] = res.Message
} else if res.HookType == argoappv1.HookTypePreSync {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", res.Group, res.Kind, res.Namespace, res.Name, res.HookPhase, "", res.HookType, res.Message)
}
}
}
} else {
fmt.Fprintf(w, "GROUP\tKIND\tNAMESPACE\tNAME\tSTATUS\tHEALTH\n")
}
for _, res := range app.Status.Resources {
healthStatus := ""
if res.Health != nil {
healthStatus = res.Health.Status
}
if showOperation {
message := messages[fmt.Sprintf("%s/%s/%s/%s", res.Group, res.Kind, res.Namespace, res.Name)]
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s", res.Group, res.Kind, res.Namespace, res.Name, res.Status, healthStatus, "", message)
} else {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s", res.Group, res.Kind, res.Namespace, res.Name, res.Status, healthStatus)
}
fmt.Fprint(w, "\n")
}
if showOperation && syncRes != nil {
for _, res := range syncRes.Resources {
if res.HookType == argoappv1.HookTypeSync || res.HookType == argoappv1.HookTypePostSync {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", res.Group, res.Kind, res.Namespace, res.Name, res.HookPhase, "", res.HookType, res.Message)
}
}
}
} | go | func printAppResources(w io.Writer, app *argoappv1.Application, showOperation bool) {
messages := make(map[string]string)
opState := app.Status.OperationState
var syncRes *argoappv1.SyncOperationResult
if showOperation {
fmt.Fprintf(w, "GROUP\tKIND\tNAMESPACE\tNAME\tSTATUS\tHEALTH\tHOOK\tMESSAGE\n")
if opState != nil {
if opState.SyncResult != nil {
syncRes = opState.SyncResult
}
}
if syncRes != nil {
for _, res := range syncRes.Resources {
if !res.IsHook() {
messages[fmt.Sprintf("%s/%s/%s/%s", res.Group, res.Kind, res.Namespace, res.Name)] = res.Message
} else if res.HookType == argoappv1.HookTypePreSync {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", res.Group, res.Kind, res.Namespace, res.Name, res.HookPhase, "", res.HookType, res.Message)
}
}
}
} else {
fmt.Fprintf(w, "GROUP\tKIND\tNAMESPACE\tNAME\tSTATUS\tHEALTH\n")
}
for _, res := range app.Status.Resources {
healthStatus := ""
if res.Health != nil {
healthStatus = res.Health.Status
}
if showOperation {
message := messages[fmt.Sprintf("%s/%s/%s/%s", res.Group, res.Kind, res.Namespace, res.Name)]
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s", res.Group, res.Kind, res.Namespace, res.Name, res.Status, healthStatus, "", message)
} else {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s", res.Group, res.Kind, res.Namespace, res.Name, res.Status, healthStatus)
}
fmt.Fprint(w, "\n")
}
if showOperation && syncRes != nil {
for _, res := range syncRes.Resources {
if res.HookType == argoappv1.HookTypeSync || res.HookType == argoappv1.HookTypePostSync {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", res.Group, res.Kind, res.Namespace, res.Name, res.HookPhase, "", res.HookType, res.Message)
}
}
}
} | [
"func",
"printAppResources",
"(",
"w",
"io",
".",
"Writer",
",",
"app",
"*",
"argoappv1",
".",
"Application",
",",
"showOperation",
"bool",
")",
"{",
"messages",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"opState",
":=",
"app",
... | // printAppResources prints the resources of an application in a tabwriter table
// Optionally prints the message from the operation state | [
"printAppResources",
"prints",
"the",
"resources",
"of",
"an",
"application",
"in",
"a",
"tabwriter",
"table",
"Optionally",
"prints",
"the",
"message",
"from",
"the",
"operation",
"state"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1040-L1085 |
161,856 | argoproj/argo-cd | cmd/argocd/commands/app.go | Key | func (rs *resourceState) Key() string {
return fmt.Sprintf("%s/%s/%s/%s", rs.Group, rs.Kind, rs.Namespace, rs.Name)
} | go | func (rs *resourceState) Key() string {
return fmt.Sprintf("%s/%s/%s/%s", rs.Group, rs.Kind, rs.Namespace, rs.Name)
} | [
"func",
"(",
"rs",
"*",
"resourceState",
")",
"Key",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"rs",
".",
"Group",
",",
"rs",
".",
"Kind",
",",
"rs",
".",
"Namespace",
",",
"rs",
".",
"Name",
")",
"\n",
"}"... | // Key returns a unique-ish key for the resource. | [
"Key",
"returns",
"a",
"unique",
"-",
"ish",
"key",
"for",
"the",
"resource",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1249-L1251 |
161,857 | argoproj/argo-cd | cmd/argocd/commands/app.go | Merge | func (rs *resourceState) Merge(newState *resourceState) bool {
updated := false
for _, field := range []string{"Status", "Health", "Hook", "Message"} {
v := reflect.ValueOf(rs).Elem().FieldByName(field)
currVal := v.String()
newVal := reflect.ValueOf(newState).Elem().FieldByName(field).String()
if newVal != "" && currVal != newVal {
v.SetString(newVal)
updated = true
}
}
return updated
} | go | func (rs *resourceState) Merge(newState *resourceState) bool {
updated := false
for _, field := range []string{"Status", "Health", "Hook", "Message"} {
v := reflect.ValueOf(rs).Elem().FieldByName(field)
currVal := v.String()
newVal := reflect.ValueOf(newState).Elem().FieldByName(field).String()
if newVal != "" && currVal != newVal {
v.SetString(newVal)
updated = true
}
}
return updated
} | [
"func",
"(",
"rs",
"*",
"resourceState",
")",
"Merge",
"(",
"newState",
"*",
"resourceState",
")",
"bool",
"{",
"updated",
":=",
"false",
"\n",
"for",
"_",
",",
"field",
":=",
"range",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\""... | // Merge merges the new state with any different contents from another resourceState.
// Blank fields in the receiver state will be updated to non-blank.
// Non-blank fields in the receiver state will never be updated to blank.
// Returns whether or not any keys were updated. | [
"Merge",
"merges",
"the",
"new",
"state",
"with",
"any",
"different",
"contents",
"from",
"another",
"resourceState",
".",
"Blank",
"fields",
"in",
"the",
"receiver",
"state",
"will",
"be",
"updated",
"to",
"non",
"-",
"blank",
".",
"Non",
"-",
"blank",
"f... | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1262-L1274 |
161,858 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationHistoryCommand | func NewApplicationHistoryCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
output string
)
var command = &cobra.Command{
Use: "history APPNAME",
Short: "Show application deployment history",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
appName := args[0]
app, err := appIf.Get(context.Background(), &application.ApplicationQuery{Name: &appName})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "ID\tDATE\tREVISION\n")
for _, depInfo := range app.Status.History {
rev := depInfo.Source.TargetRevision
if len(depInfo.Revision) >= 7 {
rev = fmt.Sprintf("%s (%s)", rev, depInfo.Revision[0:7])
}
fmt.Fprintf(w, "%d\t%s\t%s\n", depInfo.ID, depInfo.DeployedAt, rev)
}
_ = w.Flush()
},
}
command.Flags().StringVarP(&output, "output", "o", "", "Output format. One of: wide")
return command
} | go | func NewApplicationHistoryCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
output string
)
var command = &cobra.Command{
Use: "history APPNAME",
Short: "Show application deployment history",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
appName := args[0]
app, err := appIf.Get(context.Background(), &application.ApplicationQuery{Name: &appName})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "ID\tDATE\tREVISION\n")
for _, depInfo := range app.Status.History {
rev := depInfo.Source.TargetRevision
if len(depInfo.Revision) >= 7 {
rev = fmt.Sprintf("%s (%s)", rev, depInfo.Revision[0:7])
}
fmt.Fprintf(w, "%d\t%s\t%s\n", depInfo.ID, depInfo.DeployedAt, rev)
}
_ = w.Flush()
},
}
command.Flags().StringVarP(&output, "output", "o", "", "Output format. One of: wide")
return command
} | [
"func",
"NewApplicationHistoryCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"output",
"string",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
... | // NewApplicationHistoryCommand returns a new instance of an `argocd app history` command | [
"NewApplicationHistoryCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"history",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1523-L1554 |
161,859 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationRollbackCommand | func NewApplicationRollbackCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
prune bool
timeout uint
)
var command = &cobra.Command{
Use: "rollback APPNAME ID",
Short: "Rollback application to a previous deployed version by History ID",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
appName := args[0]
depID, err := strconv.Atoi(args[1])
errors.CheckError(err)
acdClient := argocdclient.NewClientOrDie(clientOpts)
conn, appIf := acdClient.NewApplicationClientOrDie()
defer util.Close(conn)
ctx := context.Background()
app, err := appIf.Get(ctx, &application.ApplicationQuery{Name: &appName})
errors.CheckError(err)
var depInfo *argoappv1.RevisionHistory
for _, di := range app.Status.History {
if di.ID == int64(depID) {
depInfo = &di
break
}
}
if depInfo == nil {
log.Fatalf("Application '%s' does not have deployment id '%d' in history\n", app.ObjectMeta.Name, depID)
}
_, err = appIf.Rollback(ctx, &application.ApplicationRollbackRequest{
Name: &appName,
ID: int64(depID),
Prune: prune,
})
errors.CheckError(err)
_, err = waitOnApplicationStatus(acdClient, appName, timeout, false, false, true, false, nil)
errors.CheckError(err)
},
}
command.Flags().BoolVar(&prune, "prune", false, "Allow deleting unexpected resources")
command.Flags().UintVar(&timeout, "timeout", defaultCheckTimeoutSeconds, "Time out after this many seconds")
return command
} | go | func NewApplicationRollbackCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
prune bool
timeout uint
)
var command = &cobra.Command{
Use: "rollback APPNAME ID",
Short: "Rollback application to a previous deployed version by History ID",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
appName := args[0]
depID, err := strconv.Atoi(args[1])
errors.CheckError(err)
acdClient := argocdclient.NewClientOrDie(clientOpts)
conn, appIf := acdClient.NewApplicationClientOrDie()
defer util.Close(conn)
ctx := context.Background()
app, err := appIf.Get(ctx, &application.ApplicationQuery{Name: &appName})
errors.CheckError(err)
var depInfo *argoappv1.RevisionHistory
for _, di := range app.Status.History {
if di.ID == int64(depID) {
depInfo = &di
break
}
}
if depInfo == nil {
log.Fatalf("Application '%s' does not have deployment id '%d' in history\n", app.ObjectMeta.Name, depID)
}
_, err = appIf.Rollback(ctx, &application.ApplicationRollbackRequest{
Name: &appName,
ID: int64(depID),
Prune: prune,
})
errors.CheckError(err)
_, err = waitOnApplicationStatus(acdClient, appName, timeout, false, false, true, false, nil)
errors.CheckError(err)
},
}
command.Flags().BoolVar(&prune, "prune", false, "Allow deleting unexpected resources")
command.Flags().UintVar(&timeout, "timeout", defaultCheckTimeoutSeconds, "Time out after this many seconds")
return command
} | [
"func",
"NewApplicationRollbackCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"prune",
"bool",
"\n",
"timeout",
"uint",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
... | // NewApplicationRollbackCommand returns a new instance of an `argocd app rollback` command | [
"NewApplicationRollbackCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"rollback",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1557-L1604 |
161,860 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationManifestsCommand | func NewApplicationManifestsCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
source string
revision string
)
var command = &cobra.Command{
Use: "manifests APPNAME",
Short: "Print manifests of an application",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
appName := args[0]
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
ctx := context.Background()
resources, err := appIf.ManagedResources(context.Background(), &application.ResourcesQuery{ApplicationName: &appName})
errors.CheckError(err)
var unstructureds []*unstructured.Unstructured
switch source {
case "git":
if revision != "" {
q := application.ApplicationManifestQuery{
Name: &appName,
Revision: revision,
}
res, err := appIf.GetManifests(ctx, &q)
errors.CheckError(err)
for _, mfst := range res.Manifests {
obj, err := argoappv1.UnmarshalToUnstructured(mfst)
errors.CheckError(err)
unstructureds = append(unstructureds, obj)
}
} else {
targetObjs, err := targetObjects(resources.Items)
errors.CheckError(err)
unstructureds = targetObjs
}
case "live":
liveObjs, err := liveObjects(resources.Items)
errors.CheckError(err)
unstructureds = liveObjs
default:
log.Fatalf("Unknown source type '%s'", source)
}
for _, obj := range unstructureds {
fmt.Println("---")
yamlBytes, err := yaml.Marshal(obj)
errors.CheckError(err)
fmt.Printf("%s\n", yamlBytes)
}
},
}
command.Flags().StringVar(&source, "source", "git", "Source of manifests. One of: live|git")
command.Flags().StringVar(&revision, "revision", "", "Show manifests at a specific revision")
return command
} | go | func NewApplicationManifestsCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
source string
revision string
)
var command = &cobra.Command{
Use: "manifests APPNAME",
Short: "Print manifests of an application",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
appName := args[0]
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
ctx := context.Background()
resources, err := appIf.ManagedResources(context.Background(), &application.ResourcesQuery{ApplicationName: &appName})
errors.CheckError(err)
var unstructureds []*unstructured.Unstructured
switch source {
case "git":
if revision != "" {
q := application.ApplicationManifestQuery{
Name: &appName,
Revision: revision,
}
res, err := appIf.GetManifests(ctx, &q)
errors.CheckError(err)
for _, mfst := range res.Manifests {
obj, err := argoappv1.UnmarshalToUnstructured(mfst)
errors.CheckError(err)
unstructureds = append(unstructureds, obj)
}
} else {
targetObjs, err := targetObjects(resources.Items)
errors.CheckError(err)
unstructureds = targetObjs
}
case "live":
liveObjs, err := liveObjects(resources.Items)
errors.CheckError(err)
unstructureds = liveObjs
default:
log.Fatalf("Unknown source type '%s'", source)
}
for _, obj := range unstructureds {
fmt.Println("---")
yamlBytes, err := yaml.Marshal(obj)
errors.CheckError(err)
fmt.Printf("%s\n", yamlBytes)
}
},
}
command.Flags().StringVar(&source, "source", "git", "Source of manifests. One of: live|git")
command.Flags().StringVar(&revision, "revision", "", "Show manifests at a specific revision")
return command
} | [
"func",
"NewApplicationManifestsCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"source",
"string",
"\n",
"revision",
"string",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
... | // NewApplicationManifestsCommand returns a new instance of an `argocd app manifests` command | [
"NewApplicationManifestsCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"manifests",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1633-L1692 |
161,861 | argoproj/argo-cd | cmd/argocd/commands/app.go | NewApplicationTerminateOpCommand | func NewApplicationTerminateOpCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "terminate-op APPNAME",
Short: "Terminate running operation of an application",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
appName := args[0]
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
ctx := context.Background()
_, err := appIf.TerminateOperation(ctx, &application.OperationTerminateRequest{Name: &appName})
errors.CheckError(err)
fmt.Printf("Application '%s' operation terminating\n", appName)
},
}
return command
} | go | func NewApplicationTerminateOpCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "terminate-op APPNAME",
Short: "Terminate running operation of an application",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
appName := args[0]
conn, appIf := argocdclient.NewClientOrDie(clientOpts).NewApplicationClientOrDie()
defer util.Close(conn)
ctx := context.Background()
_, err := appIf.TerminateOperation(ctx, &application.OperationTerminateRequest{Name: &appName})
errors.CheckError(err)
fmt.Printf("Application '%s' operation terminating\n", appName)
},
}
return command
} | [
"func",
"NewApplicationTerminateOpCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"... | // NewApplicationTerminateOpCommand returns a new instance of an `argocd app terminate-op` command | [
"NewApplicationTerminateOpCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"app",
"terminate",
"-",
"op",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/app.go#L1695-L1714 |
161,862 | argoproj/argo-cd | cmd/argocd/commands/cluster.go | NewClusterCommand | func NewClusterCommand(clientOpts *argocdclient.ClientOptions, pathOpts *clientcmd.PathOptions) *cobra.Command {
var command = &cobra.Command{
Use: "cluster",
Short: "Manage cluster credentials",
Run: func(c *cobra.Command, args []string) {
c.HelpFunc()(c, args)
os.Exit(1)
},
}
command.AddCommand(NewClusterAddCommand(clientOpts, pathOpts))
command.AddCommand(NewClusterGetCommand(clientOpts))
command.AddCommand(NewClusterListCommand(clientOpts))
command.AddCommand(NewClusterRemoveCommand(clientOpts))
return command
} | go | func NewClusterCommand(clientOpts *argocdclient.ClientOptions, pathOpts *clientcmd.PathOptions) *cobra.Command {
var command = &cobra.Command{
Use: "cluster",
Short: "Manage cluster credentials",
Run: func(c *cobra.Command, args []string) {
c.HelpFunc()(c, args)
os.Exit(1)
},
}
command.AddCommand(NewClusterAddCommand(clientOpts, pathOpts))
command.AddCommand(NewClusterGetCommand(clientOpts))
command.AddCommand(NewClusterListCommand(clientOpts))
command.AddCommand(NewClusterRemoveCommand(clientOpts))
return command
} | [
"func",
"NewClusterCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
",",
"pathOpts",
"*",
"clientcmd",
".",
"PathOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
... | // NewClusterCommand returns a new instance of an `argocd cluster` command | [
"NewClusterCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"cluster",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/cluster.go#L28-L43 |
161,863 | argoproj/argo-cd | cmd/argocd/commands/cluster.go | NewClusterGetCommand | func NewClusterGetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "get",
Short: "Get cluster information",
Run: func(c *cobra.Command, args []string) {
if len(args) == 0 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, clusterIf := argocdclient.NewClientOrDie(clientOpts).NewClusterClientOrDie()
defer util.Close(conn)
for _, clusterName := range args {
clst, err := clusterIf.Get(context.Background(), &cluster.ClusterQuery{Server: clusterName})
errors.CheckError(err)
yamlBytes, err := yaml.Marshal(clst)
errors.CheckError(err)
fmt.Printf("%v", string(yamlBytes))
}
},
}
return command
} | go | func NewClusterGetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "get",
Short: "Get cluster information",
Run: func(c *cobra.Command, args []string) {
if len(args) == 0 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, clusterIf := argocdclient.NewClientOrDie(clientOpts).NewClusterClientOrDie()
defer util.Close(conn)
for _, clusterName := range args {
clst, err := clusterIf.Get(context.Background(), &cluster.ClusterQuery{Server: clusterName})
errors.CheckError(err)
yamlBytes, err := yaml.Marshal(clst)
errors.CheckError(err)
fmt.Printf("%v", string(yamlBytes))
}
},
}
return command
} | [
"func",
"NewClusterGetCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
... | // NewClusterGetCommand returns a new instance of an `argocd cluster get` command | [
"NewClusterGetCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"cluster",
"get",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/cluster.go#L189-L210 |
161,864 | argoproj/argo-cd | cmd/argocd/commands/cluster.go | NewClusterRemoveCommand | func NewClusterRemoveCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "rm",
Short: "Remove cluster credentials",
Run: func(c *cobra.Command, args []string) {
if len(args) == 0 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, clusterIf := argocdclient.NewClientOrDie(clientOpts).NewClusterClientOrDie()
defer util.Close(conn)
// clientset, err := kubernetes.NewForConfig(conf)
// errors.CheckError(err)
for _, clusterName := range args {
// TODO(jessesuen): find the right context and remove manager RBAC artifacts
// err := common.UninstallClusterManagerRBAC(clientset)
// errors.CheckError(err)
_, err := clusterIf.Delete(context.Background(), &cluster.ClusterQuery{Server: clusterName})
errors.CheckError(err)
}
},
}
return command
} | go | func NewClusterRemoveCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "rm",
Short: "Remove cluster credentials",
Run: func(c *cobra.Command, args []string) {
if len(args) == 0 {
c.HelpFunc()(c, args)
os.Exit(1)
}
conn, clusterIf := argocdclient.NewClientOrDie(clientOpts).NewClusterClientOrDie()
defer util.Close(conn)
// clientset, err := kubernetes.NewForConfig(conf)
// errors.CheckError(err)
for _, clusterName := range args {
// TODO(jessesuen): find the right context and remove manager RBAC artifacts
// err := common.UninstallClusterManagerRBAC(clientset)
// errors.CheckError(err)
_, err := clusterIf.Delete(context.Background(), &cluster.ClusterQuery{Server: clusterName})
errors.CheckError(err)
}
},
}
return command
} | [
"func",
"NewClusterRemoveCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",... | // NewClusterRemoveCommand returns a new instance of an `argocd cluster list` command | [
"NewClusterRemoveCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"cluster",
"list",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/cluster.go#L213-L238 |
161,865 | argoproj/argo-cd | cmd/argocd/commands/cluster.go | NewClusterListCommand | func NewClusterListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "list",
Short: "List configured clusters",
Run: func(c *cobra.Command, args []string) {
conn, clusterIf := argocdclient.NewClientOrDie(clientOpts).NewClusterClientOrDie()
defer util.Close(conn)
clusters, err := clusterIf.List(context.Background(), &cluster.ClusterQuery{})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "SERVER\tNAME\tSTATUS\tMESSAGE\n")
for _, c := range clusters.Items {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", c.Server, c.Name, c.ConnectionState.Status, c.ConnectionState.Message)
}
_ = w.Flush()
},
}
return command
} | go | func NewClusterListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "list",
Short: "List configured clusters",
Run: func(c *cobra.Command, args []string) {
conn, clusterIf := argocdclient.NewClientOrDie(clientOpts).NewClusterClientOrDie()
defer util.Close(conn)
clusters, err := clusterIf.List(context.Background(), &cluster.ClusterQuery{})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "SERVER\tNAME\tSTATUS\tMESSAGE\n")
for _, c := range clusters.Items {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", c.Server, c.Name, c.ConnectionState.Status, c.ConnectionState.Message)
}
_ = w.Flush()
},
}
return command
} | [
"func",
"NewClusterListCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
... | // NewClusterListCommand returns a new instance of an `argocd cluster rm` command | [
"NewClusterListCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"cluster",
"rm",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/cluster.go#L241-L259 |
161,866 | argoproj/argo-cd | server/account/account.go | NewServer | func NewServer(sessionMgr *session.SessionManager, settingsMgr *settings.SettingsManager) *Server {
return &Server{
sessionMgr: sessionMgr,
settingsMgr: settingsMgr,
}
} | go | func NewServer(sessionMgr *session.SessionManager, settingsMgr *settings.SettingsManager) *Server {
return &Server{
sessionMgr: sessionMgr,
settingsMgr: settingsMgr,
}
} | [
"func",
"NewServer",
"(",
"sessionMgr",
"*",
"session",
".",
"SessionManager",
",",
"settingsMgr",
"*",
"settings",
".",
"SettingsManager",
")",
"*",
"Server",
"{",
"return",
"&",
"Server",
"{",
"sessionMgr",
":",
"sessionMgr",
",",
"settingsMgr",
":",
"settin... | // NewServer returns a new instance of the Session service | [
"NewServer",
"returns",
"a",
"new",
"instance",
"of",
"the",
"Session",
"service"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/account/account.go#L26-L32 |
161,867 | argoproj/argo-cd | server/account/account.go | UpdatePassword | func (s *Server) UpdatePassword(ctx context.Context, q *UpdatePasswordRequest) (*UpdatePasswordResponse, error) {
username := getAuthenticatedUser(ctx)
if username != common.ArgoCDAdminUsername {
return nil, status.Errorf(codes.InvalidArgument, "password can only be changed for local users, not user %q", username)
}
cdSettings, err := s.settingsMgr.GetSettings()
if err != nil {
return nil, err
}
err = s.sessionMgr.VerifyUsernamePassword(username, q.CurrentPassword)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "current password does not match")
}
hashedPassword, err := password.HashPassword(q.NewPassword)
if err != nil {
return nil, err
}
cdSettings.AdminPasswordHash = hashedPassword
cdSettings.AdminPasswordMtime = time.Now().UTC()
err = s.settingsMgr.SaveSettings(cdSettings)
if err != nil {
return nil, err
}
log.Infof("user '%s' updated password", username)
return &UpdatePasswordResponse{}, nil
} | go | func (s *Server) UpdatePassword(ctx context.Context, q *UpdatePasswordRequest) (*UpdatePasswordResponse, error) {
username := getAuthenticatedUser(ctx)
if username != common.ArgoCDAdminUsername {
return nil, status.Errorf(codes.InvalidArgument, "password can only be changed for local users, not user %q", username)
}
cdSettings, err := s.settingsMgr.GetSettings()
if err != nil {
return nil, err
}
err = s.sessionMgr.VerifyUsernamePassword(username, q.CurrentPassword)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "current password does not match")
}
hashedPassword, err := password.HashPassword(q.NewPassword)
if err != nil {
return nil, err
}
cdSettings.AdminPasswordHash = hashedPassword
cdSettings.AdminPasswordMtime = time.Now().UTC()
err = s.settingsMgr.SaveSettings(cdSettings)
if err != nil {
return nil, err
}
log.Infof("user '%s' updated password", username)
return &UpdatePasswordResponse{}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"UpdatePassword",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"*",
"UpdatePasswordRequest",
")",
"(",
"*",
"UpdatePasswordResponse",
",",
"error",
")",
"{",
"username",
":=",
"getAuthenticatedUser",
"(",
"ctx",
")",... | // UpdatePassword updates the password of the local admin superuser. | [
"UpdatePassword",
"updates",
"the",
"password",
"of",
"the",
"local",
"admin",
"superuser",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/account/account.go#L35-L66 |
161,868 | argoproj/argo-cd | server/version/version.go | Version | func (s *Server) Version(context.Context, *empty.Empty) (*VersionMessage, error) {
vers := argocd.GetVersion()
ksonnetVersion, err := ksutil.KsonnetVersion()
if err != nil {
return nil, err
}
return &VersionMessage{
Version: vers.Version,
BuildDate: vers.BuildDate,
GitCommit: vers.GitCommit,
GitTag: vers.GitTag,
GitTreeState: vers.GitTreeState,
GoVersion: vers.GoVersion,
Compiler: vers.Compiler,
Platform: vers.Platform,
KsonnetVersion: ksonnetVersion,
}, nil
} | go | func (s *Server) Version(context.Context, *empty.Empty) (*VersionMessage, error) {
vers := argocd.GetVersion()
ksonnetVersion, err := ksutil.KsonnetVersion()
if err != nil {
return nil, err
}
return &VersionMessage{
Version: vers.Version,
BuildDate: vers.BuildDate,
GitCommit: vers.GitCommit,
GitTag: vers.GitTag,
GitTreeState: vers.GitTreeState,
GoVersion: vers.GoVersion,
Compiler: vers.Compiler,
Platform: vers.Platform,
KsonnetVersion: ksonnetVersion,
}, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Version",
"(",
"context",
".",
"Context",
",",
"*",
"empty",
".",
"Empty",
")",
"(",
"*",
"VersionMessage",
",",
"error",
")",
"{",
"vers",
":=",
"argocd",
".",
"GetVersion",
"(",
")",
"\n",
"ksonnetVersion",
",... | // Version returns the version of the API server | [
"Version",
"returns",
"the",
"version",
"of",
"the",
"API",
"server"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/version/version.go#L14-L31 |
161,869 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleCommand | func NewProjectRoleCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
roleCommand := &cobra.Command{
Use: "role",
Short: "Manage a project's roles",
Run: func(c *cobra.Command, args []string) {
c.HelpFunc()(c, args)
os.Exit(1)
},
}
roleCommand.AddCommand(NewProjectRoleListCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleGetCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleCreateCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleDeleteCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleCreateTokenCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleDeleteTokenCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleAddPolicyCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleRemovePolicyCommand(clientOpts))
return roleCommand
} | go | func NewProjectRoleCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
roleCommand := &cobra.Command{
Use: "role",
Short: "Manage a project's roles",
Run: func(c *cobra.Command, args []string) {
c.HelpFunc()(c, args)
os.Exit(1)
},
}
roleCommand.AddCommand(NewProjectRoleListCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleGetCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleCreateCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleDeleteCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleCreateTokenCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleDeleteTokenCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleAddPolicyCommand(clientOpts))
roleCommand.AddCommand(NewProjectRoleRemovePolicyCommand(clientOpts))
return roleCommand
} | [
"func",
"NewProjectRoleCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"roleCommand",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Ru... | // NewProjectRoleCommand returns a new instance of the `argocd proj role` command | [
"NewProjectRoleCommand",
"returns",
"a",
"new",
"instance",
"of",
"the",
"argocd",
"proj",
"role",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L26-L44 |
161,870 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleAddPolicyCommand | func NewProjectRoleAddPolicyCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
opts policyOpts
)
var command = &cobra.Command{
Use: "add-policy PROJECT ROLE-NAME",
Short: "Add a policy to a project role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
role, roleIndex, err := projectutil.GetRoleByName(proj, roleName)
errors.CheckError(err)
policy := fmt.Sprintf(policyTemplate, proj.Name, role.Name, opts.action, proj.Name, opts.object, opts.permission)
proj.Spec.Roles[roleIndex].Policies = append(role.Policies, policy)
_, err = projIf.Update(context.Background(), &project.ProjectUpdateRequest{Project: proj})
errors.CheckError(err)
},
}
addPolicyFlags(command, &opts)
return command
} | go | func NewProjectRoleAddPolicyCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
opts policyOpts
)
var command = &cobra.Command{
Use: "add-policy PROJECT ROLE-NAME",
Short: "Add a policy to a project role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
role, roleIndex, err := projectutil.GetRoleByName(proj, roleName)
errors.CheckError(err)
policy := fmt.Sprintf(policyTemplate, proj.Name, role.Name, opts.action, proj.Name, opts.object, opts.permission)
proj.Spec.Roles[roleIndex].Policies = append(role.Policies, policy)
_, err = projIf.Update(context.Background(), &project.ProjectUpdateRequest{Project: proj})
errors.CheckError(err)
},
}
addPolicyFlags(command, &opts)
return command
} | [
"func",
"NewProjectRoleAddPolicyCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"opts",
"policyOpts",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use"... | // NewProjectRoleAddPolicyCommand returns a new instance of an `argocd proj role add-policy` command | [
"NewProjectRoleAddPolicyCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"role",
"add",
"-",
"policy",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L47-L79 |
161,871 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleCreateCommand | func NewProjectRoleCreateCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
description string
)
var command = &cobra.Command{
Use: "create PROJECT ROLE-NAME",
Short: "Create a project role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
_, _, err = projectutil.GetRoleByName(proj, roleName)
if err == nil {
fmt.Printf("Role '%s' already exists\n", roleName)
return
}
proj.Spec.Roles = append(proj.Spec.Roles, v1alpha1.ProjectRole{Name: roleName, Description: description})
_, err = projIf.Update(context.Background(), &project.ProjectUpdateRequest{Project: proj})
errors.CheckError(err)
fmt.Printf("Role '%s' created\n", roleName)
},
}
command.Flags().StringVarP(&description, "description", "", "", "Project description")
return command
} | go | func NewProjectRoleCreateCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
description string
)
var command = &cobra.Command{
Use: "create PROJECT ROLE-NAME",
Short: "Create a project role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
_, _, err = projectutil.GetRoleByName(proj, roleName)
if err == nil {
fmt.Printf("Role '%s' already exists\n", roleName)
return
}
proj.Spec.Roles = append(proj.Spec.Roles, v1alpha1.ProjectRole{Name: roleName, Description: description})
_, err = projIf.Update(context.Background(), &project.ProjectUpdateRequest{Project: proj})
errors.CheckError(err)
fmt.Printf("Role '%s' created\n", roleName)
},
}
command.Flags().StringVarP(&description, "description", "", "", "Project description")
return command
} | [
"func",
"NewProjectRoleCreateCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"description",
"string",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use"... | // NewProjectRoleCreateCommand returns a new instance of an `argocd proj role create` command | [
"NewProjectRoleCreateCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"role",
"create",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L127-L161 |
161,872 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleCreateTokenCommand | func NewProjectRoleCreateTokenCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
expiresIn string
)
var command = &cobra.Command{
Use: "create-token PROJECT ROLE-NAME",
Short: "Create a project token",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
duration, err := timeutil.ParseDuration(expiresIn)
errors.CheckError(err)
token, err := projIf.CreateToken(context.Background(), &project.ProjectTokenCreateRequest{Project: projName, Role: roleName, ExpiresIn: int64(duration.Seconds())})
errors.CheckError(err)
fmt.Println(token.Token)
},
}
command.Flags().StringVarP(&expiresIn, "expires-in", "e", "0s", "Duration before the token will expire. (Default: No expiration)")
return command
} | go | func NewProjectRoleCreateTokenCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var (
expiresIn string
)
var command = &cobra.Command{
Use: "create-token PROJECT ROLE-NAME",
Short: "Create a project token",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
duration, err := timeutil.ParseDuration(expiresIn)
errors.CheckError(err)
token, err := projIf.CreateToken(context.Background(), &project.ProjectTokenCreateRequest{Project: projName, Role: roleName, ExpiresIn: int64(duration.Seconds())})
errors.CheckError(err)
fmt.Println(token.Token)
},
}
command.Flags().StringVarP(&expiresIn, "expires-in", "e", "0s", "Duration before the token will expire. (Default: No expiration)")
return command
} | [
"func",
"NewProjectRoleCreateTokenCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"(",
"expiresIn",
"string",
"\n",
")",
"\n",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"U... | // NewProjectRoleCreateTokenCommand returns a new instance of an `argocd proj role create-token` command | [
"NewProjectRoleCreateTokenCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"role",
"create",
"-",
"token",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L198-L224 |
161,873 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleDeleteTokenCommand | func NewProjectRoleDeleteTokenCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "delete-token PROJECT ROLE-NAME ISSUED-AT",
Short: "Delete a project token",
Run: func(c *cobra.Command, args []string) {
if len(args) != 3 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
issuedAt, err := strconv.ParseInt(args[2], 10, 64)
errors.CheckError(err)
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
_, err = projIf.DeleteToken(context.Background(), &project.ProjectTokenDeleteRequest{Project: projName, Role: roleName, Iat: issuedAt})
errors.CheckError(err)
},
}
return command
} | go | func NewProjectRoleDeleteTokenCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "delete-token PROJECT ROLE-NAME ISSUED-AT",
Short: "Delete a project token",
Run: func(c *cobra.Command, args []string) {
if len(args) != 3 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
issuedAt, err := strconv.ParseInt(args[2], 10, 64)
errors.CheckError(err)
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
_, err = projIf.DeleteToken(context.Background(), &project.ProjectTokenDeleteRequest{Project: projName, Role: roleName, Iat: issuedAt})
errors.CheckError(err)
},
}
return command
} | [
"func",
"NewProjectRoleDeleteTokenCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"... | // NewProjectRoleDeleteTokenCommand returns a new instance of an `argocd proj role delete-token` command | [
"NewProjectRoleDeleteTokenCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"role",
"delete",
"-",
"token",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L227-L249 |
161,874 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleListCommand | func NewProjectRoleListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "list PROJECT",
Short: "List all the roles in a project",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
project, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "ROLE-NAME\tDESCRIPTION\n")
for _, role := range project.Spec.Roles {
fmt.Fprintf(w, "%s\t%s\n", role.Name, role.Description)
}
_ = w.Flush()
},
}
return command
} | go | func NewProjectRoleListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "list PROJECT",
Short: "List all the roles in a project",
Run: func(c *cobra.Command, args []string) {
if len(args) != 1 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
project, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "ROLE-NAME\tDESCRIPTION\n")
for _, role := range project.Spec.Roles {
fmt.Fprintf(w, "%s\t%s\n", role.Name, role.Description)
}
_ = w.Flush()
},
}
return command
} | [
"func",
"NewProjectRoleListCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",... | // NewProjectRoleListCommand returns a new instance of an `argocd proj roles list` command | [
"NewProjectRoleListCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"roles",
"list",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L252-L276 |
161,875 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleGetCommand | func NewProjectRoleGetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "get PROJECT ROLE-NAME",
Short: "Get the details of a specific role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
role, _, err := projectutil.GetRoleByName(proj, roleName)
errors.CheckError(err)
printRoleFmtStr := "%-15s%s\n"
fmt.Printf(printRoleFmtStr, "Role Name:", roleName)
fmt.Printf(printRoleFmtStr, "Description:", role.Description)
fmt.Printf("Policies:\n")
fmt.Printf("%s\n", proj.ProjectPoliciesString())
fmt.Printf("JWT Tokens:\n")
// TODO(jessesuen): print groups
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "ID\tISSUED-AT\tEXPIRES-AT\n")
for _, token := range role.JWTTokens {
expiresAt := "<none>"
if token.ExpiresAt > 0 {
expiresAt = humanizeTimestamp(token.ExpiresAt)
}
fmt.Fprintf(w, "%d\t%s\t%s\n", token.IssuedAt, humanizeTimestamp(token.IssuedAt), expiresAt)
}
_ = w.Flush()
},
}
return command
} | go | func NewProjectRoleGetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "get PROJECT ROLE-NAME",
Short: "Get the details of a specific role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName := args[0]
roleName := args[1]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
role, _, err := projectutil.GetRoleByName(proj, roleName)
errors.CheckError(err)
printRoleFmtStr := "%-15s%s\n"
fmt.Printf(printRoleFmtStr, "Role Name:", roleName)
fmt.Printf(printRoleFmtStr, "Description:", role.Description)
fmt.Printf("Policies:\n")
fmt.Printf("%s\n", proj.ProjectPoliciesString())
fmt.Printf("JWT Tokens:\n")
// TODO(jessesuen): print groups
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
fmt.Fprintf(w, "ID\tISSUED-AT\tEXPIRES-AT\n")
for _, token := range role.JWTTokens {
expiresAt := "<none>"
if token.ExpiresAt > 0 {
expiresAt = humanizeTimestamp(token.ExpiresAt)
}
fmt.Fprintf(w, "%d\t%s\t%s\n", token.IssuedAt, humanizeTimestamp(token.IssuedAt), expiresAt)
}
_ = w.Flush()
},
}
return command
} | [
"func",
"NewProjectRoleGetCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
","... | // NewProjectRoleGetCommand returns a new instance of an `argocd proj roles get` command | [
"NewProjectRoleGetCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"roles",
"get",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L279-L319 |
161,876 | argoproj/argo-cd | cmd/argocd/commands/project_role.go | NewProjectRoleAddGroupCommand | func NewProjectRoleAddGroupCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "add-group PROJECT ROLE-NAME GROUP-CLAIM",
Short: "Add a policy to a project role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName, roleName, groupName := args[0], args[1], args[2]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
updated, err := projectutil.AddGroupToRole(proj, roleName, groupName)
errors.CheckError(err)
if updated {
fmt.Printf("Group '%s' already present in role '%s'\n", groupName, roleName)
return
}
_, err = projIf.Update(context.Background(), &project.ProjectUpdateRequest{Project: proj})
errors.CheckError(err)
fmt.Printf("Group '%s' added to role '%s'\n", groupName, roleName)
},
}
return command
} | go | func NewProjectRoleAddGroupCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
var command = &cobra.Command{
Use: "add-group PROJECT ROLE-NAME GROUP-CLAIM",
Short: "Add a policy to a project role",
Run: func(c *cobra.Command, args []string) {
if len(args) != 2 {
c.HelpFunc()(c, args)
os.Exit(1)
}
projName, roleName, groupName := args[0], args[1], args[2]
conn, projIf := argocdclient.NewClientOrDie(clientOpts).NewProjectClientOrDie()
defer util.Close(conn)
proj, err := projIf.Get(context.Background(), &project.ProjectQuery{Name: projName})
errors.CheckError(err)
updated, err := projectutil.AddGroupToRole(proj, roleName, groupName)
errors.CheckError(err)
if updated {
fmt.Printf("Group '%s' already present in role '%s'\n", groupName, roleName)
return
}
_, err = projIf.Update(context.Background(), &project.ProjectUpdateRequest{Project: proj})
errors.CheckError(err)
fmt.Printf("Group '%s' added to role '%s'\n", groupName, roleName)
},
}
return command
} | [
"func",
"NewProjectRoleAddGroupCommand",
"(",
"clientOpts",
"*",
"argocdclient",
".",
"ClientOptions",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"command",
"=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
... | // NewProjectRoleAddGroupCommand returns a new instance of an `argocd proj role add-group` command | [
"NewProjectRoleAddGroupCommand",
"returns",
"a",
"new",
"instance",
"of",
"an",
"argocd",
"proj",
"role",
"add",
"-",
"group",
"command"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/cmd/argocd/commands/project_role.go#L322-L348 |
161,877 | argoproj/argo-cd | server/rbacpolicy/rbacpolicy.go | NewRBACPolicyEnforcer | func NewRBACPolicyEnforcer(enf *rbac.Enforcer, projLister applister.AppProjectNamespaceLister) *RBACPolicyEnforcer {
return &RBACPolicyEnforcer{
enf: enf,
projLister: projLister,
}
} | go | func NewRBACPolicyEnforcer(enf *rbac.Enforcer, projLister applister.AppProjectNamespaceLister) *RBACPolicyEnforcer {
return &RBACPolicyEnforcer{
enf: enf,
projLister: projLister,
}
} | [
"func",
"NewRBACPolicyEnforcer",
"(",
"enf",
"*",
"rbac",
".",
"Enforcer",
",",
"projLister",
"applister",
".",
"AppProjectNamespaceLister",
")",
"*",
"RBACPolicyEnforcer",
"{",
"return",
"&",
"RBACPolicyEnforcer",
"{",
"enf",
":",
"enf",
",",
"projLister",
":",
... | // NewRBACPolicyEnforcer returns a new RBAC Enforcer for the Argo CD API Server | [
"NewRBACPolicyEnforcer",
"returns",
"a",
"new",
"RBAC",
"Enforcer",
"for",
"the",
"Argo",
"CD",
"API",
"Server"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/rbacpolicy/rbacpolicy.go#L38-L43 |
161,878 | argoproj/argo-cd | server/rbacpolicy/rbacpolicy.go | EnforceClaims | func (p *RBACPolicyEnforcer) EnforceClaims(claims jwt.Claims, rvals ...interface{}) bool {
mapClaims, err := jwtutil.MapClaims(claims)
if err != nil {
return false
}
subject := jwtutil.GetField(mapClaims, "sub")
// Check if the request is for an application resource. We have special enforcement which takes
// into consideration the project's token and group bindings
var runtimePolicy string
proj := p.getProjectFromRequest(rvals...)
if proj != nil {
if strings.HasPrefix(subject, "proj:") {
return p.enforceProjectToken(subject, mapClaims, proj, rvals...)
}
runtimePolicy = proj.ProjectPoliciesString()
}
// Check the subject. This is typically the 'admin' case.
// NOTE: the call to EnforceRuntimePolicy will also consider the default role
vals := append([]interface{}{subject}, rvals[1:]...)
if p.enf.EnforceRuntimePolicy(runtimePolicy, vals...) {
return true
}
// Finally check if any of the user's groups grant them permissions
groups := jwtutil.GetGroups(mapClaims)
for _, group := range groups {
vals := append([]interface{}{group}, rvals[1:]...)
if p.enf.EnforceRuntimePolicy(runtimePolicy, vals...) {
return true
}
}
logCtx := log.WithField("claims", claims).WithField("rval", rvals)
logCtx.Debug("enforce failed")
return false
} | go | func (p *RBACPolicyEnforcer) EnforceClaims(claims jwt.Claims, rvals ...interface{}) bool {
mapClaims, err := jwtutil.MapClaims(claims)
if err != nil {
return false
}
subject := jwtutil.GetField(mapClaims, "sub")
// Check if the request is for an application resource. We have special enforcement which takes
// into consideration the project's token and group bindings
var runtimePolicy string
proj := p.getProjectFromRequest(rvals...)
if proj != nil {
if strings.HasPrefix(subject, "proj:") {
return p.enforceProjectToken(subject, mapClaims, proj, rvals...)
}
runtimePolicy = proj.ProjectPoliciesString()
}
// Check the subject. This is typically the 'admin' case.
// NOTE: the call to EnforceRuntimePolicy will also consider the default role
vals := append([]interface{}{subject}, rvals[1:]...)
if p.enf.EnforceRuntimePolicy(runtimePolicy, vals...) {
return true
}
// Finally check if any of the user's groups grant them permissions
groups := jwtutil.GetGroups(mapClaims)
for _, group := range groups {
vals := append([]interface{}{group}, rvals[1:]...)
if p.enf.EnforceRuntimePolicy(runtimePolicy, vals...) {
return true
}
}
logCtx := log.WithField("claims", claims).WithField("rval", rvals)
logCtx.Debug("enforce failed")
return false
} | [
"func",
"(",
"p",
"*",
"RBACPolicyEnforcer",
")",
"EnforceClaims",
"(",
"claims",
"jwt",
".",
"Claims",
",",
"rvals",
"...",
"interface",
"{",
"}",
")",
"bool",
"{",
"mapClaims",
",",
"err",
":=",
"jwtutil",
".",
"MapClaims",
"(",
"claims",
")",
"\n",
... | // EnforceClaims is an RBAC claims enforcer specific to the Argo CD API server | [
"EnforceClaims",
"is",
"an",
"RBAC",
"claims",
"enforcer",
"specific",
"to",
"the",
"Argo",
"CD",
"API",
"server"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/rbacpolicy/rbacpolicy.go#L46-L82 |
161,879 | argoproj/argo-cd | server/rbacpolicy/rbacpolicy.go | enforceProjectToken | func (p *RBACPolicyEnforcer) enforceProjectToken(subject string, claims jwt.MapClaims, proj *v1alpha1.AppProject, rvals ...interface{}) bool {
subjectSplit := strings.Split(subject, ":")
if len(subjectSplit) != 3 {
return false
}
projName, roleName := subjectSplit[1], subjectSplit[2]
if projName != proj.Name {
// this should never happen (we generated a project token for a different project)
return false
}
iat, err := jwtutil.GetIssuedAt(claims)
if err != nil {
return false
}
_, _, err = projectutil.GetJWTToken(proj, roleName, iat)
if err != nil {
// if we get here the token is still valid, but has been revoked (no longer exists in the project)
return false
}
vals := append([]interface{}{subject}, rvals[1:]...)
return p.enf.EnforceRuntimePolicy(proj.ProjectPoliciesString(), vals...)
} | go | func (p *RBACPolicyEnforcer) enforceProjectToken(subject string, claims jwt.MapClaims, proj *v1alpha1.AppProject, rvals ...interface{}) bool {
subjectSplit := strings.Split(subject, ":")
if len(subjectSplit) != 3 {
return false
}
projName, roleName := subjectSplit[1], subjectSplit[2]
if projName != proj.Name {
// this should never happen (we generated a project token for a different project)
return false
}
iat, err := jwtutil.GetIssuedAt(claims)
if err != nil {
return false
}
_, _, err = projectutil.GetJWTToken(proj, roleName, iat)
if err != nil {
// if we get here the token is still valid, but has been revoked (no longer exists in the project)
return false
}
vals := append([]interface{}{subject}, rvals[1:]...)
return p.enf.EnforceRuntimePolicy(proj.ProjectPoliciesString(), vals...)
} | [
"func",
"(",
"p",
"*",
"RBACPolicyEnforcer",
")",
"enforceProjectToken",
"(",
"subject",
"string",
",",
"claims",
"jwt",
".",
"MapClaims",
",",
"proj",
"*",
"v1alpha1",
".",
"AppProject",
",",
"rvals",
"...",
"interface",
"{",
"}",
")",
"bool",
"{",
"subje... | // enforceProjectToken will check to see the valid token has not yet been revoked in the project | [
"enforceProjectToken",
"will",
"check",
"to",
"see",
"the",
"valid",
"token",
"has",
"not",
"yet",
"been",
"revoked",
"in",
"the",
"project"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/server/rbacpolicy/rbacpolicy.go#L114-L136 |
161,880 | argoproj/argo-cd | controller/cache/cache.go | Run | func (c *liveStateCache) Run(ctx context.Context) {
util.RetryUntilSucceed(func() error {
clusterEventCallback := func(event *db.ClusterEvent) {
c.lock.Lock()
defer c.lock.Unlock()
if cluster, ok := c.clusters[event.Cluster.Server]; ok {
if event.Type == watch.Deleted {
cluster.invalidate()
delete(c.clusters, event.Cluster.Server)
} else if event.Type == watch.Modified {
cluster.cluster = event.Cluster
cluster.invalidate()
}
} else if event.Type == watch.Added && isClusterHasApps(c.appInformer.GetStore().List(), event.Cluster) {
go func() {
// warm up cache for cluster with apps
_, _ = c.getSyncedCluster(event.Cluster.Server)
}()
}
}
return c.db.WatchClusters(ctx, clusterEventCallback)
}, "watch clusters", ctx, clusterRetryTimeout)
<-ctx.Done()
} | go | func (c *liveStateCache) Run(ctx context.Context) {
util.RetryUntilSucceed(func() error {
clusterEventCallback := func(event *db.ClusterEvent) {
c.lock.Lock()
defer c.lock.Unlock()
if cluster, ok := c.clusters[event.Cluster.Server]; ok {
if event.Type == watch.Deleted {
cluster.invalidate()
delete(c.clusters, event.Cluster.Server)
} else if event.Type == watch.Modified {
cluster.cluster = event.Cluster
cluster.invalidate()
}
} else if event.Type == watch.Added && isClusterHasApps(c.appInformer.GetStore().List(), event.Cluster) {
go func() {
// warm up cache for cluster with apps
_, _ = c.getSyncedCluster(event.Cluster.Server)
}()
}
}
return c.db.WatchClusters(ctx, clusterEventCallback)
}, "watch clusters", ctx, clusterRetryTimeout)
<-ctx.Done()
} | [
"func",
"(",
"c",
"*",
"liveStateCache",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"util",
".",
"RetryUntilSucceed",
"(",
"func",
"(",
")",
"error",
"{",
"clusterEventCallback",
":=",
"func",
"(",
"event",
"*",
"db",
".",
"ClusterEvent... | // Run watches for resource changes annotated with application label on all registered clusters and schedule corresponding app refresh. | [
"Run",
"watches",
"for",
"resource",
"changes",
"annotated",
"with",
"application",
"label",
"on",
"all",
"registered",
"clusters",
"and",
"schedule",
"corresponding",
"app",
"refresh",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/controller/cache/cache.go#L162-L188 |
161,881 | argoproj/argo-cd | util/oidc/provider.go | NewOIDCProvider | func NewOIDCProvider(issuerURL string, client *http.Client) Provider {
return &providerImpl{
issuerURL: issuerURL,
client: client,
}
} | go | func NewOIDCProvider(issuerURL string, client *http.Client) Provider {
return &providerImpl{
issuerURL: issuerURL,
client: client,
}
} | [
"func",
"NewOIDCProvider",
"(",
"issuerURL",
"string",
",",
"client",
"*",
"http",
".",
"Client",
")",
"Provider",
"{",
"return",
"&",
"providerImpl",
"{",
"issuerURL",
":",
"issuerURL",
",",
"client",
":",
"client",
",",
"}",
"\n",
"}"
] | // NewOIDCProvider initializes an OIDC provider | [
"NewOIDCProvider",
"initializes",
"an",
"OIDC",
"provider"
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/oidc/provider.go#L36-L41 |
161,882 | argoproj/argo-cd | util/oidc/provider.go | provider | func (p *providerImpl) provider() (*gooidc.Provider, error) {
if p.goOIDCProvider != nil {
return p.goOIDCProvider, nil
}
prov, err := p.newGoOIDCProvider()
if err != nil {
return nil, err
}
p.goOIDCProvider = prov
return p.goOIDCProvider, nil
} | go | func (p *providerImpl) provider() (*gooidc.Provider, error) {
if p.goOIDCProvider != nil {
return p.goOIDCProvider, nil
}
prov, err := p.newGoOIDCProvider()
if err != nil {
return nil, err
}
p.goOIDCProvider = prov
return p.goOIDCProvider, nil
} | [
"func",
"(",
"p",
"*",
"providerImpl",
")",
"provider",
"(",
")",
"(",
"*",
"gooidc",
".",
"Provider",
",",
"error",
")",
"{",
"if",
"p",
".",
"goOIDCProvider",
"!=",
"nil",
"{",
"return",
"p",
".",
"goOIDCProvider",
",",
"nil",
"\n",
"}",
"\n",
"p... | // oidcProvider lazily initializes, memoizes, and returns the OIDC provider. | [
"oidcProvider",
"lazily",
"initializes",
"memoizes",
"and",
"returns",
"the",
"OIDC",
"provider",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/util/oidc/provider.go#L44-L54 |
161,883 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *AWSAuthConfig) DeepCopy() *AWSAuthConfig {
if in == nil {
return nil
}
out := new(AWSAuthConfig)
in.DeepCopyInto(out)
return out
} | go | func (in *AWSAuthConfig) DeepCopy() *AWSAuthConfig {
if in == nil {
return nil
}
out := new(AWSAuthConfig)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"AWSAuthConfig",
")",
"DeepCopy",
"(",
")",
"*",
"AWSAuthConfig",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"AWSAuthConfig",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
"out",... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AWSAuthConfig. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"AWSAuthConfig",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L20-L27 |
161,884 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *AppProject) DeepCopy() *AppProject {
if in == nil {
return nil
}
out := new(AppProject)
in.DeepCopyInto(out)
return out
} | go | func (in *AppProject) DeepCopy() *AppProject {
if in == nil {
return nil
}
out := new(AppProject)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"AppProject",
")",
"DeepCopy",
"(",
")",
"*",
"AppProject",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"AppProject",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
"out",
")",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppProject. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"AppProject",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L39-L46 |
161,885 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *AppProjectList) DeepCopy() *AppProjectList {
if in == nil {
return nil
}
out := new(AppProjectList)
in.DeepCopyInto(out)
return out
} | go | func (in *AppProjectList) DeepCopy() *AppProjectList {
if in == nil {
return nil
}
out := new(AppProjectList)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"AppProjectList",
")",
"DeepCopy",
"(",
")",
"*",
"AppProjectList",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"AppProjectList",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
"ou... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppProjectList. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"AppProjectList",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L72-L79 |
161,886 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *AppProjectSpec) DeepCopy() *AppProjectSpec {
if in == nil {
return nil
}
out := new(AppProjectSpec)
in.DeepCopyInto(out)
return out
} | go | func (in *AppProjectSpec) DeepCopy() *AppProjectSpec {
if in == nil {
return nil
}
out := new(AppProjectSpec)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"AppProjectSpec",
")",
"DeepCopy",
"(",
")",
"*",
"AppProjectSpec",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"AppProjectSpec",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
"ou... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppProjectSpec. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"AppProjectSpec",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L123-L130 |
161,887 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *Application) DeepCopy() *Application {
if in == nil {
return nil
}
out := new(Application)
in.DeepCopyInto(out)
return out
} | go | func (in *Application) DeepCopy() *Application {
if in == nil {
return nil
}
out := new(Application)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"Application",
")",
"DeepCopy",
"(",
")",
"*",
"Application",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"Application",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
"out",
")"... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Application. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"Application",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L148-L155 |
161,888 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationCondition) DeepCopy() *ApplicationCondition {
if in == nil {
return nil
}
out := new(ApplicationCondition)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationCondition) DeepCopy() *ApplicationCondition {
if in == nil {
return nil
}
out := new(ApplicationCondition)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationCondition",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationCondition",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationCondition",
")",
"\n",
"in",
".",
"DeepCopyI... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationCondition. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationCondition",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L172-L179 |
161,889 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationDestination) DeepCopy() *ApplicationDestination {
if in == nil {
return nil
}
out := new(ApplicationDestination)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationDestination) DeepCopy() *ApplicationDestination {
if in == nil {
return nil
}
out := new(ApplicationDestination)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationDestination",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationDestination",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationDestination",
")",
"\n",
"in",
".",
"Dee... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationDestination. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationDestination",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L188-L195 |
161,890 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationList) DeepCopy() *ApplicationList {
if in == nil {
return nil
}
out := new(ApplicationList)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationList) DeepCopy() *ApplicationList {
if in == nil {
return nil
}
out := new(ApplicationList)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationList",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationList",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationList",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationList. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationList",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L213-L220 |
161,891 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSource) DeepCopy() *ApplicationSource {
if in == nil {
return nil
}
out := new(ApplicationSource)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSource) DeepCopy() *ApplicationSource {
if in == nil {
return nil
}
out := new(ApplicationSource)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSource",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSource",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSource",
")",
"\n",
"in",
".",
"DeepCopyInto",
"... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSource. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSource",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L262-L269 |
161,892 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSourceDirectory) DeepCopy() *ApplicationSourceDirectory {
if in == nil {
return nil
}
out := new(ApplicationSourceDirectory)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSourceDirectory) DeepCopy() *ApplicationSourceDirectory {
if in == nil {
return nil
}
out := new(ApplicationSourceDirectory)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSourceDirectory",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSourceDirectory",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSourceDirectory",
")",
"\n",
"in",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSourceDirectory. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSourceDirectory",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L279-L286 |
161,893 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSourceHelm) DeepCopy() *ApplicationSourceHelm {
if in == nil {
return nil
}
out := new(ApplicationSourceHelm)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSourceHelm) DeepCopy() *ApplicationSourceHelm {
if in == nil {
return nil
}
out := new(ApplicationSourceHelm)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSourceHelm",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSourceHelm",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSourceHelm",
")",
"\n",
"in",
".",
"DeepCo... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSourceHelm. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSourceHelm",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L305-L312 |
161,894 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSourceJsonnet) DeepCopy() *ApplicationSourceJsonnet {
if in == nil {
return nil
}
out := new(ApplicationSourceJsonnet)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSourceJsonnet) DeepCopy() *ApplicationSourceJsonnet {
if in == nil {
return nil
}
out := new(ApplicationSourceJsonnet)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSourceJsonnet",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSourceJsonnet",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSourceJsonnet",
")",
"\n",
"in",
".",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSourceJsonnet. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSourceJsonnet",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L331-L338 |
161,895 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSourceKsonnet) DeepCopy() *ApplicationSourceKsonnet {
if in == nil {
return nil
}
out := new(ApplicationSourceKsonnet)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSourceKsonnet) DeepCopy() *ApplicationSourceKsonnet {
if in == nil {
return nil
}
out := new(ApplicationSourceKsonnet)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSourceKsonnet",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSourceKsonnet",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSourceKsonnet",
")",
"\n",
"in",
".",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSourceKsonnet. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSourceKsonnet",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L352-L359 |
161,896 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSourceKustomize) DeepCopy() *ApplicationSourceKustomize {
if in == nil {
return nil
}
out := new(ApplicationSourceKustomize)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSourceKustomize) DeepCopy() *ApplicationSourceKustomize {
if in == nil {
return nil
}
out := new(ApplicationSourceKustomize)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSourceKustomize",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSourceKustomize",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSourceKustomize",
")",
"\n",
"in",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSourceKustomize. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSourceKustomize",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L378-L385 |
161,897 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSourcePlugin) DeepCopy() *ApplicationSourcePlugin {
if in == nil {
return nil
}
out := new(ApplicationSourcePlugin)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSourcePlugin) DeepCopy() *ApplicationSourcePlugin {
if in == nil {
return nil
}
out := new(ApplicationSourcePlugin)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSourcePlugin",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSourcePlugin",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSourcePlugin",
")",
"\n",
"in",
".",
"... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSourcePlugin. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSourcePlugin",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L394-L401 |
161,898 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationSpec) DeepCopy() *ApplicationSpec {
if in == nil {
return nil
}
out := new(ApplicationSpec)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationSpec) DeepCopy() *ApplicationSpec {
if in == nil {
return nil
}
out := new(ApplicationSpec)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationSpec",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationSpec",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationSpec",
")",
"\n",
"in",
".",
"DeepCopyInto",
"(",
... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSpec. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationSpec",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L424-L431 |
161,899 | argoproj/argo-cd | pkg/apis/application/v1alpha1/zz_generated.deepcopy.go | DeepCopy | func (in *ApplicationStatus) DeepCopy() *ApplicationStatus {
if in == nil {
return nil
}
out := new(ApplicationStatus)
in.DeepCopyInto(out)
return out
} | go | func (in *ApplicationStatus) DeepCopy() *ApplicationStatus {
if in == nil {
return nil
}
out := new(ApplicationStatus)
in.DeepCopyInto(out)
return out
} | [
"func",
"(",
"in",
"*",
"ApplicationStatus",
")",
"DeepCopy",
"(",
")",
"*",
"ApplicationStatus",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"new",
"(",
"ApplicationStatus",
")",
"\n",
"in",
".",
"DeepCopyInto",
"... | // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationStatus. | [
"DeepCopy",
"is",
"an",
"autogenerated",
"deepcopy",
"function",
"copying",
"the",
"receiver",
"creating",
"a",
"new",
"ApplicationStatus",
"."
] | 5c353a12f2c67d8ab0d5d9aa619c9059c5261640 | https://github.com/argoproj/argo-cd/blob/5c353a12f2c67d8ab0d5d9aa619c9059c5261640/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go#L473-L480 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.