k8s middleware cleanup, testcases, basic SRV (#181)

* Removing unnecessary gitignore pattern

* Updating Makefile to run unittests for subpackages

* Adding Corefile validation to ignore overlapping zones

* Fixing SRV query handling

* Updating README.md now that SRV works

* Fixing debug message, adding code comment

* Clarifying implementation of zone normalization

* "Overlapping zones" is ill-defined. Reimplemented zone overlap/subzone
  checking to contain these functions in k8s middleware and provide
  better code comments explaining the normalization.

* Separate build verbosity from test verbosity

* Cleaning up comments to match repo code style

* Merging warning messages into single message
* Moving function docs to before function declaration

* Adding test cases for k8sclient connector

* Tests cover connector create and setting base url
* Fixed bugs in connector create and setting base url functions

* Updaing README to group and order development work

* Priority focused on achieving functional parity with SkyDNS.

* Adding work items to README and cleaning up formatting

* More README format cleaning

* List formating

* Refactoring k8s API call to allow dependency injection

* Add test cases for data parsing from k8s into dataobject structures

* URL is dependency-injected to allow replacement with a mock http
  server during test execution

* Adding more data validation for JSON parsing tests

* Adding test case for GetResourceList()

* Adding notes about SkyDNS embedded IP and port record names

* Marked test case implemented.

* Fixing formatting for example command.

* Fixing formatting

* Adding notes about Docker image building.

* Adding SkyDNS work item

* Updating TODO list

* Adding name template to Corefile to specify how k8s record names are assembled

* Adding template support for multi-segment zones

* Updating example CoreFile for k8s with template comment

* Misc whitespace cleanup

* Adding SkyDNS naming notes

* Adding namespace filtering to CoreFile config

* Updating example k8sCoreFile to specify namespaces

* Removing unused codepath

* Adding check for valid namespace

* More README TODO restructuring to focus effort

* Adding template validation while parsing CoreFile

* Record name template is considered invalid if it contains a symbol of the form ${bar} where the symbol
  "${bar}" is not an accepted template symbol.

* Refactoring generation of answer records

* Parse typeName out of query string
* Refactor answer record creation as operation over list of ServiceItems

* Moving k8s API caching into SkyDNS equivalency segment

* Adding function to assemble record names from template

* Warning: This commit may be broken. Syncing to get laptop code over to dev machine.

* More todo notes

* Adding comment describing sample test data.

* Update k8sCorefile

* Adding comment

* Adding filtering support for kubernetes "type"

* Required refactoring to support reuse of the StringInSlice function.

* Cleaning up formatting

* Adding note about SkyDNS supporting word "any".

* baseUrl -> baseURL

* Also removed debug statement from core/setup/kubernetes.go

* Fixing test breaking from Url -> URL naming changes

* Changing record name template language ${...} -> {...}

* Fix formatting with go fmt

* Updating all k8sclient data getters to return error value

* Adding error message to k8sclient data accessors

* Cleaning up setup for kubernetes

* Removed verbose nils in initial k8s middleware instance
* Set reasonable defaults if CoreFile has no parameters in the
kubernetes block. (k8s endpoint, and name template)

* Formatting cleanup -- go fmt

core/setup/kubernetes.go

@@ -1,29 +1,34 @@
 package setup
 
 import (
-//	"crypto/tls"
-//	"crypto/x509"
-    "fmt"
-//	"io/ioutil"
-//	"net"
-//	"net/http"
-//	"time"
+	//"crypto/tls"
+	//"crypto/x509"
+	"fmt"
+	//"io/ioutil"
+	//"net"
+	//"net/http"
+	"strings"
+	//"time"
 
 	"github.com/miekg/coredns/middleware"
 	"github.com/miekg/coredns/middleware/kubernetes"
 	k8sc "github.com/miekg/coredns/middleware/kubernetes/k8sclient"
+	"github.com/miekg/coredns/middleware/kubernetes/nametemplate"
 	"github.com/miekg/coredns/middleware/proxy"
-//	"github.com/miekg/coredns/middleware/singleflight"
+	//"github.com/miekg/coredns/middleware/singleflight"
 
 	"golang.org/x/net/context"
 )
 
-const defaultK8sEndpoint = "http://localhost:8080"
+const (
+	defaultK8sEndpoint  = "http://localhost:8080"
+	defaultNameTemplate = "{service}.{namespace}.{zone}"
+)
 
 // Kubernetes sets up the kubernetes middleware.
 func Kubernetes(c *Controller) (middleware.Middleware, error) {
-    fmt.Println("controller %v", c)
-    // TODO: Determine if subzone support required
+	fmt.Println("controller %v", c)
+	// TODO: Determine if subzone support required
 
 	kubernetes, err := kubernetesParse(c)
 
@@ -39,29 +44,40 @@ func Kubernetes(c *Controller) (middleware.Middleware, error) {
 
 func kubernetesParse(c *Controller) (kubernetes.Kubernetes, error) {
 
-    /*
-     * TODO: Remove unused state and simplify.
-     * Inflight and Ctx might not be needed. Leaving in place until
-     * we take a pass at API caching and optimizing connector to the
-     * k8s API. Single flight (or limited upper-bound) for inflight 
-     * API calls may be desirable.
-     */ 
+	/*
+	 * TODO: Remove unused state and simplify.
+	 * Inflight and Ctx might not be needed. Leaving in place until
+	 * we take a pass at API caching and optimizing connector to the
+	 * k8s API. Single flight (or limited upper-bound) for inflight
+	 * API calls may be desirable.
+	 */
 
 	k8s := kubernetes.Kubernetes{
-        Proxy:      proxy.New([]string{}),
-		Ctx:        context.Background(),
-//		Inflight:   &singleflight.Group{},
-        APIConn:    nil,
+		Proxy: proxy.New([]string{}),
+		Ctx:   context.Background(),
+		//      Inflight:   &singleflight.Group{},
 	}
 	var (
-		endpoints     = []string{defaultK8sEndpoint}
+		endpoints  = []string{defaultK8sEndpoint}
+		template   = defaultNameTemplate
+		namespaces = []string{}
 	)
+
+	k8s.APIConn = k8sc.NewK8sConnector(endpoints[0])
+	k8s.NameTemplate = new(nametemplate.NameTemplate)
+	k8s.NameTemplate.SetTemplate(template)
+
 	for c.Next() {
 		if c.Val() == "kubernetes" {
-			k8s.Zones = c.RemainingArgs()
-			if len(k8s.Zones) == 0 {
+			zones := c.RemainingArgs()
+
+			if len(zones) == 0 {
 				k8s.Zones = c.ServerBlockHosts
+			} else {
+				// Normalize requested zones
+				k8s.Zones = kubernetes.NormalizeZoneList(zones)
 			}
+
 			middleware.Zones(k8s.Zones).FullyQualify()
 			if c.NextBlock() {
 				// TODO(miek): 2 switches?
@@ -72,22 +88,33 @@ func kubernetesParse(c *Controller) (kubernetes.Kubernetes, error) {
 						return kubernetes.Kubernetes{}, c.ArgErr()
 					}
 					endpoints = args
-                    k8s.APIConn = k8sc.NewK8sConnector(endpoints[0])
+					k8s.APIConn = k8sc.NewK8sConnector(endpoints[0])
 				}
 				for c.Next() {
 					switch c.Val() {
-					case "endpoint":
+					case "template":
 						args := c.RemainingArgs()
 						if len(args) == 0 {
 							return kubernetes.Kubernetes{}, c.ArgErr()
 						}
-						endpoints = args
+						template = strings.Join(args, "")
+						err := k8s.NameTemplate.SetTemplate(template)
+						if err != nil {
+							return kubernetes.Kubernetes{}, err
+						}
+					case "namespaces":
+						args := c.RemainingArgs()
+						if len(args) == 0 {
+							return kubernetes.Kubernetes{}, c.ArgErr()
+						}
+						namespaces = args
+						k8s.Namespaces = &namespaces
 					}
 				}
 			}
 			return k8s, nil
 		}
-        fmt.Println("endpoints='%v'", endpoints)
 	}
+	fmt.Println("here before return")
 	return kubernetes.Kubernetes{}, nil
 }