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

     1  /*
     2  Copyright (c) 2018 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  	"flag"
    22  	"fmt"
    23  
    24  	"github.com/vmware/govmomi/govc/cli"
    25  	"github.com/vmware/govmomi/govc/flags"
    26  	"github.com/vmware/govmomi/object"
    27  	"github.com/vmware/govmomi/units"
    28  	"github.com/vmware/govmomi/vim25/mo"
    29  	"github.com/vmware/govmomi/vim25/types"
    30  	"github.com/vmware/govmomi/vslm"
    31  )
    32  
    33  type disk struct {
    34  	*flags.DatastoreFlag
    35  	*flags.ResourcePoolFlag
    36  	*flags.StoragePodFlag
    37  
    38  	size units.ByteSize
    39  	keep *bool
    40  }
    41  
    42  func init() {
    43  	cli.Register("disk.create", &disk{})
    44  }
    45  
    46  func (cmd *disk) Register(ctx context.Context, f *flag.FlagSet) {
    47  	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
    48  	cmd.DatastoreFlag.Register(ctx, f)
    49  
    50  	cmd.StoragePodFlag, ctx = flags.NewStoragePodFlag(ctx)
    51  	cmd.StoragePodFlag.Register(ctx, f)
    52  
    53  	cmd.ResourcePoolFlag, ctx = flags.NewResourcePoolFlag(ctx)
    54  	cmd.ResourcePoolFlag.Register(ctx, f)
    55  
    56  	_ = cmd.size.Set("10G")
    57  	f.Var(&cmd.size, "size", "Size of new disk")
    58  	f.Var(flags.NewOptionalBool(&cmd.keep), "keep", "Keep disk after VM is deleted")
    59  }
    60  
    61  func (cmd *disk) Process(ctx context.Context) error {
    62  	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
    63  		return err
    64  	}
    65  	if err := cmd.StoragePodFlag.Process(ctx); err != nil {
    66  		return err
    67  	}
    68  	return cmd.ResourcePoolFlag.Process(ctx)
    69  }
    70  
    71  func (cmd *disk) Usage() string {
    72  	return "NAME"
    73  }
    74  
    75  func (cmd *disk) Description() string {
    76  	return `Create disk NAME on DS.
    77  
    78  Examples:
    79    govc disk.create -size 24G my-disk`
    80  }
    81  
    82  func (cmd *disk) Run(ctx context.Context, f *flag.FlagSet) error {
    83  	name := f.Arg(0)
    84  	if name == "" {
    85  		return flag.ErrHelp
    86  	}
    87  
    88  	c, err := cmd.DatastoreFlag.Client()
    89  	if err != nil {
    90  		return err
    91  	}
    92  
    93  	var pool *object.ResourcePool
    94  	var ds mo.Reference
    95  	if cmd.StoragePodFlag.Isset() {
    96  		ds, err = cmd.StoragePod()
    97  		if err != nil {
    98  			return err
    99  		}
   100  		pool, err = cmd.ResourcePool()
   101  		if err != nil {
   102  			return err
   103  		}
   104  	} else {
   105  		ds, err = cmd.Datastore()
   106  		if err != nil {
   107  			return err
   108  		}
   109  	}
   110  
   111  	m := vslm.NewObjectManager(c)
   112  
   113  	spec := types.VslmCreateSpec{
   114  		Name:              name,
   115  		CapacityInMB:      int64(cmd.size) / units.MB,
   116  		KeepAfterDeleteVm: cmd.keep,
   117  		BackingSpec: &types.VslmCreateSpecDiskFileBackingSpec{
   118  			VslmCreateSpecBackingSpec: types.VslmCreateSpecBackingSpec{
   119  				Datastore: ds.Reference(),
   120  			},
   121  			ProvisioningType: string(types.BaseConfigInfoDiskFileBackingInfoProvisioningTypeThin),
   122  		},
   123  	}
   124  
   125  	if cmd.StoragePodFlag.Isset() {
   126  		if err = m.PlaceDisk(ctx, &spec, pool.Reference()); err != nil {
   127  			return err
   128  		}
   129  	}
   130  
   131  	task, err := m.CreateDisk(ctx, spec)
   132  	if err != nil {
   133  		return nil
   134  	}
   135  
   136  	logger := cmd.DatastoreFlag.ProgressLogger(fmt.Sprintf("Creating %s...", spec.Name))
   137  
   138  	res, err := task.WaitForResult(ctx, logger)
   139  	logger.Wait()
   140  	if err != nil {
   141  		return err
   142  	}
   143  
   144  	fmt.Println(res.Result.(types.VStorageObject).Config.Id.Id)
   145  
   146  	return nil
   147  }