First round of i18n in acs-engine based on gettext. Subsequent change…

.gitignore

@@ -15,3 +15,4 @@ test/acs-engine-test/acs-engine-test.exe
 pkg/operations/junit.xml
 pkg/operations/kubernetesupgrade/junit.xml
 pkg/acsengine/templates.go
+pkg/i18n/translations.go

Dockerfile

@@ -2,7 +2,7 @@ FROM buildpack-deps:xenial
 
 RUN apt-get update \
     && apt-get -y upgrade \
-    && apt-get -y install python-pip make build-essential curl openssl vim jq \
+    && apt-get -y install python-pip make build-essential curl openssl vim jq gettext \
     && rm -rf /var/lib/apt/lists/*
 
 ENV GO_VERSION 1.8
@@ -34,6 +34,10 @@ RUN git clone https://github.com/akesterson/cmdarg.git /tmp/cmdarg \
 RUN git clone https://github.com/akesterson/shunit.git /tmp/shunit \
     && cd /tmp/shunit && make install && rm -rf /tmp/shunit
 
+# Go tool for internationalization and localization
+RUN go get github.com/JiangtianLi/gettext/... \
+    && go install github.com/JiangtianLi/gettext/...
+
 # Used by some CI jobs
 ADD ./test/bootstrap/checkout-pr.sh /tmp/checkout-pr.sh
 

cmd/deploy.go

@@ -9,13 +9,15 @@ import (
 	"time"
 
 	log "github.com/Sirupsen/logrus"
+	"github.com/leonelquinteros/gotext"
 	"github.com/spf13/cobra"
 
 	"encoding/json"
 
 	"github.com/Azure/acs-engine/pkg/acsengine"
 	"github.com/Azure/acs-engine/pkg/api"
 	"github.com/Azure/acs-engine/pkg/armhelpers"
+	"github.com/Azure/acs-engine/pkg/i18n"
 )
 
 const (
@@ -40,6 +42,7 @@ type deployCmd struct {
 	// derived
 	containerService *api.ContainerService
 	apiVersion       string
+	locale           *gotext.Locale
 
 	client        armhelpers.ACSEngineClient
 	resourceGroup string
@@ -78,6 +81,11 @@ func newDeployCmd() *cobra.Command {
 func (dc *deployCmd) validate(cmd *cobra.Command, args []string) {
 	var err error
 
+	dc.locale, err = i18n.LoadTranslations()
+	if err != nil {
+		log.Fatalf("error loading translation files: %s", err.Error())
+	}
+
 	if dc.apimodelPath == "" {
 		if len(args) > 0 {
 			dc.apimodelPath = args[0]
@@ -94,8 +102,13 @@ func (dc *deployCmd) validate(cmd *cobra.Command, args []string) {
 		log.Fatalf("specified api model does not exist (%s)", dc.apimodelPath)
 	}
 
+	apiloader := &api.Apiloader{
+		Translator: &i18n.Translator{
+			Locale: dc.locale,
+		},
+	}
 	// skip validating the model fields for now
-	dc.containerService, dc.apiVersion, err = api.LoadContainerServiceFromFile(dc.apimodelPath, false)
+	dc.containerService, dc.apiVersion, err = apiloader.LoadContainerServiceFromFile(dc.apimodelPath, false)
 	if err != nil {
 		log.Fatalf("error parsing the api model: %s", err.Error())
 	}
@@ -112,7 +125,7 @@ func (dc *deployCmd) validate(cmd *cobra.Command, args []string) {
 	// autofillApimodel calls log.Fatal() directly and does not return errors
 	autofillApimodel(dc)
 
-	_, _, err = revalidateApimodel(dc.containerService, dc.apiVersion)
+	_, _, err = revalidateApimodel(apiloader, dc.containerService, dc.apiVersion)
 	if err != nil {
 		log.Fatalf("Failed to validate the apimodel after populating values: %s", err)
 	}
@@ -162,7 +175,12 @@ func autofillApimodel(dc *deployCmd) {
 	if dc.containerService.Properties.LinuxProfile.SSH.PublicKeys == nil ||
 		len(dc.containerService.Properties.LinuxProfile.SSH.PublicKeys) == 0 ||
 		dc.containerService.Properties.LinuxProfile.SSH.PublicKeys[0].KeyData == "" {
-		_, publicKey, err := acsengine.CreateSaveSSH(dc.containerService.Properties.LinuxProfile.AdminUsername, dc.outputDirectory)
+		creator := &acsengine.SSHCreator{
+			Translator: &i18n.Translator{
+				Locale: dc.locale,
+			},
+		}
+		_, publicKey, err := creator.CreateSaveSSH(dc.containerService.Properties.LinuxProfile.AdminUsername, dc.outputDirectory)
 		if err != nil {
 			log.Fatal("Failed to generate SSH Key")
 		}
@@ -211,17 +229,23 @@ func autofillApimodel(dc *deployCmd) {
 	}
 }
 
-func revalidateApimodel(containerService *api.ContainerService, apiVersion string) (*api.ContainerService, string, error) {
+func revalidateApimodel(apiloader *api.Apiloader, containerService *api.ContainerService, apiVersion string) (*api.ContainerService, string, error) {
 	// This isn't terribly elegant, but it's the easiest way to go for now w/o duplicating a bunch of code
-	rawVersionedAPIModel, err := api.SerializeContainerService(containerService, apiVersion)
+	rawVersionedAPIModel, err := apiloader.SerializeContainerService(containerService, apiVersion)
 	if err != nil {
 		return nil, "", err
 	}
-	return api.DeserializeContainerService(rawVersionedAPIModel, true)
+	return apiloader.DeserializeContainerService(rawVersionedAPIModel, true)
 }
 
 func (dc *deployCmd) run() error {
-	templateGenerator, err := acsengine.InitializeTemplateGenerator(dc.classicMode)
+	ctx := acsengine.Context{
+		Translator: &i18n.Translator{
+			Locale: dc.locale,
+		},
+	}
+
+	templateGenerator, err := acsengine.InitializeTemplateGenerator(ctx, dc.classicMode)
 	if err != nil {
 		log.Fatalln("failed to initialize template generator: %s", err.Error())
 	}
@@ -240,7 +264,12 @@ func (dc *deployCmd) run() error {
 		log.Fatalf("error pretty printing template parameters: %s \n", err.Error())
 	}
 
-	if err = acsengine.WriteTLSArtifacts(dc.containerService, dc.apiVersion, template, parametersFile, dc.outputDirectory, certsgenerated, dc.parametersOnly); err != nil {
+	writer := &acsengine.ArtifactWriter{
+		Translator: &i18n.Translator{
+			Locale: dc.locale,
+		},
+	}
+	if err = writer.WriteTLSArtifacts(dc.containerService, dc.apiVersion, template, parametersFile, dc.outputDirectory, certsgenerated, dc.parametersOnly); err != nil {
 		log.Fatalf("error writing artifacts: %s \n", err.Error())
 	}
 

cmd/deploy_test.go

@@ -47,8 +47,12 @@ func TestAutofillApimodelAllowsPrespecifiedCreds(t *testing.T) {
 }
 
 func testAutodeployCredentialHandling(t *testing.T, useManagedIdentity bool, clientID, clientSecret string) {
+	apiloader := &api.Apiloader{
+		Translator: nil,
+	}
+
 	apimodel := getExampleAPIModel(useManagedIdentity, clientID, clientSecret)
-	cs, ver, err := api.DeserializeContainerService([]byte(apimodel), false)
+	cs, ver, err := apiloader.DeserializeContainerService([]byte(apimodel), false)
 	if err != nil {
 		t.Fatalf("unexpected error deserializing the example apimodel: %s", err)
 	}
@@ -73,7 +77,7 @@ func testAutodeployCredentialHandling(t *testing.T, useManagedIdentity bool, cli
 	// cleanup, since auto-populations creates dirs and saves the SSH private key that it might create
 	defer os.RemoveAll(deployCmd.outputDirectory)
 
-	cs, _, err = revalidateApimodel(cs, ver)
+	cs, _, err = revalidateApimodel(apiloader, cs, ver)
 	if err != nil {
 		log.Fatalf("unexpected error validating apimodel after populating defaults: %s", err)
 	}

cmd/generate.go

@@ -7,7 +7,9 @@ import (
 
 	"github.com/Azure/acs-engine/pkg/acsengine"
 	"github.com/Azure/acs-engine/pkg/api"
+	"github.com/Azure/acs-engine/pkg/i18n"
 	log "github.com/Sirupsen/logrus"
+	"github.com/leonelquinteros/gotext"
 	"github.com/spf13/cobra"
 )
 
@@ -29,6 +31,7 @@ type generateCmd struct {
 	// derived
 	containerService *api.ContainerService
 	apiVersion       string
+	locale           *gotext.Locale
 }
 
 func newGenerateCmd() *cobra.Command {
@@ -61,6 +64,11 @@ func (gc *generateCmd) validate(cmd *cobra.Command, args []string) {
 	var caKeyBytes []byte
 	var err error
 
+	gc.locale, err = i18n.LoadTranslations()
+	if err != nil {
+		log.Fatalf("error loading translation files: %s", err.Error())
+	}
+
 	if gc.apimodelPath == "" {
 		if len(args) > 0 {
 			gc.apimodelPath = args[0]
@@ -77,7 +85,12 @@ func (gc *generateCmd) validate(cmd *cobra.Command, args []string) {
 		log.Fatalf("specified api model does not exist (%s)", gc.apimodelPath)
 	}
 
-	gc.containerService, gc.apiVersion, err = api.LoadContainerServiceFromFile(gc.apimodelPath, true)
+	apiloader := &api.Apiloader{
+		Translator: &i18n.Translator{
+			Locale: gc.locale,
+		},
+	}
+	gc.containerService, gc.apiVersion, err = apiloader.LoadContainerServiceFromFile(gc.apimodelPath, true)
 	if err != nil {
 		log.Fatalf("error parsing the api model: %s", err.Error())
 	}
@@ -111,7 +124,12 @@ func (gc *generateCmd) validate(cmd *cobra.Command, args []string) {
 func (gc *generateCmd) run() error {
 	log.Infoln("Generating assets...")
 
-	templateGenerator, err := acsengine.InitializeTemplateGenerator(gc.classicMode)
+	ctx := acsengine.Context{
+		Translator: &i18n.Translator{
+			Locale: gc.locale,
+		},
+	}
+	templateGenerator, err := acsengine.InitializeTemplateGenerator(ctx, gc.classicMode)
 	if err != nil {
 		log.Fatalln("failed to initialize template generator: %s", err.Error())
 	}
@@ -131,7 +149,12 @@ func (gc *generateCmd) run() error {
 		}
 	}
 
-	if err = acsengine.WriteTLSArtifacts(gc.containerService, gc.apiVersion, template, parameters, gc.outputDirectory, certsGenerated, gc.parametersOnly); err != nil {
+	writer := &acsengine.ArtifactWriter{
+		Translator: &i18n.Translator{
+			Locale: gc.locale,
+		},
+	}
+	if err = writer.WriteTLSArtifacts(gc.containerService, gc.apiVersion, template, parameters, gc.outputDirectory, certsGenerated, gc.parametersOnly); err != nil {
 		log.Fatalf("error writing artifacts: %s \n", err.Error())
 	}
 

cmd/upgrade.go

@@ -9,7 +9,9 @@ import (
 
 	"github.com/Azure/acs-engine/pkg/api"
 	"github.com/Azure/acs-engine/pkg/armhelpers"
+	"github.com/Azure/acs-engine/pkg/i18n"
 	"github.com/Azure/acs-engine/pkg/operations/kubernetesupgrade"
+	"github.com/leonelquinteros/gotext"
 
 	log "github.com/Sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -35,6 +37,7 @@ type upgradeCmd struct {
 	upgradeContainerService *api.UpgradeContainerService
 	upgradeAPIVersion       string
 	client                  armhelpers.ACSEngineClient
+	locale                  *gotext.Locale
 	nameSuffix              string
 }
 
@@ -65,6 +68,11 @@ func (uc *upgradeCmd) validate(cmd *cobra.Command, args []string) {
 
 	var err error
 
+	uc.locale, err = i18n.LoadTranslations()
+	if err != nil {
+		log.Fatalf("error loading translation files: %s", err.Error())
+	}
+
 	if uc.resourceGroupName == "" {
 		cmd.Usage()
 		log.Fatal("--resource-group must be specified")
@@ -92,7 +100,12 @@ func (uc *upgradeCmd) validate(cmd *cobra.Command, args []string) {
 		log.Fatalf("specified api model does not exist (%s)", apiModelPath)
 	}
 
-	uc.containerService, uc.apiVersion, err = api.LoadContainerServiceFromFile(apiModelPath, true)
+	apiloader := &api.Apiloader{
+		Translator: &i18n.Translator{
+			Locale: uc.locale,
+		},
+	}
+	uc.containerService, uc.apiVersion, err = apiloader.LoadContainerServiceFromFile(apiModelPath, true)
 	if err != nil {
 		log.Fatalf("error parsing the api model: %s", err.Error())
 	}
@@ -101,7 +114,12 @@ func (uc *upgradeCmd) validate(cmd *cobra.Command, args []string) {
 		log.Fatalf("specified upgrade model file does not exist (%s)", uc.upgradeModelFile)
 	}
 
-	uc.upgradeContainerService, uc.upgradeAPIVersion, err = api.LoadUpgradeContainerServiceFromFile(uc.upgradeModelFile)
+	upgradeapiloader := &api.UpgradeApiloader{
+		Translator: &i18n.Translator{
+			Locale: uc.locale,
+		},
+	}
+	uc.upgradeContainerService, uc.upgradeAPIVersion, err = upgradeapiloader.LoadUpgradeContainerServiceFromFile(uc.upgradeModelFile)
 	if err != nil {
 		log.Fatalf("error parsing the upgrade api model: %s", err.Error())
 	}
@@ -134,6 +152,9 @@ func (uc *upgradeCmd) run(cmd *cobra.Command, args []string) error {
 	uc.validate(cmd, args)
 
 	upgradeCluster := kubernetesupgrade.UpgradeCluster{
+		Translator: &i18n.Translator{
+			Locale: uc.locale,
+		},
 		Client: uc.client,
 	}
 

glide.yaml

@@ -32,6 +32,8 @@ import:
 - package: github.com/spf13/cobra
   version: 4cdb38c072b86bf795d2c81de50784d9fdd6eb77
 - package: github.com/spf13/pflag
+- package: github.com/leonelquinteros/gotext
+  version: v1.1.1
   version: e57e3eeb33f795204c1ca35f56c44f83227c6e66
 - package: gopkg.in/go-playground/validator.v9
   version: v9.4.0