github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Switch to glog for logging, bridge logging to glog. 

1) imported glog to third_party (previous commit)
2) add support for third_party/update.sh to update just one pkg
3) search-and-replace:
  s/log.Printf/glog.Infof/
  s/log.Print/glog.Info/
  s/log.Fatalf/glog.Fatalf/
  s/log.Fatal/glog.Fatal/
4) convert glog.Info.*, err into glog.Error*

Adds some util interfaces to logging and calls them from each cmd, which
will set the default log output to write to glog.  Pass glog-wrapped
Loggers to etcd for logging.

Log files will go to /tmp - we should probably follow this up with a
default log dir for each cmd.

The glog lib is sort of weak in that it only flushes every 30 seconds, so
we spin up our own flushing goroutine.
pull/6/head
Tim Hockin 2014-06-24 20:51:57 -07:00
parent 381ac4328c
commit 9f9e75f508
26 changed files with 251 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
cmd/apiserver/apiserver.go
View File

@ -20,13 +20,13 @@ package main
import ( import (
"flag" "flag"
"log"
"net" "net"
"strconv" "strconv"
"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider" "github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
"github.com/GoogleCloudPlatform/kubernetes/pkg/master" "github.com/GoogleCloudPlatform/kubernetes/pkg/master"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/golang/glog"
) )
var ( var (
@ -44,9 +44,11 @@ func init() {
func main() { func main() {
flag.Parse() flag.Parse()
util.InitLogs()
defer util.FlushLogs()
if len(machineList) == 0 { if len(machineList) == 0 {
log.Fatal("No machines specified!") glog.Fatal("No machines specified!")
} }
var cloud cloudprovider.Interface var cloud cloudprovider.Interface
@ -55,13 +57,13 @@ func main() {
var err error var err error
cloud, err = cloudprovider.NewGCECloud() cloud, err = cloudprovider.NewGCECloud()
if err != nil { if err != nil {
log.Fatal("Couldn't connect to GCE cloud: %#v", err) glog.Fatal("Couldn't connect to GCE cloud: %#v", err)
} }
default: default:
if len(*cloudProvider) > 0 { if len(*cloudProvider) > 0 {
log.Printf("Unknown cloud provider: %s", *cloudProvider) glog.Infof("Unknown cloud provider: %s", *cloudProvider)
} else { } else {
log.Print("No cloud provider specified.") glog.Info("No cloud provider specified.")
} }
} }
@ -72,5 +74,5 @@ func main() {
m = master.NewMemoryServer(machineList, cloud) m = master.NewMemoryServer(machineList, cloud)
} }
log.Fatal(m.Run(net.JoinHostPort(*address, strconv.Itoa(int(*port))), *apiPrefix)) glog.Fatal(m.Run(net.JoinHostPort(*address, strconv.Itoa(int(*port))), *apiPrefix))
} }

43
cmd/cloudcfg/cloudcfg.go
View File

@ -20,7 +20,6 @@ import (
"flag" "flag"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log"
"net/url" "net/url"
"os" "os"
"strconv" "strconv"
@ -29,6 +28,8 @@ import (
kube_client "github.com/GoogleCloudPlatform/kubernetes/pkg/client" kube_client "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudcfg" "github.com/GoogleCloudPlatform/kubernetes/pkg/cloudcfg"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/golang/glog"
) )
const APP_VERSION = "0.1" const APP_VERSION = "0.1"
@ -66,21 +67,21 @@ func usage() {
flag.PrintDefaults() flag.PrintDefaults()
} }
// Reads & parses config file. On error, calls log.Fatal(). // Reads & parses config file. On error, calls glog.Fatal().
func readConfig(storage string) []byte { func readConfig(storage string) []byte {
if len(*config) == 0 { if len(*config) == 0 {
log.Fatal("Need config file (-c)") glog.Fatal("Need config file (-c)")
} }
data, err := ioutil.ReadFile(*config) data, err := ioutil.ReadFile(*config)
if err != nil { if err != nil {
log.Fatalf("Unable to read %v: %#v\n", *config, err) glog.Fatalf("Unable to read %v: %#v\n", *config, err)
} }
data, err = cloudcfg.ToWireFormat(data, storage) data, err = cloudcfg.ToWireFormat(data, storage)
if err != nil { if err != nil {
log.Fatalf("Error parsing %v as an object for %v: %#v\n", *config, storage, err) glog.Fatalf("Error parsing %v as an object for %v: %#v\n", *config, storage, err)
} }
if *verbose { if *verbose {
log.Printf("Parsed config file successfully; sending:\n%v\n", string(data)) glog.Infof("Parsed config file successfully; sending:\n%v\n", string(data))
} }
return data return data
} }
@ -92,6 +93,8 @@ func main() {
} }
flag.Parse() // Scan the arguments list flag.Parse() // Scan the arguments list
util.InitLogs()
defer util.FlushLogs()
if *versionFlag { if *versionFlag {
fmt.Println("Version:", APP_VERSION) fmt.Println("Version:", APP_VERSION)
@ -101,7 +104,7 @@ func main() {
secure := true secure := true
parsedUrl, err := url.Parse(*httpServer) parsedUrl, err := url.Parse(*httpServer)
if err != nil { if err != nil {
log.Fatalf("Unable to parse %v as a URL\n", err) glog.Fatalf("Unable to parse %v as a URL\n", err)
} }
if parsedUrl.Scheme != "" && parsedUrl.Scheme != "https" { if parsedUrl.Scheme != "" && parsedUrl.Scheme != "https" {
secure = false secure = false
@ -111,14 +114,14 @@ func main() {
if secure { if secure {
auth, err = cloudcfg.LoadAuthInfo(*authConfig) auth, err = cloudcfg.LoadAuthInfo(*authConfig)
if err != nil { if err != nil {
log.Fatalf("Error loading auth: %#v", err) glog.Fatalf("Error loading auth: %#v", err)
} }
} }
if *proxy { if *proxy {
log.Println("Starting to serve on localhost:8001") glog.Info("Starting to serve on localhost:8001")
server := cloudcfg.NewProxyServer(*www, *httpServer, auth) server := cloudcfg.NewProxyServer(*www, *httpServer, auth)
log.Fatal(server.Serve()) glog.Fatal(server.Serve())
} }
if len(flag.Args()) < 1 { if len(flag.Args()) < 1 {
@ -129,7 +132,7 @@ func main() {
matchFound := executeAPIRequest(method, auth) || executeControllerRequest(method, auth) matchFound := executeAPIRequest(method, auth) || executeControllerRequest(method, auth)
if matchFound == false { if matchFound == false {
log.Fatalf("Unknown command %s", method) glog.Fatalf("Unknown command %s", method)
} }
} }
@ -137,7 +140,7 @@ func main() {
func executeAPIRequest(method string, auth *kube_client.AuthInfo) bool { func executeAPIRequest(method string, auth *kube_client.AuthInfo) bool {
parseStorage := func() string { parseStorage := func() string {
if len(flag.Args()) != 2 { if len(flag.Args()) != 2 {
log.Fatal("usage: cloudcfg [OPTIONS] get|list|create|update|delete <url>") glog.Fatal("usage: cloudcfg [OPTIONS] get|list|create|update|delete <url>")
} }
return strings.Trim(flag.Arg(1), "/") return strings.Trim(flag.Arg(1), "/")
} }
@ -165,7 +168,7 @@ func executeAPIRequest(method string, auth *kube_client.AuthInfo) bool {
} }
obj, err := r.Do().Get() obj, err := r.Do().Get()
if err != nil { if err != nil {
log.Fatalf("Got request error: %v\n", err) glog.Fatalf("Got request error: %v\n", err)
return false return false
} }
@ -179,7 +182,7 @@ func executeAPIRequest(method string, auth *kube_client.AuthInfo) bool {
} }
if err = printer.PrintObj(obj, os.Stdout); err != nil { if err = printer.PrintObj(obj, os.Stdout); err != nil {
log.Fatalf("Failed to print: %#v\nRaw received object:\n%#v\n", err, obj) glog.Fatalf("Failed to print: %#v\nRaw received object:\n%#v\n", err, obj)
} }
fmt.Print("\n") fmt.Print("\n")
@ -190,7 +193,7 @@ func executeAPIRequest(method string, auth *kube_client.AuthInfo) bool {
func executeControllerRequest(method string, auth *kube_client.AuthInfo) bool { func executeControllerRequest(method string, auth *kube_client.AuthInfo) bool {
parseController := func() string { parseController := func() string {
if len(flag.Args()) != 2 { if len(flag.Args()) != 2 {
log.Fatal("usage: cloudcfg [OPTIONS] stop|rm|rollingupdate <controller>") glog.Fatal("usage: cloudcfg [OPTIONS] stop|rm|rollingupdate <controller>")
} }
return flag.Arg(1) return flag.Arg(1)
} }
@ -207,31 +210,31 @@ func executeControllerRequest(method string, auth *kube_client.AuthInfo) bool {
err = cloudcfg.Update(parseController(), c, *updatePeriod) err = cloudcfg.Update(parseController(), c, *updatePeriod)
case "run": case "run":
if len(flag.Args()) != 4 { if len(flag.Args()) != 4 {
log.Fatal("usage: cloudcfg [OPTIONS] run <image> <replicas> <controller>") glog.Fatal("usage: cloudcfg [OPTIONS] run <image> <replicas> <controller>")
} }
image := flag.Arg(1) image := flag.Arg(1)
replicas, err := strconv.Atoi(flag.Arg(2)) replicas, err := strconv.Atoi(flag.Arg(2))
name := flag.Arg(3) name := flag.Arg(3)
if err != nil { if err != nil {
log.Fatalf("Error parsing replicas: %#v", err) glog.Fatalf("Error parsing replicas: %#v", err)
} }
err = cloudcfg.RunController(image, name, replicas, c, *portSpec, *servicePort) err = cloudcfg.RunController(image, name, replicas, c, *portSpec, *servicePort)
case "resize": case "resize":
args := flag.Args() args := flag.Args()
if len(args) < 3 { if len(args) < 3 {
log.Fatal("usage: cloudcfg resize <controller> <replicas>") glog.Fatal("usage: cloudcfg resize <controller> <replicas>")
} }
name := args[1] name := args[1]
replicas, err := strconv.Atoi(args[2]) replicas, err := strconv.Atoi(args[2])
if err != nil { if err != nil {
log.Fatalf("Error parsing replicas: %#v", err) glog.Fatalf("Error parsing replicas: %#v", err)
} }
err = cloudcfg.ResizeController(name, replicas, c) err = cloudcfg.ResizeController(name, replicas, c)
default: default:
return false return false
} }
if err != nil { if err != nil {
log.Fatalf("Error: %#v", err) glog.Fatalf("Error: %#v", err)
} }
return true return true
} }

10
cmd/controller-manager/controller-manager.go
View File

@ -23,13 +23,13 @@ package main
import ( import (
"flag" "flag"
"log"
"os"
"time" "time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
"github.com/GoogleCloudPlatform/kubernetes/pkg/controller" "github.com/GoogleCloudPlatform/kubernetes/pkg/controller"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/golang/glog"
) )
var ( var (
@ -39,13 +39,15 @@ var (
func main() { func main() {
flag.Parse() flag.Parse()
util.InitLogs()
defer util.FlushLogs()
if len(*etcd_servers) == 0 || len(*master) == 0 { if len(*etcd_servers) == 0 || len(*master) == 0 {
log.Fatal("usage: controller-manager -etcd_servers <servers> -master <master>") glog.Fatal("usage: controller-manager -etcd_servers <servers> -master <master>")
} }
// Set up logger for etcd client // Set up logger for etcd client
etcd.SetLogger(log.New(os.Stderr, "etcd ", log.LstdFlags)) etcd.SetLogger(util.NewLogger("etcd "))
controllerManager := controller.MakeReplicationManager( controllerManager := controller.MakeReplicationManager(
etcd.NewClient([]string{*etcd_servers}), etcd.NewClient([]string{*etcd_servers}),

24
cmd/integration/integration.go
View File

@ -21,7 +21,6 @@ package main
import ( import (
"encoding/json" "encoding/json"
"io/ioutil" "io/ioutil"
"log"
"net/http" "net/http"
"net/http/httptest" "net/http/httptest"
"time" "time"
@ -31,14 +30,19 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/controller" "github.com/GoogleCloudPlatform/kubernetes/pkg/controller"
"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet" "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet"
"github.com/GoogleCloudPlatform/kubernetes/pkg/master" "github.com/GoogleCloudPlatform/kubernetes/pkg/master"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/golang/glog"
) )
func main() { func main() {
util.InitLogs()
defer util.FlushLogs()
manifestUrl := ServeCachedManifestFile() manifestUrl := ServeCachedManifestFile()
// Setup // Setup
servers := []string{"http://localhost:4001"} servers := []string{"http://localhost:4001"}
log.Printf("Creating etcd client pointing to %v", servers) glog.Infof("Creating etcd client pointing to %v", servers)
machineList := []string{"localhost", "machine"} machineList := []string{"localhost", "machine"}
// Master // Master
@ -75,22 +79,22 @@ func main() {
go otherKubelet.RunKubelet("", "", servers[0], "localhost", 0) go otherKubelet.RunKubelet("", "", servers[0], "localhost", 0)
// Ok. we're good to go. // Ok. we're good to go.
log.Printf("API Server started on %s", apiserver.URL) glog.Infof("API Server started on %s", apiserver.URL)
// Wait for the synchronization threads to come up. // Wait for the synchronization threads to come up.
time.Sleep(time.Second * 10) time.Sleep(time.Second * 10)
kubeClient := client.New(apiserver.URL, nil) kubeClient := client.New(apiserver.URL, nil)
data, err := ioutil.ReadFile("api/examples/controller.json") data, err := ioutil.ReadFile("api/examples/controller.json")
if err != nil { if err != nil {
log.Fatalf("Unexpected error: %#v", err) glog.Fatalf("Unexpected error: %#v", err)
} }
var controllerRequest api.ReplicationController var controllerRequest api.ReplicationController
if err = json.Unmarshal(data, &controllerRequest); err != nil { if err = json.Unmarshal(data, &controllerRequest); err != nil {
log.Fatalf("Unexpected error: %#v", err) glog.Fatalf("Unexpected error: %#v", err)
} }
if _, err = kubeClient.CreateReplicationController(controllerRequest); err != nil { if _, err = kubeClient.CreateReplicationController(controllerRequest); err != nil {
log.Fatalf("Unexpected error: %#v", err) glog.Fatalf("Unexpected error: %#v", err)
} }
// Give the controllers some time to actually create the pods // Give the controllers some time to actually create the pods
time.Sleep(time.Second * 10) time.Sleep(time.Second * 10)
@ -98,7 +102,7 @@ func main() {
// Validate that they're truly up. // Validate that they're truly up.
pods, err := kubeClient.ListPods(nil) pods, err := kubeClient.ListPods(nil)
if err != nil || len(pods.Items) != 2 { if err != nil || len(pods.Items) != 2 {
log.Fatal("FAILED") glog.Fatal("FAILED")
} }
// Check that kubelet tried to make the pods. // Check that kubelet tried to make the pods.
@ -120,9 +124,9 @@ func main() {
// We expect 5: 2 net containers + 2 pods from the replication controller + // We expect 5: 2 net containers + 2 pods from the replication controller +
// 1 net container + 2 pods from the URL. // 1 net container + 2 pods from the URL.
if len(createdPods) != 7 { if len(createdPods) != 7 {
log.Fatalf("Unexpected list of created pods: %#v\n", createdPods) glog.Fatalf("Unexpected list of created pods: %#v\n", createdPods)
} }
log.Printf("OK") glog.Infof("OK")
} }
// Serve a file for kubelet to read. // Serve a file for kubelet to read.
@ -132,7 +136,7 @@ func ServeCachedManifestFile() (servingAddress string) {
w.Write([]byte(testManifestFile)) w.Write([]byte(testManifestFile))
return return
} }
log.Fatalf("Got request: %#v\n", r) glog.Fatalf("Got request: %#v\n", r)
http.NotFound(w, r) http.NotFound(w, r)
})) }))
return server.URL + "/manifest" return server.URL + "/manifest"

12
cmd/kubelet/kubelet.go
View File

@ -22,15 +22,15 @@ package main
import ( import (
"flag" "flag"
"log"
"math/rand" "math/rand"
"os"
"os/exec" "os/exec"
"time" "time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet" "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/fsouza/go-dockerclient" "github.com/fsouza/go-dockerclient"
"github.com/golang/glog"
) )
var ( var (
@ -49,15 +49,17 @@ const dockerBinary = "/usr/bin/docker"
func main() { func main() {
flag.Parse() flag.Parse()
util.InitLogs()
defer util.FlushLogs()
rand.Seed(time.Now().UTC().UnixNano()) rand.Seed(time.Now().UTC().UnixNano())
// Set up logger for etcd client // Set up logger for etcd client
etcd.SetLogger(log.New(os.Stderr, "etcd ", log.LstdFlags)) etcd.SetLogger(util.NewLogger("etcd "))
endpoint := "unix:///var/run/docker.sock" endpoint := "unix:///var/run/docker.sock"
dockerClient, err := docker.NewClient(endpoint) dockerClient, err := docker.NewClient(endpoint)
if err != nil { if err != nil {
log.Fatal("Couldn't connnect to docker.") glog.Fatal("Couldn't connnect to docker.")
} }
hostname := []byte(*hostnameOverride) hostname := []byte(*hostnameOverride)
@ -66,7 +68,7 @@ func main() {
// want the FQDN, and this is the easiest way to get it. // want the FQDN, and this is the easiest way to get it.
hostname, err = exec.Command("hostname", "-f").Output() hostname, err = exec.Command("hostname", "-f").Output()
if err != nil { if err != nil {
log.Fatalf("Couldn't determine hostname: %v", err) glog.Fatalf("Couldn't determine hostname: %v", err)
} }
} }

14
cmd/localkube/localkube.go
View File

@ -22,10 +22,8 @@ package main
import ( import (
"flag" "flag"
"fmt" "fmt"
"log"
"math/rand" "math/rand"
"net" "net"
"os"
"strconv" "strconv"
"time" "time"
@ -33,8 +31,10 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/controller" "github.com/GoogleCloudPlatform/kubernetes/pkg/controller"
"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet" "github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet"
"github.com/GoogleCloudPlatform/kubernetes/pkg/master" "github.com/GoogleCloudPlatform/kubernetes/pkg/master"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/fsouza/go-dockerclient" "github.com/fsouza/go-dockerclient"
"github.com/golang/glog"
) )
// kubelet flags // kubelet flags
@ -65,7 +65,7 @@ func fakeKubelet() {
endpoint := "unix:///var/run/docker.sock" endpoint := "unix:///var/run/docker.sock"
dockerClient, err := docker.NewClient(endpoint) dockerClient, err := docker.NewClient(endpoint)
if err != nil { if err != nil {
log.Fatal("Couldn't connnect to docker.") glog.Fatal("Couldn't connnect to docker.")
} }
myKubelet := kubelet.Kubelet{ myKubelet := kubelet.Kubelet{
@ -81,7 +81,7 @@ func fakeKubelet() {
// Starts api services (the master). Never returns. // Starts api services (the master). Never returns.
func apiServer() { func apiServer() {
m := master.New([]string{*etcdServer}, []string{*kubeletAddress}, nil) m := master.New([]string{*etcdServer}, []string{*kubeletAddress}, nil)
log.Fatal(m.Run(net.JoinHostPort(*masterAddress, strconv.Itoa(int(*masterPort))), *apiPrefix)) glog.Fatal(m.Run(net.JoinHostPort(*masterAddress, strconv.Itoa(int(*masterPort))), *apiPrefix))
} }
// Starts up a controller manager. Never returns. // Starts up a controller manager. Never returns.
@ -96,16 +96,18 @@ func controllerManager() {
func main() { func main() {
flag.Parse() flag.Parse()
util.InitLogs()
defer util.FlushLogs()
rand.Seed(time.Now().UTC().UnixNano()) rand.Seed(time.Now().UTC().UnixNano())
// Set up logger for etcd client // Set up logger for etcd client
etcd.SetLogger(log.New(os.Stderr, "etcd ", log.LstdFlags)) etcd.SetLogger(util.NewLogger("etcd "))
go apiServer() go apiServer()
go fakeKubelet() go fakeKubelet()
go controllerManager() go controllerManager()
log.Printf("All components started.\nMaster running at: http://%s:%d\nKubelet running at: http://%s:%d\n", glog.Infof("All components started.\nMaster running at: http://%s:%d\nKubelet running at: http://%s:%d\n",
*masterAddress, *masterPort, *masterAddress, *masterPort,
*kubeletAddress, *kubeletPort) *kubeletAddress, *kubeletPort)
select {} select {}

10
cmd/proxy/proxy.go
View File

@ -18,12 +18,12 @@ package main
import ( import (
"flag" "flag"
"log"
"os"
"github.com/GoogleCloudPlatform/kubernetes/pkg/proxy" "github.com/GoogleCloudPlatform/kubernetes/pkg/proxy"
"github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/config" "github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/config"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/golang/glog"
) )
var ( var (
@ -33,11 +33,13 @@ var (
func main() { func main() {
flag.Parse() flag.Parse()
util.InitLogs()
defer util.FlushLogs()
// Set up logger for etcd client // Set up logger for etcd client
etcd.SetLogger(log.New(os.Stderr, "etcd ", log.LstdFlags)) etcd.SetLogger(util.NewLogger("etcd "))
log.Printf("Using configuration file %s and etcd_servers %s", *config_file, *etcd_servers) glog.Infof("Using configuration file %s and etcd_servers %s", *config_file, *etcd_servers)
proxyConfig := config.NewServiceConfig() proxyConfig := config.NewServiceConfig()

6
pkg/apiserver/apiserver.go
View File

@ -19,7 +19,6 @@ package apiserver
import ( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log"
"net/http" "net/http"
"net/url" "net/url"
"runtime/debug" "runtime/debug"
@ -29,6 +28,7 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/golang/glog"
) )
// RESTStorage is a generic interface for RESTful storage services // RESTStorage is a generic interface for RESTful storage services
@ -84,7 +84,7 @@ func (server *ApiServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if x := recover(); x != nil { if x := recover(); x != nil {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
fmt.Fprint(w, "apiserver panic. Look in log for details.") fmt.Fprint(w, "apiserver panic. Look in log for details.")
log.Printf("ApiServer panic'd on %v %v: %#v\n%s\n", req.Method, req.RequestURI, x, debug.Stack()) glog.Infof("ApiServer panic'd on %v %v: %#v\n%s\n", req.Method, req.RequestURI, x, debug.Stack())
} }
}() }()
logger := MakeLogged(req, w) logger := MakeLogged(req, w)
@ -172,7 +172,7 @@ func (server *ApiServer) handleREST(parts []string, requestUrl *url.URL, req *ht
sync := requestUrl.Query().Get("sync") == "true" sync := requestUrl.Query().Get("sync") == "true"
timeout, err := time.ParseDuration(requestUrl.Query().Get("timeout")) timeout, err := time.ParseDuration(requestUrl.Query().Get("timeout"))
if err != nil && len(requestUrl.Query().Get("timeout")) > 0 { if err != nil && len(requestUrl.Query().Get("timeout")) > 0 {
log.Printf("Failed to parse: %#v '%s'", err, requestUrl.Query().Get("timeout")) glog.Errorf("Failed to parse: %#v '%s'", err, requestUrl.Query().Get("timeout"))
timeout = time.Second * 30 timeout = time.Second * 30
} }
switch req.Method { switch req.Method {

5
pkg/apiserver/logger.go
View File

@ -18,10 +18,11 @@ package apiserver
import ( import (
"fmt" "fmt"
"log"
"net/http" "net/http"
"runtime" "runtime"
"time" "time"
"github.com/golang/glog"
) )
// Add a layer on top of ResponseWriter, so we can track latency and error // Add a layer on top of ResponseWriter, so we can track latency and error
@ -56,7 +57,7 @@ func (rl *respLogger) Addf(format string, data ...interface{}) {
// Log is intended to be called once at the end of your request handler, via defer // Log is intended to be called once at the end of your request handler, via defer
func (rl *respLogger) Log() { func (rl *respLogger) Log() {
latency := time.Since(rl.startTime) latency := time.Since(rl.startTime)
log.Printf("%s %s: (%v) %v%v%v", rl.req.Method, rl.req.RequestURI, latency, rl.status, rl.statusStack, rl.addedInfo) glog.Infof("%s %s: (%v) %v%v%v", rl.req.Method, rl.req.RequestURI, latency, rl.status, rl.statusStack, rl.addedInfo)
} }
// Implement http.ResponseWriter // Implement http.ResponseWriter

4
pkg/client/client.go
View File

@ -21,11 +21,11 @@ import (
"fmt" "fmt"
"io" "io"
"io/ioutil" "io/ioutil"
"log"
"net/http" "net/http"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/golang/glog"
) )
// ClientInterface holds the methods for clients of Kubenetes, an interface to allow mock testing // ClientInterface holds the methods for clients of Kubenetes, an interface to allow mock testing
@ -135,7 +135,7 @@ func (c *Client) rawRequest(method, path string, requestBody io.Reader, target i
err = api.DecodeInto(body, target) err = api.DecodeInto(body, target)
} }
if err != nil { if err != nil {
log.Printf("Failed to parse: %s\n", string(body)) glog.Infof("Failed to parse: %s\n", string(body))
// FIXME: no need to return err here? // FIXME: no need to return err here?
} }
return body, err return body, err

8
pkg/cloudcfg/cloudcfg.go
View File

@ -20,7 +20,6 @@ import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log"
"os" "os"
"strconv" "strconv"
"strings" "strings"
@ -29,6 +28,7 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/golang/glog"
"gopkg.in/v1/yaml" "gopkg.in/v1/yaml"
) )
@ -134,17 +134,17 @@ func makePorts(spec string) []api.Port {
for _, part := range parts { for _, part := range parts {
pieces := strings.Split(part, ":") pieces := strings.Split(part, ":")
if len(pieces) != 2 { if len(pieces) != 2 {
log.Printf("Bad port spec: %s", part) glog.Infof("Bad port spec: %s", part)
continue continue
} }
host, err := strconv.Atoi(pieces[0]) host, err := strconv.Atoi(pieces[0])
if err != nil { if err != nil {
log.Printf("Host part is not integer: %s %v", pieces[0], err) glog.Errorf("Host part is not integer: %s %v", pieces[0], err)
continue continue
} }
container, err := strconv.Atoi(pieces[1]) container, err := strconv.Atoi(pieces[1])
if err != nil { if err != nil {
log.Printf("Container part is not integer: %s %v", pieces[1], err) glog.Errorf("Container part is not integer: %s %v", pieces[1], err)
continue continue
} }
result = append(result, api.Port{ContainerPort: container, HostPort: host}) result = append(result, api.Port{ContainerPort: container, HostPort: host})

20
pkg/controller/replication_controller.go
View File

@ -19,7 +19,6 @@ package controller
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"log"
"math/rand" "math/rand"
"strings" "strings"
"time" "time"
@ -29,6 +28,7 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/golang/glog"
) )
// ReplicationManager is responsible for synchronizing ReplicationController objects stored in etcd // ReplicationManager is responsible for synchronizing ReplicationController objects stored in etcd
@ -69,7 +69,7 @@ func (r RealPodControl) createReplica(controllerSpec api.ReplicationController)
} }
_, err := r.kubeClient.CreatePod(pod) _, err := r.kubeClient.CreatePod(pod)
if err != nil { if err != nil {
log.Printf("%#v\n", err) glog.Errorf("%#v\n", err)
} }
} }
@ -111,7 +111,7 @@ func (rm *ReplicationManager) watchControllers() {
}() }()
_, err := rm.etcdClient.Watch("/registry/controllers", 0, true, watchChannel, stop) _, err := rm.etcdClient.Watch("/registry/controllers", 0, true, watchChannel, stop)
if err != etcd.ErrWatchStoppedByUser { if err != etcd.ErrWatchStoppedByUser {
log.Printf("etcd.Watch stopped unexpectedly: %v (%#v)", err, err) glog.Errorf("etcd.Watch stopped unexpectedly: %v (%#v)", err, err)
} }
}() }()
@ -126,10 +126,10 @@ func (rm *ReplicationManager) watchControllers() {
// that called us call us again. // that called us call us again.
return return
} }
log.Printf("Got watch: %#v", watchResponse) glog.Infof("Got watch: %#v", watchResponse)
controller, err := rm.handleWatchResponse(watchResponse) controller, err := rm.handleWatchResponse(watchResponse)
if err != nil { if err != nil {
log.Printf("Error handling data: %#v, %#v", err, watchResponse) glog.Errorf("Error handling data: %#v, %#v", err, watchResponse)
continue continue
} }
rm.syncHandler(*controller) rm.syncHandler(*controller)
@ -185,15 +185,15 @@ func (rm *ReplicationManager) syncReplicationController(controllerSpec api.Repli
} }
filteredList := rm.filterActivePods(podList.Items) filteredList := rm.filterActivePods(podList.Items)
diff := len(filteredList) - controllerSpec.DesiredState.Replicas diff := len(filteredList) - controllerSpec.DesiredState.Replicas
log.Printf("%#v", filteredList) glog.Infof("%#v", filteredList)
if diff < 0 { if diff < 0 {
diff *= -1 diff *= -1
log.Printf("Too few replicas, creating %d\n", diff) glog.Infof("Too few replicas, creating %d\n", diff)
for i := 0; i < diff; i++ { for i := 0; i < diff; i++ {
rm.podControl.createReplica(controllerSpec) rm.podControl.createReplica(controllerSpec)
} }
} else if diff > 0 { } else if diff > 0 {
log.Print("Too many replicas, deleting") glog.Info("Too many replicas, deleting")
for i := 0; i < diff; i++ { for i := 0; i < diff; i++ {
rm.podControl.deletePod(filteredList[i].ID) rm.podControl.deletePod(filteredList[i].ID)
} }
@ -206,13 +206,13 @@ func (rm *ReplicationManager) synchronize() {
helper := util.EtcdHelper{rm.etcdClient} helper := util.EtcdHelper{rm.etcdClient}
err := helper.ExtractList("/registry/controllers", &controllerSpecs) err := helper.ExtractList("/registry/controllers", &controllerSpecs)
if err != nil { if err != nil {
log.Printf("Synchronization error: %v (%#v)", err, err) glog.Errorf("Synchronization error: %v (%#v)", err, err)
return return
} }
for _, controllerSpec := range controllerSpecs { for _, controllerSpec := range controllerSpecs {
err = rm.syncHandler(controllerSpec) err = rm.syncHandler(controllerSpec)
if err != nil { if err != nil {
log.Printf("Error synchronizing: %#v", err) glog.Errorf("Error synchronizing: %#v", err)
} }
} }
} }

76
pkg/kubelet/kubelet.go
View File

@ -20,7 +20,6 @@ import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log"
"math/rand" "math/rand"
"net/http" "net/http"
"os" "os"
@ -36,6 +35,7 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/fsouza/go-dockerclient" "github.com/fsouza/go-dockerclient"
"github.com/golang/glog"
"github.com/google/cadvisor/info" "github.com/google/cadvisor/info"
"gopkg.in/v1/yaml" "gopkg.in/v1/yaml"
) )
@ -102,27 +102,27 @@ func (kl *Kubelet) RunKubelet(config_path, manifest_url, etcd_servers, address s
} }
updateChannel := make(chan manifestUpdate) updateChannel := make(chan manifestUpdate)
if config_path != "" { if config_path != "" {
log.Printf("Watching for file configs at %s", config_path) glog.Infof("Watching for file configs at %s", config_path)
go util.Forever(func() { go util.Forever(func() {
kl.WatchFiles(config_path, updateChannel) kl.WatchFiles(config_path, updateChannel)
}, kl.FileCheckFrequency) }, kl.FileCheckFrequency)
} }
if manifest_url != "" { if manifest_url != "" {
log.Printf("Watching for HTTP configs at %s", manifest_url) glog.Infof("Watching for HTTP configs at %s", manifest_url)
go util.Forever(func() { go util.Forever(func() {
if err := kl.extractFromHTTP(manifest_url, updateChannel); err != nil { if err := kl.extractFromHTTP(manifest_url, updateChannel); err != nil {
log.Printf("Error syncing http: %#v", err) glog.Errorf("Error syncing http: %#v", err)
} }
}, kl.HTTPCheckFrequency) }, kl.HTTPCheckFrequency)
} }
if etcd_servers != "" { if etcd_servers != "" {
servers := []string{etcd_servers} servers := []string{etcd_servers}
log.Printf("Watching for etcd configs at %v", servers) glog.Infof("Watching for etcd configs at %v", servers)
kl.EtcdClient = etcd.NewClient(servers) kl.EtcdClient = etcd.NewClient(servers)
go util.Forever(func() { kl.SyncAndSetupEtcdWatch(updateChannel) }, 20*time.Second) go util.Forever(func() { kl.SyncAndSetupEtcdWatch(updateChannel) }, 20*time.Second)
} }
if address != "" { if address != "" {
log.Printf("Starting to listen on %s:%d", address, port) glog.Infof("Starting to listen on %s:%d", address, port)
handler := KubeletServer{ handler := KubeletServer{
Kubelet: kl, Kubelet: kl,
UpdateChannel: updateChannel, UpdateChannel: updateChannel,
@ -160,9 +160,9 @@ func (kl *Kubelet) LogEvent(event *api.Event) error {
response, err = kl.EtcdClient.AddChild(fmt.Sprintf("/events/%s", event.Container.Name), string(data), 60*60*48 /* 2 days */) response, err = kl.EtcdClient.AddChild(fmt.Sprintf("/events/%s", event.Container.Name), string(data), 60*60*48 /* 2 days */)
// TODO(bburns) : examine response here. // TODO(bburns) : examine response here.
if err != nil { if err != nil {
log.Printf("Error writing event: %s\n", err) glog.Errorf("Error writing event: %s\n", err)
if response != nil { if response != nil {
log.Printf("Response was: %#v\n", *response) glog.Infof("Response was: %#v\n", *response)
} }
} }
return err return err
@ -330,7 +330,7 @@ func makePortsAndBindings(container *api.Container) (map[docker.Port]struct{}, m
protocol = "/tcp" protocol = "/tcp"
default: default:
if len(port.Protocol) != 0 { if len(port.Protocol) != 0 {
log.Printf("Unknown protocol: %s, defaulting to tcp.", port.Protocol) glog.Infof("Unknown protocol: %s, defaulting to tcp.", port.Protocol)
} }
protocol = "/tcp" protocol = "/tcp"
} }
@ -381,7 +381,7 @@ func (kl *Kubelet) KillContainer(name string) error {
} }
if !found { if !found {
// This is weird, but not an error, so yell and then return nil // This is weird, but not an error, so yell and then return nil
log.Printf("Couldn't find container: %s", name) glog.Infof("Couldn't find container: %s", name)
return nil return nil
} }
err = kl.DockerClient.StopContainer(id, 10) err = kl.DockerClient.StopContainer(id, 10)
@ -411,7 +411,7 @@ func (kl *Kubelet) extractFromFile(name string) (api.ContainerManifest, error) {
data, err := ioutil.ReadAll(file) data, err := ioutil.ReadAll(file)
if err != nil { if err != nil {
log.Printf("Couldn't read from file: %v", err) glog.Errorf("Couldn't read from file: %v", err)
return manifest, err return manifest, err
} }
if err = kl.ExtractYAMLData(data, &manifest); err != nil { if err = kl.ExtractYAMLData(data, &manifest); err != nil {
@ -433,7 +433,7 @@ func (kl *Kubelet) extractFromDir(name string) ([]api.ContainerManifest, error)
for _, file := range files { for _, file := range files {
manifest, err := kl.extractFromFile(file) manifest, err := kl.extractFromFile(file)
if err != nil { if err != nil {
log.Printf("Couldn't read from file %s: %v", file, err) glog.Errorf("Couldn't read from file %s: %v", file, err)
return manifests, err return manifests, err
} }
manifests = append(manifests, manifest) manifests = append(manifests, manifest)
@ -449,26 +449,26 @@ func (kl *Kubelet) WatchFiles(config_path string, updateChannel chan<- manifestU
statInfo, err := os.Stat(config_path) statInfo, err := os.Stat(config_path)
if err != nil { if err != nil {
if !os.IsNotExist(err) { if !os.IsNotExist(err) {
log.Printf("Error accessing path: %#v", err) glog.Errorf("Error accessing path: %#v", err)
} }
return return
} }
if statInfo.Mode().IsDir() { if statInfo.Mode().IsDir() {
manifests, err := kl.extractFromDir(config_path) manifests, err := kl.extractFromDir(config_path)
if err != nil { if err != nil {
log.Printf("Error polling dir: %#v", err) glog.Errorf("Error polling dir: %#v", err)
return return
} }
updateChannel <- manifestUpdate{fileSource, manifests} updateChannel <- manifestUpdate{fileSource, manifests}
} else if statInfo.Mode().IsRegular() { } else if statInfo.Mode().IsRegular() {
manifest, err := kl.extractFromFile(config_path) manifest, err := kl.extractFromFile(config_path)
if err != nil { if err != nil {
log.Printf("Error polling file: %#v", err) glog.Errorf("Error polling file: %#v", err)
return return
} }
updateChannel <- manifestUpdate{fileSource, []api.ContainerManifest{manifest}} updateChannel <- manifestUpdate{fileSource, []api.ContainerManifest{manifest}}
} else { } else {
log.Printf("Error accessing config - not a directory or file") glog.Errorf("Error accessing config - not a directory or file")
return return
} }
} }
@ -544,15 +544,15 @@ func (kl *Kubelet) getKubeletStateFromEtcd(key string, updateChannel chan<- mani
if util.IsEtcdNotFound(err) { if util.IsEtcdNotFound(err) {
return nil return nil
} }
log.Printf("Error on etcd get of %s: %#v", key, err) glog.Errorf("Error on etcd get of %s: %#v", key, err)
return err return err
} }
manifests, err := kl.ResponseToManifests(response) manifests, err := kl.ResponseToManifests(response)
if err != nil { if err != nil {
log.Printf("Error parsing response (%#v): %s", response, err) glog.Errorf("Error parsing response (%#v): %s", response, err)
return err return err
} }
log.Printf("Got state from etcd: %+v", manifests) glog.Infof("Got state from etcd: %+v", manifests)
updateChannel <- manifestUpdate{etcdSource, manifests} updateChannel <- manifestUpdate{etcdSource, manifests}
return nil return nil
} }
@ -583,7 +583,7 @@ func (kl *Kubelet) SyncAndSetupEtcdWatch(updateChannel chan<- manifestUpdate) {
go kl.WatchEtcd(watchChannel, updateChannel) go kl.WatchEtcd(watchChannel, updateChannel)
kl.getKubeletStateFromEtcd(key, updateChannel) kl.getKubeletStateFromEtcd(key, updateChannel)
log.Printf("Setting up a watch for configuration changes in etcd for %s", key) glog.Infof("Setting up a watch for configuration changes in etcd for %s", key)
kl.EtcdClient.Watch(key, 0, true, watchChannel, done) kl.EtcdClient.Watch(key, 0, true, watchChannel, done)
} }
} }
@ -600,7 +600,7 @@ func (kl *Kubelet) TimeoutWatch(done chan bool) {
func (kl *Kubelet) ExtractYAMLData(buf []byte, output interface{}) error { func (kl *Kubelet) ExtractYAMLData(buf []byte, output interface{}) error {
err := yaml.Unmarshal(buf, output) err := yaml.Unmarshal(buf, output)
if err != nil { if err != nil {
log.Printf("Couldn't unmarshal configuration: %v", err) glog.Errorf("Couldn't unmarshal configuration: %v", err)
return err return err
} }
return nil return nil
@ -625,13 +625,13 @@ func (kl *Kubelet) WatchEtcd(watchChannel <-chan *etcd.Response, updateChannel c
if watchResponse == nil { if watchResponse == nil {
return return
} }
log.Printf("Got etcd change: %#v", watchResponse) glog.Infof("Got etcd change: %#v", watchResponse)
manifests, err := kl.extractFromEtcd(watchResponse) manifests, err := kl.extractFromEtcd(watchResponse)
if err != nil { if err != nil {
log.Printf("Error handling response from etcd: %#v", err) glog.Errorf("Error handling response from etcd: %#v", err)
continue continue
} }
log.Printf("manifests: %#v", manifests) glog.Infof("manifests: %#v", manifests)
// Ok, we have a valid configuration, send to channel for // Ok, we have a valid configuration, send to channel for
// rejiggering. // rejiggering.
updateChannel <- manifestUpdate{etcdSource, manifests} updateChannel <- manifestUpdate{etcdSource, manifests}
@ -672,20 +672,20 @@ func (kl *Kubelet) createNetworkContainer(manifest *api.ContainerManifest) (stri
// Sync the configured list of containers (desired state) with the host current state // Sync the configured list of containers (desired state) with the host current state
func (kl *Kubelet) SyncManifests(config []api.ContainerManifest) error { func (kl *Kubelet) SyncManifests(config []api.ContainerManifest) error {
log.Printf("Desired: %#v", config) glog.Infof("Desired: %#v", config)
var err error var err error
desired := map[string]bool{} desired := map[string]bool{}
for _, manifest := range config { for _, manifest := range config {
netName, exists, err := kl.networkContainerExists(&manifest) netName, exists, err := kl.networkContainerExists(&manifest)
if err != nil { if err != nil {
log.Printf("Failed to introspect network container. (%#v) Skipping container %s", err, manifest.Id) glog.Errorf("Failed to introspect network container. (%#v) Skipping container %s", err, manifest.Id)
continue continue
} }
if !exists { if !exists {
log.Printf("Network container doesn't exist, creating") glog.Infof("Network container doesn't exist, creating")
netName, err = kl.createNetworkContainer(&manifest) netName, err = kl.createNetworkContainer(&manifest)
if err != nil { if err != nil {
log.Printf("Failed to create network container: %#v", err) glog.Errorf("Failed to create network container: %#v", err)
} }
// Docker list prefixes '/' for some reason, so let's do that... // Docker list prefixes '/' for some reason, so let's do that...
netName = "/" + netName netName = "/" + netName
@ -695,14 +695,14 @@ func (kl *Kubelet) SyncManifests(config []api.ContainerManifest) error {
var exists bool var exists bool
exists, actualName, err := kl.ContainerExists(&manifest, &element) exists, actualName, err := kl.ContainerExists(&manifest, &element)
if err != nil { if err != nil {
log.Printf("Error detecting container: %#v skipping.", err) glog.Errorf("Error detecting container: %#v skipping.", err)
continue continue
} }
if !exists { if !exists {
log.Printf("%#v doesn't exist, creating", element) glog.Infof("%#v doesn't exist, creating", element)
kl.DockerPuller.Pull(element.Image) kl.DockerPuller.Pull(element.Image)
if err != nil { if err != nil {
log.Printf("Error pulling container: %#v", err) glog.Errorf("Error pulling container: %#v", err)
continue continue
} }
// netName has the '/' prefix, so slice it off // netName has the '/' prefix, so slice it off
@ -713,18 +713,18 @@ func (kl *Kubelet) SyncManifests(config []api.ContainerManifest) error {
if err != nil { if err != nil {
// TODO(bburns) : Perhaps blacklist a container after N failures? // TODO(bburns) : Perhaps blacklist a container after N failures?
log.Printf("Error creating container: %#v", err) glog.Errorf("Error creating container: %#v", err)
desired[actualName] = true desired[actualName] = true
continue continue
} }
} else { } else {
log.Printf("%#v exists as %v", element.Name, actualName) glog.Infof("%#v exists as %v", element.Name, actualName)
} }
desired[actualName] = true desired[actualName] = true
} }
} }
existingContainers, _ := kl.ListContainers() existingContainers, _ := kl.ListContainers()
log.Printf("Existing: %#v Desired: %#v", existingContainers, desired) glog.Infof("Existing: %#v Desired: %#v", existingContainers, desired)
for _, container := range existingContainers { for _, container := range existingContainers {
// Skip containers that we didn't create to allow users to manually // Skip containers that we didn't create to allow users to manually
// spin up their own containers if they want. // spin up their own containers if they want.
@ -732,10 +732,10 @@ func (kl *Kubelet) SyncManifests(config []api.ContainerManifest) error {
continue continue
} }
if !desired[container] { if !desired[container] {
log.Printf("Killing: %s", container) glog.Infof("Killing: %s", container)
err = kl.KillContainer(container) err = kl.KillContainer(container)
if err != nil { if err != nil {
log.Printf("Error killing container: %#v", err) glog.Errorf("Error killing container: %#v", err)
} }
} }
} }
@ -753,7 +753,7 @@ func (kl *Kubelet) RunSyncLoop(updateChannel <-chan manifestUpdate, handler Sync
for { for {
select { select {
case u := <-updateChannel: case u := <-updateChannel:
log.Printf("Got configuration from %s: %#v", u.source, u.manifests) glog.Infof("Got configuration from %s: %#v", u.source, u.manifests)
last[u.source] = u.manifests last[u.source] = u.manifests
case <-time.After(kl.SyncFrequency): case <-time.After(kl.SyncFrequency):
} }
@ -765,7 +765,7 @@ func (kl *Kubelet) RunSyncLoop(updateChannel <-chan manifestUpdate, handler Sync
err := handler.SyncManifests(manifests) err := handler.SyncManifests(manifests)
if err != nil { if err != nil {
log.Printf("Couldn't sync containers : %#v", err) glog.Errorf("Couldn't sync containers : %#v", err)
} }
} }
} }

6
pkg/master/pod_cache.go
View File

@ -17,7 +17,6 @@ limitations under the License.
package master package master
import ( import (
"log"
"sync" "sync"
"time" "time"
@ -25,6 +24,7 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/GoogleCloudPlatform/kubernetes/pkg/registry" "github.com/GoogleCloudPlatform/kubernetes/pkg/registry"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/golang/glog"
) )
// PodCache contains both a cache of container information, as well as the mechanism for keeping // PodCache contains both a cache of container information, as well as the mechanism for keeping
@ -74,13 +74,13 @@ func (p *PodCache) updateContainerInfo(host, id string) error {
func (p *PodCache) UpdateAllContainers() { func (p *PodCache) UpdateAllContainers() {
pods, err := p.pods.ListPods(labels.Everything()) pods, err := p.pods.ListPods(labels.Everything())
if err != nil { if err != nil {
log.Printf("Error synchronizing container: %#v", err) glog.Errorf("Error synchronizing container: %#v", err)
return return
} }
for _, pod := range pods { for _, pod := range pods {
err := p.updateContainerInfo(pod.CurrentState.Host, pod.ID) err := p.updateContainerInfo(pod.CurrentState.Host, pod.ID)
if err != nil { if err != nil {
log.Printf("Error synchronizing container: %#v", err) glog.Errorf("Error synchronizing container: %#v", err)
} }
} }
} }

28
pkg/proxy/config/config.go
View File

@ -17,11 +17,11 @@ limitations under the License.
package config package config
import ( import (
"log"
"sync" "sync"
"time" "time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/golang/glog"
) )
type Operation int type Operation int
@ -110,14 +110,14 @@ func NewServiceConfig() ServiceConfig {
} }
func (impl *ServiceConfig) Run() { func (impl *ServiceConfig) Run() {
log.Printf("Starting the config Run loop") glog.Infof("Starting the config Run loop")
for { for {
select { select {
case source := <-impl.serviceNotifyChannel: case source := <-impl.serviceNotifyChannel:
log.Printf("Got new service configuration from source %s", source) glog.Infof("Got new service configuration from source %s", source)
impl.NotifyServiceUpdate() impl.NotifyServiceUpdate()
case source := <-impl.endpointsNotifyChannel: case source := <-impl.endpointsNotifyChannel:
log.Printf("Got new endpoint configuration from source %s", source) glog.Infof("Got new endpoint configuration from source %s", source)
impl.NotifyEndpointsUpdate() impl.NotifyEndpointsUpdate()
case <-time.After(1 * time.Second): case <-time.After(1 * time.Second):
} }
@ -132,24 +132,24 @@ func (impl *ServiceConfig) ServiceChannelListener(source string, listenChannel c
case update := <-listenChannel: case update := <-listenChannel:
switch update.Op { switch update.Op {
case ADD: case ADD:
log.Printf("Adding new service from source %s : %v", source, update.Services) glog.Infof("Adding new service from source %s : %v", source, update.Services)
for _, value := range update.Services { for _, value := range update.Services {
serviceMap[value.ID] = value serviceMap[value.ID] = value
} }
case REMOVE: case REMOVE:
log.Printf("Removing a service %v", update) glog.Infof("Removing a service %v", update)
for _, value := range update.Services { for _, value := range update.Services {
delete(serviceMap, value.ID) delete(serviceMap, value.ID)
} }
case SET: case SET:
log.Printf("Setting services %v", update) glog.Infof("Setting services %v", update)
// Clear the old map entries by just creating a new map // Clear the old map entries by just creating a new map
serviceMap = make(map[string]api.Service) serviceMap = make(map[string]api.Service)
for _, value := range update.Services { for _, value := range update.Services {
serviceMap[value.ID] = value serviceMap[value.ID] = value
} }
default: default:
log.Printf("Received invalid update type: %v", update) glog.Infof("Received invalid update type: %v", update)
continue continue
} }
impl.configLock.Lock() impl.configLock.Lock()
@ -167,25 +167,25 @@ func (impl *ServiceConfig) EndpointsChannelListener(source string, listenChannel
case update := <-listenChannel: case update := <-listenChannel:
switch update.Op { switch update.Op {
case ADD: case ADD:
log.Printf("Adding a new endpoint %v", update) glog.Infof("Adding a new endpoint %v", update)
for _, value := range update.Endpoints { for _, value := range update.Endpoints {
endpointMap[value.Name] = value endpointMap[value.Name] = value
} }
case REMOVE: case REMOVE:
log.Printf("Removing an endpoint %v", update) glog.Infof("Removing an endpoint %v", update)
for _, value := range update.Endpoints { for _, value := range update.Endpoints {
delete(endpointMap, value.Name) delete(endpointMap, value.Name)
} }
case SET: case SET:
log.Printf("Setting services %v", update) glog.Infof("Setting services %v", update)
// Clear the old map entries by just creating a new map // Clear the old map entries by just creating a new map
endpointMap = make(map[string]api.Endpoints) endpointMap = make(map[string]api.Endpoints)
for _, value := range update.Endpoints { for _, value := range update.Endpoints {
endpointMap[value.Name] = value endpointMap[value.Name] = value
} }
default: default:
log.Printf("Received invalid update type: %v", update) glog.Infof("Received invalid update type: %v", update)
continue continue
} }
impl.configLock.Lock() impl.configLock.Lock()
@ -280,7 +280,7 @@ func (impl *ServiceConfig) NotifyServiceUpdate() {
} }
} }
impl.configLock.RUnlock() impl.configLock.RUnlock()
log.Printf("Unified configuration %+v", services) glog.Infof("Unified configuration %+v", services)
impl.handlerLock.RLock() impl.handlerLock.RLock()
handlers := impl.serviceHandlers handlers := impl.serviceHandlers
impl.handlerLock.RUnlock() impl.handlerLock.RUnlock()
@ -300,7 +300,7 @@ func (impl *ServiceConfig) NotifyEndpointsUpdate() {
} }
} }
impl.configLock.RUnlock() impl.configLock.RUnlock()
log.Printf("Unified configuration %+v", endpoints) glog.Infof("Unified configuration %+v", endpoints)
impl.handlerLock.RLock() impl.handlerLock.RLock()
handlers := impl.endpointHandlers handlers := impl.endpointHandlers
impl.handlerLock.RUnlock() impl.handlerLock.RUnlock()

32
pkg/proxy/config/etcd.go
View File

@ -36,12 +36,12 @@ package config
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"log"
"strings" "strings"
"time" "time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/coreos/go-etcd/etcd" "github.com/coreos/go-etcd/etcd"
"github.com/golang/glog"
) )
const RegistryRoot = "registry/services" const RegistryRoot = "registry/services"
@ -72,7 +72,7 @@ func (impl ConfigSourceEtcd) Run() {
if err == nil { if err == nil {
break break
} }
log.Printf("Failed to get any services: %v", err) glog.Errorf("Failed to get any services: %v", err)
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
} }
@ -92,7 +92,7 @@ func (impl ConfigSourceEtcd) Run() {
for { for {
services, endpoints, err = impl.GetServices() services, endpoints, err = impl.GetServices()
if err != nil { if err != nil {
log.Printf("ConfigSourceEtcd: Failed to get services: %v", err) glog.Errorf("ConfigSourceEtcd: Failed to get services: %v", err)
} else { } else {
if len(services) > 0 { if len(services) > 0 {
serviceUpdate := ServiceUpdate{Op: SET, Services: services} serviceUpdate := ServiceUpdate{Op: SET, Services: services}
@ -112,7 +112,7 @@ func (impl ConfigSourceEtcd) Run() {
func (impl ConfigSourceEtcd) GetServices() ([]api.Service, []api.Endpoints, error) { func (impl ConfigSourceEtcd) GetServices() ([]api.Service, []api.Endpoints, error) {
response, err := impl.client.Get(RegistryRoot+"/specs", true, false) response, err := impl.client.Get(RegistryRoot+"/specs", true, false)
if err != nil { if err != nil {
log.Printf("Failed to get the key %s: %v", RegistryRoot, err) glog.Errorf("Failed to get the key %s: %v", RegistryRoot, err)
return make([]api.Service, 0), make([]api.Endpoints, 0), err return make([]api.Service, 0), make([]api.Endpoints, 0), err
} }
if response.Node.Dir == true { if response.Node.Dir == true {
@ -125,15 +125,15 @@ func (impl ConfigSourceEtcd) GetServices() ([]api.Service, []api.Endpoints, erro
var svc api.Service var svc api.Service
err = json.Unmarshal([]byte(node.Value), &svc) err = json.Unmarshal([]byte(node.Value), &svc)
if err != nil { if err != nil {
log.Printf("Failed to load Service: %s (%#v)", node.Value, err) glog.Errorf("Failed to load Service: %s (%#v)", node.Value, err)
continue continue
} }
retServices[i] = svc retServices[i] = svc
endpoints, err := impl.GetEndpoints(svc.ID) endpoints, err := impl.GetEndpoints(svc.ID)
if err != nil { if err != nil {
log.Printf("Couldn't get endpoints for %s : %v skipping", svc.ID, err) glog.Errorf("Couldn't get endpoints for %s : %v skipping", svc.ID, err)
} }
log.Printf("Got service: %s on localport %d mapping to: %s", svc.ID, svc.Port, endpoints) glog.Infof("Got service: %s on localport %d mapping to: %s", svc.ID, svc.Port, endpoints)
retEndpoints[i] = endpoints retEndpoints[i] = endpoints
} }
return retServices, retEndpoints, err return retServices, retEndpoints, err
@ -145,7 +145,7 @@ func (impl ConfigSourceEtcd) GetEndpoints(service string) (api.Endpoints, error)
key := fmt.Sprintf(RegistryRoot + "/endpoints/" + service) key := fmt.Sprintf(RegistryRoot + "/endpoints/" + service)
response, err := impl.client.Get(key, true, false) response, err := impl.client.Get(key, true, false)
if err != nil { if err != nil {
log.Printf("Failed to get the key: %s %v", key, err) glog.Errorf("Failed to get the key: %s %v", key, err)
return api.Endpoints{}, err return api.Endpoints{}, err
} }
// Parse all the endpoint specifications in this value. // Parse all the endpoint specifications in this value.
@ -173,7 +173,7 @@ func ParseEndpoints(jsonString string) (api.Endpoints, error) {
} }
func (impl ConfigSourceEtcd) WatchForChanges() { func (impl ConfigSourceEtcd) WatchForChanges() {
log.Print("Setting up a watch for new services") glog.Info("Setting up a watch for new services")
watchChannel := make(chan *etcd.Response) watchChannel := make(chan *etcd.Response)
go impl.client.Watch("/registry/services/", 0, true, watchChannel, nil) go impl.client.Watch("/registry/services/", 0, true, watchChannel, nil)
for { for {
@ -183,7 +183,7 @@ func (impl ConfigSourceEtcd) WatchForChanges() {
} }
func (impl ConfigSourceEtcd) ProcessChange(response *etcd.Response) { func (impl ConfigSourceEtcd) ProcessChange(response *etcd.Response) {
log.Printf("Processing a change in service configuration... %s", *response) glog.Infof("Processing a change in service configuration... %s", *response)
// If it's a new service being added (signified by a localport being added) // If it's a new service being added (signified by a localport being added)
// then process it as such // then process it as such
@ -192,11 +192,11 @@ func (impl ConfigSourceEtcd) ProcessChange(response *etcd.Response) {
} else if response.Action == "set" { } else if response.Action == "set" {
service, err := EtcdResponseToService(response) service, err := EtcdResponseToService(response)
if err != nil { if err != nil {
log.Printf("Failed to parse %s Port: %s", response, err) glog.Errorf("Failed to parse %s Port: %s", response, err)
return return
} }
log.Printf("New service added/updated: %#v", service) glog.Infof("New service added/updated: %#v", service)
serviceUpdate := ServiceUpdate{Op: ADD, Services: []api.Service{*service}} serviceUpdate := ServiceUpdate{Op: ADD, Services: []api.Service{*service}}
impl.serviceChannel <- serviceUpdate impl.serviceChannel <- serviceUpdate
return return
@ -204,22 +204,22 @@ func (impl ConfigSourceEtcd) ProcessChange(response *etcd.Response) {
if response.Action == "delete" { if response.Action == "delete" {
parts := strings.Split(response.Node.Key[1:], "/") parts := strings.Split(response.Node.Key[1:], "/")
if len(parts) == 4 { if len(parts) == 4 {
log.Printf("Deleting service: %s", parts[3]) glog.Infof("Deleting service: %s", parts[3])
serviceUpdate := ServiceUpdate{Op: REMOVE, Services: []api.Service{{JSONBase: api.JSONBase{ID: parts[3]}}}} serviceUpdate := ServiceUpdate{Op: REMOVE, Services: []api.Service{{JSONBase: api.JSONBase{ID: parts[3]}}}}
impl.serviceChannel <- serviceUpdate impl.serviceChannel <- serviceUpdate
return return
} else { } else {
log.Printf("Unknown service delete: %#v", parts) glog.Infof("Unknown service delete: %#v", parts)
} }
} }
} }
func (impl ConfigSourceEtcd) ProcessEndpointResponse(response *etcd.Response) { func (impl ConfigSourceEtcd) ProcessEndpointResponse(response *etcd.Response) {
log.Printf("Processing a change in endpoint configuration... %s", *response) glog.Infof("Processing a change in endpoint configuration... %s", *response)
var endpoints api.Endpoints var endpoints api.Endpoints
err := json.Unmarshal([]byte(response.Node.Value), &endpoints) err := json.Unmarshal([]byte(response.Node.Value), &endpoints)
if err != nil { if err != nil {
log.Printf("Failed to parse service out of etcd key: %v : %+v", response.Node.Value, err) glog.Errorf("Failed to parse service out of etcd key: %v : %+v", response.Node.Value, err)
return return
} }
endpointsUpdate := EndpointsUpdate{Op: ADD, Endpoints: []api.Endpoints{endpoints}} endpointsUpdate := EndpointsUpdate{Op: ADD, Endpoints: []api.Endpoints{endpoints}}

8
pkg/proxy/config/file.go
View File

@ -34,11 +34,11 @@ import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"io/ioutil" "io/ioutil"
"log"
"reflect" "reflect"
"time" "time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/golang/glog"
) )
// TODO: kill this struct. // TODO: kill this struct.
@ -68,7 +68,7 @@ func NewConfigSourceFile(filename string, serviceChannel chan ServiceUpdate, end
} }
func (impl ConfigSourceFile) Run() { func (impl ConfigSourceFile) Run() {
log.Printf("Watching file %s", impl.filename) glog.Infof("Watching file %s", impl.filename)
var lastData []byte var lastData []byte
var lastServices []api.Service var lastServices []api.Service
var lastEndpoints []api.Endpoints var lastEndpoints []api.Endpoints
@ -76,12 +76,12 @@ func (impl ConfigSourceFile) Run() {
for { for {
data, err := ioutil.ReadFile(impl.filename) data, err := ioutil.ReadFile(impl.filename)
if err != nil { if err != nil {
log.Printf("Couldn't read file: %s : %v", impl.filename, err) glog.Errorf("Couldn't read file: %s : %v", impl.filename, err)
} else { } else {
var config ConfigFile var config ConfigFile
err = json.Unmarshal(data, &config) err = json.Unmarshal(data, &config)
if err != nil { if err != nil {
log.Printf("Couldn't unmarshal configuration from file : %s %v", data, err) glog.Errorf("Couldn't unmarshal configuration from file : %s %v", data, err)
} else { } else {
if !bytes.Equal(lastData, data) { if !bytes.Equal(lastData, data) {
lastData = data lastData = data

26
pkg/proxy/proxier.go
View File

@ -19,11 +19,11 @@ package proxy
import ( import (
"fmt" "fmt"
"io" "io"
"log"
"net" "net"
"time" "time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/golang/glog"
) )
// Proxier is a simple proxy for tcp connections between a localhost:lport and services that provide // Proxier is a simple proxy for tcp connections between a localhost:lport and services that provide
@ -38,11 +38,11 @@ func NewProxier(loadBalancer LoadBalancer) *Proxier {
} }
func CopyBytes(in, out *net.TCPConn) { func CopyBytes(in, out *net.TCPConn) {
log.Printf("Copying from %v <-> %v <-> %v <-> %v", glog.Infof("Copying from %v <-> %v <-> %v <-> %v",
in.RemoteAddr(), in.LocalAddr(), out.LocalAddr(), out.RemoteAddr()) in.RemoteAddr(), in.LocalAddr(), out.LocalAddr(), out.RemoteAddr())
_, err := io.Copy(in, out) _, err := io.Copy(in, out)
if err != nil && err != io.EOF { if err != nil && err != io.EOF {
log.Printf("I/O error: %v", err) glog.Errorf("I/O error: %v", err)
} }
in.CloseRead() in.CloseRead()
@ -51,7 +51,7 @@ func CopyBytes(in, out *net.TCPConn) {
// Create a bidirectional byte shuffler. Copies bytes to/from each connection. // Create a bidirectional byte shuffler. Copies bytes to/from each connection.
func ProxyConnection(in, out *net.TCPConn) { func ProxyConnection(in, out *net.TCPConn) {
log.Printf("Creating proxy between %v <-> %v <-> %v <-> %v", glog.Infof("Creating proxy between %v <-> %v <-> %v <-> %v",
in.RemoteAddr(), in.LocalAddr(), out.LocalAddr(), out.RemoteAddr()) in.RemoteAddr(), in.LocalAddr(), out.LocalAddr(), out.RemoteAddr())
go CopyBytes(in, out) go CopyBytes(in, out)
go CopyBytes(out, in) go CopyBytes(out, in)
@ -61,25 +61,25 @@ func (proxier Proxier) AcceptHandler(service string, listener net.Listener) {
for { for {
inConn, err := listener.Accept() inConn, err := listener.Accept()
if err != nil { if err != nil {
log.Printf("Accept failed: %v", err) glog.Errorf("Accept failed: %v", err)
continue continue
} }
log.Printf("Accepted connection from: %v to %v", inConn.RemoteAddr(), inConn.LocalAddr()) glog.Infof("Accepted connection from: %v to %v", inConn.RemoteAddr(), inConn.LocalAddr())
// Figure out where this request should go. // Figure out where this request should go.
endpoint, err := proxier.loadBalancer.LoadBalance(service, inConn.RemoteAddr()) endpoint, err := proxier.loadBalancer.LoadBalance(service, inConn.RemoteAddr())
if err != nil { if err != nil {
log.Printf("Couldn't find an endpoint for %s %v", service, err) glog.Errorf("Couldn't find an endpoint for %s %v", service, err)
inConn.Close() inConn.Close()
continue continue
} }
log.Printf("Mapped service %s to endpoint %s", service, endpoint) glog.Infof("Mapped service %s to endpoint %s", service, endpoint)
outConn, err := net.DialTimeout("tcp", endpoint, time.Duration(5)*time.Second) outConn, err := net.DialTimeout("tcp", endpoint, time.Duration(5)*time.Second)
// We basically need to take everything from inConn and send to outConn // We basically need to take everything from inConn and send to outConn
// and anything coming from outConn needs to be sent to inConn. // and anything coming from outConn needs to be sent to inConn.
if err != nil { if err != nil {
log.Printf("Dial failed: %v", err) glog.Errorf("Dial failed: %v", err)
inConn.Close() inConn.Close()
continue continue
} }
@ -112,22 +112,22 @@ func (proxier Proxier) addServiceOnUnusedPort(service string) (string, error) {
} }
func (proxier Proxier) addServiceCommon(service string, l net.Listener) { func (proxier Proxier) addServiceCommon(service string, l net.Listener) {
log.Printf("Listening for %s on %s", service, l.Addr().String()) glog.Infof("Listening for %s on %s", service, l.Addr().String())
// If that succeeds, start the accepting loop. // If that succeeds, start the accepting loop.
go proxier.AcceptHandler(service, l) go proxier.AcceptHandler(service, l)
} }
func (proxier Proxier) OnUpdate(services []api.Service) { func (proxier Proxier) OnUpdate(services []api.Service) {
log.Printf("Received update notice: %+v", services) glog.Infof("Received update notice: %+v", services)
for _, service := range services { for _, service := range services {
port, exists := proxier.serviceMap[service.ID] port, exists := proxier.serviceMap[service.ID]
if !exists || port != service.Port { if !exists || port != service.Port {
log.Printf("Adding a new service %s on port %d", service.ID, service.Port) glog.Infof("Adding a new service %s on port %d", service.ID, service.Port)
err := proxier.AddService(service.ID, service.Port) err := proxier.AddService(service.ID, service.Port)
if err == nil { if err == nil {
proxier.serviceMap[service.ID] = service.Port proxier.serviceMap[service.ID] = service.Port
} else { } else {
log.Printf("Failed to start listening for %s on %d", service.ID, service.Port) glog.Infof("Failed to start listening for %s on %d", service.ID, service.Port)
} }
} }
} }

6
pkg/proxy/roundrobbin.go
View File

@ -20,7 +20,6 @@ package proxy
import ( import (
"errors" "errors"
"log"
"net" "net"
"reflect" "reflect"
"strconv" "strconv"
@ -28,6 +27,7 @@ import (
"sync" "sync"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/golang/glog"
) )
type LoadBalancerRR struct { type LoadBalancerRR struct {
@ -86,7 +86,7 @@ func (impl LoadBalancerRR) OnUpdate(endpoints []api.Endpoints) {
for _, value := range endpoints { for _, value := range endpoints {
existingEndpoints, exists := impl.endpointsMap[value.Name] existingEndpoints, exists := impl.endpointsMap[value.Name]
if !exists || !reflect.DeepEqual(value.Endpoints, existingEndpoints) { if !exists || !reflect.DeepEqual(value.Endpoints, existingEndpoints) {
log.Printf("LoadBalancerRR: Setting endpoints for %s to %+v", value.Name, value.Endpoints) glog.Infof("LoadBalancerRR: Setting endpoints for %s to %+v", value.Name, value.Endpoints)
impl.endpointsMap[value.Name] = impl.FilterValidEndpoints(value.Endpoints) impl.endpointsMap[value.Name] = impl.FilterValidEndpoints(value.Endpoints)
// Start RR from the beginning if added or updated. // Start RR from the beginning if added or updated.
impl.rrIndex[value.Name] = 0 impl.rrIndex[value.Name] = 0
@ -97,7 +97,7 @@ func (impl LoadBalancerRR) OnUpdate(endpoints []api.Endpoints) {
for key, value := range impl.endpointsMap { for key, value := range impl.endpointsMap {
_, exists := tmp[key] _, exists := tmp[key]
if !exists { if !exists {
log.Printf("LoadBalancerRR: Removing endpoints for %s -> %+v", key, value) glog.Infof("LoadBalancerRR: Removing endpoints for %s -> %+v", key, value)
delete(impl.endpointsMap, key) delete(impl.endpointsMap, key)
} }
} }

6
pkg/registry/endpoints.go
View File

@ -18,10 +18,10 @@ package registry
import ( import (
"fmt" "fmt"
"log"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/golang/glog"
) )
func MakeEndpointController(serviceRegistry ServiceRegistry, podRegistry PodRegistry) *EndpointController { func MakeEndpointController(serviceRegistry ServiceRegistry, podRegistry PodRegistry) *EndpointController {
@ -45,7 +45,7 @@ func (e *EndpointController) SyncServiceEndpoints() error {
for _, service := range services.Items { for _, service := range services.Items {
pods, err := e.podRegistry.ListPods(labels.Set(service.Selector).AsSelector()) pods, err := e.podRegistry.ListPods(labels.Set(service.Selector).AsSelector())
if err != nil { if err != nil {
log.Printf("Error syncing service: %#v, skipping.", service) glog.Errorf("Error syncing service: %#v, skipping.", service)
resultErr = err resultErr = err
continue continue
} }
@ -59,7 +59,7 @@ func (e *EndpointController) SyncServiceEndpoints() error {
Endpoints: endpoints, Endpoints: endpoints,
}) })
if err != nil { if err != nil {
log.Printf("Error updating endpoints: %#v", err) glog.Errorf("Error updating endpoints: %#v", err)
continue continue
} }
} }

4
pkg/registry/etcd_registry.go
View File

@ -19,11 +19,11 @@ package registry
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"log"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/golang/glog"
) )
// TODO: Need to add a reconciler loop that makes sure that things in pods are reflected into // TODO: Need to add a reconciler loop that makes sure that things in pods are reflected into
@ -158,7 +158,7 @@ func (registry *EtcdRegistry) deletePodFromMachine(machine, podID string) error
// This really shouldn't happen, it indicates something is broken, and likely // This really shouldn't happen, it indicates something is broken, and likely
// there is a lost pod somewhere. // there is a lost pod somewhere.
// However it is "deleted" so log it and move on // However it is "deleted" so log it and move on
log.Printf("Couldn't find: %s in %#v", podID, manifests) glog.Infof("Couldn't find: %s in %#v", podID, manifests)
} }
if err = registry.updateManifests(machine, newManifests); err != nil { if err = registry.updateManifests(machine, newManifests); err != nil {
return err return err

6
pkg/registry/pod_registry.go
View File

@ -18,7 +18,6 @@ package registry
import ( import (
"fmt" "fmt"
"log"
"strings" "strings"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
@ -26,6 +25,7 @@ import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider" "github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/golang/glog"
) )
// PodRegistryStorage implements the RESTStorage interface in terms of a PodRegistry // PodRegistryStorage implements the RESTStorage interface in terms of a PodRegistry
@ -65,7 +65,7 @@ func (storage *PodRegistryStorage) List(selector labels.Selector) (interface{},
for ix, pod := range pods { for ix, pod := range pods {
info, err := storage.podCache.GetContainerInfo(pod.CurrentState.Host, pod.ID) info, err := storage.podCache.GetContainerInfo(pod.CurrentState.Host, pod.ID)
if err != nil { if err != nil {
log.Printf("Error getting container info: %#v", err) glog.Errorf("Error getting container info: %#v", err)
continue continue
} }
result.Items[ix].CurrentState.Info = info result.Items[ix].CurrentState.Info = info
@ -103,7 +103,7 @@ func getInstanceIP(cloud cloudprovider.Interface, host string) string {
} }
addr, err := instances.IPAddress(host) addr, err := instances.IPAddress(host)
if err != nil { if err != nil {
log.Printf("Error getting instance IP: %#v", err) glog.Errorf("Error getting instance IP: %#v", err)
return "" return ""
} }
return addr.String() return addr.String()

50
pkg/util/logs.go Normal file
View File

@ -0,0 +1,50 @@
/*
Copyright 2014 Google Inc. All rights reserved.
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 util
import (
"flag"
"log"
"time"
"github.com/golang/glog"
)
var logFlushFreq = flag.Duration("log_flush_frequency", 5*time.Second, "Maximum number of seconds between log flushes")
// This serves as a bridge between the standard log package and the glog package.
type GlogWriter struct{}
func (writer GlogWriter) Write(data []byte) (n int, err error) {
glog.Info(string(data))
return len(data), nil
}
func InitLogs() {
log.SetOutput(GlogWriter{})
log.SetFlags(0)
// The default glog flush interval is 30 seconds, which is frighteningly long.
go Forever(glog.Flush, *logFlushFreq)
}
func FlushLogs() {
glog.Flush()
}
func NewLogger(prefix string) *log.Logger {
return log.New(GlogWriter{}, prefix, 0)
}

5
pkg/util/util.go
View File

@ -19,9 +19,10 @@ package util
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"log"
"runtime" "runtime"
"time" "time"
"github.com/golang/glog"
) )
// Simply catches a crash and logs an error. Meant to be called via defer. // Simply catches a crash and logs an error. Meant to be called via defer.
@ -36,7 +37,7 @@ func HandleCrash() {
} }
callers = callers + fmt.Sprintf("%v:%v\n", file, line) callers = callers + fmt.Sprintf("%v:%v\n", file, line)
} }
log.Printf("Recovered from panic: %#v (%v)\n%v", r, r, callers) glog.Infof("Recovered from panic: %#v (%v)\n%v", r, r, callers)
} }
} }

1
third_party/deps.sh vendored
View File

@ -1,6 +1,7 @@
TOP_PACKAGES=" TOP_PACKAGES="
github.com/coreos/go-etcd/etcd github.com/coreos/go-etcd/etcd
github.com/fsouza/go-dockerclient github.com/fsouza/go-dockerclient
github.com/golang/glog
code.google.com/p/goauth2/compute/serviceaccount code.google.com/p/goauth2/compute/serviceaccount
code.google.com/p/goauth2/oauth code.google.com/p/goauth2/oauth
code.google.com/p/google-api-go-client/compute/v1 code.google.com/p/google-api-go-client/compute/v1

4
third_party/update.sh vendored
View File

@ -13,6 +13,10 @@ cd $THIRD_PARTY_DIR
. ./deps.sh . ./deps.sh
if [ $# -gt 0 ]; then
PACKAGES="$@"
fi
# Create a temp GOPATH root. It must be an absolute path # Create a temp GOPATH root. It must be an absolute path
mkdir -p ../output/go_dep_update mkdir -p ../output/go_dep_update
cd ../output/go_dep_update cd ../output/go_dep_update