package internal

import "github.com/vmware/govmomi/simulator/internal"

Index ¶

• Variables
• type Fetch
• type FetchBody
• func (b *FetchBody) Fault() *soap.Fault
• type FetchResponse
• type InternalServiceInstanceContent
• type ObjectLock
• func NewObjectLock(lock sync.Locker) *ObjectLock
• func (l *ObjectLock) Acquire(onBehalfOf SharedLockingContext)
• func (l *ObjectLock) Release(onBehalfOf SharedLockingContext)
• type RetrieveInternalContent
• type RetrieveInternalContentBody
• func (b *RetrieveInternalContentBody) Fault() *soap.Fault
• type RetrieveInternalContentResponse
• type Server
• func NewServer(handler http.Handler) *Server
• func NewTLSServer(handler http.Handler) *Server
• func NewUnstartedServer(handler http.Handler, serve string) *Server
• func (s *Server) Certificate() *x509.Certificate
• func (s *Server) Client() *http.Client
• func (s *Server) Close()
• func (s *Server) CloseClientConnections()
• func (s *Server) Start()
• func (s *Server) StartTLS()
• type SharedLockingContext

Variables ¶

var LocalhostCert = []byte("" /* 1181 byte string literal not displayed */)

LocalhostCert is a PEM-encoded TLS cert with SAN IPs "127.0.0.1" and "[::1]", expiring at Jan 29 16:00:00 2084 GMT. generated from src/crypto/tls: go run generate_cert.go --rsa-bits 2048 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h

Please note the certificate was updated to 2048 bits due to macOS now requiring RSA keys of at least 2048 bits. For more information, please see: https://developer.apple.com/documentation/security/preventing_insecure_network_connections

var LocalhostKey = []byte("" /* 1705 byte string literal not displayed */)

LocalhostKey is the private key for localhostCert.

Types ¶

type Fetch ¶

type Fetch struct {
	This types.ManagedObjectReference `xml:"_this"`
	Prop string                       `xml:"prop"`
}

type FetchBody ¶

type FetchBody struct {
	Req    *Fetch         `xml:"Fetch,omitempty"`
	Res    *FetchResponse `xml:"FetchResponse,omitempty"`
	Fault_ *soap.Fault    `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
}

func (*FetchBody) Fault ¶

func (b *FetchBody) Fault() *soap.Fault

type FetchResponse ¶

type FetchResponse struct {
	Returnval types.AnyType `xml:"returnval,omitempty,typeattr"`
}

type InternalServiceInstanceContent ¶

type InternalServiceInstanceContent struct {
	types.DynamicData

	NfcService types.ManagedObjectReference `xml:"nfcService"`
}

type ObjectLock ¶

type ObjectLock struct {
	// contains filtered or unexported fields
}

ObjectLock implements a basic "reference-counted" mutex, where a single SharedLockingContext can "share" the lock across code paths or child tasks.

func NewObjectLock ¶

func NewObjectLock(lock sync.Locker) *ObjectLock

NewObjectLock creates a new ObjectLock. Pass new(sync.Mutex) if you don't have a custom sync.Locker.

func (*ObjectLock) Acquire ¶

func (l *ObjectLock) Acquire(onBehalfOf SharedLockingContext)

Acquire blocks until it can acquire the lock for onBehalfOf

func (*ObjectLock) Release ¶

func (l *ObjectLock) Release(onBehalfOf SharedLockingContext)

Release decrements the reference count. The caller should pass their context, which is used to sanity check that the Unlock() call is valid. If this is the last reference to the lock for this SharedLockingContext, the lock is Unlocked and can be acquired by another SharedLockingContext.

type RetrieveInternalContent ¶

type RetrieveInternalContent struct {
	This types.ManagedObjectReference `xml:"_this"`
}

type RetrieveInternalContentBody ¶

type RetrieveInternalContentBody struct {
	Res    *RetrieveInternalContentResponse `xml:"RetrieveInternalContentResponse,omitempty"`
	Fault_ *soap.Fault                      `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
}

func (*RetrieveInternalContentBody) Fault ¶

func (b *RetrieveInternalContentBody) Fault() *soap.Fault

type RetrieveInternalContentResponse ¶

type RetrieveInternalContentResponse struct {
	Returnval InternalServiceInstanceContent `xml:"returnval"`
}

type Server ¶

type Server struct {
	URL      string // base URL of form http://ipaddr:port with no trailing slash
	Listener net.Listener

	// TLS is the optional TLS configuration, populated with a new config
	// after TLS is started. If set on an unstarted server before StartTLS
	// is called, existing fields are copied into the new config.
	TLS *tls.Config

	// Config may be changed after calling NewUnstartedServer and
	// before Start or StartTLS.
	Config *http.Server
	// contains filtered or unexported fields
}

A Server is an HTTP server listening on a system-chosen port on the local loopback interface, for use in end-to-end HTTP tests.

func NewServer ¶

func NewServer(handler http.Handler) *Server

NewServer starts and returns a new Server. The caller should call Close when finished, to shut it down.

func NewTLSServer ¶

func NewTLSServer(handler http.Handler) *Server

NewTLSServer starts and returns a new Server using TLS. The caller should call Close when finished, to shut it down.

func NewUnstartedServer ¶

func NewUnstartedServer(handler http.Handler, serve string) *Server

NewUnstartedServer returns a new Server but doesn't start it.

After changing its configuration, the caller should call Start or StartTLS.

The caller should call Close when finished, to shut it down. serve allows the server's listen address to be specified.

func (*Server) Certificate ¶

func (s *Server) Certificate() *x509.Certificate

Certificate returns the certificate used by the server, or nil if the server doesn't use TLS.

func (*Server) Client ¶

func (s *Server) Client() *http.Client

Client returns an HTTP client configured for making requests to the server. It is configured to trust the server's TLS test certificate and will close its idle connections on Server.Close.

func (*Server) Close ¶

func (s *Server) Close()

Close shuts down the server and blocks until all outstanding requests on this server have completed.

func (*Server) CloseClientConnections ¶

func (s *Server) CloseClientConnections()

CloseClientConnections closes any open HTTP connections to the test Server.

func (*Server) Start ¶

func (s *Server) Start()

Start starts a server from NewUnstartedServer.

func (*Server) StartTLS ¶

func (s *Server) StartTLS()

StartTLS starts TLS on a server from NewUnstartedServer.

type SharedLockingContext ¶

type SharedLockingContext interface{}

SharedLockingContext is used to identify when locks can be shared. In practice, simulator code uses the simulator.Context for a request, but in principle this could be anything.

Source Files ¶

object_lock.go server.go testcert.go types.go