Give AddressManager responsibility for its host

You no longer have to pass a hostname to initialise the addressmanager.
The DefaultAddressManager always listens on localhost. If you want to
listen on some other interface, you can use a different AddressManager.

pkg/framework/test/address_manager.go

@@ -8,7 +8,7 @@ import (
 // AddressManager knows how to generate and remember a single address on some
 // local interface for a service to listen on.
 type AddressManager interface {
-	Initialize(host string) (port int, resolvedAddress string, err error)
+	Initialize() (port int, resolvedAddress string, err error)
 	Host() (string, error)
 	Port() (int, error)
 }
@@ -22,13 +22,13 @@ type DefaultAddressManager struct {
 	host string
 }
 
-// Initialize returns a address a process can listen on. Given a hostname it returns an address,
+// Initialize returns a address a process can listen on. It returns
 // a tuple consisting of a free port and the hostname resolved to its IP.
-func (d *DefaultAddressManager) Initialize(host string) (port int, resolvedHost string, err error) {
+func (d *DefaultAddressManager) Initialize() (port int, resolvedHost string, err error) {
 	if d.port != 0 {
 		return 0, "", fmt.Errorf("this DefaultAddressManager is already initialized")
 	}
-	addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:0", host))
+	addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
 	if err != nil {
 		return
 	}

pkg/framework/test/address_manager_test.go

@@ -18,7 +18,7 @@ var _ = Describe("DefaultAddressManager", func() {
 
 	Describe("Initialize", func() {
 		It("returns a free port and an address to bind to", func() {
-			port, host, err := defaultAddressManager.Initialize("localhost")
+			port, host, err := defaultAddressManager.Initialize()
 
 			Expect(err).NotTo(HaveOccurred())
 			Expect(host).To(Equal("127.0.0.1"))
@@ -33,32 +33,11 @@ var _ = Describe("DefaultAddressManager", func() {
 			Expect(err).NotTo(HaveOccurred())
 		})
 
-		Context("when given an invalid hostname", func() {
-			It("propagates the error", func() {
-				_, _, err := defaultAddressManager.Initialize("this is not a hostname")
-
-				Expect(err).To(MatchError(ContainSubstring("no such host")))
-			})
-		})
-
-		Context("when given a hostname that we don't have permission to listen on", func() {
-			It("propagates the error", func() {
-				_, _, err := defaultAddressManager.Initialize("example.com")
-
-				Expect(err).To(SatisfyAny(
-					// Linux
-					MatchError(ContainSubstring("bind: cannot assign requested address")),
-					// Darwin
-					MatchError(ContainSubstring("bind: can't assign requested address")),
-				))
-			})
-		})
-
 		Context("initialized multiple times", func() {
 			It("fails", func() {
-				_, _, err := defaultAddressManager.Initialize("localhost")
+				_, _, err := defaultAddressManager.Initialize()
 				Expect(err).NotTo(HaveOccurred())
-				_, _, err = defaultAddressManager.Initialize("localhost")
+				_, _, err = defaultAddressManager.Initialize()
 				Expect(err).To(MatchError(ContainSubstring("already initialized")))
 			})
 		})
@@ -69,7 +48,7 @@ var _ = Describe("DefaultAddressManager", func() {
 			Expect(err).To(MatchError(ContainSubstring("not initialized yet")))
 		})
 		It("returns the same port as previously allocated by Initialize", func() {
-			expectedPort, _, err := defaultAddressManager.Initialize("localhost")
+			expectedPort, _, err := defaultAddressManager.Initialize()
 			Expect(err).NotTo(HaveOccurred())
 			actualPort, err := defaultAddressManager.Port()
 			Expect(err).NotTo(HaveOccurred())
@@ -82,7 +61,7 @@ var _ = Describe("DefaultAddressManager", func() {
 			Expect(err).To(MatchError(ContainSubstring("not initialized yet")))
 		})
 		It("returns the same port as previously allocated by Initialize", func() {
-			_, expectedHost, err := defaultAddressManager.Initialize("localhost")
+			_, expectedHost, err := defaultAddressManager.Initialize()
 			Expect(err).NotTo(HaveOccurred())
 			actualHost, err := defaultAddressManager.Host()
 			Expect(err).NotTo(HaveOccurred())

pkg/framework/test/apiserver.go

@@ -51,7 +51,7 @@ func (s *APIServer) URL() (string, error) {
 func (s *APIServer) Start() error {
 	s.ensureInitialized()
 
-	port, addr, err := s.AddressManager.Initialize("localhost")
+	port, addr, err := s.AddressManager.Initialize()
 	if err != nil {
 		return err
 	}

pkg/framework/test/apiserver_test.go

@@ -88,7 +88,6 @@ var _ = Describe("Apiserver", func() {
 
 				By("...in turn calling the AddressManager")
 				Expect(fakeAddressManager.InitializeCallCount()).To(Equal(1))
-				Expect(fakeAddressManager.InitializeArgsForCall(0)).To(Equal("localhost"))
 
 				By("...in turn calling the CertDirManager")
 				Expect(fakeCertDirManager.CreateCallCount()).To(Equal(1))

pkg/framework/test/etcd.go

@@ -61,7 +61,7 @@ func (e *Etcd) URL() (string, error) {
 func (e *Etcd) Start() error {
 	e.ensureInitialized()
 
-	port, host, err := e.AddressManager.Initialize("localhost")
+	port, host, err := e.AddressManager.Initialize()
 	if err != nil {
 		return err
 	}

pkg/framework/test/etcd_test.go

@@ -76,7 +76,6 @@ var _ = Describe("Etcd", func() {
 
 				By("...in turn calling using the AddressManager")
 				Expect(fakeAddressManager.InitializeCallCount()).To(Equal(1))
-				Expect(fakeAddressManager.InitializeArgsForCall(0)).To(Equal("localhost"))
 
 				By("...in turn using the DataDirManager")
 				Expect(fakeDataDirManager.CreateCallCount()).To(Equal(1))

pkg/framework/test/testfakes/fake_address_manager.go

@@ -8,12 +8,10 @@ import (
 )
 
 type FakeAddressManager struct {
-	InitializeStub        func(host string) (port int, resolvedAddress string, err error)
+	InitializeStub        func() (port int, resolvedAddress string, err error)
 	initializeMutex       sync.RWMutex
-	initializeArgsForCall []struct {
-		host string
-	}
-	initializeReturns struct {
+	initializeArgsForCall []struct{}
+	initializeReturns     struct {
 		result1 int
 		result2 string
 		result3 error
@@ -49,16 +47,14 @@ type FakeAddressManager struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeAddressManager) Initialize(host string) (port int, resolvedAddress string, err error) {
+func (fake *FakeAddressManager) Initialize() (port int, resolvedAddress string, err error) {
 	fake.initializeMutex.Lock()
 	ret, specificReturn := fake.initializeReturnsOnCall[len(fake.initializeArgsForCall)]
-	fake.initializeArgsForCall = append(fake.initializeArgsForCall, struct {
-		host string
-	}{host})
-	fake.recordInvocation("Initialize", []interface{}{host})
+	fake.initializeArgsForCall = append(fake.initializeArgsForCall, struct{}{})
+	fake.recordInvocation("Initialize", []interface{}{})
 	fake.initializeMutex.Unlock()
 	if fake.InitializeStub != nil {
-		return fake.InitializeStub(host)
+		return fake.InitializeStub()
 	}
 	if specificReturn {
 		return ret.result1, ret.result2, ret.result3
@@ -72,12 +68,6 @@ func (fake *FakeAddressManager) InitializeCallCount() int {
 	return len(fake.initializeArgsForCall)
 }
 
-func (fake *FakeAddressManager) InitializeArgsForCall(i int) string {
-	fake.initializeMutex.RLock()
-	defer fake.initializeMutex.RUnlock()
-	return fake.initializeArgsForCall[i].host
-}
-
 func (fake *FakeAddressManager) InitializeReturns(result1 int, result2 string, result3 error) {
 	fake.InitializeStub = nil
 	fake.initializeReturns = struct {