readOnly: false
    - mountPath: /etc/srv/kubernetes/addon-manager/
      name: srvkube
      readOnly: true
    env:
    - name: KUBECTL_PRUNE_WHITELIST_OVERRIDE
      value: {{kubectl_prune_whitelist_override}}
    - name: KUBECTL_EXTRA_PRUNE_WHITELIST
      value: {{kubectl_extra_prune_whitelist}}
    - name: KUBECTL_OPTS
      value: '--kubeconfig=/etc/srv/kubernetes/addon-manager/kubeconfig'
  volumes:

		// coverage.
		resp, err := http.Get(srv.URL)
		if err == nil {
			var body []byte
			body, err = io.ReadAll(resp.Body)
			if err == nil && testing.Verbose() {
				t.Logf("GET %s:\n%s", srv.URL, body)
			}
			resp.Body.Close()
		}
		if err != nil {
			t.Error(err)
		}

		srv.Close()
	})

                    },
                    {
                        "name": "srvkube",
                        "readOnly": true,
                        "mountPath": "/etc/srv/kubernetes/cluster-autoscaler"
                    },
                    {
                        "name": "logfile",
                        "mountPath": "/var/log/cluster-autoscaler.log",

			}
		}

		if objAPI := newObjectLayerFn(); objAPI != nil {
			shutdownLogIf(context.Background(), objAPI.Shutdown(context.Background()))
		}

		if srv := newConsoleServerFn(); srv != nil {
			shutdownLogIf(context.Background(), srv.Shutdown())
		}

		if globalEventNotifier != nil {
			globalEventNotifier.RemoveAllBucketTargets()
		}

		return true
	}

	for {
		select {

	}

	l, err := net.Listen("unix", s.path)
	if err != nil {
		return fmt.Errorf("listen error (%v): %v", s.path, err)
	}
	defer l.Close()

	srv := http.Server{Handler: s.mux}
	go func() {
		<-stopCh
		srv.Close()
	}()
	return srv.Serve(l)

		return
	}

	_, err = deployment.New(ctx).
		With(&clt, echo.Config{
			Service:        "clt",
			Namespace:      echoNsInst,
			ServiceAccount: true,
		}).
		With(&srv, echo.Config{
			Service:   "srv",
			Namespace: echoNsInst,
			Ports: []echo.Port{
				{
					Name:     "http",
					Protocol: protocol.HTTP,
					// We use a port > 1024 to not require root
					WorkloadPort: 8888,

    volumeMounts:
    - mountPath: /etc/gce.conf
      name: cloudconfig
      readOnly: true
    - mountPath: /var/log/glbc.log
      name: logfile
      readOnly: false
    - mountPath: /etc/srv/kubernetes/l7-lb-controller
      name: srvkube
      readOnly: true
    resources:
      # Request is set to accommodate this pod alongside the other
      # master components on a single core master.
      requests:

func TestCrossXMLHandler(t *testing.T) {
	// Server initialization.
	router := mux.NewRouter().SkipClean(true).UseEncodedPath()
	handler := setCrossDomainPolicyMiddleware(router)
	srv := httptest.NewServer(handler)

	resp, err := http.Get(srv.URL + crossDomainXMLEntity)
	if err != nil {
		t.Fatal(err)
	}
	if resp.StatusCode != http.StatusOK {
		t.Fatal("Unexpected http status received", resp.Status)
	}

	r.HandleFunc(attrPath, handleAttrs(attrs)).Methods("GET")

	srv := &http.Server{Addr: addr, Handler: r}

	go func() {
		if err := srv.ListenAndServe(); err != http.ErrServerClosed {
			log.Fatalf("listen: %v\n", err)
		}
	}()
	return srv

        "readOnly": false
      },
      { "name": "varlogetcd",
        "mountPath": "/var/log/etcd{{ suffix }}.log",
        "readOnly": false
      },
      { "name": "etc",
        "mountPath": "/etc/srv/kubernetes",
        "readOnly": false
      }
    ]
    }
],
"volumes":[
  { "name": "varetcd",
    "hostPath": {
        "path": "/mnt/master-pd/var/etcd"}
  },
  { "name": "varlogetcd",