github.com/vmware/govmomi@v0.37.1/govc/flags/datastore.go (about)

     1  /*
     2  Copyright (c) 2014-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 flags
    18  
    19  import (
    20  	"context"
    21  	"flag"
    22  	"fmt"
    23  	"os"
    24  
    25  	"github.com/vmware/govmomi/object"
    26  	"github.com/vmware/govmomi/vim25/types"
    27  )
    28  
    29  type DatastoreFlag struct {
    30  	common
    31  
    32  	*DatacenterFlag
    33  
    34  	Name string
    35  
    36  	ds *object.Datastore
    37  }
    38  
    39  var datastoreFlagKey = flagKey("datastore")
    40  
    41  // NewCustomDatastoreFlag creates and returns a new DatastoreFlag without
    42  // trying to retrieve an existing one from the specified context.
    43  func NewCustomDatastoreFlag(ctx context.Context) (*DatastoreFlag, context.Context) {
    44  	v := &DatastoreFlag{}
    45  	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
    46  	return v, ctx
    47  }
    48  
    49  func NewDatastoreFlag(ctx context.Context) (*DatastoreFlag, context.Context) {
    50  	if v := ctx.Value(datastoreFlagKey); v != nil {
    51  		return v.(*DatastoreFlag), ctx
    52  	}
    53  
    54  	v, ctx := NewCustomDatastoreFlag(ctx)
    55  	ctx = context.WithValue(ctx, datastoreFlagKey, v)
    56  	return v, ctx
    57  }
    58  
    59  func (f *DatastoreFlag) Register(ctx context.Context, fs *flag.FlagSet) {
    60  	f.RegisterOnce(func() {
    61  		f.DatacenterFlag.Register(ctx, fs)
    62  
    63  		env := "GOVC_DATASTORE"
    64  		value := os.Getenv(env)
    65  		usage := fmt.Sprintf("Datastore [%s]", env)
    66  		fs.StringVar(&f.Name, "ds", value, usage)
    67  	})
    68  }
    69  
    70  func (f *DatastoreFlag) Process(ctx context.Context) error {
    71  	return f.ProcessOnce(func() error {
    72  		if err := f.DatacenterFlag.Process(ctx); err != nil {
    73  			return err
    74  		}
    75  		return nil
    76  	})
    77  }
    78  
    79  func (flag *DatastoreFlag) IsSet() bool {
    80  	return flag.Name != ""
    81  }
    82  
    83  func (f *DatastoreFlag) Args(args []string) []object.DatastorePath {
    84  	var files []object.DatastorePath
    85  
    86  	for _, arg := range args {
    87  		var p object.DatastorePath
    88  
    89  		if p.FromString(arg) {
    90  			f.Name = p.Datastore
    91  		} else {
    92  			p.Datastore = f.Name
    93  			p.Path = arg
    94  		}
    95  
    96  		files = append(files, p)
    97  	}
    98  
    99  	return files
   100  }
   101  
   102  func (f *DatastoreFlag) Datastore() (*object.Datastore, error) {
   103  	if f.ds != nil {
   104  		return f.ds, nil
   105  	}
   106  
   107  	var p object.DatastorePath
   108  	if p.FromString(f.Name) {
   109  		// Example use case:
   110  		//   -ds "$(govc object.collect -s vm/foo config.files.logDirectory)"
   111  		f.Name = p.Datastore
   112  	}
   113  
   114  	finder, err := f.Finder()
   115  	if err != nil {
   116  		return nil, err
   117  	}
   118  
   119  	if f.ds, err = finder.DatastoreOrDefault(context.TODO(), f.Name); err != nil {
   120  		return nil, err
   121  	}
   122  
   123  	return f.ds, nil
   124  }
   125  
   126  func (flag *DatastoreFlag) DatastoreIfSpecified() (*object.Datastore, error) {
   127  	if flag.Name == "" {
   128  		return nil, nil
   129  	}
   130  	return flag.Datastore()
   131  }
   132  
   133  func (f *DatastoreFlag) DatastorePath(name string) (string, error) {
   134  	ds, err := f.Datastore()
   135  	if err != nil {
   136  		return "", err
   137  	}
   138  
   139  	return ds.Path(name), nil
   140  }
   141  
   142  func (f *DatastoreFlag) Stat(ctx context.Context, file string) (types.BaseFileInfo, error) {
   143  	ds, err := f.Datastore()
   144  	if err != nil {
   145  		return nil, err
   146  	}
   147  
   148  	return ds.Stat(ctx, file)
   149  
   150  }