Small code enhancements

server/server.go

@@ -343,7 +343,7 @@ func (s *Server) AddListener(listener func(types.Configuration)) {
 	s.configurationListeners = append(s.configurationListeners, listener)
 }
 
-// getCertificate allows to customize tlsConfig.GetCertificate behaviour to get the certificates inserted dynamically
+// getCertificate allows to customize tlsConfig.GetCertificate behavior to get the certificates inserted dynamically
 func (s *serverEntryPoint) getCertificate(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
 	domainToCheck := types.CanonicalDomain(clientHello.ServerName)
 
@@ -498,7 +498,7 @@ func (s *Server) startServer(serverEntryPoint *serverEntryPoint) {
 }
 
 func (s *Server) setupServerEntryPoint(newServerEntryPointName string, newServerEntryPoint *serverEntryPoint) *serverEntryPoint {
-	serverMiddlewares, err := s.buildServerEntryPointMiddlewares(newServerEntryPointName, newServerEntryPoint)
+	serverMiddlewares, err := s.buildServerEntryPointMiddlewares(newServerEntryPointName)
 	if err != nil {
 		log.Fatal("Error preparing server: ", err)
 	}

server/server_configuration.go

@@ -165,7 +165,7 @@ func (s *Server) loadFrontendConfig(
 		if backendsHandlers[entryPointName+providerName+frontendHash] == nil {
 			log.Debugf("Creating backend %s", frontend.Backend)
 
-			handlers, responseModifier, postConfig, err := s.buildMiddlewares(frontendName, frontend, config.Backends, entryPointName, entryPoint, providerName)
+			handlers, responseModifier, postConfig, err := s.buildMiddlewares(frontendName, frontend, config.Backends, entryPointName, providerName)
 			if err != nil {
 				return nil, err
 			}
@@ -566,11 +566,15 @@ func (s *Server) buildServerEntryPoints() map[string]*serverEntryPoint {
 			if entryPoint.Configuration.TLS.DefaultCertificate != nil {
 				cert, err := tls.LoadX509KeyPair(entryPoint.Configuration.TLS.DefaultCertificate.CertFile.String(), entryPoint.Configuration.TLS.DefaultCertificate.KeyFile.String())
 				if err != nil {
+					log.Error(err)
+					continue
 				}
 				serverEntryPoints[entryPointName].certs.DefaultCertificate = &cert
 			} else {
 				cert, err := generate.DefaultCertificate()
 				if err != nil {
+					log.Error(err)
+					continue
 				}
 				serverEntryPoints[entryPointName].certs.DefaultCertificate = cert
 			}

server/server_loadbalancer.go

@@ -228,7 +228,7 @@ func (s *Server) getRoundTripper(entryPointName string, passTLSCert bool, tls *t
 // For the settings that can't be configured in Traefik it uses the default http.Transport settings.
 // An exception to this is the MaxIdleConns setting as we only provide the option MaxIdleConnsPerHost
 // in Traefik at this point in time. Setting this value to the default of 100 could lead to confusing
-// behaviour and backwards compatibility issues.
+// behavior and backwards compatibility issues.
 func createHTTPTransport(globalConfiguration configuration.GlobalConfiguration) (*http.Transport, error) {
 	dialer := &net.Dialer{
 		Timeout:   configuration.DefaultDialTimeout,

server/server_middlewares.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/containous/traefik/configuration"
 	"github.com/containous/traefik/log"
 	"github.com/containous/traefik/middlewares"
 	"github.com/containous/traefik/middlewares/accesslog"
@@ -22,9 +21,7 @@ type handlerPostConfig func(backendsHandlers map[string]http.Handler) error
 type modifyResponse func(*http.Response) error
 
 func (s *Server) buildMiddlewares(frontendName string, frontend *types.Frontend,
-	backends map[string]*types.Backend,
-	entryPointName string, entryPoint *configuration.EntryPoint,
-	providerName string) ([]negroni.Handler, modifyResponse, handlerPostConfig, error) {
+	backends map[string]*types.Backend, entryPointName string, providerName string) ([]negroni.Handler, modifyResponse, handlerPostConfig, error) {
 
 	var middle []negroni.Handler
 	var postConfig handlerPostConfig
@@ -109,7 +106,7 @@ func (s *Server) buildMiddlewares(frontendName string, frontend *types.Frontend,
 	return middle, buildModifyResponse(secureMiddleware, headerMiddleware), postConfig, nil
 }
 
-func (s *Server) buildServerEntryPointMiddlewares(serverEntryPointName string, serverEntryPoint *serverEntryPoint) ([]negroni.Handler, error) {
+func (s *Server) buildServerEntryPointMiddlewares(serverEntryPointName string) ([]negroni.Handler, error) {
 	serverMiddlewares := []negroni.Handler{middlewares.NegroniRecoverHandler()}
 
 	if s.tracingMiddleware.IsEnabled() {

server/server_test.go

@@ -35,16 +35,16 @@ func TestPrepareServerTimeouts(t *testing.T) {
 					WriteTimeout: parse.Duration(14 * time.Second),
 				},
 			},
-			expectedIdleTimeout:  time.Duration(10 * time.Second),
-			expectedReadTimeout:  time.Duration(12 * time.Second),
-			expectedWriteTimeout: time.Duration(14 * time.Second),
+			expectedIdleTimeout:  10 * time.Second,
+			expectedReadTimeout:  12 * time.Second,
+			expectedWriteTimeout: 14 * time.Second,
 		},
 		{
 			desc:                 "using defaults",
 			globalConfig:         configuration.GlobalConfiguration{},
-			expectedIdleTimeout:  time.Duration(180 * time.Second),
-			expectedReadTimeout:  time.Duration(0 * time.Second),
-			expectedWriteTimeout: time.Duration(0 * time.Second),
+			expectedIdleTimeout:  180 * time.Second,
+			expectedReadTimeout:  0 * time.Second,
+			expectedWriteTimeout: 0 * time.Second,
 		},
 	}
 
@@ -106,7 +106,7 @@ func TestListenProvidersSkipsSameConfigurationForProvider(t *testing.T) {
 			case config := <-server.configurationValidatedChan:
 				// set the current configuration
 				// this is usually done in the processing part of the published configuration
-				// so we have to emulate the behaviour here
+				// so we have to emulate the behavior here
 				currentConfigurations := server.currentConfigurations.Get().(types.Configurations)
 				currentConfigurations[config.ProviderName] = config.Configuration
 				server.currentConfigurations.Set(currentConfigurations)