@@ -81,6 +81,7 @@ type Container struct {

 	MountLabel, ProcessLabel string

 	AppArmorProfile          string

 	RestartCount             int

+	UpdateDns                bool

 	// Maps container paths to volume paths.  The key in this is the path to which

 	// the volume is being mounted inside the container.  Value is the path of the

@@ -942,6 +943,29 @@ func (container *Container) DisableLink(name string) {

 func (container *Container) setupContainerDns() error {

 	if container.ResolvConfPath != "" {

+		// check if this is an existing container that needs DNS update:

+		if container.UpdateDns {

+			// read the host's resolv.conf, get the hash and call updateResolvConf

+			log.Debugf("Check container (%s) for update to resolv.conf - UpdateDns flag was set", container.ID)

+			latestResolvConf, latestHash := resolvconf.GetLastModified()

+

+			// because the new host resolv.conf might have localhost nameservers..

+			updatedResolvConf, modified := resolvconf.RemoveReplaceLocalDns(latestResolvConf)

+			if modified {

+				// changes have occurred during resolv.conf localhost cleanup: generate an updated hash

+				newHash, err := utils.HashData(bytes.NewReader(updatedResolvConf))

+				if err != nil {

+					return err

+				}

+				latestHash = newHash

+			}

+

+			if err := container.updateResolvConf(updatedResolvConf, latestHash); err != nil {

+				return err

+			}

+			// successful update of the restarting container; set the flag off

+			container.UpdateDns = false

+		}

 		return nil

 	}

@@ -980,17 +1004,86 @@ func (container *Container) setupContainerDns() error {

 		}

 		// replace any localhost/127.* nameservers

-		resolvConf = utils.RemoveLocalDns(resolvConf)

-		// if the resulting resolvConf is empty, use DefaultDns

-		if !bytes.Contains(resolvConf, []byte("nameserver")) {

-			log.Infof("No non localhost DNS resolver found in resolv.conf and containers can't use it. Using default external servers : %v", DefaultDns)

-			// prefix the default dns options with nameserver

-			resolvConf = append(resolvConf, []byte("\nnameserver "+strings.Join(DefaultDns, "\nnameserver "))...)

-		}

+		resolvConf, _ = resolvconf.RemoveReplaceLocalDns(resolvConf)

+	}

+	//get a sha256 hash of the resolv conf at this point so we can check

+	//for changes when the host resolv.conf changes (e.g. network update)

+	resolvHash, err := utils.HashData(bytes.NewReader(resolvConf))

+	if err != nil {

+		return err

+	}

+	resolvHashFile := container.ResolvConfPath + ".hash"

+	if err = ioutil.WriteFile(resolvHashFile, []byte(resolvHash), 0644); err != nil {

+		return err

 	}

 	return ioutil.WriteFile(container.ResolvConfPath, resolvConf, 0644)

 }

+// called when the host's resolv.conf changes to check whether container's resolv.conf

+// is unchanged by the container "user" since container start: if unchanged, the

+// container's resolv.conf will be updated to match the host's new resolv.conf

+func (container *Container) updateResolvConf(updatedResolvConf []byte, newResolvHash string) error {

+

+	if container.ResolvConfPath == "" {

+		return nil

+	}

+	if container.Running {

+		//set a marker in the hostConfig to update on next start/restart

+		container.UpdateDns = true

+		return nil

+	}

+

+	resolvHashFile := container.ResolvConfPath + ".hash"

+

+	//read the container's current resolv.conf and compute the hash

+	resolvBytes, err := ioutil.ReadFile(container.ResolvConfPath)

+	if err != nil {

+		return err

+	}

+	curHash, err := utils.HashData(bytes.NewReader(resolvBytes))

+	if err != nil {

+		return err

+	}

+

+	//read the hash from the last time we wrote resolv.conf in the container

+	hashBytes, err := ioutil.ReadFile(resolvHashFile)

+	if err != nil {

+		return err

+	}

+

+	//if the user has not modified the resolv.conf of the container since we wrote it last

+	//we will replace it with the updated resolv.conf from the host

+	if string(hashBytes) == curHash {

+		log.Debugf("replacing %q with updated host resolv.conf", container.ResolvConfPath)

+

+		// for atomic updates to these files, use temporary files with os.Rename:

+		dir := path.Dir(container.ResolvConfPath)

+		tmpHashFile, err := ioutil.TempFile(dir, "hash")

+		if err != nil {

+			return err

+		}

+		tmpResolvFile, err := ioutil.TempFile(dir, "resolv")

+		if err != nil {

+			return err

+		}

+

+		// write the updates to the temp files

+		if err = ioutil.WriteFile(tmpHashFile.Name(), []byte(newResolvHash), 0644); err != nil {

+			return err

+		}

+		if err = ioutil.WriteFile(tmpResolvFile.Name(), updatedResolvConf, 0644); err != nil {

+			return err

+		}

+

+		// rename the temp files for atomic replace

+		if err = os.Rename(tmpHashFile.Name(), resolvHashFile); err != nil {

+			return err

+		}

+		return os.Rename(tmpResolvFile.Name(), container.ResolvConfPath)

+	}

+	return nil

+}

+

 func (container *Container) updateParentsHosts() error {

 	parents, err := container.daemon.Parents(container.Name)

 	if err != nil {

@@ -1,6 +1,7 @@

 package daemon

 import (

+	"bytes"

 	"fmt"

 	"io"

 	"io/ioutil"

@@ -32,6 +33,7 @@ import (

 	"github.com/docker/docker/pkg/graphdb"

 	"github.com/docker/docker/pkg/ioutils"

 	"github.com/docker/docker/pkg/namesgenerator"

+	"github.com/docker/docker/pkg/networkfs/resolvconf"

 	"github.com/docker/docker/pkg/parsers"

 	"github.com/docker/docker/pkg/parsers/kernel"

 	"github.com/docker/docker/pkg/sysinfo"

@@ -40,10 +42,11 @@ import (

 	"github.com/docker/docker/trust"

 	"github.com/docker/docker/utils"

 	"github.com/docker/docker/volumes"

+

+	"github.com/go-fsnotify/fsnotify"

 )

 var (

-	DefaultDns                = []string{"8.8.8.8", "8.8.4.4"}

 	validContainerNameChars   = `[a-zA-Z0-9][a-zA-Z0-9_.-]`

 	validContainerNamePattern = regexp.MustCompile(`^/?` + validContainerNameChars + `+$`)

 )

@@ -408,6 +411,60 @@ func (daemon *Daemon) restore() error {

 	return nil

 }

+// set up the watch on the host's /etc/resolv.conf so that we can update container's

+// live resolv.conf when the network changes on the host

+func (daemon *Daemon) setupResolvconfWatcher() error {

+

+	watcher, err := fsnotify.NewWatcher()

+	if err != nil {

+		return err

+	}

+

+	//this goroutine listens for the events on the watch we add

+	//on the resolv.conf file on the host

+	go func() {

+		for {

+			select {

+			case event := <-watcher.Events:

+				if event.Op&fsnotify.Write == fsnotify.Write {

+					// verify a real change happened before we go further--a file write may have happened

+					// without an actual change to the file

+					updatedResolvConf, newResolvConfHash, err := resolvconf.GetIfChanged()

+					if err != nil {

+						log.Debugf("Error retrieving updated host resolv.conf: %v", err)

+					} else if updatedResolvConf != nil {

+						// because the new host resolv.conf might have localhost nameservers..

+						updatedResolvConf, modified := resolvconf.RemoveReplaceLocalDns(updatedResolvConf)

+						if modified {

+							// changes have occurred during localhost cleanup: generate an updated hash

+							newHash, err := utils.HashData(bytes.NewReader(updatedResolvConf))

+							if err != nil {

+								log.Debugf("Error generating hash of new resolv.conf: %v", err)

+							} else {

+								newResolvConfHash = newHash

+							}

+						}

+						log.Debugf("host network resolv.conf changed--walking container list for updates")

+						contList := daemon.containers.List()

+						for _, container := range contList {

+							if err := container.updateResolvConf(updatedResolvConf, newResolvConfHash); err != nil {

+								log.Debugf("Error on resolv.conf update check for container ID: %s: %v", container.ID, err)

+							}

+						}

+					}

+				}

+			case err := <-watcher.Errors:

+				log.Debugf("host resolv.conf notify error: %v", err)

+			}

+		}

+	}()

+

+	if err := watcher.Add("/etc/resolv.conf"); err != nil {

+		return err

+	}

+	return nil

+}

+

 func (daemon *Daemon) checkDeprecatedExpose(config *runconfig.Config) bool {

 	if config != nil {

 		if config.PortSpecs != nil {

@@ -930,6 +987,12 @@ func NewDaemonFromDirectory(config *Config, eng *engine.Engine) (*Daemon, error)

 	if err := daemon.restore(); err != nil {

 		return nil, err

 	}

+

+	// set up filesystem watch on resolv.conf for network changes

+	if err := daemon.setupResolvconfWatcher(); err != nil {

+		return nil, err

+	}

+

 	// Setup shutdown handlers

 	// FIXME: can these shutdown handlers be registered closer to their source?

 	eng.OnShutdown(func() {

@@ -24,34 +24,3 @@ func TestMergeLxcConfig(t *testing.T) {

 		t.Fatalf("expected %s got %s", expected, cpuset)

 	}

 }

-

-func TestRemoveLocalDns(t *testing.T) {

-	ns0 := "nameserver 10.16.60.14\nnameserver 10.16.60.21\n"

-

-	if result := utils.RemoveLocalDns([]byte(ns0)); result != nil {

-		if ns0 != string(result) {

-			t.Fatalf("Failed No Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

-		}

-	}

-

-	ns1 := "nameserver 10.16.60.14\nnameserver 10.16.60.21\nnameserver 127.0.0.1\n"

-	if result := utils.RemoveLocalDns([]byte(ns1)); result != nil {

-		if ns0 != string(result) {

-			t.Fatalf("Failed Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

-		}

-	}

-

-	ns1 = "nameserver 10.16.60.14\nnameserver 127.0.0.1\nnameserver 10.16.60.21\n"

-	if result := utils.RemoveLocalDns([]byte(ns1)); result != nil {

-		if ns0 != string(result) {

-			t.Fatalf("Failed Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

-		}

-	}

-

-	ns1 = "nameserver 127.0.1.1\nnameserver 10.16.60.14\nnameserver 10.16.60.21\n"

-	if result := utils.RemoveLocalDns([]byte(ns1)); result != nil {

-		if ns0 != string(result) {

-			t.Fatalf("Failed Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

-		}

-	}

-}

@@ -130,7 +130,7 @@ information.  You can see this by running `mount` inside a container:

     ...

     /dev/disk/by-uuid/1fec...ebdf on /etc/hostname type ext4 ...

     /dev/disk/by-uuid/1fec...ebdf on /etc/hosts type ext4 ...

-    tmpfs on /etc/resolv.conf type tmpfs ...

+    /dev/disk/by-uuid/1fec...ebdf on /etc/resolv.conf type ext4 ...

     ...

 This arrangement allows Docker to do clever things like keep

@@ -178,7 +178,20 @@ Four different options affect container domain name services.

 Note that Docker, in the absence of either of the last two options

 above, will make `/etc/resolv.conf` inside of each container look like

 the `/etc/resolv.conf` of the host machine where the `docker` daemon is

-running.  The options then modify this default configuration.

+running.  You might wonder what happens when the host machine's

+`/etc/resolv.conf` file changes.  The `docker` daemon has a file change

+notifier active which will watch for changes to the host DNS configuration.

+When the host file changes, all stopped containers which have a matching

+`resolv.conf` to the host will be updated immediately to this newest host

+configuration.  Containers which are running when the host configuration

+changes will need to stop and start to pick up the host changes due to lack

+of a facility to ensure atomic writes of the `resolv.conf` file while the

+container is running. If the container's `resolv.conf` has been edited since

+it was started with the default configuration, no replacement will be

+attempted as it would overwrite the changes performed by the container.

+If the options (`--dns` or `--dns-search`) have been used to modify the 

+default host configuration, then the replacement with an updated host's

+`/etc/resolv.conf` will not happen as well.

 ## Communication between containers and the wider world

@@ -1403,6 +1403,157 @@ func TestRunDnsOptionsBasedOnHostResolvConf(t *testing.T) {

 	logDone("run - dns options based on host resolv.conf")

 }

+// Test the file watch notifier on docker host's /etc/resolv.conf

+// A go-routine is responsible for auto-updating containers which are

+// stopped and have an unmodified copy of resolv.conf, as well as

+// marking running containers as requiring an update on next restart

+func TestRunResolvconfUpdater(t *testing.T) {

+

+	tmpResolvConf := []byte("search pommesfrites.fr\nnameserver 12.34.56.78")

+	tmpLocalhostResolvConf := []byte("nameserver 127.0.0.1")

+

+	//take a copy of resolv.conf for restoring after test completes

+	resolvConfSystem, err := ioutil.ReadFile("/etc/resolv.conf")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	//cleanup

+	defer func() {

+		deleteAllContainers()

+		if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil {

+			t.Fatal(err)

+		}

+	}()

+

+	//1. test that a non-running container gets an updated resolv.conf

+	cmd := exec.Command(dockerBinary, "run", "--name='first'", "busybox", "true")

+	if _, err := runCommand(cmd); err != nil {

+		t.Fatal(err)

+	}

+	containerID1, err := getIDByName("first")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	// replace resolv.conf with our temporary copy

+	bytesResolvConf := []byte(tmpResolvConf)

+	if err := ioutil.WriteFile("/etc/resolv.conf", bytesResolvConf, 0644); err != nil {

+		t.Fatal(err)

+	}

+

+	time.Sleep(time.Second / 2)

+	// check for update in container

+	containerResolv, err := readContainerFile(containerID1, "resolv.conf")

+	if err != nil {

+		t.Fatal(err)

+	}

+	if !bytes.Equal(containerResolv, bytesResolvConf) {

+		t.Fatalf("Stopped container does not have updated resolv.conf; expected %q, got %q", tmpResolvConf, string(containerResolv))

+	}

+

+	//2. test that a non-running container does not receive resolv.conf updates

+	//   if it modified the container copy of the starting point resolv.conf

+	cmd = exec.Command(dockerBinary, "run", "--name='second'", "busybox", "sh", "-c", "echo 'search mylittlepony.com' >>/etc/resolv.conf")

+	if _, err = runCommand(cmd); err != nil {

+		t.Fatal(err)

+	}

+	containerID2, err := getIDByName("second")

+	if err != nil {

+		t.Fatal(err)

+	}

+	containerResolvHashBefore, err := readContainerFile(containerID2, "resolv.conf.hash")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	//make a change to resolv.conf (in this case replacing our tmp copy with orig copy)

+	if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil {

+		t.Fatal(err)

+	}

+

+	time.Sleep(time.Second / 2)

+	containerResolvHashAfter, err := readContainerFile(containerID2, "resolv.conf.hash")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	if !bytes.Equal(containerResolvHashBefore, containerResolvHashAfter) {

+		t.Fatalf("Stopped container with modified resolv.conf should not have been updated; expected hash: %v, new hash: %v", containerResolvHashBefore, containerResolvHashAfter)

+	}

+

+	//3. test that a running container's resolv.conf is not modified while running

+	cmd = exec.Command(dockerBinary, "run", "-d", "busybox", "top")

+	out, _, err := runCommandWithOutput(cmd)

+	if err != nil {

+		t.Fatal(err)

+	}

+	runningContainerID := strings.TrimSpace(out)

+

+	containerResolvHashBefore, err = readContainerFile(runningContainerID, "resolv.conf.hash")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	// replace resolv.conf

+	if err := ioutil.WriteFile("/etc/resolv.conf", bytesResolvConf, 0644); err != nil {

+		t.Fatal(err)

+	}

+

+	// make sure the updater has time to run to validate we really aren't

+	// getting updated

+	time.Sleep(time.Second / 2)

+	containerResolvHashAfter, err = readContainerFile(runningContainerID, "resolv.conf.hash")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	if !bytes.Equal(containerResolvHashBefore, containerResolvHashAfter) {

+		t.Fatalf("Running container's resolv.conf should not be updated; expected hash: %v, new hash: %v", containerResolvHashBefore, containerResolvHashAfter)

+	}

+

+	//4. test that a running container's resolv.conf is updated upon restart

+	//   (the above container is still running..)

+	cmd = exec.Command(dockerBinary, "restart", runningContainerID)

+	if _, err = runCommand(cmd); err != nil {

+		t.Fatal(err)

+	}

+

+	// check for update in container

+	containerResolv, err = readContainerFile(runningContainerID, "resolv.conf")

+	if err != nil {

+		t.Fatal(err)

+	}

+	if !bytes.Equal(containerResolv, bytesResolvConf) {

+		t.Fatalf("Restarted container should have updated resolv.conf; expected %q, got %q", tmpResolvConf, string(containerResolv))

+	}

+

+	//5. test that additions of a localhost resolver are cleaned from

+	//   host resolv.conf before updating container's resolv.conf copies

+

+	// replace resolv.conf with a localhost-only nameserver copy

+	bytesResolvConf = []byte(tmpLocalhostResolvConf)

+	if err = ioutil.WriteFile("/etc/resolv.conf", bytesResolvConf, 0644); err != nil {

+		t.Fatal(err)

+	}

+

+	time.Sleep(time.Second / 2)

+	// our first exited container ID should have been updated, but with default DNS

+	// after the cleanup of resolv.conf found only a localhost nameserver:

+	containerResolv, err = readContainerFile(containerID1, "resolv.conf")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	expected := "\nnameserver 8.8.8.8\nnameserver 8.8.4.4"

+	if !bytes.Equal(containerResolv, []byte(expected)) {

+		t.Fatalf("Container does not have cleaned/replaced DNS in resolv.conf; expected %q, got %q", expected, string(containerResolv))

+	}

+

+	//cleanup, restore original resolv.conf happens in defer func()

+	logDone("run - resolv.conf updater")

+}

+

 func TestRunAddHost(t *testing.T) {

 	defer deleteAllContainers()

 	cmd := exec.Command(dockerBinary, "run", "--add-host=extra:86.75.30.9", "busybox", "grep", "extra", "/etc/hosts")

@@ -5,13 +5,25 @@ import (

 	"io/ioutil"

 	"regexp"

 	"strings"

+	"sync"

+

+	log "github.com/Sirupsen/logrus"

+	"github.com/docker/docker/utils"

 )

 var (

-	nsRegexp     = regexp.MustCompile(`^\s*nameserver\s*(([0-9]+\.){3}([0-9]+))\s*$`)

-	searchRegexp = regexp.MustCompile(`^\s*search\s*(([^\s]+\s*)*)$`)

+	defaultDns      = []string{"8.8.8.8", "8.8.4.4"}

+	localHostRegexp = regexp.MustCompile(`(?m)^nameserver 127[^\n]+\n*`)

+	nsRegexp        = regexp.MustCompile(`^\s*nameserver\s*(([0-9]+\.){3}([0-9]+))\s*$`)

+	searchRegexp    = regexp.MustCompile(`^\s*search\s*(([^\s]+\s*)*)$`)

 )

+var lastModified struct {

+	sync.Mutex

+	sha256   string

+	contents []byte

+}

+

 func Get() ([]byte, error) {

 	resolv, err := ioutil.ReadFile("/etc/resolv.conf")

 	if err != nil {

@@ -20,6 +32,57 @@ func Get() ([]byte, error) {

 	return resolv, nil

 }

+// Retrieves the host /etc/resolv.conf file, checks against the last hash

+// and, if modified since last check, returns the bytes and new hash.

+// This feature is used by the resolv.conf updater for containers

+func GetIfChanged() ([]byte, string, error) {

+	lastModified.Lock()

+	defer lastModified.Unlock()

+

+	resolv, err := ioutil.ReadFile("/etc/resolv.conf")

+	if err != nil {

+		return nil, "", err

+	}

+	newHash, err := utils.HashData(bytes.NewReader(resolv))

+	if err != nil {

+		return nil, "", err

+	}

+	if lastModified.sha256 != newHash {

+		lastModified.sha256 = newHash

+		lastModified.contents = resolv

+		return resolv, newHash, nil

+	}

+	// nothing changed, so return no data

+	return nil, "", nil

+}

+

+// retrieve the last used contents and hash of the host resolv.conf

+// Used by containers updating on restart

+func GetLastModified() ([]byte, string) {

+	lastModified.Lock()

+	defer lastModified.Unlock()

+

+	return lastModified.contents, lastModified.sha256

+}

+

+// RemoveReplaceLocalDns looks for localhost (127.*) entries in the provided

+// resolv.conf, removing local nameserver entries, and, if the resulting

+// cleaned config has no defined nameservers left, adds default DNS entries

+// It also returns a boolean to notify the caller if changes were made at all

+func RemoveReplaceLocalDns(resolvConf []byte) ([]byte, bool) {

+	changed := false

+	cleanedResolvConf := localHostRegexp.ReplaceAll(resolvConf, []byte{})

+	// if the resulting resolvConf is empty, use defaultDns

+	if !bytes.Contains(cleanedResolvConf, []byte("nameserver")) {

+		log.Infof("No non-localhost DNS nameservers are left in resolv.conf. Using default external servers : %v", defaultDns)

+		cleanedResolvConf = append(cleanedResolvConf, []byte("\nnameserver "+strings.Join(defaultDns, "\nnameserver "))...)

+	}

+	if !bytes.Equal(resolvConf, cleanedResolvConf) {

+		changed = true

+	}

+	return cleanedResolvConf, changed

+}

+

 // getLines parses input into lines and strips away comments.

 func getLines(input []byte, commentMarker []byte) [][]byte {

 	lines := bytes.Split(input, []byte("\n"))

@@ -156,3 +156,34 @@ func TestBuildWithZeroLengthDomainSearch(t *testing.T) {

 		t.Fatalf("Expected to not find '%s' got '%s'", notExpected, content)

 	}

 }

+

+func TestRemoveReplaceLocalDns(t *testing.T) {

+	ns0 := "nameserver 10.16.60.14\nnameserver 10.16.60.21\n"

+

+	if result, _ := RemoveReplaceLocalDns([]byte(ns0)); result != nil {

+		if ns0 != string(result) {

+			t.Fatalf("Failed No Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

+		}

+	}

+

+	ns1 := "nameserver 10.16.60.14\nnameserver 10.16.60.21\nnameserver 127.0.0.1\n"

+	if result, _ := RemoveReplaceLocalDns([]byte(ns1)); result != nil {

+		if ns0 != string(result) {

+			t.Fatalf("Failed Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

+		}

+	}

+

+	ns1 = "nameserver 10.16.60.14\nnameserver 127.0.0.1\nnameserver 10.16.60.21\n"

+	if result, _ := RemoveReplaceLocalDns([]byte(ns1)); result != nil {

+		if ns0 != string(result) {

+			t.Fatalf("Failed Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

+		}

+	}

+

+	ns1 = "nameserver 127.0.1.1\nnameserver 10.16.60.14\nnameserver 10.16.60.21\n"

+	if result, _ := RemoveReplaceLocalDns([]byte(ns1)); result != nil {

+		if ns0 != string(result) {

+			t.Fatalf("Failed Localhost: expected \n<%s> got \n<%s>", ns0, string(result))

+		}

+	}

+}

@@ -55,6 +55,8 @@ clone git github.com/docker/libtrust 230dfd18c232

 clone git github.com/Sirupsen/logrus v0.6.0

+clone git github.com/go-fsnotify/fsnotify v1.0.4

+

 # get Go tip's archive/tar, for xattr support and improved performance

 # TODO after Go 1.4 drops, bump our minimum supported version and drop this vendored dep

 if [ "$1" = '--go' ]; then

@@ -291,14 +291,6 @@ func NewHTTPRequestError(msg string, res *http.Response) error {

 	}

 }

-var localHostRx = regexp.MustCompile(`(?m)^nameserver 127[^\n]+\n*`)

-

-// RemoveLocalDns looks into the /etc/resolv.conf,

-// and removes any local nameserver entries.

-func RemoveLocalDns(resolvConf []byte) []byte {

-	return localHostRx.ReplaceAll(resolvConf, []byte{})

-}

-

 // An StatusError reports an unsuccessful exit by a command.

 type StatusError struct {

 	Status     string

new file mode 100644

@@ -0,0 +1,6 @@

+# Setup a Global .gitignore for OS and editor generated files:

+# https://help.github.com/articles/ignoring-files

+# git config --global core.excludesfile ~/.gitignore_global

+

+.vagrant

+*.sublime-project

new file mode 100644

@@ -0,0 +1,13 @@

+language: go

+

+go:

+  - 1.2

+  - tip

+

+# not yet https://github.com/travis-ci/travis-ci/issues/2318

+os:

+  - linux

+  - osx

+

+notifications:

+  email: false

new file mode 100644

@@ -0,0 +1,32 @@

+# Names should be added to this file as

+#	Name or Organization <email address>

+# The email address is not required for organizations.

+

+# You can update this list using the following command:

+#

+#   $ git shortlog -se | awk '{print $2 " " $3 " " $4}'

+

+# Please keep the list sorted.

+

+Adrien Bustany <adrien@bustany.org>

+Caleb Spare <cespare@gmail.com>

+Case Nelson <case@teammating.com>

+Chris Howey <howeyc@gmail.com> <chris@howey.me>

+Christoffer Buchholz <christoffer.buchholz@gmail.com>

+Dave Cheney <dave@cheney.net>

+Francisco Souza <f@souza.cc>

+Hari haran <hariharan.uno@gmail.com>

+John C Barstow

+Kelvin Fo <vmirage@gmail.com>

+Nathan Youngman <git@nathany.com>

+Paul Hammond <paul@paulhammond.org>

+Pursuit92 <JoshChase@techpursuit.net>

+Rob Figueiredo <robfig@gmail.com>

+Soge Zhang <zhssoge@gmail.com>

+Tilak Sharma <tilaks@google.com>

+Travis Cline <travis.cline@gmail.com>

+Tudor Golubenco <tudor.g@gmail.com>

+Yukang <moorekang@gmail.com>

+bronze1man <bronze1man@gmail.com>

+debrando <denis.brandolini@gmail.com>

+henrikedwards <henrik.edwards@gmail.com>

new file mode 100644

@@ -0,0 +1,237 @@

+# Changelog

+

+## v1.0.4 / 2014-09-07

+

+* kqueue: add dragonfly to the build tags.

+* Rename source code files, rearrange code so exported APIs are at the top.

+* Add done channel to example code. [#37](https://github.com/go-fsnotify/fsnotify/pull/37) (thanks @chenyukang)

+

+## v1.0.3 / 2014-08-19

+

+* [Fix] Windows MOVED_TO now translates to Create like on BSD and Linux. [#36](https://github.com/go-fsnotify/fsnotify/issues/36)

+

+## v1.0.2 / 2014-08-17

+

+* [Fix] Missing create events on OS X. [#14](https://github.com/go-fsnotify/fsnotify/issues/14) (thanks @zhsso)

+* [Fix] Make ./path and path equivalent. (thanks @zhsso)

+

+## v1.0.0 / 2014-08-15

+

+* [API] Remove AddWatch on Windows, use Add.

+* Improve documentation for exported identifiers. [#30](https://github.com/go-fsnotify/fsnotify/issues/30)

+* Minor updates based on feedback from golint.

+

+## dev / 2014-07-09

+

+* Moved to [github.com/go-fsnotify/fsnotify](https://github.com/go-fsnotify/fsnotify).

+* Use os.NewSyscallError instead of returning errno (thanks @hariharan-uno)

+ 

+## dev / 2014-07-04

+

+* kqueue: fix incorrect mutex used in Close()

+* Update example to demonstrate usage of Op.

+

+## dev / 2014-06-28

+

+* [API] Don't set the Write Op for attribute notifications [#4](https://github.com/go-fsnotify/fsnotify/issues/4)

+* Fix for String() method on Event (thanks Alex Brainman)

+* Don't build on Plan 9 or Solaris (thanks @4ad)

+

+## dev / 2014-06-21

+

+* Events channel of type Event rather than *Event.

+* [internal] use syscall constants directly for inotify and kqueue.

+* [internal] kqueue: rename events to kevents and fileEvent to event.

+

+## dev / 2014-06-19

+

+* Go 1.3+ required on Windows (uses syscall.ERROR_MORE_DATA internally).

+* [internal] remove cookie from Event struct (unused).

+* [internal] Event struct has the same definition across every OS.

+* [internal] remove internal watch and removeWatch methods.

+

+## dev / 2014-06-12

+

+* [API] Renamed Watch() to Add() and RemoveWatch() to Remove().

+* [API] Pluralized channel names: Events and Errors.

+* [API] Renamed FileEvent struct to Event.

+* [API] Op constants replace methods like IsCreate().

+

+## dev / 2014-06-12

+

+* Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98)

+

+## dev / 2014-05-23

+

+* [API] Remove current implementation of WatchFlags.

+    * current implementation doesn't take advantage of OS for efficiency

+    * provides little benefit over filtering events as they are received, but has  extra bookkeeping and mutexes

+    * no tests for the current implementation

+    * not fully implemented on Windows [#93](https://github.com/howeyc/fsnotify/issues/93#issuecomment-39285195)

+

+## v0.9.2 / 2014-08-17

+

+* [Backport] Fix missing create events on OS X. [#14](https://github.com/go-fsnotify/fsnotify/issues/14) (thanks @zhsso)

+

+## v0.9.1 / 2014-06-12

+

+* Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98)

+

+## v0.9.0 / 2014-01-17

+

+* IsAttrib() for events that only concern a file's metadata [#79][] (thanks @abustany)

+* [Fix] kqueue: fix deadlock [#77][] (thanks @cespare)

+* [NOTICE] Development has moved to `code.google.com/p/go.exp/fsnotify` in preparation for inclusion in the Go standard library.

+

+## v0.8.12 / 2013-11-13

+

+* [API] Remove FD_SET and friends from Linux adapter

+

+## v0.8.11 / 2013-11-02

+

+* [Doc] Add Changelog [#72][] (thanks @nathany)

+* [Doc] Spotlight and double modify events on OS X [#62][] (reported by @paulhammond)

+

+## v0.8.10 / 2013-10-19

+

+* [Fix] kqueue: remove file watches when parent directory is removed [#71][] (reported by @mdwhatcott)

+* [Fix] kqueue: race between Close and readEvents [#70][] (reported by @bernerdschaefer)

+* [Doc] specify OS-specific limits in README (thanks @debrando)

+

+## v0.8.9 / 2013-09-08

+

+* [Doc] Contributing (thanks @nathany)

+* [Doc] update package path in example code [#63][] (thanks @paulhammond)

+* [Doc] GoCI badge in README (Linux only) [#60][]

+* [Doc] Cross-platform testing with Vagrant  [#59][] (thanks @nathany)

+

+## v0.8.8 / 2013-06-17

+

+* [Fix] Windows: handle `ERROR_MORE_DATA` on Windows [#49][] (thanks @jbowtie)

+

+## v0.8.7 / 2013-06-03

+

+* [API] Make syscall flags internal

+* [Fix] inotify: ignore event changes

+* [Fix] race in symlink test [#45][] (reported by @srid)

+* [Fix] tests on Windows

+* lower case error messages

+

+## v0.8.6 / 2013-05-23

+

+* kqueue: Use EVT_ONLY flag on Darwin

+* [Doc] Update README with full example

+

+## v0.8.5 / 2013-05-09

+

+* [Fix] inotify: allow monitoring of "broken" symlinks (thanks @tsg)

+

+## v0.8.4 / 2013-04-07

+

+* [Fix] kqueue: watch all file events [#40][] (thanks @ChrisBuchholz)

+

+## v0.8.3 / 2013-03-13

+

+* [Fix] inoitfy/kqueue memory leak [#36][] (reported by @nbkolchin)

+* [Fix] kqueue: use fsnFlags for watching a directory [#33][] (reported by @nbkolchin)

+

+## v0.8.2 / 2013-02-07

+

+* [Doc] add Authors

+* [Fix] fix data races for map access [#29][] (thanks @fsouza)

+

+## v0.8.1 / 2013-01-09

+

+* [Fix] Windows path separators

+* [Doc] BSD License

+

+## v0.8.0 / 2012-11-09

+

+* kqueue: directory watching improvements (thanks @vmirage)

+* inotify: add `IN_MOVED_TO` [#25][] (requested by @cpisto)

+* [Fix] kqueue: deleting watched directory [#24][] (reported by @jakerr)

+

+## v0.7.4 / 2012-10-09

+

+* [Fix] inotify: fixes from https://codereview.appspot.com/5418045/ (ugorji)

+* [Fix] kqueue: preserve watch flags when watching for delete [#21][] (reported by @robfig)

+* [Fix] kqueue: watch the directory even if it isn't a new watch (thanks @robfig)

+* [Fix] kqueue: modify after recreation of file

+

+## v0.7.3 / 2012-09-27

+

+* [Fix] kqueue: watch with an existing folder inside the watched folder (thanks @vmirage)

+* [Fix] kqueue: no longer get duplicate CREATE events

+

+## v0.7.2 / 2012-09-01

+

+* kqueue: events for created directories

+

+## v0.7.1 / 2012-07-14

+

+* [Fix] for renaming files

+

+## v0.7.0 / 2012-07-02

+

+* [Feature] FSNotify flags

+* [Fix] inotify: Added file name back to event path

+

+## v0.6.0 / 2012-06-06

+

+* kqueue: watch files after directory created (thanks @tmc)

+

+## v0.5.1 / 2012-05-22

+

+* [Fix] inotify: remove all watches before Close()

+

+## v0.5.0 / 2012-05-03

+

+* [API] kqueue: return errors during watch instead of sending over channel

+* kqueue: match symlink behavior on Linux

+* inotify: add `DELETE_SELF` (requested by @taralx)

+* [Fix] kqueue: handle EINTR (reported by @robfig)

+* [Doc] Godoc example [#1][] (thanks @davecheney)

+

+## v0.4.0 / 2012-03-30

+

+* Go 1 released: build with go tool

+* [Feature] Windows support using winfsnotify

+* Windows does not have attribute change notifications

+* Roll attribute notifications into IsModify