rename the public exvar package to be expvar.
R=rsc
DELTA=684 (324 added, 324 deleted, 36 changed)
OCL=35161
CL=35163
diff --git a/src/pkg/expvar/Makefile b/src/pkg/expvar/Makefile
new file mode 100644
index 0000000..49e8de6
--- /dev/null
+++ b/src/pkg/expvar/Makefile
@@ -0,0 +1,11 @@
+# Copyright 2009 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.$(GOARCH)
+
+TARG=expvar
+GOFILES=\
+ expvar.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/src/pkg/expvar/expvar.go b/src/pkg/expvar/expvar.go
new file mode 100644
index 0000000..9d04a42
--- /dev/null
+++ b/src/pkg/expvar/expvar.go
@@ -0,0 +1,222 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The expvar package provides a standardized interface to public variables,
+// such as operation counters in servers. It exposes these variables via
+// HTTP at /debug/vars in JSON format.
+package expvar
+
+import (
+ "bytes";
+ "fmt";
+ "http";
+ "log";
+ "strconv";
+ "sync";
+)
+
+// Var is an abstract type for all exported variables.
+type Var interface {
+ String() string;
+}
+
+// Int is a 64-bit integer variable, and satisfies the Var interface.
+type Int struct {
+ i int64;
+ mu sync.Mutex;
+}
+
+func (v *Int) String() string {
+ return strconv.Itoa64(v.i)
+}
+
+func (v *Int) Add(delta int64) {
+ v.mu.Lock();
+ defer v.mu.Unlock();
+ v.i += delta;
+}
+
+// Map is a string-to-Var map variable, and satisfies the Var interface.
+type Map struct {
+ m map[string] Var;
+ mu sync.Mutex;
+}
+
+// KeyValue represents a single entry in a Map.
+type KeyValue struct {
+ Key string;
+ Value Var;
+}
+
+func (v *Map) String() string {
+ v.mu.Lock();
+ defer v.mu.Unlock();
+ b := new(bytes.Buffer);
+ fmt.Fprintf(b, "{");
+ first := true;
+ for key, val := range v.m {
+ if !first {
+ fmt.Fprintf(b, ", ");
+ }
+ fmt.Fprintf(b, "\"%s\": %v", key, val.String());
+ first = false;
+ }
+ fmt.Fprintf(b, "}");
+ return b.String()
+}
+
+func (v *Map) Init() *Map {
+ v.m = make(map[string] Var);
+ return v
+}
+
+func (v *Map) Get(key string) Var {
+ v.mu.Lock();
+ defer v.mu.Unlock();
+ if av, ok := v.m[key]; ok {
+ return av
+ }
+ return nil
+}
+
+func (v *Map) Set(key string, av Var) {
+ v.mu.Lock();
+ defer v.mu.Unlock();
+ v.m[key] = av;
+}
+
+func (v *Map) Add(key string, delta int64) {
+ v.mu.Lock();
+ defer v.mu.Unlock();
+ av, ok := v.m[key];
+ if !ok {
+ av = new(Int);
+ v.m[key] = av;
+ }
+
+ // Add to Int; ignore otherwise.
+ if iv, ok := av.(*Int); ok {
+ iv.Add(delta);
+ }
+}
+
+// TODO(rsc): Make sure map access in separate thread is safe.
+func (v *Map) iterate(c chan<- KeyValue) {
+ for k, v := range v.m {
+ c <- KeyValue{ k, v };
+ }
+ close(c);
+}
+
+func (v *Map) Iter() <-chan KeyValue {
+ c := make(chan KeyValue);
+ go v.iterate(c);
+ return c
+}
+
+// String is a string variable, and satisfies the Var interface.
+type String struct {
+ s string;
+}
+
+func (v *String) String() string {
+ return strconv.Quote(v.s)
+}
+
+func (v *String) Set(value string) {
+ v.s = value;
+}
+
+// IntFunc wraps a func() int64 to create a value that satisfies the Var interface.
+// The function will be called each time the Var is evaluated.
+type IntFunc func() int64;
+
+func (v IntFunc) String() string {
+ return strconv.Itoa64(v())
+}
+
+
+// All published variables.
+var vars map[string] Var = make(map[string] Var);
+var mutex sync.Mutex;
+
+// Publish declares an named exported variable. This should be called from a
+// package's init function when it creates its Vars. If the name is already
+// registered then this will log.Crash.
+func Publish(name string, v Var) {
+ mutex.Lock();
+ defer mutex.Unlock();
+ if _, existing := vars[name]; existing {
+ log.Crash("Reuse of exported var name:", name);
+ }
+ vars[name] = v;
+}
+
+// Get retrieves a named exported variable.
+func Get(name string) Var {
+ if v, ok := vars[name]; ok {
+ return v
+ }
+ return nil
+}
+
+// RemoveAll removes all exported variables.
+// This is for tests; don't call this on a real server.
+func RemoveAll() {
+ mutex.Lock();
+ defer mutex.Unlock();
+ vars = make(map[string] Var);
+}
+
+// Convenience functions for creating new exported variables.
+
+func NewInt(name string) *Int {
+ v := new(Int);
+ Publish(name, v);
+ return v
+}
+
+func NewMap(name string) *Map {
+ v := new(Map).Init();
+ Publish(name, v);
+ return v
+}
+
+func NewString(name string) *String {
+ v := new(String);
+ Publish(name, v);
+ return v
+}
+
+// TODO(rsc): Make sure map access in separate thread is safe.
+func iterate(c chan<- KeyValue) {
+ for k, v := range vars {
+ c <- KeyValue{ k, v };
+ }
+ close(c);
+}
+
+func Iter() <-chan KeyValue {
+ c := make(chan KeyValue);
+ go iterate(c);
+ return c
+}
+
+func expvarHandler(c *http.Conn, req *http.Request) {
+ c.SetHeader("content-type", "application/json; charset=utf-8");
+ fmt.Fprintf(c, "{\n");
+ first := true;
+ for name, value := range vars {
+ if !first {
+ fmt.Fprintf(c, ",\n");
+ }
+ first = false;
+ fmt.Fprintf(c, " %q: %s", name, value);
+ }
+ fmt.Fprintf(c, "\n}\n");
+}
+
+func init() {
+ http.Handle("/debug/vars", http.HandlerFunc(expvarHandler));
+}
diff --git a/src/pkg/expvar/expvar_test.go b/src/pkg/expvar/expvar_test.go
new file mode 100644
index 0000000..1f3e3d6
--- /dev/null
+++ b/src/pkg/expvar/expvar_test.go
@@ -0,0 +1,91 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package expvar
+
+import (
+ "json";
+ "testing";
+)
+
+func TestInt(t *testing.T) {
+ reqs := NewInt("requests");
+ if reqs.i != 0 {
+ t.Errorf("reqs.i = %v, want 4", reqs.i)
+ }
+ if reqs != Get("requests").(*Int) {
+ t.Errorf("Get() failed.")
+ }
+
+ reqs.Add(1);
+ reqs.Add(3);
+ if reqs.i != 4 {
+ t.Errorf("reqs.i = %v, want 4", reqs.i)
+ }
+
+ if s := reqs.String(); s != "4" {
+ t.Errorf("reqs.String() = %q, want \"4\"", s);
+ }
+}
+
+func TestString(t *testing.T) {
+ name := NewString("my-name");
+ if name.s != "" {
+ t.Errorf("name.s = %q, want \"\"", name.s)
+ }
+
+ name.Set("Mike");
+ if name.s != "Mike" {
+ t.Errorf("name.s = %q, want \"Mike\"", name.s)
+ }
+
+ if s := name.String(); s != "\"Mike\"" {
+ t.Errorf("reqs.String() = %q, want \"\"Mike\"\"", s);
+ }
+}
+
+func TestMapCounter(t *testing.T) {
+ colours := NewMap("bike-shed-colours");
+
+ colours.Add("red", 1);
+ colours.Add("red", 2);
+ colours.Add("blue", 4);
+ if x := colours.m["red"].(*Int).i; x != 3 {
+ t.Errorf("colours.m[\"red\"] = %v, want 3", x)
+ }
+ if x := colours.m["blue"].(*Int).i; x != 4 {
+ t.Errorf("colours.m[\"blue\"] = %v, want 4", x)
+ }
+
+ // colours.String() should be '{"red":3, "blue":4}',
+ // though the order of red and blue could vary.
+ s := colours.String();
+ j, ok, errtok := json.StringToJson(s);
+ if !ok {
+ t.Errorf("colours.String() isn't valid JSON: %v", errtok)
+ }
+ if j.Kind() != json.MapKind {
+ t.Error("colours.String() didn't produce a map.")
+ }
+ red := j.Get("red");
+ if red.Kind() != json.NumberKind {
+ t.Error("red.Kind() is not a NumberKind.")
+ }
+ if x := red.Number(); x != 3 {
+ t.Error("red = %v, want 3", x)
+ }
+}
+
+func TestIntFunc(t *testing.T) {
+ x := int(4);
+ ix := IntFunc(func() int64 { return int64(x) });
+ if s := ix.String(); s != "4" {
+ t.Errorf("ix.String() = %v, want 4", s);
+ }
+
+ x++;
+ if s := ix.String(); s != "5" {
+ t.Errorf("ix.String() = %v, want 5", s);
+ }
+}
