diff --git a/Procfile b/Procfile index e663cf7e1e33e..62f3c27ad1d50 100644 --- a/Procfile +++ b/Procfile @@ -1,4 +1,4 @@ controller: go run ./cmd/argocd-application-controller/main.go --app-resync 10 -api-server: go run ./cmd/argocd-server/main.go --insecure +api-server: go run ./cmd/argocd-server/main.go --insecure --disable-auth repo-server: go run ./cmd/argocd-repo-server/main.go dex: sh -c "go run ./cmd/argocd-util/main.go gendexcfg -o `pwd`/dist/dex.yaml && docker run --rm -p 5556:5556 -p 5557:5557 -v `pwd`/dist/dex.yaml:/dex.yaml quay.io/coreos/dex:v2.10.0 serve /dex.yaml" \ No newline at end of file diff --git a/cmd/argocd-util/main.go b/cmd/argocd-util/main.go index 4e407dfbcb3fe..26e34506e8f71 100644 --- a/cmd/argocd-util/main.go +++ b/cmd/argocd-util/main.go @@ -10,7 +10,6 @@ import ( "github.com/argoproj/argo-cd/errors" "github.com/argoproj/argo-cd/util/cli" "github.com/argoproj/argo-cd/util/dex" - "github.com/ghodss/yaml" log "github.com/sirupsen/logrus" "github.com/spf13/cobra" "k8s.io/client-go/kubernetes" @@ -117,12 +116,7 @@ func genDexConfig(clientConfig clientcmd.ClientConfig) ([]byte, error) { errors.CheckError(err) kubeClient := kubernetes.NewForConfigOrDie(config) - dexCfg, err := dex.GetDexConfig(kubeClient, namespace) - errors.CheckError(err) - if dexCfg == nil { - return nil, nil - } - return yaml.Marshal(dexCfg) + return dex.GenerateDexConfigYAML(kubeClient, namespace) } func main() { diff --git a/install/install.go b/install/install.go index f1bc721e50606..4d93f84b7a275 100644 --- a/install/install.go +++ b/install/install.go @@ -7,11 +7,11 @@ import ( "github.com/argoproj/argo-cd/common" "github.com/argoproj/argo-cd/errors" - "github.com/argoproj/argo-cd/util/config" "github.com/argoproj/argo-cd/util/diff" "github.com/argoproj/argo-cd/util/kube" "github.com/argoproj/argo-cd/util/password" "github.com/argoproj/argo-cd/util/session" + "github.com/argoproj/argo-cd/util/settings" tlsutil "github.com/argoproj/argo-cd/util/tls" "github.com/ghodss/yaml" "github.com/gobuffalo/packr" @@ -131,8 +131,8 @@ func (i *Installer) InstallApplicationCRD() { func (i *Installer) InstallSettings() { kubeclientset, err := kubernetes.NewForConfig(i.config) errors.CheckError(err) - configManager := config.NewConfigManager(kubeclientset, i.Namespace) - _, err = configManager.GetSettings() + settingsMgr := settings.NewSettingsManager(kubeclientset, i.Namespace) + _, err = settingsMgr.GetSettings() if err == nil { log.Infof("Settings already exists. Skipping creation") return @@ -141,7 +141,7 @@ func (i *Installer) InstallSettings() { log.Fatal(err) } // configmap/secret not yet created - var newSettings config.ArgoCDSettings + var newSettings settings.ArgoCDSettings // set JWT signature signature, err := session.MakeSignature(32) @@ -173,7 +173,7 @@ func (i *Installer) InstallSettings() { errors.CheckError(err) newSettings.Certificate = cert - err = configManager.SaveSettings(&newSettings) + err = settingsMgr.SaveSettings(&newSettings) errors.CheckError(err) } diff --git a/server/server.go b/server/server.go index 70c354d191ee9..4cd467f24b29e 100644 --- a/server/server.go +++ b/server/server.go @@ -20,12 +20,13 @@ import ( "github.com/argoproj/argo-cd/server/cluster" "github.com/argoproj/argo-cd/server/repository" "github.com/argoproj/argo-cd/server/session" + "github.com/argoproj/argo-cd/server/settings" "github.com/argoproj/argo-cd/server/version" - "github.com/argoproj/argo-cd/util/config" dexutil "github.com/argoproj/argo-cd/util/dex" grpc_util "github.com/argoproj/argo-cd/util/grpc" jsonutil "github.com/argoproj/argo-cd/util/json" util_session "github.com/argoproj/argo-cd/util/session" + settings_util "github.com/argoproj/argo-cd/util/settings" tlsutil "github.com/argoproj/argo-cd/util/tls" golang_proto "github.com/golang/protobuf/proto" grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware" @@ -59,9 +60,10 @@ type ArgoCDServer struct { ArgoCDServerOpts ssoClientApp *dexutil.ClientApp - settings config.ArgoCDSettings + settings settings_util.ArgoCDSettings log *log.Entry sessionMgr *util_session.SessionManager + settingsMgr *settings_util.SettingsManager } type ArgoCDServerOpts struct { @@ -76,8 +78,8 @@ type ArgoCDServerOpts struct { // NewServer returns a new instance of the ArgoCD API server func NewServer(opts ArgoCDServerOpts) *ArgoCDServer { - configManager := config.NewConfigManager(opts.KubeClientset, opts.Namespace) - settings, err := configManager.GetSettings() + settingsMgr := settings_util.NewSettingsManager(opts.KubeClientset, opts.Namespace) + settings, err := settingsMgr.GetSettings() if err != nil { log.Fatal(err) } @@ -87,6 +89,7 @@ func NewServer(opts ArgoCDServerOpts) *ArgoCDServer { log: log.NewEntry(log.New()), settings: *settings, sessionMgr: &sessionMgr, + settingsMgr: settingsMgr, } } @@ -210,13 +213,15 @@ func (a *ArgoCDServer) newGRPCServer() *grpc.Server { grpcS := grpc.NewServer(sOpts...) clusterService := cluster.NewServer(a.Namespace, a.KubeClientset, a.AppClientset) repoService := repository.NewServer(a.Namespace, a.KubeClientset, a.AppClientset) - sessionService := session.NewServer(a.Namespace, a.KubeClientset, a.AppClientset, a.settings) + sessionService := session.NewServer(a.settings) applicationService := application.NewServer(a.Namespace, a.KubeClientset, a.AppClientset, a.RepoClientset, repoService, clusterService) + settingsService := settings.NewServer(a.settingsMgr) version.RegisterVersionServiceServer(grpcS, &version.Server{}) cluster.RegisterClusterServiceServer(grpcS, clusterService) application.RegisterApplicationServiceServer(grpcS, applicationService) repository.RegisterRepositoryServiceServer(grpcS, repoService) session.RegisterSessionServiceServer(grpcS, sessionService) + settings.RegisterSettingsServiceServer(grpcS, settingsService) // Register reflection service on gRPC server. reflection.Register(grpcS) @@ -273,6 +278,7 @@ func (a *ArgoCDServer) newHTTPServer(ctx context.Context) *http.Server { mustRegisterGWHandler(application.RegisterApplicationServiceHandlerFromEndpoint, ctx, gwmux, endpoint, dOpts) mustRegisterGWHandler(repository.RegisterRepositoryServiceHandlerFromEndpoint, ctx, gwmux, endpoint, dOpts) mustRegisterGWHandler(session.RegisterSessionServiceHandlerFromEndpoint, ctx, gwmux, endpoint, dOpts) + mustRegisterGWHandler(settings.RegisterSettingsServiceHandlerFromEndpoint, ctx, gwmux, endpoint, dOpts) a.registerDexHandlers(mux) diff --git a/server/session/session.go b/server/session/session.go index 09c9be5a9a305..c9c199ef67bbe 100644 --- a/server/session/session.go +++ b/server/session/session.go @@ -3,29 +3,21 @@ package session import ( "context" - appclientset "github.com/argoproj/argo-cd/pkg/client/clientset/versioned" - "github.com/argoproj/argo-cd/util/config" "github.com/argoproj/argo-cd/util/password" "github.com/argoproj/argo-cd/util/session" + "github.com/argoproj/argo-cd/util/settings" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" - "k8s.io/client-go/kubernetes" ) // Server provides a Session service type Server struct { - ns string - kubeclientset kubernetes.Interface - appclientset appclientset.Interface - serversettings config.ArgoCDSettings + serversettings settings.ArgoCDSettings } // NewServer returns a new instance of the Session service -func NewServer(namespace string, kubeclientset kubernetes.Interface, appclientset appclientset.Interface, serversettings config.ArgoCDSettings) *Server { +func NewServer(serversettings settings.ArgoCDSettings) *Server { return &Server{ - ns: namespace, - appclientset: appclientset, - kubeclientset: kubeclientset, serversettings: serversettings, } } diff --git a/server/settings/settings.go b/server/settings/settings.go new file mode 100644 index 0000000000000..5146d1a8d690e --- /dev/null +++ b/server/settings/settings.go @@ -0,0 +1,36 @@ +package settings + +import ( + "github.com/argoproj/argo-cd/util/settings" + "github.com/ghodss/yaml" + "golang.org/x/net/context" +) + +// Server provides a Settings service +type Server struct { + mgr *settings.SettingsManager +} + +// NewServer returns a new instance of the Repository service +func NewServer(mgr *settings.SettingsManager) *Server { + return &Server{ + mgr: mgr, + } +} + +// Get returns ArgoCD settings +func (s *Server) Get(ctx context.Context, q *SettingsQuery) (*Settings, error) { + argoCDSettings, err := s.mgr.GetSettings() + if err != nil { + return nil, err + } + set := Settings{ + URL: argoCDSettings.URL, + } + var cfg DexConfig + err = yaml.Unmarshal([]byte(argoCDSettings.DexConfig), &cfg) + if err == nil { + set.DexConfig = &cfg + } + return &set, nil +} diff --git a/server/settings/settings.pb.go b/server/settings/settings.pb.go new file mode 100644 index 0000000000000..467d854111695 --- /dev/null +++ b/server/settings/settings.pb.go @@ -0,0 +1,859 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: server/settings/settings.proto + +/* + Package settings is a generated protocol buffer package. + + Settings Service + + Settings Service API retrives ArgoCD settings + + It is generated from these files: + server/settings/settings.proto + + It has these top-level messages: + SettingsQuery + Settings + DexConfig + Connector +*/ +package settings + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" +import _ "google.golang.org/genproto/googleapis/api/annotations" + +import context "golang.org/x/net/context" +import grpc "google.golang.org/grpc" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +// SettingsQuery is a query for ArgoCD settings +type SettingsQuery struct { +} + +func (m *SettingsQuery) Reset() { *m = SettingsQuery{} } +func (m *SettingsQuery) String() string { return proto.CompactTextString(m) } +func (*SettingsQuery) ProtoMessage() {} +func (*SettingsQuery) Descriptor() ([]byte, []int) { return fileDescriptorSettings, []int{0} } + +type Settings struct { + URL string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` + DexConfig *DexConfig `protobuf:"bytes,2,opt,name=dexConfig" json:"dexConfig,omitempty"` +} + +func (m *Settings) Reset() { *m = Settings{} } +func (m *Settings) String() string { return proto.CompactTextString(m) } +func (*Settings) ProtoMessage() {} +func (*Settings) Descriptor() ([]byte, []int) { return fileDescriptorSettings, []int{1} } + +func (m *Settings) GetURL() string { + if m != nil { + return m.URL + } + return "" +} + +func (m *Settings) GetDexConfig() *DexConfig { + if m != nil { + return m.DexConfig + } + return nil +} + +type DexConfig struct { + Connectors []*Connector `protobuf:"bytes,1,rep,name=connectors" json:"connectors,omitempty"` +} + +func (m *DexConfig) Reset() { *m = DexConfig{} } +func (m *DexConfig) String() string { return proto.CompactTextString(m) } +func (*DexConfig) ProtoMessage() {} +func (*DexConfig) Descriptor() ([]byte, []int) { return fileDescriptorSettings, []int{2} } + +func (m *DexConfig) GetConnectors() []*Connector { + if m != nil { + return m.Connectors + } + return nil +} + +type Connector struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` +} + +func (m *Connector) Reset() { *m = Connector{} } +func (m *Connector) String() string { return proto.CompactTextString(m) } +func (*Connector) ProtoMessage() {} +func (*Connector) Descriptor() ([]byte, []int) { return fileDescriptorSettings, []int{3} } + +func (m *Connector) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *Connector) GetType() string { + if m != nil { + return m.Type + } + return "" +} + +func init() { + proto.RegisterType((*SettingsQuery)(nil), "cluster.SettingsQuery") + proto.RegisterType((*Settings)(nil), "cluster.Settings") + proto.RegisterType((*DexConfig)(nil), "cluster.DexConfig") + proto.RegisterType((*Connector)(nil), "cluster.Connector") +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// Client API for SettingsService service + +type SettingsServiceClient interface { + // Get returns ArgoCD settings + Get(ctx context.Context, in *SettingsQuery, opts ...grpc.CallOption) (*Settings, error) +} + +type settingsServiceClient struct { + cc *grpc.ClientConn +} + +func NewSettingsServiceClient(cc *grpc.ClientConn) SettingsServiceClient { + return &settingsServiceClient{cc} +} + +func (c *settingsServiceClient) Get(ctx context.Context, in *SettingsQuery, opts ...grpc.CallOption) (*Settings, error) { + out := new(Settings) + err := grpc.Invoke(ctx, "/cluster.SettingsService/Get", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for SettingsService service + +type SettingsServiceServer interface { + // Get returns ArgoCD settings + Get(context.Context, *SettingsQuery) (*Settings, error) +} + +func RegisterSettingsServiceServer(s *grpc.Server, srv SettingsServiceServer) { + s.RegisterService(&_SettingsService_serviceDesc, srv) +} + +func _SettingsService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SettingsQuery) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SettingsServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cluster.SettingsService/Get", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SettingsServiceServer).Get(ctx, req.(*SettingsQuery)) + } + return interceptor(ctx, in, info, handler) +} + +var _SettingsService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cluster.SettingsService", + HandlerType: (*SettingsServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Get", + Handler: _SettingsService_Get_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "server/settings/settings.proto", +} + +func (m *SettingsQuery) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SettingsQuery) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *Settings) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Settings) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.URL) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintSettings(dAtA, i, uint64(len(m.URL))) + i += copy(dAtA[i:], m.URL) + } + if m.DexConfig != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintSettings(dAtA, i, uint64(m.DexConfig.Size())) + n1, err := m.DexConfig.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + } + return i, nil +} + +func (m *DexConfig) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DexConfig) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Connectors) > 0 { + for _, msg := range m.Connectors { + dAtA[i] = 0xa + i++ + i = encodeVarintSettings(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *Connector) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Connector) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintSettings(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + if len(m.Type) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintSettings(dAtA, i, uint64(len(m.Type))) + i += copy(dAtA[i:], m.Type) + } + return i, nil +} + +func encodeVarintSettings(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *SettingsQuery) Size() (n int) { + var l int + _ = l + return n +} + +func (m *Settings) Size() (n int) { + var l int + _ = l + l = len(m.URL) + if l > 0 { + n += 1 + l + sovSettings(uint64(l)) + } + if m.DexConfig != nil { + l = m.DexConfig.Size() + n += 1 + l + sovSettings(uint64(l)) + } + return n +} + +func (m *DexConfig) Size() (n int) { + var l int + _ = l + if len(m.Connectors) > 0 { + for _, e := range m.Connectors { + l = e.Size() + n += 1 + l + sovSettings(uint64(l)) + } + } + return n +} + +func (m *Connector) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovSettings(uint64(l)) + } + l = len(m.Type) + if l > 0 { + n += 1 + l + sovSettings(uint64(l)) + } + return n +} + +func sovSettings(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozSettings(x uint64) (n int) { + return sovSettings(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *SettingsQuery) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SettingsQuery: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SettingsQuery: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSettings(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSettings + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Settings) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Settings: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Settings: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSettings + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.URL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DexConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSettings + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DexConfig == nil { + m.DexConfig = &DexConfig{} + } + if err := m.DexConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSettings(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSettings + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DexConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DexConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DexConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Connectors", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSettings + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Connectors = append(m.Connectors, &Connector{}) + if err := m.Connectors[len(m.Connectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSettings(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSettings + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Connector) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Connector: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Connector: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSettings + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSettings + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSettings + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSettings(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSettings + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSettings(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSettings + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSettings + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSettings + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthSettings + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSettings + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipSettings(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthSettings = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSettings = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("server/settings/settings.proto", fileDescriptorSettings) } + +var fileDescriptorSettings = []byte{ + // 322 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0x41, 0x4b, 0xc3, 0x40, + 0x10, 0x85, 0xd9, 0x46, 0xac, 0x19, 0x91, 0xea, 0x22, 0x12, 0x8b, 0xc4, 0x92, 0x53, 0x41, 0x4c, + 0xb4, 0x3d, 0x79, 0x12, 0x5a, 0x41, 0x10, 0x2f, 0xa6, 0x88, 0x20, 0x78, 0x48, 0xd3, 0x71, 0x8d, + 0xb4, 0x3b, 0x65, 0xb3, 0x29, 0xf6, 0xea, 0x5f, 0xf0, 0x4f, 0x79, 0x14, 0xbc, 0x8b, 0x04, 0x7f, + 0x88, 0x74, 0xdb, 0x44, 0xab, 0xb7, 0xc7, 0xf7, 0x66, 0x92, 0xb7, 0xf3, 0xc0, 0x4d, 0x51, 0x4d, + 0x50, 0x05, 0x29, 0x6a, 0x9d, 0x48, 0x91, 0x96, 0xc2, 0x1f, 0x2b, 0xd2, 0xc4, 0xab, 0xf1, 0x30, + 0x4b, 0x35, 0xaa, 0xfa, 0xb6, 0x20, 0x41, 0x86, 0x05, 0x33, 0x35, 0xb7, 0xeb, 0x7b, 0x82, 0x48, + 0x0c, 0x31, 0x88, 0xc6, 0x49, 0x10, 0x49, 0x49, 0x3a, 0xd2, 0x09, 0xc9, 0xc5, 0xb2, 0x57, 0x83, + 0x8d, 0xde, 0xe2, 0x73, 0x57, 0x19, 0xaa, 0xa9, 0x77, 0x03, 0x6b, 0x05, 0xe0, 0xbb, 0x60, 0x65, + 0x6a, 0xe8, 0xb0, 0x06, 0x6b, 0xda, 0x9d, 0x6a, 0xfe, 0xb1, 0x6f, 0x5d, 0x87, 0x97, 0xe1, 0x8c, + 0xf1, 0x23, 0xb0, 0x07, 0xf8, 0xd4, 0x25, 0x79, 0x9f, 0x08, 0xa7, 0xd2, 0x60, 0xcd, 0xf5, 0x16, + 0xf7, 0x17, 0x41, 0xfc, 0xb3, 0xc2, 0x09, 0x7f, 0x86, 0xbc, 0x53, 0xb0, 0x4b, 0xce, 0x5b, 0x00, + 0x31, 0x49, 0x89, 0xb1, 0x26, 0x95, 0x3a, 0xac, 0x61, 0x2d, 0xed, 0x77, 0x0b, 0x2b, 0xfc, 0x35, + 0xe5, 0xb5, 0xc1, 0x2e, 0x0d, 0xce, 0x61, 0x45, 0x46, 0x23, 0x9c, 0x67, 0x0b, 0x8d, 0x9e, 0x31, + 0x3d, 0x1d, 0xa3, 0x89, 0x63, 0x87, 0x46, 0xb7, 0xee, 0xa0, 0x56, 0x3c, 0xa7, 0x87, 0x6a, 0x92, + 0xc4, 0xc8, 0x2f, 0xc0, 0x3a, 0x47, 0xcd, 0x77, 0xca, 0xdf, 0x2d, 0x1d, 0xa0, 0xbe, 0xf5, 0x8f, + 0x7b, 0xce, 0xf3, 0xfb, 0xd7, 0x4b, 0x85, 0xf3, 0x4d, 0x73, 0xc4, 0xc9, 0x71, 0xd9, 0x40, 0xe7, + 0xe4, 0x35, 0x77, 0xd9, 0x5b, 0xee, 0xb2, 0xcf, 0xdc, 0x65, 0xb7, 0x07, 0x22, 0xd1, 0x0f, 0x59, + 0xdf, 0x8f, 0x69, 0x14, 0x44, 0xca, 0x74, 0xf1, 0x68, 0xc4, 0x61, 0x3c, 0x08, 0xfe, 0xb4, 0xd8, + 0x5f, 0x35, 0x05, 0xb4, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xef, 0x0e, 0xd5, 0xb9, 0xdf, 0x01, + 0x00, 0x00, +} diff --git a/server/settings/settings.pb.gw.go b/server/settings/settings.pb.gw.go new file mode 100644 index 0000000000000..ecc4b20bf818a --- /dev/null +++ b/server/settings/settings.pb.gw.go @@ -0,0 +1,116 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: server/settings/settings.proto + +/* +Package settings is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package settings + +import ( + "io" + "net/http" + + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "golang.org/x/net/context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/status" +) + +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray + +func request_SettingsService_Get_0(ctx context.Context, marshaler runtime.Marshaler, client SettingsServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SettingsQuery + var metadata runtime.ServerMetadata + + msg, err := client.Get(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +// RegisterSettingsServiceHandlerFromEndpoint is same as RegisterSettingsServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterSettingsServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterSettingsServiceHandler(ctx, mux, conn) +} + +// RegisterSettingsServiceHandler registers the http handlers for service SettingsService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterSettingsServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterSettingsServiceHandlerClient(ctx, mux, NewSettingsServiceClient(conn)) +} + +// RegisterSettingsServiceHandler registers the http handlers for service SettingsService to "mux". +// The handlers forward requests to the grpc endpoint over the given implementation of "SettingsServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SettingsServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "SettingsServiceClient" to call the correct interceptors. +func RegisterSettingsServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SettingsServiceClient) error { + + mux.Handle("GET", pattern_SettingsService_Get_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + if cn, ok := w.(http.CloseNotifier); ok { + go func(done <-chan struct{}, closed <-chan bool) { + select { + case <-done: + case <-closed: + cancel() + } + }(ctx.Done(), cn.CloseNotify()) + } + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SettingsService_Get_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_SettingsService_Get_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_SettingsService_Get_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "settings"}, "")) +) + +var ( + forward_SettingsService_Get_0 = runtime.ForwardResponseMessage +) diff --git a/server/settings/settings.proto b/server/settings/settings.proto new file mode 100644 index 0000000000000..95ec8d7dcc22c --- /dev/null +++ b/server/settings/settings.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; +option go_package = "github.com/argoproj/argo-cd/server/settings"; + +// Settings Service +// +// Settings Service API retrives ArgoCD settings +package cluster; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; + +// SettingsQuery is a query for ArgoCD settings +message SettingsQuery { +} + +message Settings { + string url = 1 [(gogoproto.customname) = "URL"];; + DexConfig dexConfig = 2; +} + +message DexConfig { + repeated Connector connectors = 1; +} + +message Connector { + string name = 1; + string type = 2; +} + +// SettingsService +service SettingsService { + + // Get returns ArgoCD settings + rpc Get(SettingsQuery) returns (Settings) { + option (google.api.http).get = "/api/v1/settings"; + } + +} diff --git a/util/dex/config.go b/util/dex/config.go index 5d0cf78e4adc6..38dd61bce6720 100644 --- a/util/dex/config.go +++ b/util/dex/config.go @@ -7,7 +7,7 @@ import ( "strings" "github.com/argoproj/argo-cd/common" - "github.com/argoproj/argo-cd/util/config" + "github.com/argoproj/argo-cd/util/settings" "github.com/ghodss/yaml" log "github.com/sirupsen/logrus" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -21,18 +21,16 @@ const ( DexClientAppID = "argo-cd" ) -type DexConfig map[string]interface{} - -func GetDexConfig(kubeClientset kubernetes.Interface, namespace string) (*DexConfig, error) { - configMgr := config.NewConfigManager(kubeClientset, namespace) - settings, err := configMgr.GetSettings() +func GenerateDexConfigYAML(kubeClientset kubernetes.Interface, namespace string) ([]byte, error) { + settingsMgr := settings.NewSettingsManager(kubeClientset, namespace) + settings, err := settingsMgr.GetSettings() if err != nil { return nil, err } if !settings.IsSSOConfigured() { return nil, nil } - var dexCfg DexConfig + var dexCfg map[string]interface{} err = yaml.Unmarshal([]byte(settings.DexConfig), &dexCfg) if err != nil { return nil, fmt.Errorf("failed to unmarshal dex.config from configmap: %v", err) @@ -88,8 +86,7 @@ func GetDexConfig(kubeClientset kubernetes.Interface, namespace string) (*DexCon return nil, err } dexCfg = replaceMapSecrets(dexCfg, secretValues) - - return &dexCfg, nil + return yaml.Marshal(dexCfg) } // formulateOAuthClientSecret calculates an arbitrary, but predictable OAuth2 client secret string @@ -120,7 +117,7 @@ func getSecretValues(kubeClientset kubernetes.Interface, namespace string) (map[ } // replaceMapSecrets takes a json object and recursively looks for any secret key references in the -// object and replaces the value withe secret value +// object and replaces the value with the secret value func replaceMapSecrets(obj map[string]interface{}, secretValues map[string]string) map[string]interface{} { newObj := make(map[string]interface{}) for k, v := range obj { diff --git a/util/config/configmanager.go b/util/settings/settings.go similarity index 63% rename from util/config/configmanager.go rename to util/settings/settings.go index b9074843187ce..3f58880501848 100644 --- a/util/config/configmanager.go +++ b/util/settings/settings.go @@ -1,4 +1,4 @@ -package config +package settings import ( "crypto/tls" @@ -35,33 +35,28 @@ type ArgoCDSettings struct { } const ( - // configManagerAdminPasswordKey designates the key for a root password inside a Kubernetes secret. - configManagerAdminPasswordKey = "admin.password" - - // configManagerServerSignatureKey designates the key for a server secret key inside a Kubernetes secret. - configManagerServerSignatureKey = "server.secretkey" - - // configManagerServerCertificate designates the key for the public cert used in TLS - configManagerServerCertificate = "server.crt" - - // configManagerServerPrivateKey designates the key for the private key used in TLS - configManagerServerPrivateKey = "server.key" - - // configManagerURL designates the key where ArgoCDs external URL is set - configManagerURLKey = "url" - - // configManagerDexConfig designates the key for the dex config - configManagerDexConfigKey = "dex.config" + // settingAdminPasswordKey designates the key for a root password inside a Kubernetes secret. + settingAdminPasswordKey = "admin.password" + // settingServerSignatureKey designates the key for a server secret key inside a Kubernetes secret. + settingServerSignatureKey = "server.secretkey" + // settingServerCertificate designates the key for the public cert used in TLS + settingServerCertificate = "server.crt" + // settingServerPrivateKey designates the key for the private key used in TLS + settingServerPrivateKey = "server.key" + // settingURLKey designates the key where ArgoCDs external URL is set + settingURLKey = "url" + // settingDexConfigKey designates the key for the dex config + settingDexConfigKey = "dex.config" ) -// ConfigManager holds config info for a new manager with which to access Kubernetes ConfigMaps. -type ConfigManager struct { +// SettingsManager holds config info for a new manager with which to access Kubernetes ConfigMaps. +type SettingsManager struct { clientset kubernetes.Interface namespace string } // GetSettings retrieves settings from the ConfigManager. -func (mgr *ConfigManager) GetSettings() (*ArgoCDSettings, error) { +func (mgr *SettingsManager) GetSettings() (*ArgoCDSettings, error) { argoCDCM, err := mgr.clientset.CoreV1().ConfigMaps(mgr.namespace).Get(common.ArgoCDConfigMapName, metav1.GetOptions{}) if err != nil { return nil, err @@ -72,28 +67,28 @@ func (mgr *ConfigManager) GetSettings() (*ArgoCDSettings, error) { } var settings ArgoCDSettings - settings.DexConfig = argoCDCM.Data[configManagerDexConfigKey] - settings.URL = argoCDCM.Data[configManagerURLKey] + settings.DexConfig = argoCDCM.Data[settingDexConfigKey] + settings.URL = argoCDCM.Data[settingURLKey] - adminPasswordHash, ok := argoCDSecret.Data[configManagerAdminPasswordKey] + adminPasswordHash, ok := argoCDSecret.Data[settingAdminPasswordKey] if !ok { return nil, fmt.Errorf("admin user not found") } settings.LocalUsers = map[string]string{ common.ArgoCDAdminUsername: string(adminPasswordHash), } - secretKey, ok := argoCDSecret.Data[configManagerServerSignatureKey] + secretKey, ok := argoCDSecret.Data[settingServerSignatureKey] if !ok { return nil, fmt.Errorf("server secret key not found") } settings.ServerSignature = secretKey - serverCert, certOk := argoCDSecret.Data[configManagerServerCertificate] - serverKey, keyOk := argoCDSecret.Data[configManagerServerPrivateKey] + serverCert, certOk := argoCDSecret.Data[settingServerCertificate] + serverKey, keyOk := argoCDSecret.Data[settingServerPrivateKey] if certOk && keyOk { cert, err := tls.X509KeyPair(serverCert, serverKey) if err != nil { - return nil, fmt.Errorf("invalid x509 key pair %s/%s in secret: %s", configManagerServerCertificate, configManagerServerPrivateKey, err) + return nil, fmt.Errorf("invalid x509 key pair %s/%s in secret: %s", settingServerCertificate, settingServerPrivateKey, err) } settings.Certificate = &cert } @@ -101,7 +96,7 @@ func (mgr *ConfigManager) GetSettings() (*ArgoCDSettings, error) { } // SaveSettings serializes ArgoCD settings and upserts it into K8s secret/configmap -func (mgr *ConfigManager) SaveSettings(settings *ArgoCDSettings) error { +func (mgr *SettingsManager) SaveSettings(settings *ArgoCDSettings) error { // Upsert the config data argoCDCM, err := mgr.clientset.CoreV1().ConfigMaps(mgr.namespace).Get(common.ArgoCDConfigMapName, metav1.GetOptions{}) createCM := false @@ -117,8 +112,8 @@ func (mgr *ConfigManager) SaveSettings(settings *ArgoCDSettings) error { } createCM = true } - argoCDCM.Data[configManagerURLKey] = settings.URL - argoCDCM.Data[configManagerDexConfigKey] = settings.DexConfig + argoCDCM.Data[settingURLKey] = settings.URL + argoCDCM.Data[settingDexConfigKey] = settings.DexConfig if createCM { _, err = mgr.clientset.CoreV1().ConfigMaps(mgr.namespace).Create(argoCDCM) } else { @@ -144,15 +139,15 @@ func (mgr *ConfigManager) SaveSettings(settings *ArgoCDSettings) error { createSecret = true } argoCDSecret.StringData = make(map[string]string) - argoCDSecret.StringData[configManagerServerSignatureKey] = string(settings.ServerSignature) - argoCDSecret.StringData[configManagerAdminPasswordKey] = settings.LocalUsers[common.ArgoCDAdminUsername] + argoCDSecret.StringData[settingServerSignatureKey] = string(settings.ServerSignature) + argoCDSecret.StringData[settingAdminPasswordKey] = settings.LocalUsers[common.ArgoCDAdminUsername] if settings.Certificate != nil { certBytes, keyBytes := tlsutil.EncodeX509KeyPair(*settings.Certificate) - argoCDSecret.StringData[configManagerServerCertificate] = string(certBytes) - argoCDSecret.StringData[configManagerServerPrivateKey] = string(keyBytes) + argoCDSecret.StringData[settingServerCertificate] = string(certBytes) + argoCDSecret.StringData[settingServerPrivateKey] = string(keyBytes) } else { - delete(argoCDSecret.Data, configManagerServerCertificate) - delete(argoCDSecret.Data, configManagerServerPrivateKey) + delete(argoCDSecret.Data, settingServerCertificate) + delete(argoCDSecret.Data, settingServerPrivateKey) } if createSecret { _, err = mgr.clientset.CoreV1().Secrets(mgr.namespace).Create(argoCDSecret) @@ -165,9 +160,9 @@ func (mgr *ConfigManager) SaveSettings(settings *ArgoCDSettings) error { return nil } -// NewConfigManager generates a new ConfigManager pointer and returns it -func NewConfigManager(clientset kubernetes.Interface, namespace string) *ConfigManager { - return &ConfigManager{ +// NewSettingsManager generates a new SettingsManager pointer and returns it +func NewSettingsManager(clientset kubernetes.Interface, namespace string) *SettingsManager { + return &SettingsManager{ clientset: clientset, namespace: namespace, }