luci_depkoy: Add instance class, params.

deploytool/cmd/luci_deploy/deploy_appengine.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
         "fmt"
         "path/filepath"
         "sort"
+        "strconv"
         "strings"
 
         "github.com/luci/luci-go/common/errors"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/deploytool/api/deploy"
         "github.com/luci/luci-go/deploytool/managedfs"
 )
 
+// gaeDefaultModule is the name of the default GAE module.
+var gaeDefaultModule = "default"
+
 // gaeDeployment is a consolidated AppEngine deployment configuration. It
 // includes staged configurations for specifically-deployed components, as well
 // as global AppEngine state (e.g., index, queue, etc.).
 type gaeDeployment struct {
         // project is the cloud project that this deployment is targeting.
         project *layoutDeploymentCloudProject
 
         // modules is the set of staged AppEngine modules that are being deployed. The
         // map is keyed on the module names.
         modules map[string]*stagedGAEModule
@@ skipping 14 matching lines @@
         return &gaeDeployment{
                 project: project,
                 modules: make(map[string]*stagedGAEModule),
         }
 }
 
 func (d *gaeDeployment) addModule(module *layoutDeploymentGAEModule) {
         d.modules[module.ModuleName] = &stagedGAEModule{
                 layoutDeploymentGAEModule: module,
                 gaeDep: d,
+
+                // Default no-op action stubs.
+                localBuildFn: func(*work) error { return nil },
+                pushFn:       func(*work) error { return nil },
         }
         d.moduleNames = append(d.moduleNames, module.ModuleName)
 }
 
 func (d *gaeDeployment) clearModules() {
         d.modules, d.moduleNames = nil, nil
 }
 
 func (d *gaeDeployment) stage(w *work, root *managedfs.Dir, params *deployParams) error {
         sort.Strings(d.moduleNames)
@@ skipping 42 matching lines @@
                         continue
                 }
 
                 if d.versionModuleMap == nil {
                         d.versionModuleMap = make(map[string][]string)
                 }
 
                 version := module.version.String()
                 moduleName := module.ModuleName
                 if moduleName == "" {
-                        moduleName = "default"
+                        moduleName = gaeDefaultModule
                 }
                 d.versionModuleMap[version] = append(d.versionModuleMap[version], moduleName)
         }
         return nil
 }
 
 func (d *gaeDeployment) localBuild(w *work) error {
         // During the build phase, we simply assert that builds work as a sanity
         // check. This prevents us from having to engage remote deployment services
         // only to find that some fundamental build problem has occurred.
         return w.RunMulti(func(workC chan<- func() error) {
                 for _, name := range d.moduleNames {
                         module := d.modules[name]
                         workC <- func() error {
                                 // Run the module's build function.
-                                if module.localBuildFn == nil {
-                                        return nil
-                                }
                                 return module.localBuildFn(w)
                         }
                 }
         })
 }
 
 func (d *gaeDeployment) push(w *work) error {
-        // Run push  operations on modules in parallel.
+        // Always push the default module first and independently, since this is a
+        // GAE requirement for initial deployments.
+        if module := d.modules[gaeDefaultModule]; module != nil {
+                if err := module.pushFn(w); err != nil {
+                        return errors.Annotate(err).Reason("failed to push default module").Err()
+                }
+        }
+
+        // Push the remaining GAE modules in parallel.
         return w.RunMulti(func(workC chan<- func() error) {
                 for _, name := range d.moduleNames {
+                        if name == gaeDefaultModule {
+                                // (Pushed above)
+                                continue
+                        }
+
                         module := d.modules[name]
-                        if module.pushFn != nil {
-                                workC <- func() error {
-                                        return module.pushFn(w)
-                                }
+                        workC <- func() error {
+                                return module.pushFn(w)
                         }
                 }
         })
 }
 
 func (d *gaeDeployment) commit(w *work) error {
         appcfg, err := w.tools.appcfg()
         if err != nil {
                 return errors.Annotate(err).Err()
         }
@@ skipping 115 matching lines @@
         base := root
 
         // appYAMLPath is used in the immediate "switch" statement as a
         // parameter to some inline functions. It will be populated later in this
         // staging function, well before those inline functions are evaluated.
         //
         // It is a pointer so that if, somehow, this does not end up being the case,
         // we will panic instead of silently using an empty string.
         var appYAMLPath *string
 
+        // Our "__deploy" directory will be where deploy-specific artifacts are
+        // blended with the current app. The name is chosen to (probably) not
+        // interfere with app files.
+        deployDir, err := root.EnsureDirectory("__deploy")
+        if err != nil {
+                return errors.Annotate(err).Reason("failed to create deploy directory").Err()
+        }
+
         // Build each Component. We will delete any existing contents and leave it
         // unmanaged to allow our build system to put whatever files it wants in
         // there.
-        buildDir, err := root.EnsureDirectory("build")
+        buildDir, err := deployDir.EnsureDirectory("build")
         if err != nil {
                 return errors.Annotate(err).Reason("failed to create build directory").Err()
         }
         if err := buildDir.CleanUp(); err != nil {
                 return errors.Annotate(err).Reason("failed to cleanup build directory").Err()
         }
         buildDir.Ignore()
 
         // Build our Component into this directory.
         if err := buildComponent(w, m.comp, buildDir); err != nil {
@@ skipping 22 matching lines @@
                 mainPkg := fmt.Sprintf("%s/main", m.comp.comp.title)
                 mainPkgParts := strings.Split(mainPkg, "/")
                 mainPkgDir, err := goSrcDir.EnsureDirectory(mainPkgParts[0], mainPkgParts[1:]...)
                 if err != nil {
                         return errors.Annotate(err).Reason("failed to create directory for main package %(pkg)q").
                                 D("pkg", mainPkg).Err()
                 }
                 m.goPath = []string{root.String(), goPath.String()}
 
                 // Choose how to push based on whether or not this is a Managed VM.
-                if m.ManagedVm != nil {
+                if m.GetManagedVm() != nil {
                         // If this is a Managed VM, symlink files from the main package.
                         //
                         // NOTE: This has the effect of prohibiting the entry point package for
                         // GAE Managed VMs from importing "internal" directories, since this stub
                         // space is outside of the main package space.
                         pkgPath := findGoPackage(t.GoModule.EntryPackage, m.goPath)
                         if pkgPath == "" {
                                 return errors.Reason("unable to find path for %(package)q").D("package", t.GoModule.EntryPackage).Err()
                         }
 
@@ skipping 27 matching lines @@
 
         case *deploy.AppEngineModule_StaticModule_:
                 m.pushFn = func(w *work) error {
                         return m.pushClassic(w, *appYAMLPath)
                 }
         }
 
         // Build our static files map.
         //
         // For each static files directory, symlink a generated directory immediately
-        // under our source.
+        // under our deployment directory.
+        staticDir, err := deployDir.EnsureDirectory("static")
+        if err != nil {
+                return errors.Annotate(err).Reason("failed to create static directory").Err()
+        }
+
         staticMap := make(map[string]string)
         staticBuildPathMap := make(map[*deploy.BuildPath]string)
         if handlerSet := m.Handlers; handlerSet != nil {
                 for _, h := range handlerSet.Handler {
                         var bp *deploy.BuildPath
                         switch t := h.GetContent().(type) {
                         case *deploy.AppEngineModule_Handler_StaticBuildDir:
                                 bp = t.StaticBuildDir
                         case *deploy.AppEngineModule_Handler_StaticFiles_:
                                 bp = t.StaticFiles.GetBuild()
                         }
                         if bp == nil {
                                 continue
                         }
 
                         // Have we already mapped this BuildPath?
                         if _, ok := staticBuildPathMap[bp]; ok {
                                 continue
                         }
 
                         // Get the actual path for this BuildPath entry.
                         dirPath, err := m.comp.buildPath(bp)
                         if err != nil {
                                 return errors.Annotate(err).Reason("cannot resolve static directory").Err()
                         }
 
                         // Do we already have a static map entry for this filesystem source path?
                         staticName, ok := staticMap[dirPath]
                         if !ok {
-                                sd := base.File(fmt.Sprintf("_static_%d", len(staticMap)))
+                                sd := staticDir.File(strconv.Itoa(len(staticMap)))
                                 if err := sd.SymlinkFrom(dirPath, true); err != nil {
                                         return errors.Annotate(err).Reason("failed to symlink static content for [%(path)s]").
                                                 D("path", dirPath).Err()
                                 }
-                                staticName = sd.Name()
+                                if staticName, err = root.RelPathFrom(sd.String()); err != nil {
+                                        return errors.Annotate(err).Reason("failed to get relative path").Err()
+                                }
                                 staticMap[dirPath] = staticName
                         }
                         staticBuildPathMap[bp] = staticName
                 }
         }
 
         // "app.yaml" / "module.yaml"
         appYAML, err := gaeBuildAppYAML(m.AppEngineModule, staticBuildPathMap)
         if err != nil {
                 return errors.Annotate(err).Reason("failed to generate module YAML").Err()
@@ skipping 51 matching lines @@
                 "--verbose",
                 "update", appYAML,
         ).cwd(appPath)
         x = addGoEnv(m.goPath, x)
         if err := x.check(w); err != nil {
                 return errors.Annotate(err).Reason("failed to deploy classic GAE module").Err()
         }
         return nil
 }
 
-// localBuildGo performs a local build against a Go binary.
+// localBuildGo performs verification of a Go binary.
 func (m *stagedGAEModule) localBuildGo(w *work, mainPkg string) error {
         gt, err := w.goTool(m.goPath)
         if err != nil {
                 return errors.Annotate(err).Reason("failed to get Go tool").Err()
         }
         if err := gt.build(w, "", mainPkg); err != nil {
-                return errors.Annotate(err).Reason("failed to build %(pkg)q").D("pkg", mainPkg).Err()
+                return errors.Annotate(err).Reason("failed to local build %(pkg)q").D("pkg", mainPkg).Err()
         }
         return nil
 }
 
 // pushGoMVM pushes a Go Managed VM version to the AppEngine instance.
 func (m *stagedGAEModule) pushGoMVM(w *work, appYAMLPath string) error {
         appDir, appYAML := filepath.Split(appYAMLPath)
 
         // Deploy Managed VM.
         aedeploy, err := w.tools.aedeploy(m.goPath)
@@ skipping 24 matching lines @@
         case log.Debug:
                 gcloudArgs = append(gcloudArgs, []string{"--verbosity", "debug"}...)
         }
 
         x := aedeploy.bootstrap(gcloud.exec(gcloudArgs[0], gcloudArgs[1:]...)).outputAt(logLevel).cwd(appDir)
         if err := x.check(w); err != nil {
                 return errors.Annotate(err).Reason("failed to deploy managed VM").Err()
         }
         return nil
 }