"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
	cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
	"k8s.io/kubernetes/cmd/kubeadm/app/phases/controlplane"
	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
	configutil "k8s.io/kubernetes/cmd/kubeadm/app/util/config"
	kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"

}

func runWaitControlPlanePhase(c workflow.RunData) error {
	data, ok := c.(JoinData)
	if !ok {
		return errors.New("wait-control-plane phase invoked with an invalid data struct")
	}

	if data.Cfg().ControlPlane == nil {
		return nil
	}

	initCfg, err := data.InitCfg()
	if err != nil {
		return errors.Wrap(err, "could not obtain InitConfiguration during the wait-control-plane phase")
	}

	// FileDiscovery flag sets the file or URL from which to load cluster information (for file-based discovery)
	FileDiscovery = "discovery-file"

	// ControlPlane flag instructs kubeadm to create a new control plane instance on this node
	ControlPlane = "control-plane"

	// UploadCerts flag instructs kubeadm to upload certificates
	UploadCerts = "upload-certs"

		}
		xdsResponse, err := multixds.RequestAndProcessXds(&xdsRequest, *centralOpts, ctx.IstioNamespace(), kubeClient)
		if err != nil {
			return nil, err
		}
		*outXDS = xdsResponse
		if xdsResponse.ControlPlane == nil {
			return &istioVersion.MeshInfo{
				istioVersion.ServerInfo{
					Component: "MISSING CP ID",
					Info: istioVersion.BuildInfo{
						Version: "MISSING CP ID",
					},

	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apiserver/pkg/admission"
	"k8s.io/apiserver/pkg/server"
	"k8s.io/apiserver/pkg/util/webhook"
	"k8s.io/client-go/informers"

	"k8s.io/kubernetes/pkg/controlplane/apiserver/options"
)

func CreateAPIExtensionsConfig(
	kubeAPIServerConfig server.Config,
	kubeInformers informers.SharedInformerFactory,
	pluginInitializers []admission.PluginInitializer,

// It can be configured and called directly or via the hyperkube framework.
package app

import (
	"k8s.io/apimachinery/pkg/runtime/schema"
	controlplaneapiserver "k8s.io/kubernetes/pkg/controlplane/apiserver"
)

// The proper way to resolve this letting the aggregator know the desired group and version-within-group order of the underlying servers

packages_without_install=(
	"k8s.io/kubernetes/pkg/apis/abac"
	"k8s.io/kubernetes/pkg/apis/admission"
	"k8s.io/kubernetes/pkg/apis/apidiscovery"
)
known_version_files=(
	"pkg/controlplane/import_known_versions.go"
)
for expected_install_package in "${expected_install_packages[@]}"; do
	found=0
	for package_without_install in "${packages_without_install[@]}"; do

					rt.expectedBytes,
					actualBytes,
				)
			}
		})
	}
}

func TestDiscoveryServerVersion(t *testing.T) {
	dryRunGetter := &InitDryRunGetter{
		controlPlaneName: "controlPlane",
		serviceSubnet:    "serviceSubnet",
	}
	c := NewDryRunClient(dryRunGetter, io.Discard)
	fakeclientDiscovery, ok := c.Discovery().(*fakediscovery.FakeDiscovery)
	if !ok {

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package controlplane

import (
	"fmt"
	"reflect"
	"testing"

	"istio.io/api/operator/v1alpha1"
	"istio.io/istio/operator/pkg/component"
	"istio.io/istio/operator/pkg/name"
	"istio.io/istio/operator/pkg/translate"

func SetDefaults_JoinConfiguration(obj *JoinConfiguration) {
	if obj.CACertPath == "" {
		obj.CACertPath = DefaultCACertPath
	}

	SetDefaults_JoinControlPlane(obj.ControlPlane)
	SetDefaults_Discovery(&obj.Discovery)
	SetDefaults_NodeRegistration(&obj.NodeRegistration)
}

// SetDefaults_JoinControlPlane assigns default values for a joining control plane node