func main() {
	// STARTINIT OMIT
	me := "http://10.0.0.1"
	peers := groupcache.NewHTTPPool(me)

	// Whenever peers change:
	peers.Set("http://10.0.0.1", "http://10.0.0.2", "http://10.0.0.3")
	// ENDINIT OMIT

	// STARTGROUP OMIT
	var thumbNails = groupcache.NewGroup("thumbnail", 64<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			fileName := key
			dest.SetBytes(generateThumbnail(fileName))
			return nil
		}))
	// ENDGROUP OMIT

	var ctx groupcache.Context
	var w http.ResponseWriter
	var r *http.Request

	// STARTUSE OMIT
	var data []byte
	err := thumbNails.Get(ctx, "big-file.jpg",
		groupcache.AllocatingByteSliceSink(&data))
	// ...
	_ = err               // OMIT
	var modTime time.Time // OMIT
	http.ServeContent(w, r, "big-file-thumb.jpg", modTime, bytes.NewReader(data))
	// ENDUSE OMIT
}

func main() {
	flag.Parse()

	peers := gc.NewHTTPPool("http://localhost:" + *port)
	peers.Set("http://localhost:8001", "http://localhost:8002")

	cg = gc.NewGroup("QRCache", 1<<20, gc.GetterFunc(
		func(ctx gc.Context, key string, dest gc.Sink) error {
			fmt.Printf("asking for data of %s\n", key)
			url := fmt.Sprintf("http://chart.apis.google.com/chart?chs=300x300&cht=qr&choe=UTF-8&chl=%s", key)
			resp, err := http.Get(url)
			if err != nil {
				return nil
			}
			body, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				return nil
			}
			value := base64.StdEncoding.EncodeToString(body)
			dest.SetBytes([]byte(value))
			return nil
		}))

	// run groupcache process in goroutine
	go http.ListenAndServe("localhost:"+*port, peers)

	http.Handle("/", http.HandlerFunc(QR))
	err := http.ListenAndServe(*addr, nil)
	if err != nil {
		log.Fatal("ListenAndServe:", err)
	}
}

func main() {
	flag.Parse()

	// Setup the doozer connection.
	d, err := doozer.Dial(daddr)
	if err != nil {
		log.Fatalf("connecting to doozer: %v\n", err)
	}
	defer d.Close()

	// Setup the cache.
	pool = groupcache.NewHTTPPool("http://" + addr)
	dict = groupcache.NewGroup("dict", 64<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			def, err := query(key)
			if err != nil {
				err = fmt.Errorf("querying remote dictionary: %v", err)
				log.Println(err)
				return err
			}

			log.Println("retrieved remote definition for", key)
			dest.SetString(def)
			return nil
		}))

	// Start watching for changes and signals.
	go watch(d)

	// Add the handler for definition requests and then start the
	// server.
	http.Handle("/define/", http.HandlerFunc(handler))
	log.Println(http.ListenAndServe(addr, nil))
}

func main() {
	me := ":" + os.Args[1]
	peers := groupcache.NewHTTPPool("http://localhost" + me)
	peers.Set("http://localhost:8081", "http://localhost:8082",
		"http://localhost:8083")
	helloworld := groupcache.NewGroup("helloworld",
		1024*1024*10, groupcache.GetterFunc(
			func(ctx groupcache.Context,
				key string,
				dest groupcache.Sink) error {
				log.Println(me)
				dest.SetString(me + "->" + key)
				return nil
			}))
	fmt.Println("GroupName: ", helloworld.Name())
	http.HandleFunc("/xbox/", func(w http.ResponseWriter, r *http.Request) {
		parts := strings.SplitN(r.URL.Path[len("/xbox/"):], "/", 1)
		for _, x := range parts {
			fmt.Println("get: ", x)
		}
		if len(parts) != 1 {
			http.Error(w, "Bad Request", http.StatusBadRequest)
			return
		}
		var data []byte
		helloworld.Get(nil, parts[0], groupcache.AllocatingByteSliceSink(&data))
		w.Write(data)
		log.Println("Gets: ", helloworld.Stats.Gets.String())
		log.Println("Load: ", helloworld.Stats.Loads.String())
		log.Println("LocalLoad: ", helloworld.Stats.LocalLoads.String())
		log.Println("PeerError: ", helloworld.Stats.PeerErrors.String())
		log.Println("PeerLoad: ", helloworld.Stats.PeerLoads.String())
	})
	http.ListenAndServe(me, nil)
}

func Pool(ec2conn *ec2.EC2) *EC2CachePool {
	localip := getLocalIP(ec2conn)

	peers := &EC2CachePool{
		groupcache.NewHTTPPool(fmt.Sprintf("http://%s:%s", localip, *cacheport)),
		ec2conn,
	}

	peerAddrs, err := peers.discoverPeers()
	if err != nil {
		log.Fatal("discovery:", err)
	}

	log.Println("Alerting peers:", peerAddrs)

	// Inform each peer that they should also discover peers
	for _, peer := range peerAddrs {
		client, err := rpc.DialHTTP("tcp", fmt.Sprintf("%s:%s", peer, *rpcport))
		if err != nil {
			log.Println("error dialing:", err)
			continue
		}

		var reply int
		err = client.Call("EC2CachePool.RefreshPeers", new(Args), &reply)
		if err != nil {
			log.Fatal("refresh rpc failure:", err)
		}

		log.Println("Refreshed peers on:", peer)
	}

	return peers
}

func main() {
	// STARTINIT OMIT
	me := "http://127.0.0.1:11211"
	peers := groupcache.NewHTTPPool(me)

	// Whenever peers change:
	peers.Set("http://127.0.0.1:11211")
	// ENDINIT OMIT

	// STARTGROUP OMIT
	var thumbNails = groupcache.NewGroup("thumbnail", 64<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			dest.SetBytes(generateThumbnail(key))
			return nil
		}))
	// ENDGROUP OMIT

	var ctx groupcache.Context

	// STARTUSE OMIT
	var data []byte
	thumbNails.Get(ctx, "big-file.jpg", groupcache.AllocatingByteSliceSink(&data))

	fmt.Println(string(data))
}

func DebugPool() *DebugCachePool {
	peers := &DebugCachePool{
		groupcache.NewHTTPPool("http://localhost:9001"),
	}

	peers.Set("http://localhost:9001")

	return peers
}

func setupGroupcache(config GroupcacheConfig) error {
	if config.GB == 0 {
		return nil
	}
	var cacheBytes int64
	cacheBytes = int64(config.GB) << 30

	pool := groupcache.NewHTTPPool(config.Host)
	if pool != nil {
		dvid.Infof("Initializing groupcache with %d GB at %s...\n", config.GB, config.Host)
		manager.gcache.cache = groupcache.NewGroup("immutable", cacheBytes, groupcache.GetterFunc(
			func(c groupcache.Context, key string, dest groupcache.Sink) error {
				// Use KeyValueDB defined as context.
				gctx, ok := c.(GroupcacheCtx)
				if !ok {
					return fmt.Errorf("bad groupcache context: expected GroupcacheCtx, got %v", c)
				}

				// First four bytes of key is instance ID to isolate groupcache collisions.
				tk := TKey(key[4:])
				data, err := gctx.KeyValueDB.Get(gctx.Context, tk)
				if err != nil {
					return err
				}
				return dest.SetBytes(data)
			}))
		manager.gcache.supported = make(map[dvid.DataSpecifier]struct{})
		for _, dataspec := range config.Instances {
			name := strings.Trim(dataspec, "\"")
			parts := strings.Split(name, ":")
			switch len(parts) {
			case 2:
				dataid := dvid.GetDataSpecifier(dvid.InstanceName(parts[0]), dvid.UUID(parts[1]))
				manager.gcache.supported[dataid] = struct{}{}
			default:
				dvid.Errorf("bad data instance specification %q given for groupcache support in config file\n", dataspec)
			}
		}

		// If we have additional peers, add them and start a listener via the HTTP port.
		if len(config.Peers) > 0 {
			peers := []string{config.Host}
			peers = append(peers, config.Peers...)
			pool.Set(peers...)
			dvid.Infof("Groupcache configuration has %d peers in addition to local host.\n", len(config.Peers))
			dvid.Infof("Starting groupcache HTTP server on %s\n", config.Host)
			http.ListenAndServe(config.Host, http.HandlerFunc(pool.ServeHTTP))
		}
	}
	return nil
}

func main() {
	var err error
	p = groupcache.NewHTTPPool("http://127.0.0.1:50000")
	// update p's list
	p.Set("http://127.0.0.1:50001", "http://127.0.0.1:50002")

	// create a new group by name and set a function for get a value by key
	// if you g.Get KEY at first time, it will store the value use sink, run the function
	// if you g.Get KEY not at first time, actually it NOT entry the function
	// does not support update a key's value
	g = groupcache.NewGroup("dns", 64<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) (err error) {
			if ctx == nil {
				ctx = "fuck"
			}
			log.Println(key, ctx)
			err = dest.SetString(ctx.(string))
			return
		}))

	// let it listen
	go http.ListenAndServe("127.0.0.1:50000", nil)

	// get a key's value into data

	time.Sleep(2 * time.Second)
	var data []byte
	var key = "key"
	err = g.Get("aa", key, groupcache.AllocatingByteSliceSink(&data))
	if err != nil {
		log.Println("get error:", err)
	}
	log.Println(string(data))

	time.Sleep(2 * time.Second)
	key = "key1"
	err = g.Get("bb", key, groupcache.AllocatingByteSliceSink(&data))
	if err != nil {
		log.Println("get error:", err)
	}
	log.Println(string(data))

	time.Sleep(2 * time.Second)
	key = "key"
	err = g.Get("cc", key, groupcache.AllocatingByteSliceSink(&data))
	if err != nil {
		log.Println("get error:", err)
	}
	log.Println(string(data))
}

func initGroupcacheHTTPPool() {
	self := (&url.URL{Scheme: "http", Host: flagHTTP}).String()
	var peers []string
	peers = append(peers, self)
	for _, p := range strings.Split(flagGroupcachePeers, ",") {
		if p == "" {
			continue
		}
		peer := (&url.URL{Scheme: "http", Host: p}).String()
		peers = append(peers, peer)
	}
	pool := groupcache.NewHTTPPool(self)
	pool.Context = imageserver_cache_groupcache.HTTPPoolContext
	pool.Transport = imageserver_cache_groupcache.NewHTTPPoolTransport(nil)
	pool.Set(peers...)
}

func start() {
	pool = groupcache.NewHTTPPool("http://" + addr)

	dns = groupcache.NewGroup("dns", 64<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			// Lookup the adddress based on the hostname (key).
			addrs, err := net.LookupHost(key)
			if err != nil {
				return err
			}

			// We'll just store the first.
			dest.SetString(addrs[0])
			return nil
		}))

	// Run in the background so we can use the console.
	go http.ListenAndServe(addr, nil)
}

func initCacheGroup() {
	self := config.Get().CacheSelf()

	pool := groupcache.NewHTTPPool(self)
	pool.Set(config.Get().CachePeers()...)

	if self != "" {
		log.Println("Cache listen on:", strings.TrimLeft(self, "http://"))
		go http.ListenAndServe(strings.TrimLeft(self, "http://"), http.HandlerFunc(pool.ServeHTTP))
	}

	cacheGroup = groupcache.NewGroup("imagio-storage", config.Get().CacheSize(), groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			dest.SetBytes(imgproc.Do(
				Construct(new(query.Options), key).(*query.Options),
			))
			return nil
		}),
	)
}

func main() {

	flag.Set("logtostderr", "true")
	flag.Parse()

	me := ":8080"
	peers := groupcache.NewHTTPPool("http://localhost" + me)
	peers.Set("http://localhost:8081", "http://localhost:8082", "http://localhost:8083")

	helloworld := groupcache.NewGroup("helloworld", 1024*1024*1024*16, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			glog.Infof("%v, key = %v", me, key)
			dest.SetString(key)
			return nil
		}))

	glog.Infof("GroupName: %v", helloworld.Name())
	http.HandleFunc("/xbox/",
		func(w http.ResponseWriter, r *http.Request) {
			parts := strings.SplitN(r.URL.Path[len("/xbox/"):], "/", 1)
			glog.Infof("parts: %v", parts)
			if len(parts) != 1 {
				http.Error(w, "Bad Request", http.StatusBadRequest)
				return
			}

			var data []byte
			helloworld.Get(nil, parts[0], groupcache.AllocatingByteSliceSink(&data))
			w.Write(data)

			glog.Infof("data: %s", data)
			glog.Infof("Stats: %#v", helloworld.Stats)
			//glog.Infof("Gets: %v", helloworld.Stats.Gets.String())
			//glog.Infof("Load: %v", helloworld.Stats.Loads.String())
			//glog.Infof("LocalLoad: %v", helloworld.Stats.LocalLoads.String())
			//glog.Infof("PeerError: %v", helloworld.Stats.PeerErrors.String())
			//glog.Infof("PeerLoad: %v", helloworld.Stats.PeerLoads.String())
		})

	http.ListenAndServe(me, nil)
}

func ServeDir(mountpoint string, target string, limit int, me string, peerlist []string) {

	peers := groupcache.NewHTTPPool(me)

	if peerlist != nil && len(peerlist) > 0 {
		peers.Set(peerlist...)
	}

	filecache = groupcache.NewGroup("filecache", int64(limit)<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			contents, err := ioutil.ReadFile(key)
			dest.SetBytes(contents)
			return err
		}))

	c, err := fuse.Mount(mountpoint)
	if err != nil {
		log.Fatal(err)
	}

	fs.Serve(c, TargetDir{target})

}

func main() {

	var port = flag.String("port", "8001", "groupcache port")
	flag.Parse()

	peers := groupcache.NewHTTPPool("http://localhost:" + *port)

	client := new(client.Client)

	var stringcache = groupcache.NewGroup("SlowDBCache", 64<<20, groupcache.GetterFunc(
		func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
			result := client.Get(key)
			fmt.Printf("asking for %s from dbserver\n", key)
			dest.SetBytes([]byte(result))
			return nil
		}))

	peers.Set("http://localhost:8001", "http://localhost:8002", "http://localhost:8003")

	frontendServer := NewServer(stringcache)

	i, err := strconv.Atoi(*port)
	if err != nil {
		// handle error
		fmt.Println(err)
		os.Exit(2)
	}
	var frontEndport = ":" + strconv.Itoa(i+1000)
	go frontendServer.Start(frontEndport)

	fmt.Println(stringcache)
	fmt.Println("cachegroup slave starting on " + *port)
	fmt.Println("frontend starting on " + frontEndport)
	http.ListenAndServe("127.0.0.1:"+*port, http.HandlerFunc(peers.ServeHTTP))

}

func main() {

	configUri := filters.LookupConfigStoreURI("main.json")
	filename := "main.json"
	config, err := NewConfig(configUri, filename)
	if err != nil {
		fmt.Printf("NewConfig(%#v) failed: %s", filename, err)
		return
	}

	pidfile := ""
	flag.StringVar(&pidfile, "pidfile", "", "goproxy pidfile")
	flag.StringVar(&config.Addr, "addr", config.Addr, "goproxy listen address")
	flag.StringVar(&config.GroupCache.Addr, "groupcache-addr", config.GroupCache.Addr, "groupcache listen address")
	if config.LogToStderr || runtime.GOOS == "windows" {
		logToStderr := true
		for i := 1; i < len(os.Args); i++ {
			if strings.HasPrefix(os.Args[i], "-logtostderr=") {
				logToStderr = false
				break
			}
		}
		if logToStderr {
			flag.Set("logtostderr", "true")
		}
	}
	flag.Parse()

	if runtime.GOOS != "windows" && pidfile != "" {
		if err = ioutil.WriteFile(pidfile, []byte(strconv.Itoa(os.Getpid())), 0644); err != nil {
			glog.Fatalf("Write pidfile(%s) error: %s", pidfile, err)
		}
	}

	var ln0 net.Listener
	if config.GroupCache.Addr != "" {
		peers := groupcache.NewHTTPPool("http://" + config.GroupCache.Addr)
		peers.Set(config.GroupCache.Peers...)
		ln0, err = net.Listen("tcp", config.GroupCache.Addr)
		if err != nil {
			glog.Fatalf("ListenTCP(%s) error: %s", config.GroupCache.Addr, err)
		}
		go http.Serve(ln0, peers)
	}

	fmt.Fprintf(os.Stderr, `------------------------------------------------------
GoProxy Version    : %s (go/%s %s/%s)
Listen Address     : %s
RoundTrip Filters  : %v
Pac Server         : http://%s/proxy.pac
------------------------------------------------------
`, Version, runtime.Version(), runtime.GOOS, runtime.GOARCH,
		config.Addr,
		strings.Join(config.Filters.RoundTrip, ","),
		config.Addr)

	requestFilters, roundtripFilters, responseFilters := getFilters(config)

	var tlsConfig *tls.Config
	if config.Http.Mode == "h2" {

		readPem := func(object string) []byte {
			store, err := storage.OpenURI(configUri)
			if err != nil {
				glog.Fatalf("store.OpenURI(%v) error: %s", configUri, err)
			}

			o, err := store.GetObject(object, -1, -1)
			if err != nil {
				glog.Fatalf("store.GetObject(%v) error: %s", object, err)
			}

			rc := o.Body()
			defer rc.Close()

			b, err := ioutil.ReadAll(rc)
			if err != nil {
				glog.Fatalf("ioutil.ReadAll error: %s", err)
			}
			return b
		}

		certPem := readPem(config.Http.Certificate)
		keyPem := readPem(config.Http.Certificate)
		tlsCert, err := tls.X509KeyPair(certPem, keyPem)
		if err != nil {
			glog.Fatalf("tls.X509KeyPair error: %s", err)
		}

		tlsConfig = &tls.Config{
			Certificates: []tls.Certificate{tlsCert},
		}
	}

	listenOpts := &httpproxy.ListenOptions{TLSConfig: tlsConfig}

	if strings.HasPrefix(config.Http.Mode, "h2") {
		// http2.VerboseLogs = true
		listenOpts.KeepAlivePeriod = 3 * time.Minute
	}
//.........这里部分代码省略.........

func (c *DimensionsCache) Start(listenUrl string) {
	peers := groupcache.NewHTTPPool(listenUrl)
	peers.Set(listenUrl)
	http.ListenAndServe("http://localhost:8001", http.HandlerFunc(peers.ServeHTTP))
}

func (g *GroupCacheProxy) MakeInitialPool(url string) PeerList {
	return groupcache.NewHTTPPool(url)
}

// LoadSentinelConfigFile loads the local config file pulled from the
// environment variable "REDSKULL_SENTINELCONFIGFILE"
func (c *Constellation) LoadSentinelConfigFile() error {
	file, err := os.Open(c.SentinelConfigName)
	if err != nil {
		log.Print(err)
		return err
	}
	defer file.Close()
	bf := bufio.NewReader(file)
	for {
		rawline, err := bf.ReadString('\n')
		if err == nil || err == io.EOF {
			line := strings.TrimSpace(rawline)
			// ignore comments
			if strings.Contains(line, "#") {
				continue
			}
			entries := strings.Split(line, " ")
			//Most values are key/value pairs
			switch entries[0] {
			case "sentinel": // Have a sentinel directive
				err := c.extractSentinelDirective(entries[1:])
				if err != nil {
					// TODO: Fix this to return a different error if we can't
					// connect to the sentinel
					log.Printf("Misshapen sentinel directive: '%s'", line)
				}
			case "port":
				iport, _ := strconv.Atoi(entries[1])
				c.SentinelConfig.Port = iport
				//log.Printf("Local sentinel is bound to port %d", c.SentinelConfig.Port)
			case "dir":
				c.SentinelConfig.Dir = entries[1]
			case "bind":
				if c.LocalOverrides.BindAddress > "" {
					log.Printf("Overriding Sentinel BIND directive '%s' with '%s'", entries[1], c.LocalOverrides.BindAddress)
				} else {
					c.SentinelConfig.Host = entries[1]
					if c.Peers == nil {
						me := "http://" + c.SentinelConfig.Host + ":" + GCPORT
						c.Peers = groupcache.NewHTTPPool(me)
						c.PeerList[c.SentinelConfig.Host+fmt.Sprintf(":%d", c.SentinelConfig.Port)] = c.SentinelConfig.Host
						c.SetPeers()
						go http.ListenAndServe(c.SentinelConfig.Host+":"+GCPORT, http.HandlerFunc(c.Peers.ServeHTTP))
						c.StartCache()
					}
				}
				log.Printf("Local sentinel is listening on IP %s", c.SentinelConfig.Host)
			case "":
				if err == io.EOF {
					log.Print("File load complete?")
					if c.LocalOverrides.BindAddress > "" {
						c.SentinelConfig.Host = c.LocalOverrides.BindAddress
						log.Printf("Local sentinel is listening on IP %s", c.SentinelConfig.Host)
					} else {
						if c.Peers == nil {
							// This means the sentinel config has no bind statement
							// So we will pull the local IP and use it
							// I don't like this but dont' have a great option either.
							myhostname, err := os.Hostname()
							if err != nil {
								log.Print(err)
							}
							myip, err := net.LookupHost(myhostname)
							if err != nil {
								log.Print(err)
							}
							c.LocalSentinel.Host = myip[0]
							log.Printf("NO BIND STATEMENT FOUND. USING: '%s'", c.LocalSentinel.Host)
							me := "http://" + c.SentinelConfig.Host + ":" + GCPORT
							c.Peers = groupcache.NewHTTPPool(me)
							c.PeerList[c.SentinelConfig.Host+fmt.Sprintf(":%d", c.SentinelConfig.Port)] = c.SentinelConfig.Host
							c.SetPeers()
							go http.ListenAndServe(c.SentinelConfig.Host+":"+GCPORT, http.HandlerFunc(c.Peers.ServeHTTP))
							c.StartCache()
						}
					}
					return nil
				}
				//log.Printf("Local:config -> %+v", c.SentinelConfig)
				//log.Printf("Found %d REMOTE sentinels", len(c.RemoteSentinels))
				//return nil
			default:
				log.Printf("UNhandled Sentinel Directive: %s", line)
			}
		} else {
			log.Print("=============== LOAD FILE ERROR ===============")
			log.Fatal(err)
		}
	}
}

// extractSentinelDirective parses the sentinel directives from the
// sentinel config file
func (c *Constellation) extractSentinelDirective(entries []string) error {
	switch entries[0] {
	case "monitor":
		pname := entries[1]
		port, _ := strconv.Atoi(entries[3])
		quorum, _ := strconv.Atoi(entries[4])
		spc := SentinelPodConfig{Name: pname, IP: entries[2], Port: port, Quorum: quorum}
		spc.Sentinels = make(map[string]string)
		// normally we should not see duplicate IP:PORT combos, however it
		// can happen when people do things manually and dont' clean up.
		// We need to detect them and ignore the second one if found,
		// reporting the error condition this will require tracking
		// ip:port pairs...
		addr := fmt.Sprintf("%s:%d", entries[2], port)
		_, exists := c.SentinelConfig.ManagedPodConfigs[addr]
		if !exists {
			c.SentinelConfig.ManagedPodConfigs[entries[1]] = spc
		}
		return nil

	case "auth-pass":
		pname := entries[1]
		pc := c.SentinelConfig.ManagedPodConfigs[pname]
		pc.AuthToken = entries[2]
		c.PodAuthMap[pname] = pc.AuthToken
		c.SentinelConfig.ManagedPodConfigs[pname] = pc
		return nil

	case "known-sentinel":
		podname := entries[1]
		sentinel_address := entries[2] + ":" + entries[3]
		pc := c.SentinelConfig.ManagedPodConfigs[podname]
		pc.Sentinels[sentinel_address] = ""
		if c.Peers == nil {
			// This means the sentinel config has no bind statement
			// So we will pull the local IP and use it
			// I don't like this but dont' have a great option either.
			myhostname, err := os.Hostname()
			if err != nil {
				log.Print(err)
			}
			myip, err := net.LookupHost(myhostname)
			if err != nil {
				log.Print(err)
			}
			c.LocalSentinel.Host = myip[0]
			log.Printf("NO BIND STATEMENT FOUND. USING: '%s'", c.LocalSentinel.Host)
			me := "http://" + c.SentinelConfig.Host + ":" + GCPORT
			c.Peers = groupcache.NewHTTPPool(me)
			c.PeerList[c.SentinelConfig.Host+fmt.Sprintf(":%d", c.SentinelConfig.Port)] = c.SentinelConfig.Host
			c.SetPeers()
			go http.ListenAndServe(c.SentinelConfig.Host+":"+GCPORT, http.HandlerFunc(c.Peers.ServeHTTP))
			c.StartCache()
		}
		c.ConfiguredSentinels[sentinel_address] = sentinel_address
		return nil

	case "known-slave":
		// Currently ignoring this, but may add call to a node manager.
		return nil

	case "config-epoch", "leader-epoch", "current-epoch", "down-after-milliseconds":
		// We don't use these keys
		return nil

	default:
		err := fmt.Errorf("Unhandled sentinel directive: %+v", entries)
		log.Print(err)
		return nil
	}
}