github.com/vmware/govmomi@v0.43.0/govc/vm/register.go (about)

     1  /*
     2  Copyright (c) 2016 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 vm
    18  
    19  import (
    20  	"context"
    21  	"flag"
    22  
    23  	"github.com/vmware/govmomi/govc/cli"
    24  	"github.com/vmware/govmomi/govc/flags"
    25  )
    26  
    27  type register struct {
    28  	*flags.DatastoreFlag
    29  	*flags.ResourcePoolFlag
    30  	*flags.HostSystemFlag
    31  	*flags.FolderFlag
    32  
    33  	name     string
    34  	template bool
    35  }
    36  
    37  func init() {
    38  	cli.Register("vm.register", &register{})
    39  }
    40  
    41  func (cmd *register) Register(ctx context.Context, f *flag.FlagSet) {
    42  	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
    43  	cmd.DatastoreFlag.Register(ctx, f)
    44  
    45  	cmd.ResourcePoolFlag, ctx = flags.NewResourcePoolFlag(ctx)
    46  	cmd.ResourcePoolFlag.Register(ctx, f)
    47  
    48  	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
    49  	cmd.HostSystemFlag.Register(ctx, f)
    50  
    51  	cmd.FolderFlag, ctx = flags.NewFolderFlag(ctx)
    52  	cmd.FolderFlag.Register(ctx, f)
    53  
    54  	f.StringVar(&cmd.name, "name", "", "Name of the VM")
    55  	f.BoolVar(&cmd.template, "template", false, "Mark VM as template")
    56  }
    57  
    58  func (cmd *register) Process(ctx context.Context) error {
    59  	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
    60  		return err
    61  	}
    62  	if err := cmd.ResourcePoolFlag.Process(ctx); err != nil {
    63  		return err
    64  	}
    65  	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
    66  		return err
    67  	}
    68  	if err := cmd.FolderFlag.Process(ctx); err != nil {
    69  		return err
    70  	}
    71  
    72  	return nil
    73  }
    74  
    75  func (cmd *register) Usage() string {
    76  	return "VMX"
    77  }
    78  
    79  func (cmd *register) Description() string {
    80  	return `Add an existing VM to the inventory.
    81  
    82  VMX is a path to the vm config file, relative to DATASTORE.
    83  
    84  Examples:
    85    govc vm.register path/name.vmx
    86    govc vm.register -template -host $host path/name.vmx`
    87  }
    88  
    89  func (cmd *register) Run(ctx context.Context, f *flag.FlagSet) error {
    90  	if len(f.Args()) != 1 {
    91  		return flag.ErrHelp
    92  	}
    93  
    94  	pool, err := cmd.ResourcePoolIfSpecified()
    95  	if err != nil {
    96  		return err
    97  	}
    98  
    99  	host, err := cmd.HostSystemFlag.HostSystemIfSpecified()
   100  	if err != nil {
   101  		return err
   102  	}
   103  
   104  	if cmd.template {
   105  		if pool != nil || host == nil {
   106  			return flag.ErrHelp
   107  		}
   108  	} else if pool == nil {
   109  		if host != nil {
   110  			pool, err = host.ResourcePool(ctx)
   111  			if err != nil {
   112  				return err
   113  			}
   114  		} else {
   115  			// neither -host nor -pool were specified, so use the default pool (ESX)
   116  			pool, err = cmd.ResourcePool()
   117  			if err != nil {
   118  				return err
   119  			}
   120  		}
   121  	}
   122  
   123  	folder, err := cmd.FolderFlag.Folder()
   124  	if err != nil {
   125  		return err
   126  	}
   127  
   128  	path, err := cmd.DatastorePath(f.Arg(0))
   129  	if err != nil {
   130  		return err
   131  	}
   132  
   133  	task, err := folder.RegisterVM(ctx, path, cmd.name, cmd.template, pool, host)
   134  	if err != nil {
   135  		return err
   136  	}
   137  
   138  	return task.Wait(ctx)
   139  }