scheduler: Make 'https://' optional in 'server' config field.

scheduler/appengine/task/swarming/swarming.go

 // Copyright 2015 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 // Package swarming implements tasks that run Swarming jobs.
 package swarming
 
 import (
         "encoding/json"
         "fmt"
         "net/url"
+        "strings"
         "time"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
         "google.golang.org/api/pubsub/v1"
 
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/retry/transient"
@@ skipping 22 matching lines @@
         return (*messages.SwarmingTask)(nil)
 }
 
 // Traits is part of Manager interface.
 func (m TaskManager) Traits() task.Traits {
         return task.Traits{
                 Multistage: true, // we use task.StatusRunning state
         }
 }
 
+func normalizeServerURL(s string) string {
+        if strings.HasPrefix(s, "https://") || strings.HasPrefix(s, "http://") {
+                return s
+        }
+        return "https://" + s
+}
+
 // ValidateProtoMessage is part of Manager interface.
 func (m TaskManager) ValidateProtoMessage(msg proto.Message) error {
         cfg, ok := msg.(*messages.SwarmingTask)
         if !ok {
                 return fmt.Errorf("wrong type %T, expecting *messages.SwarmingTask", msg)
         }
         if cfg == nil {
                 return fmt.Errorf("expecting a non-empty SwarmingTask")
         }
 
         // Validate 'server' field.
         if cfg.Server == "" {
                 return fmt.Errorf("field 'server' is required")
         }
-        u, err := url.Parse(cfg.Server)
+        u, err := url.Parse(normalizeServerURL(cfg.Server))
         if err != nil {
                 return fmt.Errorf("invalid URL %q: %s", cfg.Server, err)
         }
         if !u.IsAbs() {
                 return fmt.Errorf("not an absolute url: %q", cfg.Server)
         }
         if u.Path != "" {
                 return fmt.Errorf("not a host root url: %q", cfg.Server)
         }
 
@@ skipping 111 matching lines @@
         }
 
         // The task priority (or niceness, lower is more aggressive).
         priority := cfg.Priority
         if priority == 0 {
                 priority = 200
         }
 
         // Make sure Swarming can publish PubSub messages, grab token that would
         // identify this invocation when receiving PubSub notifications.
-        ctl.DebugLog("Preparing PubSub topic for %q", cfg.Server)
-        topic, authToken, err := ctl.PrepareTopic(c, cfg.Server)
+        serverURL := normalizeServerURL(cfg.Server)
+        ctl.DebugLog("Preparing PubSub topic for %q", serverURL)
+        topic, authToken, err := ctl.PrepareTopic(c, serverURL)
         if err != nil {
                 ctl.DebugLog("Failed to prepare PubSub topic - %s", err)
                 return err
         }
         ctl.DebugLog("PubSub topic is %q", topic)
 
         // Prepare the request.
         request := swarming.SwarmingRpcsNewTaskRequest{
                 Name:            fmt.Sprintf("scheduler:%s/%d", ctl.JobID(), ctl.InvocationID()),
                 ExpirationSecs:  expirationSecs,
@@ skipping 57 matching lines @@
         // notifications
         ctl.State().TaskData, err = json.Marshal(&taskData{
                 SwarmingTaskID: resp.TaskId,
         })
         if err != nil {
                 return err
         }
 
         // Successfully launched.
         ctl.State().Status = task.StatusRunning
-        ctl.State().ViewURL = fmt.Sprintf("%s/user/task/%s", cfg.Server, resp.TaskId)
+        ctl.State().ViewURL = fmt.Sprintf("%s/user/task/%s", serverURL, resp.TaskId)
         ctl.DebugLog("Task URL: %s", ctl.State().ViewURL)
 
         // Maybe the task was already finished? Can only happen when 'idempotent' is
         // set to true (which we don't do currently), but handle this case here for
         // completeness anyway.
         if resp.TaskResult != nil {
                 ctl.DebugLog("Task request was deduplicated")
                 m.handleTaskResult(c, ctl, resp.TaskResult)
         }
 
@@ skipping 33 matching lines @@
 func (m TaskManager) createSwarmingService(c context.Context, ctl task.Controller) (*swarming.Service, error) {
         client, err := ctl.GetClient(c, time.Minute)
         if err != nil {
                 return nil, err
         }
         service, err := swarming.New(client)
         if err != nil {
                 return nil, err
         }
         cfg := ctl.Task().(*messages.SwarmingTask)
-        service.BasePath = cfg.Server + "/_ah/api/swarming/v1/"
+        service.BasePath = normalizeServerURL(cfg.Server) + "/_ah/api/swarming/v1/"
         return service, nil
 }
 
 // checkTaskStatusLater schedules a delayed call to checkTaskStatus if the
 // invocation is still running.
 //
 // This is a fallback mechanism in case PubSub notifications are delayed or
 // lost for some reason.
 func (m TaskManager) checkTaskStatusLater(c context.Context, ctl task.Controller) {
         // TODO(vadimsh): Make the check interval configurable?
@@ skipping 62 matching lines @@
                 r.State, r.Failure, r.InternalFailure)
         switch {
         case r.State == "PENDING" || r.State == "RUNNING":
                 return // do nothing
         case r.State == "COMPLETED" && !(r.Failure || r.InternalFailure):
                 ctl.State().Status = task.StatusSucceeded
         default:
                 ctl.State().Status = task.StatusFailed
         }
 }