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

scheduler/appengine/task/buildbucket/buildbucket.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 buildbucket implements tasks that run Buildbucket jobs.
 package buildbucket
 
 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/buildbucket/buildbucket/v1"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/retry/transient"
@@ skipping 22 matching lines @@
         return (*messages.BuildbucketTask)(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.BuildbucketTask)
         if !ok {
                 return fmt.Errorf("wrong type %T, expecting *messages.BuildbucketTask", msg)
         }
         if cfg == nil {
                 return fmt.Errorf("expecting a non-empty BuildbucketTask")
         }
 
         // 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 68 matching lines @@
         for _, kv := range utils.UnpackKVList(cfg.Properties, ':') {
                 params.Properties[kv.Key] = kv.Value
         }
         paramsJSON, err := json.Marshal(&params)
         if err != nil {
                 return fmt.Errorf("failed to marshal parameters JSON - %s", err)
         }
 
         // Make sure Buildbucket 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 := buildbucket.ApiPutRequestMessage{
                 Bucket:            cfg.Bucket,
                 ClientOperationId: fmt.Sprintf("%d", ctl.InvocationNonce()),
@@ skipping 98 matching lines @@
 func (m TaskManager) createBuildbucketService(c context.Context, ctl task.Controller) (*buildbucket.Service, error) {
         client, err := ctl.GetClient(c, time.Minute)
         if err != nil {
                 return nil, err
         }
         service, err := buildbucket.New(client)
         if err != nil {
                 return nil, err
         }
         cfg := ctl.Task().(*messages.BuildbucketTask)
-        service.BasePath = cfg.Server + "/_ah/api/buildbucket/v1/"
+        service.BasePath = normalizeServerURL(cfg.Server) + "/_ah/api/buildbucket/v1/"
         return service, nil
 }
 
 // checkBuildStatusLater schedules a delayed call to checkBuildStatus 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) checkBuildStatusLater(c context.Context, ctl task.Controller) {
         // TODO(vadimsh): Make the check interval configurable?
@@ skipping 72 matching lines @@
                 r.Id, r.Status, r.Result, r.FailureReason, r.CancelationReason)
         switch {
         case r.Status == "SCHEDULED" || r.Status == "STARTED":
                 return // do nothing
         case r.Status == "COMPLETED" && r.Result == "SUCCESS":
                 ctl.State().Status = task.StatusSucceeded
         default:
                 ctl.State().Status = task.StatusFailed
         }
 }