PMM-4879 Adding support for defaults-file in new mysql service.

main.go

@@ -136,6 +136,7 @@ type gRPCServerDeps struct {
 	actions              *agents.ActionsService
 	agentsStateUpdater   *agents.StateUpdater
 	connectionCheck      *agents.ConnectionChecker
+	parseDefaultsFile    *agents.ParseDefaultsFile
 	grafanaClient        *grafana.Client
 	checksService        *checks.Service
 	dbaasClient          *dbaas.Client
@@ -188,7 +189,7 @@ func runGRPCServer(ctx context.Context, deps *gRPCServerDeps) {
 
 	nodeSvc := management.NewNodeService(deps.db)
 	serviceSvc := management.NewServiceService(deps.db, deps.agentsStateUpdater, deps.vmdb)
-	mysqlSvc := management.NewMySQLService(deps.db, deps.agentsStateUpdater, deps.connectionCheck, deps.versionCache)
+	mysqlSvc := management.NewMySQLService(deps.db, deps.agentsStateUpdater, deps.connectionCheck, deps.versionCache, deps.parseDefaultsFile)
 	mongodbSvc := management.NewMongoDBService(deps.db, deps.agentsStateUpdater, deps.connectionCheck)
 	postgresqlSvc := management.NewPostgreSQLService(deps.db, deps.agentsStateUpdater, deps.connectionCheck)
 	proxysqlSvc := management.NewProxySQLService(deps.db, deps.agentsStateUpdater, deps.connectionCheck)
@@ -726,6 +727,7 @@ func main() {
 	schedulerService := scheduler.New(db, backupService)
 	versionCache := versioncache.New(db, versioner)
 	emailer := alertmanager.NewEmailer(logrus.WithField("component", "alertmanager-emailer").Logger)
+	parseDefaultsFile := agents.NewParseDefaultsFile(agentsRegistry)
 
 	serverParams := &server.Params{
 		DB:                   db,
@@ -926,6 +928,7 @@ func main() {
 				versionCache:         versionCache,
 				supervisord:          supervisord,
 				config:               &cfg.Config,
+				parseDefaultsFile:    parseDefaultsFile,
 			})
 	}()
 

services/agents/channel/channel.go

@@ -275,6 +275,8 @@ func (c *Channel) runReceiver() {
 			c.publish(msg.Id, msg.Status, p.GetVersions)
 		case *agentpb.AgentMessage_PbmSwitchPitr:
 			c.publish(msg.Id, msg.Status, p.PbmSwitchPitr)
+		case *agentpb.AgentMessage_ParseDefaultsFile:
+			c.publish(msg.Id, msg.Status, p.ParseDefaultsFile)
 
 		case nil:
 			c.cancel(msg.Id, errors.Errorf("unimplemented: failed to handle received message %s", msg))

services/agents/parse_defaults_file.go

@@ -0,0 +1,105 @@
+// pmm-managed
+// Copyright (C) 2017 Percona LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+package agents
+
+import (
+	"context"
+	"time"
+
+	"github.com/percona/pmm/api/agentpb"
+	"github.com/percona/pmm/api/inventorypb"
+	"github.com/pkg/errors"
+
+	"github.com/percona/pmm-managed/models"
+	"github.com/percona/pmm-managed/utils/logger"
+)
+
+// ParseDefaultsFile requests from agent to parse defaultsFile.
+type ParseDefaultsFile struct {
+	r *Registry
+}
+
+// NewParseDefaultsFile creates new ParseDefaultsFile request.
+func NewParseDefaultsFile(r *Registry) *ParseDefaultsFile {
+	return &ParseDefaultsFile{
+		r: r,
+	}
+}
+
+// ParseDefaultsFile sends request (with file path) to pmm-agent to parse defaults file.
+func (p *ParseDefaultsFile) ParseDefaultsFile(ctx context.Context, pmmAgentID, filePath string, serviceType models.ServiceType) (*models.ParseDefaultsFileResult, error) {
+	l := logger.Get(ctx)
+
+	pmmAgent, err := p.r.get(pmmAgentID)
+	if err != nil {
+		return nil, err
+	}
+
+	start := time.Now()
+	defer func() {
+		if dur := time.Since(start); dur > 5*time.Second {
+			l.Warnf("ParseDefaultsFile took %s.", dur)
+		}
+	}()
+
+	request, err := createRequest(filePath, serviceType)
+	if err != nil {
+		l.Debugf("can't create ParseDefaultsFileRequest %s", err)
+		return nil, err
+	}
+
+	resp, err := pmmAgent.channel.SendAndWaitResponse(request)
+	if err != nil {
+		return nil, err
+	}
+
+	l.Infof("ParseDefaultsFile response from agent: %+v.", resp)
+	parserResponse, ok := resp.(*agentpb.ParseDefaultsFileResponse)
+	if !ok {
+		return nil, errors.New("wrong response from agent (not ParseDefaultsFileResponse model)")
+	}
+	if len(parserResponse.GetError()) != 0 {
+		return nil, errors.New(parserResponse.GetError())
+	}
+
+	return &models.ParseDefaultsFileResult{
+		Username: parserResponse.GetUsername(),
+		Password: parserResponse.GetPassword(),
+		Host:     parserResponse.GetHost(),
+		Port:     parserResponse.GetPort(),
+	}, nil
+}
+
+func createRequest(configPath string, serviceType models.ServiceType) (*agentpb.ParseDefaultsFileRequest, error) {
+	var request *agentpb.ParseDefaultsFileRequest
+
+	switch serviceType {
+	case models.MySQLServiceType:
+		request = &agentpb.ParseDefaultsFileRequest{
+			ServiceType: inventorypb.ServiceType_MYSQL_SERVICE,
+			ConfigPath:  configPath,
+		}
+	case models.ExternalServiceType:
+	case models.HAProxyServiceType:
+	case models.MongoDBServiceType:
+	case models.PostgreSQLServiceType:
+	case models.ProxySQLServiceType:
+	default:
+		return nil, errors.Errorf("unhandled service type %s", serviceType)
+	}
+	return request, nil
+}

services/management/deps.go

@@ -34,6 +34,7 @@ import (
 //go:generate mockery -name=grafanaClient -case=snake -inpkg -testonly
 //go:generate mockery -name=jobsService -case=snake -inpkg -testonly
 //go:generate mockery -name=connectionChecker -case=snake -inpkg -testonly
+//go:generate mockery -name=defaultsFileParser -case=snake -inpkg -testonly
 
 // agentsRegistry is a subset of methods of agents.Registry used by this package.
 // We use it instead of real type for testing and to avoid dependency cycle.
@@ -93,3 +94,9 @@ type connectionChecker interface {
 type versionCache interface {
 	RequestSoftwareVersionsUpdate()
 }
+
+// defaultsFileParser is a subset of methods of agents.ParseDefaultsFile.
+// We use it instead of real type for testing and to avoid dependency cycle.
+type defaultsFileParser interface {
+	ParseDefaultsFile(ctx context.Context, pmmAgentID, filePath string, serviceType models.ServiceType) (*models.ParseDefaultsFileResult, error)
+}

services/management/mysql.go

@@ -18,10 +18,13 @@ package management
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/AlekSi/pointer"
 	"github.com/percona/pmm/api/inventorypb"
 	"github.com/percona/pmm/api/managementpb"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 	"gopkg.in/reform.v1"
 
 	"github.com/percona/pmm-managed/models"
@@ -39,15 +42,17 @@ type MySQLService struct {
 	state agentsStateUpdater
 	cc    connectionChecker
 	vc    versionCache
+	pfd   defaultsFileParser
 }
 
 // NewMySQLService creates new MySQL Management Service.
-func NewMySQLService(db *reform.DB, state agentsStateUpdater, cc connectionChecker, vc versionCache) *MySQLService {
+func NewMySQLService(db *reform.DB, state agentsStateUpdater, cc connectionChecker, vc versionCache, pfd defaultsFileParser) *MySQLService {
 	return &MySQLService{
 		db:    db,
 		state: state,
 		cc:    cc,
 		vc:    vc,
+		pfd:   pfd,
 	}
 }
 
@@ -78,6 +83,30 @@ func (s *MySQLService) Add(ctx context.Context, req *managementpb.AddMySQLReques
 		if err != nil {
 			return err
 		}
+
+		if len(req.DefaultsFile) != 0 {
+			result, err := s.pfd.ParseDefaultsFile(ctx, req.GetPmmAgentId(), req.GetDefaultsFile(), models.MySQLServiceType)
+			if err != nil {
+				return status.Error(codes.FailedPrecondition, fmt.Sprintf("Defaults file error: %s.", err))
+			}
+
+			// set username and password from parsed defaults file by agent
+			if len(result.Username) != 0 {
+				req.Username = result.Username
+			}
+			if len(result.Password) != 0 {
+				req.Password = result.Password
+			}
+
+			if len(result.Host) != 0 {
+				req.Address = result.Host
+			}
+
+			if result.Port > 0 {
+				req.Port = result.Port
+			}
+		}
+
 		service, err := models.AddNewService(tx.Querier, models.MySQLServiceType, &models.AddDBMSServiceParams{
 			ServiceName:    req.ServiceName,
 			NodeID:         nodeID,