See the License for the specific language governing permissions and
limitations under the License.
*/

package certs

/*

	PHASE: CERTIFICATES

	INPUTS:
		From InitConfiguration
			.API.AdvertiseAddress is an optional parameter that can be passed for an extra addition to the SAN IPs
			.APIServer.CertSANs is an optional parameter for adding DNS names and IPs to the API Server serving cert SAN

)

var k8sVersionString = kubeadmconstants.MinimumControlPlaneVersion.String()
var nodeName = "mynode"
var cfgFiles = map[string][]byte{
	"InitConfiguration_v1beta3": []byte(fmt.Sprintf(`
apiVersion: %s
kind: InitConfiguration
`, kubeadmapiv1.SchemeGroupVersion.String())),
	"ClusterConfiguration_v1beta3": []byte(fmt.Sprintf(`
apiVersion: %s
kind: ClusterConfiguration
kubernetesVersion: %s

	var tests = []struct {
		desc                string
		name                string
		cfg                 *kubeadmapi.InitConfiguration
		expectedDNSNames    []string
		expectedIPAddresses []string
	}{
		{
			desc: "empty name",
			name: "",
			cfg: &kubeadmapi.InitConfiguration{
				LocalAPIEndpoint: kubeadmapi.APIEndpoint{AdvertiseAddress: "1.2.3.4"},
				ClusterConfiguration: kubeadmapi.ClusterConfiguration{

	externalEtcd := &kubeadmapi.InitConfiguration{
		ClusterConfiguration: kubeadmapi.ClusterConfiguration{
			Etcd: kubeadmapi.Etcd{
				External: &kubeadmapi.ExternalEtcd{
					Endpoints: []string{"10.100.0.1:2379", "10.100.0.2:2379", "10.100.0.3:2379"},
				},
			},
		},
	}

	stackedEtcd := &kubeadmapi.InitConfiguration{}

	tests := []struct {
		name             string

	}

	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")
	}

	// TODO: remove this check once WaitForAllControlPlaneComponents goes GA
	// https://github.com/kubernetes/kubeadm/issues/2907

// If the PKI assets already exists in the target folder, they are used only if evaluated equal; otherwise an error is returned.
func CreatePKIAssets(cfg *kubeadmapi.InitConfiguration) error {
	klog.V(1).Infoln("creating PKI assets")

	// This structure cannot handle multilevel CA hierarchies.
	// This isn't a problem right now, but may become one in the future.

	var certList Certificates

				InheritFlags: getAddonPhaseFlags("kube-proxy"),
				Run:          runKubeProxyAddon,
				LocalFlags:   proxyLocalFlags,
			},
		},
	}
}

func getInitData(c workflow.RunData) (*kubeadmapi.InitConfiguration, clientset.Interface, string, io.Writer, error) {
	data, ok := c.(InitData)
	if !ok {
		return nil, nil, "", nil, errors.New("addon phase invoked with an invalid data struct")
	}
	cfg := data.Cfg()

					t.Fatalf(dedent.Dedent("failed to write pod manifest\n%s\n\tfatal error: %v"), name, err)
				}
			}

			var dataDir string
			var err error
			if test.validConfig {
				cfg := &kubeadmapi.InitConfiguration{}
				dataDir, err = getEtcdDataDir(manifestPath, cfg)
			} else {
				dataDir, err = getEtcdDataDir(manifestPath, nil)
			}

			if (err != nil) != test.expectErr {
				t.Fatalf(dedent.Dedent(

	cmd.AddCommand(newCmdUserKubeConfig(out))
	return cmd
}

// newCmdUserKubeConfig returns sub commands for kubeconfig phase
func newCmdUserKubeConfig(out io.Writer) *cobra.Command {

	initCfg := &kubeadmapiv1.InitConfiguration{}
	clusterCfg := &kubeadmapiv1.ClusterConfiguration{}

	var (
		token, clientName, cfgPath string
		organizations              []string
		validityPeriod             time.Duration
	)

		return true, nil, nil
	})

	internalcfg, err := configutil.DefaultedStaticInitConfiguration()
	if err != nil {
		t.Fatalf("unexpected failure when defaulting InitConfiguration: %v", err)
	}

	if err := CreateConfigMap(&internalcfg.ClusterConfiguration, client); err != nil {
		t.Errorf("CreateConfigMap: unexpected error %v", err)
	}
}