Beispiel #1
0
func createPersistentVolume(cmd *cobra.Command, ns string, c *k8sclient.Client, fac *cmdutil.Factory) (Result, error) {
	flags := cmd.Flags()
	hostPath := flags.Lookup(hostPathFlag).Value.String()
	name := flags.Lookup(nameFlag).Value.String()
	pvs := c.PersistentVolumes()
	rc, err := pvs.List(labels.Everything(), fields.Everything())
	if err != nil {
		util.Errorf("Failed to load PersistentVolumes with error %v", err)
		return Failure, err
	}
	items := rc.Items
	for _, volume := range items {
		// TODO use the external load balancer as a way to know if we should create a route?
		vname := volume.ObjectMeta.Name
		if vname == name {
			util.Infof("Already created PersistentVolumes for %s\n", name)
			return Success, nil
		}
	}
	if hostPath == "" {
		return missingFlag(cmd, hostPathFlag)
	}
	if confirmAction(flags) == false {
		return Failure, nil
	}

	// lets create a new PV
	util.Infof("PersistentVolume name %s will be created on host path %s\n", name, hostPath)
	pv := api.PersistentVolume{
		ObjectMeta: api.ObjectMeta{
			Name: name,
		},
		Spec: api.PersistentVolumeSpec{
			Capacity: api.ResourceList{
				api.ResourceName(api.ResourceStorage): resource.MustParse("100G"),
			},
			AccessModes: []api.PersistentVolumeAccessMode{api.ReadWriteMany},
			PersistentVolumeSource: api.PersistentVolumeSource{
				HostPath: &api.HostPathVolumeSource{Path: hostPath},
			},
		},
	}

	_, err = pvs.Create(&pv)
	if err != nil {
		util.Errorf("Failed to create PersistentVolume %s at %s with error %v", name, hostPath, err)
		return Failure, err
	}
	return Success, nil
}
			serverPorts: []int{2049},
		}

		defer func() {
			volumeTestCleanup(c, config)
		}()

		pod := startVolumeServer(c, config)
		serverIP := pod.Status.PodIP
		Logf("NFS server IP address: %v", serverIP)

		pv := makePersistentVolume(serverIP)
		pvc := makePersistentVolumeClaim(ns)

		Logf("Creating PersistentVolume using NFS")
		pv, err := c.PersistentVolumes().Create(pv)
		Expect(err).NotTo(HaveOccurred())

		Logf("Creating PersistentVolumeClaim")
		pvc, err = c.PersistentVolumeClaims(ns).Create(pvc)
		Expect(err).NotTo(HaveOccurred())

		// allow the binder a chance to catch up.  should not be more than 20s.
		waitForPersistentVolumePhase(api.VolumeBound, c, pv.Name, 1*time.Second, 30*time.Second)

		pv, err = c.PersistentVolumes().Get(pv.Name)
		Expect(err).NotTo(HaveOccurred())
		if pv.Spec.ClaimRef == nil {
			Failf("Expected PersistentVolume to be bound, but got nil ClaimRef: %+v", pv)
		}