github.com/vmware/govmomi@v0.51.0/simulator/datastore_namespace_manager.go (about)

     1  // © Broadcom. All Rights Reserved.
     2  // The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package simulator
     6  
     7  import (
     8  	"path"
     9  	"strings"
    10  
    11  	"github.com/vmware/govmomi/internal"
    12  	"github.com/vmware/govmomi/object"
    13  	"github.com/vmware/govmomi/vim25/methods"
    14  	"github.com/vmware/govmomi/vim25/mo"
    15  	"github.com/vmware/govmomi/vim25/soap"
    16  	"github.com/vmware/govmomi/vim25/types"
    17  )
    18  
    19  type DatastoreNamespaceManager struct {
    20  	mo.DatastoreNamespaceManager
    21  }
    22  
    23  func (m *DatastoreNamespaceManager) ConvertNamespacePathToUuidPath(ctx *Context, req *types.ConvertNamespacePathToUuidPath) soap.HasFault {
    24  	body := new(methods.ConvertNamespacePathToUuidPathBody)
    25  
    26  	if req.Datacenter == nil {
    27  		body.Fault_ = Fault("", &types.InvalidArgument{InvalidProperty: "datacenterRef"})
    28  		return body
    29  	}
    30  
    31  	dc, ok := ctx.Map.Get(*req.Datacenter).(*Datacenter)
    32  	if !ok {
    33  		body.Fault_ = Fault("", &types.ManagedObjectNotFound{Obj: *req.Datacenter})
    34  		return body
    35  	}
    36  
    37  	var ds *Datastore
    38  	ns := ""
    39  
    40  	for _, ref := range dc.Datastore {
    41  		ds = ctx.Map.Get(ref).(*Datastore)
    42  		ns = strings.TrimPrefix(req.NamespaceUrl, ds.Summary.Url)
    43  		if ns != req.NamespaceUrl {
    44  			break
    45  		}
    46  		ds = nil
    47  	}
    48  
    49  	if ds == nil {
    50  		body.Fault_ = Fault("", &types.InvalidDatastorePath{DatastorePath: req.NamespaceUrl})
    51  		return body
    52  	}
    53  
    54  	if !internal.IsDatastoreVSAN(ds.Datastore) {
    55  		body.Fault_ = Fault("", &types.InvalidDatastore{Datastore: &ds.Self})
    56  		return body
    57  	}
    58  
    59  	body.Res = &types.ConvertNamespacePathToUuidPathResponse{
    60  		Returnval: ds.resolve(ctx, ns),
    61  	}
    62  
    63  	return body
    64  }
    65  
    66  func (m *DatastoreNamespaceManager) CreateDirectory(ctx *Context, req *types.CreateDirectory) soap.HasFault {
    67  	body := new(methods.CreateDirectoryBody)
    68  
    69  	ds, ok := ctx.Map.Get(req.Datastore).(*Datastore)
    70  	if !ok {
    71  		body.Fault_ = Fault("", &types.ManagedObjectNotFound{Obj: req.Datastore})
    72  		return body
    73  	}
    74  
    75  	if !internal.IsDatastoreVSAN(ds.Datastore) {
    76  		body.Fault_ = Fault("", &types.CannotCreateFile{
    77  			FileFault: types.FileFault{
    78  				File: "Datastore not supported for directory creation by DatastoreNamespaceManager",
    79  			},
    80  		})
    81  		return body
    82  	}
    83  
    84  	if !isValidFileName(req.DisplayName) {
    85  		body.Fault_ = Fault("", &types.InvalidDatastorePath{DatastorePath: req.DisplayName})
    86  		return body
    87  	}
    88  
    89  	p := object.DatastorePath{
    90  		Datastore: ds.Name,
    91  		Path:      req.DisplayName,
    92  	}
    93  
    94  	dc := ctx.Map.getEntityDatacenter(ds)
    95  
    96  	fm := ctx.Map.FileManager()
    97  
    98  	fault := fm.MakeDirectory(ctx, &types.MakeDirectory{
    99  		This:       fm.Self,
   100  		Name:       p.String(),
   101  		Datacenter: &dc.Self,
   102  	})
   103  
   104  	if fault.Fault() != nil {
   105  		body.Fault_ = fault.Fault()
   106  	} else {
   107  		body.Res = &types.CreateDirectoryResponse{
   108  			Returnval: ds.resolve(ctx, req.DisplayName),
   109  		}
   110  	}
   111  
   112  	return body
   113  }
   114  
   115  func (m *DatastoreNamespaceManager) DeleteDirectory(ctx *Context, req *types.DeleteDirectory) soap.HasFault {
   116  	body := new(methods.DeleteDirectoryBody)
   117  
   118  	if req.Datacenter == nil {
   119  		body.Fault_ = Fault("", &types.InvalidArgument{InvalidProperty: "datacenterRef"})
   120  		return body
   121  	}
   122  
   123  	dc, ok := ctx.Map.Get(*req.Datacenter).(*Datacenter)
   124  	if !ok {
   125  		body.Fault_ = Fault("", &types.ManagedObjectNotFound{Obj: *req.Datacenter})
   126  		return body
   127  	}
   128  
   129  	var ds *Datastore
   130  	for _, ref := range dc.Datastore {
   131  		ds = ctx.Map.Get(ref).(*Datastore)
   132  		if strings.HasPrefix(req.DatastorePath, ds.Summary.Url) {
   133  			break
   134  		}
   135  		ds = nil
   136  	}
   137  
   138  	if ds == nil || strings.Contains(req.DatastorePath, "..") {
   139  		body.Fault_ = Fault("", &types.InvalidDatastorePath{DatastorePath: req.DatastorePath})
   140  		return body
   141  	}
   142  
   143  	if !internal.IsDatastoreVSAN(ds.Datastore) {
   144  		body.Fault_ = Fault("", &types.FileFault{
   145  			File: "Datastore not supported for directory deletion by DatastoreNamespaceManager",
   146  		})
   147  		return body
   148  	}
   149  
   150  	name := &object.DatastorePath{
   151  		Datastore: ds.Name,
   152  		Path:      path.Base(req.DatastorePath),
   153  	}
   154  
   155  	fm := ctx.Map.FileManager()
   156  
   157  	fault := fm.deleteDatastoreFile(ctx, &types.DeleteDatastoreFile_Task{
   158  		Name:       name.String(),
   159  		Datacenter: req.Datacenter,
   160  	})
   161  
   162  	if fault != nil {
   163  		body.Fault_ = Fault("", fault)
   164  	} else {
   165  		body.Res = new(types.DeleteDirectoryResponse)
   166  	}
   167  
   168  	return body
   169  }
   170  
   171  func isValidFileName(s string) bool {
   172  	return !strings.Contains(s, "/") &&
   173  		!strings.Contains(s, "\\") &&
   174  		!strings.Contains(s, "..")
   175  }