github.com/vmware/govmomi@v0.43.0/govc/importx/ovf.go (about)

     1  /*
     2  Copyright (c) 2014-2024 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 importx
    18  
    19  import (
    20  	"context"
    21  	"errors"
    22  	"flag"
    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/ovf/importer"
    28  )
    29  
    30  type ovfx struct {
    31  	*flags.DatastoreFlag
    32  	*flags.HostSystemFlag
    33  	*flags.OutputFlag
    34  	*flags.ResourcePoolFlag
    35  	*flags.FolderFlag
    36  
    37  	*OptionsFlag
    38  
    39  	Importer importer.Importer
    40  }
    41  
    42  func init() {
    43  	cli.Register("import.ovf", &ovfx{})
    44  }
    45  
    46  func (cmd *ovfx) Register(ctx context.Context, f *flag.FlagSet) {
    47  	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
    48  	cmd.DatastoreFlag.Register(ctx, f)
    49  	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
    50  	cmd.HostSystemFlag.Register(ctx, f)
    51  	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
    52  	cmd.OutputFlag.Register(ctx, f)
    53  	cmd.ResourcePoolFlag, ctx = flags.NewResourcePoolFlag(ctx)
    54  	cmd.ResourcePoolFlag.Register(ctx, f)
    55  	cmd.FolderFlag, ctx = flags.NewFolderFlag(ctx)
    56  	cmd.FolderFlag.Register(ctx, f)
    57  
    58  	cmd.OptionsFlag, ctx = newOptionsFlag(ctx)
    59  	cmd.OptionsFlag.Register(ctx, f)
    60  
    61  	f.StringVar(&cmd.Importer.Name, "name", "", "Name to use for new entity")
    62  	f.BoolVar(&cmd.Importer.VerifyManifest, "m", false, "Verify checksum of uploaded files against manifest (.mf)")
    63  	f.BoolVar(&cmd.Importer.Hidden, "hidden", false, "Enable hidden properties")
    64  }
    65  
    66  func (cmd *ovfx) Process(ctx context.Context) error {
    67  	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
    68  		return err
    69  	}
    70  	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
    71  		return err
    72  	}
    73  	if err := cmd.OutputFlag.Process(ctx); err != nil {
    74  		return err
    75  	}
    76  	if err := cmd.ResourcePoolFlag.Process(ctx); err != nil {
    77  		return err
    78  	}
    79  	if err := cmd.OptionsFlag.Process(ctx); err != nil {
    80  		return err
    81  	}
    82  	if err := cmd.FolderFlag.Process(ctx); err != nil {
    83  		return err
    84  	}
    85  	return nil
    86  }
    87  
    88  func (cmd *ovfx) Usage() string {
    89  	return "PATH_TO_OVF"
    90  }
    91  
    92  func (cmd *ovfx) Run(ctx context.Context, f *flag.FlagSet) error {
    93  	fpath, err := cmd.Prepare(f)
    94  	if err != nil {
    95  		return err
    96  	}
    97  
    98  	archive := &importer.FileArchive{Path: fpath}
    99  	archive.Client = cmd.Importer.Client
   100  
   101  	cmd.Importer.Archive = archive
   102  
   103  	moref, err := cmd.Importer.Import(context.TODO(), fpath, cmd.Options)
   104  	if err != nil {
   105  		return err
   106  	}
   107  
   108  	vm := object.NewVirtualMachine(cmd.Importer.Client, *moref)
   109  	return cmd.Deploy(vm, cmd.OutputFlag)
   110  }
   111  
   112  func (cmd *ovfx) Prepare(f *flag.FlagSet) (string, error) {
   113  	var err error
   114  
   115  	args := f.Args()
   116  	if len(args) != 1 {
   117  		return "", errors.New("no file specified")
   118  	}
   119  
   120  	cmd.Importer.Log = cmd.OutputFlag.Log
   121  	cmd.Importer.Client, err = cmd.DatastoreFlag.Client()
   122  	if err != nil {
   123  		return "", err
   124  	}
   125  
   126  	cmd.Importer.Datacenter, err = cmd.DatastoreFlag.Datacenter()
   127  	if err != nil {
   128  		return "", err
   129  	}
   130  
   131  	cmd.Importer.Datastore, err = cmd.DatastoreFlag.Datastore()
   132  	if err != nil {
   133  		return "", err
   134  	}
   135  
   136  	cmd.Importer.ResourcePool, err = cmd.ResourcePoolIfSpecified()
   137  	if err != nil {
   138  		return "", err
   139  	}
   140  
   141  	host, err := cmd.HostSystemIfSpecified()
   142  	if err != nil {
   143  		return "", err
   144  	}
   145  
   146  	if cmd.Importer.ResourcePool == nil {
   147  		if host == nil {
   148  			cmd.Importer.ResourcePool, err = cmd.ResourcePoolFlag.ResourcePool()
   149  		} else {
   150  			cmd.Importer.ResourcePool, err = host.ResourcePool(context.TODO())
   151  		}
   152  		if err != nil {
   153  			return "", err
   154  		}
   155  	}
   156  
   157  	cmd.Importer.Finder, err = cmd.DatastoreFlag.Finder()
   158  	if err != nil {
   159  		return "", err
   160  	}
   161  
   162  	cmd.Importer.Host, err = cmd.HostSystemIfSpecified()
   163  	if err != nil {
   164  		return "", err
   165  	}
   166  
   167  	// The folder argument must not be set on a VM in a vApp, otherwise causes
   168  	// InvalidArgument fault: A specified parameter was not correct: pool
   169  	if cmd.Importer.ResourcePool.Reference().Type != "VirtualApp" {
   170  		cmd.Importer.Folder, err = cmd.FolderOrDefault("vm")
   171  		if err != nil {
   172  			return "", err
   173  		}
   174  	}
   175  
   176  	if cmd.Importer.Name == "" {
   177  		// Override name from options if specified
   178  		if cmd.Options.Name != nil {
   179  			cmd.Importer.Name = *cmd.Options.Name
   180  		}
   181  	} else {
   182  		cmd.Options.Name = &cmd.Importer.Name
   183  	}
   184  
   185  	return f.Arg(0), nil
   186  }