@@ -57,7 +57,7 @@ else

 verify: build

 endif

 	hack/verify-gofmt.sh

-	#hack/verify-govet.sh disable until we can verify that the output is sane

+	hack/verify-govet.sh

 	hack/verify-generated-deep-copies.sh

 	hack/verify-generated-conversions.sh

 	hack/verify-generated-completions.sh

@@ -17,12 +17,13 @@ source "${OS_ROOT}/hack/util.sh"

 cd "${OS_ROOT}"

 mkdir -p _output/govet

+os::build::setup_env

+

 FAILURE=false

 test_dirs=$(find_files | cut -d '/' -f 1-2 | sort -u)

 for test_dir in $test_dirs

 do

-  go tool vet -shadow=false \

-              $test_dir

+  go tool vet -shadow=false $test_dir

   if [ "$?" -ne 0 ]

   then 

     FAILURE=true

@@ -82,7 +82,7 @@ type Edge struct {

 }

 func NewEdge(head, tail graph.Node, kinds ...string) Edge {

-	return Edge{concrete.Edge{head, tail}, sets.NewString(kinds...)}

+	return Edge{concrete.Edge{F: head, T: tail}, sets.NewString(kinds...)}

 }

 func (e Edge) Kinds() sets.String {

@@ -650,7 +650,7 @@ func Fprint(out io.Writer, g Graph) {

 	}

 	for _, edge := range g.Edges() {

 		for _, edgeKind := range g.EdgeKinds(edge).List() {

-			fmt.Fprintf(out, "edge %d -> %d : %d\n", edge.From().ID(), edge.From().ID(), edgeKind)

+			fmt.Fprintf(out, "edge %d -> %d : %s\n", edge.From().ID(), edge.From().ID(), edgeKind)

 		}

 	}

 }

@@ -185,7 +185,7 @@ func TestNewSearchRequest(t *testing.T) {

 		case err != nil && !testCase.expectedError:

 			t.Errorf("%s: expected no error but got: %v", testCase.name, err)

 		case err == nil && testCase.expectedError:

-			t.Error("%s: expected an error but got none")

+			t.Errorf("%s: expected an error but got none", testCase.name)

 		}

 		if !reflect.DeepEqual(testCase.expectedRequest, request) {

@@ -19,12 +19,12 @@ import (

 type readOnlyClusterPolicyCache struct {

 	registry  clusterpolicyregistry.WatchingRegistry

 	indexer   cache.Indexer

-	reflector cache.Reflector

+	reflector *cache.Reflector

 	keyFunc cache.KeyFunc

 }

-func NewReadOnlyClusterPolicyCache(registry clusterpolicyregistry.WatchingRegistry) readOnlyClusterPolicyCache {

+func NewReadOnlyClusterPolicyCache(registry clusterpolicyregistry.WatchingRegistry) *readOnlyClusterPolicyCache {

 	ctx := kapi.WithNamespace(kapi.NewContext(), kapi.NamespaceAll)

 	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"namespace": cache.MetaNamespaceIndexFunc})

@@ -43,10 +43,10 @@ func NewReadOnlyClusterPolicyCache(registry clusterpolicyregistry.WatchingRegist

 		2*time.Minute,

 	)

-	return readOnlyClusterPolicyCache{

+	return &readOnlyClusterPolicyCache{

 		registry:  registry,

 		indexer:   indexer,

-		reflector: *reflector,

+		reflector: reflector,

 		keyFunc: cache.MetaNamespaceKeyFunc,

 	}

@@ -104,5 +104,5 @@ func (c *readOnlyClusterPolicyCache) Get(name string) (*authorizationapi.Cluster

 }

 func newReadOnlyClusterPolicies(cache readOnlyAuthorizationCache) client.ReadOnlyClusterPolicyInterface {

-	return &cache.readOnlyClusterPolicyCache

+	return cache.readOnlyClusterPolicyCache

 }

@@ -14,7 +14,7 @@ import (

 	testregistry "github.com/openshift/origin/pkg/authorization/registry/test"

 )

-func beforeTestingSetup_readonlyclusterpolicycache() (testCache readOnlyClusterPolicyCache, cacheChannel, testChannel chan struct{}) {

+func beforeTestingSetup_readonlyclusterpolicycache() (testCache *readOnlyClusterPolicyCache, cacheChannel, testChannel chan struct{}) {

 	cacheChannel = make(chan struct{})

 	testRegistry := testregistry.NewClusterPolicyRegistry(testClusterPolicies, nil)

@@ -19,12 +19,12 @@ import (

 type readOnlyClusterPolicyBindingCache struct {

 	registry  clusterbindingregistry.WatchingRegistry

 	indexer   cache.Indexer

-	reflector cache.Reflector

+	reflector *cache.Reflector

 	keyFunc cache.KeyFunc

 }

-func NewReadOnlyClusterPolicyBindingCache(registry clusterbindingregistry.WatchingRegistry) readOnlyClusterPolicyBindingCache {

+func NewReadOnlyClusterPolicyBindingCache(registry clusterbindingregistry.WatchingRegistry) *readOnlyClusterPolicyBindingCache {

 	ctx := kapi.WithNamespace(kapi.NewContext(), kapi.NamespaceAll)

 	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"namespace": cache.MetaNamespaceIndexFunc})

@@ -43,10 +43,10 @@ func NewReadOnlyClusterPolicyBindingCache(registry clusterbindingregistry.Watchi

 		2*time.Minute,

 	)

-	return readOnlyClusterPolicyBindingCache{

+	return &readOnlyClusterPolicyBindingCache{

 		registry:  registry,

 		indexer:   indexer,

-		reflector: *reflector,

+		reflector: reflector,

 		keyFunc: cache.MetaNamespaceKeyFunc,

 	}

@@ -104,5 +104,5 @@ func (c *readOnlyClusterPolicyBindingCache) Get(name string) (*authorizationapi.

 }

 func newReadOnlyClusterPolicyBindings(cache readOnlyAuthorizationCache) client.ReadOnlyClusterPolicyBindingInterface {

-	return &cache.readOnlyClusterPolicyBindingCache

+	return cache.readOnlyClusterPolicyBindingCache

 }

@@ -14,7 +14,7 @@ import (

 	testregistry "github.com/openshift/origin/pkg/authorization/registry/test"

 )

-func beforeTestingSetup_readonlyclusterpolicybindingcache() (testCache readOnlyClusterPolicyBindingCache, cacheChannel, testChannel chan struct{}) {

+func beforeTestingSetup_readonlyclusterpolicybindingcache() (testCache *readOnlyClusterPolicyBindingCache, cacheChannel, testChannel chan struct{}) {

 	cacheChannel = make(chan struct{})

 	testRegistry := testregistry.NewClusterPolicyBindingRegistry(testClusterPolicyBindings, nil)

@@ -19,12 +19,12 @@ import (

 type readOnlyPolicyCache struct {

 	registry  policyregistry.WatchingRegistry

 	indexer   cache.Indexer

-	reflector cache.Reflector

+	reflector *cache.Reflector

 	keyFunc cache.KeyFunc

 }

-func NewReadOnlyPolicyCache(registry policyregistry.WatchingRegistry) readOnlyPolicyCache {

+func NewReadOnlyPolicyCache(registry policyregistry.WatchingRegistry) *readOnlyPolicyCache {

 	ctx := kapi.WithNamespace(kapi.NewContext(), kapi.NamespaceAll)

 	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"namespace": cache.MetaNamespaceIndexFunc})

@@ -43,10 +43,10 @@ func NewReadOnlyPolicyCache(registry policyregistry.WatchingRegistry) readOnlyPo

 		2*time.Minute,

 	)

-	return readOnlyPolicyCache{

+	return &readOnlyPolicyCache{

 		registry:  registry,

 		indexer:   indexer,

-		reflector: *reflector,

+		reflector: reflector,

 		keyFunc: cache.MetaNamespaceKeyFunc,

 	}

@@ -120,7 +120,7 @@ type readOnlyPolicies struct {

 func newReadOnlyPolicies(cache readOnlyAuthorizationCache, namespace string) client.ReadOnlyPolicyInterface {

 	return &readOnlyPolicies{

-		readOnlyPolicyCache: &cache.readOnlyPolicyCache,

+		readOnlyPolicyCache: cache.readOnlyPolicyCache,

 		namespace:           namespace,

 	}

 }

@@ -14,7 +14,7 @@ import (

 	testregistry "github.com/openshift/origin/pkg/authorization/registry/test"

 )

-func beforeTestingSetup_readonlypolicycache() (testCache readOnlyPolicyCache, cacheChannel, testChannel chan struct{}) {

+func beforeTestingSetup_readonlypolicycache() (testCache *readOnlyPolicyCache, cacheChannel, testChannel chan struct{}) {

 	cacheChannel = make(chan struct{})

 	testRegistry := testregistry.NewPolicyRegistry(testPolicies, nil)

@@ -19,12 +19,12 @@ import (

 type readOnlyPolicyBindingCache struct {

 	registry  bindingregistry.WatchingRegistry

 	indexer   cache.Indexer

-	reflector cache.Reflector

+	reflector *cache.Reflector

 	keyFunc cache.KeyFunc

 }

-func NewReadOnlyPolicyBindingCache(registry bindingregistry.WatchingRegistry) readOnlyPolicyBindingCache {

+func NewReadOnlyPolicyBindingCache(registry bindingregistry.WatchingRegistry) *readOnlyPolicyBindingCache {

 	ctx := kapi.WithNamespace(kapi.NewContext(), kapi.NamespaceAll)

 	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"namespace": cache.MetaNamespaceIndexFunc})

@@ -43,10 +43,10 @@ func NewReadOnlyPolicyBindingCache(registry bindingregistry.WatchingRegistry) re

 		2*time.Minute,

 	)

-	return readOnlyPolicyBindingCache{

+	return &readOnlyPolicyBindingCache{

 		registry:  registry,

 		indexer:   indexer,

-		reflector: *reflector,

+		reflector: reflector,

 		keyFunc: cache.MetaNamespaceKeyFunc,

 	}

@@ -120,7 +120,7 @@ type readOnlyPolicyBindings struct {

 func newReadOnlyPolicyBindings(cache readOnlyAuthorizationCache, namespace string) client.ReadOnlyPolicyBindingInterface {

 	return &readOnlyPolicyBindings{

-		readOnlyPolicyBindingCache: &cache.readOnlyPolicyBindingCache,

+		readOnlyPolicyBindingCache: cache.readOnlyPolicyBindingCache,

 		namespace:                  namespace,

 	}

 }

@@ -14,7 +14,7 @@ import (

 	testregistry "github.com/openshift/origin/pkg/authorization/registry/test"

 )

-func beforeTestingSetup_readonlypolicybindingcache() (testCache readOnlyPolicyBindingCache, cacheChannel, testChannel chan struct{}) {

+func beforeTestingSetup_readonlypolicybindingcache() (testCache *readOnlyPolicyBindingCache, cacheChannel, testChannel chan struct{}) {

 	cacheChannel = make(chan struct{})

 	testRegistry := testregistry.NewPolicyBindingRegistry(testPolicyBindings, nil)

@@ -23,10 +23,10 @@ type ReadOnlyCache interface {

 // readOnlyAuthorizationCache embeds four parallel caches for policies and bindings on both the project and cluster level

 type readOnlyAuthorizationCache struct {

-	readOnlyPolicyCache               readOnlyPolicyCache

-	readOnlyClusterPolicyCache        readOnlyClusterPolicyCache

-	readOnlyPolicyBindingCache        readOnlyPolicyBindingCache

-	readOnlyClusterPolicyBindingCache readOnlyClusterPolicyBindingCache

+	readOnlyPolicyCache               *readOnlyPolicyCache

+	readOnlyClusterPolicyCache        *readOnlyClusterPolicyCache

+	readOnlyPolicyBindingCache        *readOnlyPolicyBindingCache

+	readOnlyClusterPolicyBindingCache *readOnlyClusterPolicyBindingCache

 }

 // Run begins watching and synchronizing the cache

@@ -52,7 +52,7 @@ func NewCmdRequestProject(name, fullName, ocLoginName, ocProjectName string, f *

 	cmd := &cobra.Command{

 		Use:     fmt.Sprintf("%s NAME [--display-name=DISPLAYNAME] [--description=DESCRIPTION]", name),

 		Short:   "Request a new project",

-		Long:    fmt.Sprintf(requestProjectLong, ocLoginName, ocProjectName),

+		Long:    requestProjectLong,

 		Example: fmt.Sprintf(requestProjectExample, fullName),

 		Run: func(cmd *cobra.Command, args []string) {

 			if err := options.complete(cmd, f); err != nil {

@@ -394,7 +394,7 @@ func WaitForBuildComplete(c osclient.BuildInterface, name string) error {

 				return nil

 			}

 			if name != list.Items[i].Name || isFailed(&list.Items[i]) {

-				return fmt.Errorf("the build %s/%s status is %q", list.Items[i].Namespace, list.Items[i].Name, &list.Items[i].Status.Phase)

+				return fmt.Errorf("the build %s/%s status is %q", list.Items[i].Namespace, list.Items[i].Name, list.Items[i].Status.Phase)

 			}

 		}

@@ -729,7 +729,7 @@ func describeVolumeSource(source *kapi.VolumeSource) string {

 	case source.HostPath != nil:

 		return fmt.Sprintf("host path %s", source.HostPath.Path)

 	case source.ISCSI != nil:

-		return fmt.Sprintf("ISCSI %s target-portal=%s type=%s lun=%s%s", source.ISCSI.IQN, source.ISCSI.TargetPortal, source.ISCSI.FSType, source.ISCSI.Lun, sourceAccessMode(source.ISCSI.ReadOnly))

+		return fmt.Sprintf("ISCSI %s target-portal=%s type=%s lun=%d%s", source.ISCSI.IQN, source.ISCSI.TargetPortal, source.ISCSI.FSType, source.ISCSI.Lun, sourceAccessMode(source.ISCSI.ReadOnly))

 	case source.NFS != nil:

 		return fmt.Sprintf("NFS %s:%s%s", source.NFS.Server, source.NFS.Path, sourceAccessMode(source.NFS.ReadOnly))

 	case source.PersistentVolumeClaim != nil:

@@ -34,7 +34,7 @@ func (o DiagnosticsOptions) buildClientDiagnostics(rawConfig *clientcmdapi.Confi

 		switch diagnosticName {

 		case clientdiags.ConfigContextsName:

 			for contextName := range rawConfig.Contexts {

-				diagnostics = append(diagnostics, clientdiags.ConfigContext{rawConfig, contextName})

+				diagnostics = append(diagnostics, clientdiags.ConfigContext{RawConfig: rawConfig, ContextName: contextName})

 			}

 		default:

@@ -46,13 +46,13 @@ func (o DiagnosticsOptions) buildClusterDiagnostics(rawConfig *clientcmdapi.Conf

 	for _, diagnosticName := range requestedDiagnostics {

 		switch diagnosticName {

 		case clustdiags.NodeDefinitionsName:

-			diagnostics = append(diagnostics, &clustdiags.NodeDefinitions{kclusterClient, clusterClient})

+			diagnostics = append(diagnostics, &clustdiags.NodeDefinitions{KubeClient: kclusterClient, OsClient: clusterClient})

 		case clustdiags.ClusterRegistryName:

-			diagnostics = append(diagnostics, &clustdiags.ClusterRegistry{kclusterClient, clusterClient})

+			diagnostics = append(diagnostics, &clustdiags.ClusterRegistry{KubeClient: kclusterClient, OsClient: clusterClient})

 		case clustdiags.ClusterRouterName:

-			diagnostics = append(diagnostics, &clustdiags.ClusterRouter{kclusterClient, clusterClient})

+			diagnostics = append(diagnostics, &clustdiags.ClusterRouter{KubeClient: kclusterClient, OsClient: clusterClient})

 		case clustdiags.ClusterRolesName:

-			diagnostics = append(diagnostics, &clustdiags.ClusterRoles{clusterClient, clusterClient})

+			diagnostics = append(diagnostics, &clustdiags.ClusterRoles{ClusterRolesClient: clusterClient, SARClient: clusterClient})

 		default:

 			return nil, false, fmt.Errorf("unknown diagnostic: %v", diagnosticName)

@@ -59,19 +59,19 @@ func (o DiagnosticsOptions) buildHostDiagnostics() ([]types.Diagnostic, bool, er

 	for _, diagnosticName := range requestedDiagnostics {

 		switch diagnosticName {

 		case systemddiags.AnalyzeLogsName:

-			diagnostics = append(diagnostics, systemddiags.AnalyzeLogs{systemdUnits})

+			diagnostics = append(diagnostics, systemddiags.AnalyzeLogs{SystemdUnits: systemdUnits})

 		case systemddiags.UnitStatusName:

-			diagnostics = append(diagnostics, systemddiags.UnitStatus{systemdUnits})

+			diagnostics = append(diagnostics, systemddiags.UnitStatus{SystemdUnits: systemdUnits})

 		case hostdiags.MasterConfigCheckName:

 			if len(o.MasterConfigLocation) > 0 {

-				diagnostics = append(diagnostics, hostdiags.MasterConfigCheck{o.MasterConfigLocation})

+				diagnostics = append(diagnostics, hostdiags.MasterConfigCheck{MasterConfigFile: o.MasterConfigLocation})

 			}

 		case hostdiags.NodeConfigCheckName:

 			if len(o.NodeConfigLocation) > 0 {

-				diagnostics = append(diagnostics, hostdiags.NodeConfigCheck{o.NodeConfigLocation})

+				diagnostics = append(diagnostics, hostdiags.NodeConfigCheck{NodeConfigFile: o.NodeConfigLocation})

 			}

 		default:

@@ -183,7 +183,7 @@ func (d *Deployer) Deploy(namespace, deploymentName string) error {

 		}

 		// Scale the deployment down to zero.

 		retryWaitParams := kubectl.NewRetryParams(1*time.Second, 120*time.Second)

-		if err := d.scaler.Scale(candidate.Namespace, candidate.Name, uint(0), &kubectl.ScalePrecondition{-1, ""}, retryWaitParams, retryWaitParams); err != nil {

+		if err := d.scaler.Scale(candidate.Namespace, candidate.Name, uint(0), &kubectl.ScalePrecondition{Size: -1, ResourceVersion: ""}, retryWaitParams, retryWaitParams); err != nil {

 			glog.Errorf("Couldn't scale down prior deployment %s: %v", deployutil.LabelForDeployment(&candidate), err)

 		} else {

 			glog.Infof("Scaled down prior deployment %s", deployutil.LabelForDeployment(&candidate))

@@ -110,7 +110,7 @@ func (c *AssetConfig) buildAssetHandler() (http.Handler, error) {

 	assetFunc := assets.JoinAssetFuncs(assets.Asset, java.Asset)

 	assetDirFunc := assets.JoinAssetDirFuncs(assets.AssetDir, java.AssetDir)

-	handler := http.FileServer(&assetfs.AssetFS{assetFunc, assetDirFunc, ""})

+	handler := http.FileServer(&assetfs.AssetFS{Asset: assetFunc, AssetDir: assetDirFunc, Prefix: ""})

 	// Map of context roots (no leading or trailing slash) to the asset path to serve for requests to a missing asset

 	subcontextMap := map[string]string{

@@ -143,7 +143,7 @@ func cacheControlFilter(handler http.Handler, value string) http.Handler {

 // namespacingFilter adds a filter that adds the namespace of the request to the context.  Not all requests will have namespaces,

 // but any that do will have the appropriate value added.

 func namespacingFilter(handler http.Handler, contextMapper kapi.RequestContextMapper) http.Handler {

-	infoResolver := &apiserver.APIRequestInfoResolver{sets.NewString("api", "osapi", "oapi"), latest.RESTMapper}

+	infoResolver := &apiserver.APIRequestInfoResolver{APIPrefixes: sets.NewString("api", "osapi", "oapi"), RestMapper: latest.RESTMapper}

 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

 		ctx, ok := contextMapper.Get(req)

@@ -338,7 +338,7 @@ func newAuthorizer(policyClient policyclient.ReadOnlyPolicyClient, projectReques

 }

 func newAuthorizationAttributeBuilder(requestContextMapper kapi.RequestContextMapper) authorizer.AuthorizationAttributeBuilder {

-	authorizationAttributeBuilder := authorizer.NewAuthorizationAttributeBuilder(requestContextMapper, &apiserver.APIRequestInfoResolver{sets.NewString("api", "osapi", "oapi"), latest.RESTMapper})

+	authorizationAttributeBuilder := authorizer.NewAuthorizationAttributeBuilder(requestContextMapper, &apiserver.APIRequestInfoResolver{APIPrefixes: sets.NewString("api", "osapi", "oapi"), RestMapper: latest.RESTMapper})

 	return authorizationAttributeBuilder

 }

@@ -51,7 +51,7 @@ type Factory struct {

 // NewFactory creates an object that holds common methods across all OpenShift commands

 func NewFactory(clientConfig kclientcmd.ClientConfig) *Factory {

-	mapper := ShortcutExpander{kubectl.ShortcutExpander{latest.RESTMapper}}

+	mapper := ShortcutExpander{RESTMapper: kubectl.ShortcutExpander{RESTMapper: latest.RESTMapper}}

 	clients := &clientCache{

 		clients: make(map[string]*client.Client),

@@ -72,7 +72,7 @@ func NewFactory(clientConfig kclientcmd.ClientConfig) *Factory {

 	w.Object = func() (meta.RESTMapper, runtime.ObjectTyper) {

 		if cfg, err := clientConfig.ClientConfig(); err == nil {

-			return kubectl.OutputVersionMapper{mapper, cfg.Version}, api.Scheme

+			return kubectl.OutputVersionMapper{RESTMapper: mapper, OutputVersion: cfg.Version}, api.Scheme

 		}

 		return mapper, api.Scheme

 	}

@@ -41,7 +41,7 @@ func encodeAndCreate(info *resource.Info, namespace string, obj runtime.Object)

 // event a failure occurs. The contents of list will be updated to include the

 // version from the server.

 func (b *Bulk) Create(list *kapi.List, namespace string) []error {

-	resourceMapper := &resource.Mapper{b.Typer, b.Mapper, resource.ClientMapperFunc(b.RESTClientFactory)}

+	resourceMapper := &resource.Mapper{ObjectTyper: b.Typer, RESTMapper: b.Mapper, ClientMapper: resource.ClientMapperFunc(b.RESTClientFactory)}

 	after := b.After

 	if after == nil {

 		after = func(*resource.Info, error) {}

@@ -30,7 +30,7 @@ type DeploymentConfigScaler struct {

 //  is not nil), and then optionally waits for it's replica count to reach the new value (if wait is not nil).

 func (scaler *DeploymentConfigScaler) Scale(namespace, name string, newSize uint, preconditions *kubectl.ScalePrecondition, retry, waitForReplicas *kubectl.RetryParams) error {

 	if preconditions == nil {

-		preconditions = &kubectl.ScalePrecondition{-1, ""}

+		preconditions = &kubectl.ScalePrecondition{Size: -1, ResourceVersion: ""}

 	}

 	if retry == nil {

 		// Make it try only once, immediately

@@ -64,7 +64,7 @@ func (scaler *DeploymentConfigScaler) ScaleSimple(namespace, name string, precon

 	const scaled = "scaled"

 	controller, err := scaler.c.GetReplicationController(namespace, name)

 	if err != nil {

-		return "", kubectl.ControllerScaleError{kubectl.ControllerScaleGetFailure, "Unknown", err}

+		return "", kubectl.ControllerScaleError{FailureType: kubectl.ControllerScaleGetFailure, ResourceVersion: "Unknown", ActualError: err}

 	}

 	if preconditions != nil {

 		if err := preconditions.Validate(controller); err != nil {

@@ -74,7 +74,7 @@ func (scaler *DeploymentConfigScaler) ScaleSimple(namespace, name string, precon

 	controller.Spec.Replicas = int(newSize)

 	// TODO: do retry on 409 errors here?

 	if _, err := scaler.c.UpdateReplicationController(namespace, controller); err != nil {

-		return "", kubectl.ControllerScaleError{kubectl.ControllerScaleUpdateFailure, controller.ResourceVersion, err}

+		return "", kubectl.ControllerScaleError{FailureType: kubectl.ControllerScaleUpdateFailure, ResourceVersion: controller.ResourceVersion, ActualError: err}

 	}

 	// TODO: do a better job of printing objects here.

 	return scaled, nil

@@ -146,7 +146,7 @@ func (s *RecreateDeploymentStrategy) DeployWithAcceptor(from *kapi.ReplicationCo

 }

 func (s *RecreateDeploymentStrategy) scaleAndWait(deployment *kapi.ReplicationController, replicas int, retry *kubectl.RetryParams, wait *kubectl.RetryParams) (*kapi.ReplicationController, error) {

-	if err := s.scaler.Scale(deployment.Namespace, deployment.Name, uint(replicas), &kubectl.ScalePrecondition{-1, ""}, retry, wait); err != nil {

+	if err := s.scaler.Scale(deployment.Namespace, deployment.Name, uint(replicas), &kubectl.ScalePrecondition{Size: -1, ResourceVersion: ""}, retry, wait); err != nil {

 		return nil, err

 	}

 	updatedDeployment, err := s.getReplicationController(deployment.Namespace, deployment.Name)

@@ -72,9 +72,9 @@ func (d *NodeDefinitions) CanRun() (bool, error) {

 		Resource: "nodes",

 	})

 	if err != nil {

-		return false, types.DiagnosticError{"DClu0005", fmt.Sprintf(clientErrorGettingNodes, err), err}

+		return false, types.DiagnosticError{ID: "DClu0005", LogMessage: fmt.Sprintf(clientErrorGettingNodes, err), Cause: err}

 	} else if !can {

-		return false, types.DiagnosticError{"DClu0006", "Client does not have access to see node status", err}

+		return false, types.DiagnosticError{ID: "DClu0006", LogMessage: "Client does not have access to see node status", Cause: err}

 	}

 	return true, nil

 }

@@ -102,9 +102,9 @@ func (d *ClusterRouter) CanRun() (bool, error) {

 		ResourceName: routerName,

 	})

 	if err != nil {

-		return false, types.DiagnosticError{"DClu2010", fmt.Sprintf(clientAccessError, err), err}

+		return false, types.DiagnosticError{ID: "DClu2010", LogMessage: fmt.Sprintf(clientAccessError, err), Cause: err}

 	} else if !can {

-		return false, types.DiagnosticError{"DClu2011", "Client does not have cluster-admin access", err}

+		return false, types.DiagnosticError{ID: "DClu2011", LogMessage: "Client does not have cluster-admin access", Cause: err}

 	}

 	return true, nil

 }

@@ -2,10 +2,11 @@ package types

 import (

 	"fmt"

-	"github.com/golang/glog"

 	"runtime"

 	"strings"

+	"github.com/golang/glog"

+

 	"github.com/openshift/origin/pkg/diagnostics/log"

 )

@@ -122,7 +123,7 @@ func (r *diagnosticResultImpl) caller(depth int) string {

 	return "diagnostic " + r.origin

 }

 func (r *diagnosticResultImpl) logError(id string, err error, msg string) {

-	r.appendLogs(2, log.Entry{id, r.caller(2), log.ErrorLevel, msg})

+	r.appendLogs(2, log.Entry{ID: id, Origin: r.caller(2), Level: log.ErrorLevel, Message: msg})

 	if de, ok := err.(DiagnosticError); ok {

 		r.appendErrors(de)

 	} else {

@@ -130,7 +131,7 @@ func (r *diagnosticResultImpl) logError(id string, err error, msg string) {

 	}

 }

 func (r *diagnosticResultImpl) logWarning(id string, err error, msg string) {

-	r.appendLogs(2, log.Entry{id, r.caller(2), log.WarnLevel, msg})

+	r.appendLogs(2, log.Entry{ID: id, Origin: r.caller(2), Level: log.WarnLevel, Message: msg})

 	if de, ok := err.(DiagnosticError); ok {

 		r.appendWarnings(de)

 	} else {

@@ -138,7 +139,7 @@ func (r *diagnosticResultImpl) logWarning(id string, err error, msg string) {

 	}

 }

 func (r *diagnosticResultImpl) logMessage(id string, level log.Level, msg string) {

-	r.appendLogs(2, log.Entry{id, r.caller(2), level, msg})

+	r.appendLogs(2, log.Entry{ID: id, Origin: r.caller(2), Level: level, Message: msg})

 }

 // Public ingress functions

@@ -804,12 +804,13 @@ func TestRunAll(t *testing.T) {

 			case *kapi.Service:

 				if test.checkPort != "" {

 					if len(tp.Spec.Ports) == 0 {

-						t.Errorf("%s: did not get any ports in service")

+						t.Errorf("%s: did not get any ports in service", test.name)

 						break

 					}

 					expectedPort, _ := strconv.Atoi(test.checkPort)

 					if tp.Spec.Ports[0].Port != expectedPort {

-						t.Errorf("%s: did not get expected port in service. Expected: %d. Got %d\n", expectedPort, tp.Spec.Ports[0].Port)

+						t.Errorf("%s: did not get expected port in service. Expected: %d. Got %d\n",

+							test.name, expectedPort, tp.Spec.Ports[0].Port)

 					}

 				}

 				if test.config.Labels != nil {

@@ -61,8 +61,6 @@ func Finalize(kubeClient kclient.Interface, namespace *kapi.Namespace) (result *

 			return nil, err

 		}

 	}

-

-	return

 }

 // finalizeInternal will update the namespace finalizer list to either have or not have origin finalizer

@@ -239,7 +239,7 @@ func TestHandleRoute(t *testing.T) {

 	// here

 	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute)

-	original := util.Time{time.Now()}

+	original := util.Time{Time: time.Now()}

 	//add

 	route := &routeapi.Route{