github.com/vmware/govmomi@v0.37.1/govc/vm/disk/create.go (about)

     1  /*
     2  Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package disk
    18  
    19  import (
    20  	"context"
    21  	"errors"
    22  	"flag"
    23  	"fmt"
    24  	"strings"
    25  
    26  	"github.com/vmware/govmomi/govc/cli"
    27  	"github.com/vmware/govmomi/govc/flags"
    28  	"github.com/vmware/govmomi/units"
    29  	"github.com/vmware/govmomi/vim25/types"
    30  )
    31  
    32  type create struct {
    33  	*flags.DatastoreFlag
    34  	*flags.OutputFlag
    35  	*flags.VirtualMachineFlag
    36  
    37  	controller string
    38  	Name       string
    39  	Bytes      units.ByteSize
    40  	Thick      bool
    41  	Eager      bool
    42  	DiskMode   string
    43  	Sharing    string
    44  }
    45  
    46  var vdmTypes = []string{
    47  	string(types.VirtualDiskModePersistent),
    48  	string(types.VirtualDiskModeNonpersistent),
    49  	string(types.VirtualDiskModeUndoable),
    50  	string(types.VirtualDiskModeIndependent_persistent),
    51  	string(types.VirtualDiskModeIndependent_nonpersistent),
    52  	string(types.VirtualDiskModeAppend),
    53  }
    54  
    55  var sharing = []string{
    56  	string(types.VirtualDiskSharingSharingNone),
    57  	string(types.VirtualDiskSharingSharingMultiWriter),
    58  }
    59  
    60  func init() {
    61  	cli.Register("vm.disk.create", &create{})
    62  }
    63  
    64  func (cmd *create) Register(ctx context.Context, f *flag.FlagSet) {
    65  	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
    66  	cmd.DatastoreFlag.Register(ctx, f)
    67  	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
    68  	cmd.OutputFlag.Register(ctx, f)
    69  	cmd.VirtualMachineFlag, ctx = flags.NewVirtualMachineFlag(ctx)
    70  	cmd.VirtualMachineFlag.Register(ctx, f)
    71  
    72  	err := (&cmd.Bytes).Set("10G")
    73  	if err != nil {
    74  		panic(err)
    75  	}
    76  
    77  	f.StringVar(&cmd.controller, "controller", "", "Disk controller")
    78  	f.StringVar(&cmd.Name, "name", "", "Name for new disk")
    79  	f.Var(&cmd.Bytes, "size", "Size of new disk")
    80  	f.BoolVar(&cmd.Thick, "thick", false, "Thick provision new disk")
    81  	f.BoolVar(&cmd.Eager, "eager", false, "Eagerly scrub new disk")
    82  	f.StringVar(&cmd.DiskMode, "mode", vdmTypes[0], fmt.Sprintf("Disk mode (%s)", strings.Join(vdmTypes, "|")))
    83  	f.StringVar(&cmd.Sharing, "sharing", "", fmt.Sprintf("Sharing (%s)", strings.Join(sharing, "|")))
    84  }
    85  
    86  func (cmd *create) Process(ctx context.Context) error {
    87  	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
    88  		return err
    89  	}
    90  	if err := cmd.OutputFlag.Process(ctx); err != nil {
    91  		return err
    92  	}
    93  	if err := cmd.VirtualMachineFlag.Process(ctx); err != nil {
    94  		return err
    95  	}
    96  	return nil
    97  }
    98  
    99  func (cmd *create) Description() string {
   100  	return `Create disk and attach to VM.
   101  
   102  Examples:
   103    govc vm.disk.create -vm $name -name $name/disk1 -size 10G
   104    govc vm.disk.create -vm $name -name $name/disk2 -size 10G -eager -thick -sharing sharingMultiWriter`
   105  }
   106  
   107  func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
   108  	if len(cmd.Name) == 0 {
   109  		return errors.New("please specify a disk name")
   110  	}
   111  
   112  	vm, err := cmd.VirtualMachine()
   113  	if err != nil {
   114  		return err
   115  	}
   116  	if vm == nil {
   117  		return errors.New("please specify a vm")
   118  	}
   119  
   120  	ds, err := cmd.Datastore()
   121  	if err != nil {
   122  		return err
   123  	}
   124  
   125  	devices, err := vm.Device(ctx)
   126  	if err != nil {
   127  		return err
   128  	}
   129  
   130  	controller, err := devices.FindDiskController(cmd.controller)
   131  	if err != nil {
   132  		return err
   133  	}
   134  
   135  	vdmMatch := false
   136  	for _, vdm := range vdmTypes {
   137  		if cmd.DiskMode == vdm {
   138  			vdmMatch = true
   139  		}
   140  	}
   141  
   142  	if !vdmMatch {
   143  		return errors.New("please specify a valid disk mode")
   144  	}
   145  
   146  	disk := devices.CreateDisk(controller, ds.Reference(), ds.Path(cmd.Name))
   147  
   148  	existing := devices.SelectByBackingInfo(disk.Backing)
   149  
   150  	if len(existing) > 0 {
   151  		_, _ = cmd.Log("Disk already present\n")
   152  		return nil
   153  	}
   154  
   155  	backing := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo)
   156  
   157  	if cmd.Thick {
   158  		backing.ThinProvisioned = types.NewBool(false)
   159  		backing.EagerlyScrub = types.NewBool(cmd.Eager)
   160  	}
   161  
   162  	backing.DiskMode = cmd.DiskMode
   163  	backing.Sharing = cmd.Sharing
   164  
   165  	_, _ = cmd.Log("Creating disk\n")
   166  	disk.CapacityInKB = int64(cmd.Bytes) / 1024
   167  	return vm.AddDevice(ctx, disk)
   168  }