graphql-engine/cli/commands/metadata_handlers.go
Kali Vara Purushotham Santhati 94a3be3e6e cli: fix lint errors
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/1749
Co-authored-by: Aravind K P <8335904+scriptonist@users.noreply.github.com>
GitOrigin-RevId: 4515f7f2c58b7f28645b2c5a5d9842aa7a844eae
2021-10-13 14:39:15 +00:00

315 lines
9.3 KiB
Go

package commands
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"os"
"github.com/hasura/graphql-engine/cli/v2/internal/hasura"
goyaml "github.com/goccy/go-yaml"
"github.com/hasura/graphql-engine/cli/v2"
"github.com/hasura/graphql-engine/cli/v2/internal/projectmetadata"
"github.com/pkg/errors"
"gopkg.in/yaml.v2"
)
type MetadataModeHandler interface {
Export(*MetadataExportOptions) error
Apply(*MetadataApplyOptions) error
Diff(*MetadataDiffOptions) error
}
func getMetadataModeHandler(mode cli.MetadataMode) MetadataModeHandler {
switch mode {
case cli.MetadataModeJSON:
return &metadataModeJSONHandler{}
case cli.MetadataModeYAML:
return &metadataModeYAMLHandler{}
default:
return &metadataModeDirectoryHandler{}
}
}
type metadataModeDirectoryHandler struct{}
func (m *metadataModeDirectoryHandler) Export(o *MetadataExportOptions) error {
metadataHandler := projectmetadata.NewHandlerFromEC(o.EC)
files, err := metadataHandler.ExportMetadata()
o.EC.Spinner.Stop()
if err != nil {
return errors.Wrap(err, "failed to export metadata")
}
err = metadataHandler.WriteMetadata(files)
if err != nil {
return errors.Wrap(err, "cannot write metadata to project")
}
return nil
}
func (m *metadataModeDirectoryHandler) Apply(o *MetadataApplyOptions) error {
metadataHandler := projectmetadata.NewHandlerFromEC(o.EC)
if !o.DryRun {
if o.EC.Config.Version == cli.V2 {
_, err := metadataHandler.V1ApplyMetadata()
if err != nil {
return errorApplyingMetadata(err)
}
o.EC.Logger.Debug("metadata applied using v1 replace_metadata")
} else {
r, err := metadataHandler.V2ApplyMetadata()
if err != nil {
return errorApplyingMetadata(err)
}
if !r.IsConsistent {
o.EC.Logger.Warn("Metadata is inconsistent")
o.EC.Logger.Warn("Use 'hasura metadata ic list' command to list inconsistent objects")
}
o.EC.Logger.Debug("metadata applied using v2 replace_metadata")
}
if len(o.rawOutput) != 0 {
// if not a dry run fetch metadata from and server and print it to stdout
return getMetadataFromServerAndWriteToStdoutByFormat(o.EC, rawOutputFormat(o.rawOutput))
}
return nil
}
if o.DryRun {
projectMetadataJSON, err := metadataHandler.MakeJSONMetadata()
if err != nil {
return fmt.Errorf("error building project metadata: %w", err)
}
if o.DryRun && len(o.rawOutput) == 0 {
// ie users who probably expect old behaviour
// show a warning about change in behaviour
o.rawOutput = string(rawOutputFormatJSON)
o.EC.Logger.Warn("behaviour of --dry-run flag has changed from v2.0.0. It used to show a diff between metadata on server and local project")
o.EC.Logger.Warn("new behaviour is to output local project metadata as JSON by default. The output format is configurable by -o flag eg: `hasura metadata apply --dry-run -o yaml`")
o.EC.Logger.Warn("the old behaviour can be achieved using `hasura metadata diff` command")
}
if err := writeByOutputFormat(o.EC.Stdout, projectMetadataJSON, rawOutputFormat(o.rawOutput)); err != nil {
return fmt.Errorf("displaying metadata failed: %w", err)
}
}
return nil
}
func (m *metadataModeDirectoryHandler) Diff(o *MetadataDiffOptions) error {
args := o.Args
messageFormat := "Showing diff between %s and %s..."
message := ""
metadataHandler := projectmetadata.NewHandlerFromEC(o.EC)
from := "project"
to := "server"
switch len(args) {
case 0:
o.Metadata[0] = o.EC.MetadataDir
from = "project"
case 1:
// 1 arg, diff given directory and the metadata on server
err := checkDir(args[0])
if err != nil {
return err
}
o.Metadata[0] = args[0]
from = o.Metadata[0]
case 2:
err := checkDir(args[0])
if err != nil {
return err
}
o.Metadata[0] = args[0]
from = o.Metadata[0]
err = checkDir(args[1])
if err != nil {
return err
}
o.Metadata[1] = args[1]
to = o.Metadata[1]
}
message = fmt.Sprintf(messageFormat, from, to)
o.EC.Logger.Info(message)
var oldYaml, newYaml []byte
if o.Metadata[1] == "" {
tmpDir, err := ioutil.TempDir("", "*")
if err != nil {
return err
}
defer os.RemoveAll(tmpDir)
metadataHandler.SetMetadataObjects(projectmetadata.GetMetadataObjectsWithDir(o.EC, tmpDir))
var files map[string][]byte
files, err = metadataHandler.ExportMetadata()
if err != nil {
return err
}
err = metadataHandler.WriteMetadata(files)
if err != nil {
return err
}
} else {
metadataHandler.SetMetadataObjects(projectmetadata.GetMetadataObjectsWithDir(o.EC, o.Metadata[1]))
}
// build server metadata
serverMeta, err := metadataHandler.BuildMetadata()
if err != nil {
return err
}
newYaml, err = yaml.Marshal(serverMeta)
if err != nil {
return errors.Wrap(err, "cannot unmarshall server metadata")
}
// build local metadata
metadataHandler.SetMetadataObjects(projectmetadata.GetMetadataObjectsWithDir(o.EC, o.Metadata[0]))
localMeta, err := metadataHandler.BuildMetadata()
if err != nil {
return err
}
oldYaml, err = yaml.Marshal(localMeta)
if err != nil {
return errors.Wrap(err, "cannot unmarshal local metadata")
}
// Here oldYaml is project's metadata and newYaml is server's metadata for having diff similar to git diff i.e taking server has base before has been taken as server's metadata
err = printDiff(string(newYaml), string(oldYaml), to, from, o.Output, o.DiffType, o.DisableColor)
if err != nil {
return err
}
return nil
}
type metadataModeJSONHandler struct{}
func (m *metadataModeJSONHandler) Export(o *MetadataExportOptions) error {
return export(o, o.EC.MetadataMode)
}
func (m *metadataModeJSONHandler) Apply(o *MetadataApplyOptions) error {
return apply(o, o.EC.MetadataMode)
}
func (m *metadataModeJSONHandler) Diff(o *MetadataDiffOptions) error {
return diff(o, o.EC.MetadataMode)
}
type metadataModeYAMLHandler struct{}
func (m *metadataModeYAMLHandler) Export(o *MetadataExportOptions) error {
return export(o, o.EC.MetadataMode)
}
func (m *metadataModeYAMLHandler) Apply(o *MetadataApplyOptions) error {
return apply(o, o.EC.MetadataMode)
}
func (m *metadataModeYAMLHandler) Diff(o *MetadataDiffOptions) error {
return diff(o, o.EC.MetadataMode)
}
func export(o *MetadataExportOptions, mode cli.MetadataMode) error {
metadata, err := ec.APIClient.V1Metadata.ExportMetadata()
if err != nil {
return fmt.Errorf("exporting metadata from server: %w", err)
}
var metadataBytes []byte
metadataBytes, err = ioutil.ReadAll(metadata)
if err != nil {
return fmt.Errorf("reading metadata from response: %w", err)
}
if mode == cli.MetadataModeYAML {
metadataBytes, err = goyaml.JSONToYAML(metadataBytes)
if err != nil {
return fmt.Errorf("parsing metadata to yaml: %w", err)
}
}
err = ioutil.WriteFile(o.EC.MetadataFile, metadataBytes, os.ModePerm)
if err != nil {
return fmt.Errorf("writing metadata to file: %w", err)
}
return nil
}
func apply(o *MetadataApplyOptions, mode cli.MetadataMode) error {
var localMetadataBytes []byte
var err error
localMetadataBytes, err = ioutil.ReadFile(o.EC.MetadataFile)
if err != nil {
return fmt.Errorf("reading metadata file: %w", err)
}
if o.DryRun {
if len(o.rawOutput) == 0 {
o.rawOutput = string(rawOutputFormatJSON)
}
if err := writeByOutputFormat(o.EC.Stdout, localMetadataBytes, rawOutputFormat(o.rawOutput)); err != nil {
return fmt.Errorf("displaying metadata failed: %w", err)
}
return nil
}
if mode == cli.MetadataModeYAML {
localMetadataBytes, err = goyaml.YAMLToJSON(localMetadataBytes)
if err != nil {
return fmt.Errorf("parsing yaml metadata to json: %w", err)
}
}
var metadata interface{}
err = json.Unmarshal(localMetadataBytes, &metadata)
if err != nil {
return fmt.Errorf("parsing metadata as json: %w", err)
}
if o.EC.Config.Version == cli.V2 {
_, err := cli.GetCommonMetadataOps(o.EC).ReplaceMetadata(bytes.NewReader(localMetadataBytes))
if err != nil {
return err
}
return nil
}
r, err := o.EC.APIClient.V1Metadata.V2ReplaceMetadata(hasura.V2ReplaceMetadataArgs{
AllowInconsistentMetadata: true,
Metadata: metadata,
})
if err != nil {
return errorApplyingMetadata(err)
}
if !r.IsConsistent {
o.EC.Logger.Warn("Metadata is inconsistent")
o.EC.Logger.Warn("Use 'hasura metadata ic list' command to list inconsistent objects")
}
if len(o.rawOutput) != 0 {
// if not a dry run fetch metadata from and server and print it to stdout
return getMetadataFromServerAndWriteToStdoutByFormat(o.EC, rawOutputFormat(o.rawOutput))
}
return nil
}
func diff(o *MetadataDiffOptions, mode cli.MetadataMode) error {
if len(o.Args) > 0 {
return fmt.Errorf("expected 0 arguments, found: %v", o.Args)
}
serverMetadata, err := cli.GetCommonMetadataOps(o.EC).ExportMetadata()
if err != nil {
return fmt.Errorf("exporting metadata from server: %w", err)
}
var serverMetadataBytes []byte
serverMetadataBytes, err = ioutil.ReadAll(serverMetadata)
if err != nil {
return fmt.Errorf("reading server metadata: %w", err)
}
if mode == cli.MetadataModeYAML {
serverMetadataBytes, err = goyaml.JSONToYAML(serverMetadataBytes)
if err != nil {
return fmt.Errorf("parsing server metadata as yaml: %w", err)
}
}
localMetadataBytes, err := ioutil.ReadFile(o.EC.MetadataFile)
if err != nil {
return fmt.Errorf("reading local metadata: %w", err)
}
return printDiff(string(serverMetadataBytes), string(localMetadataBytes), "server", "project", o.Output, o.DiffType, !o.EC.IsTerminal)
}