435c0d9fc8
This PR switches the Nomad repository from using govendor to Go modules for managing dependencies. Aspects of the Nomad workflow remain pretty much the same. The usual Makefile targets should continue to work as they always did. The API submodule simply defers to the parent Nomad version on the repository, keeping the semantics of API versioning that currently exists.
137 lines
4.4 KiB
Go
137 lines
4.4 KiB
Go
/*
|
|
Copyright (c) 2014-2016 VMware, Inc. All Rights Reserved.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
This package is the root package of the govmomi library.
|
|
|
|
The library is structured as follows:
|
|
|
|
Package vim25
|
|
|
|
The minimal usable functionality is available through the vim25 package.
|
|
It contains subpackages that contain generated types, managed objects, and all
|
|
available methods. The vim25 package is entirely independent of the other
|
|
packages in the govmomi tree -- it has no dependencies on its peers.
|
|
|
|
The vim25 package itself contains a client structure that is
|
|
passed around throughout the entire library. It abstracts a session and its
|
|
immutable state. See the vim25 package for more information.
|
|
|
|
Package session
|
|
|
|
The session package contains an abstraction for the session manager that allows
|
|
a user to login and logout. It also provides access to the current session
|
|
(i.e. to determine if the user is in fact logged in)
|
|
|
|
Package object
|
|
|
|
The object package contains wrappers for a selection of managed objects. The
|
|
constructors of these objects all take a *vim25.Client, which they pass along
|
|
to derived objects, if applicable.
|
|
|
|
Package govc
|
|
|
|
The govc package contains the govc CLI. The code in this tree is not intended
|
|
to be used as a library. Any functionality that govc contains that _could_ be
|
|
used as a library function but isn't, _should_ live in a root level package.
|
|
|
|
Other packages
|
|
|
|
Other packages, such as "event", "guest", or "license", provide wrappers for
|
|
the respective subsystems. They are typically not needed in normal workflows so
|
|
are kept outside the object package.
|
|
*/
|
|
package govmomi
|
|
|
|
import (
|
|
"context"
|
|
"net/url"
|
|
|
|
"github.com/vmware/govmomi/property"
|
|
"github.com/vmware/govmomi/session"
|
|
"github.com/vmware/govmomi/vim25"
|
|
"github.com/vmware/govmomi/vim25/soap"
|
|
"github.com/vmware/govmomi/vim25/types"
|
|
)
|
|
|
|
type Client struct {
|
|
*vim25.Client
|
|
|
|
SessionManager *session.Manager
|
|
}
|
|
|
|
// NewClient creates a new client from a URL. The client authenticates with the
|
|
// server with username/password before returning if the URL contains user information.
|
|
func NewClient(ctx context.Context, u *url.URL, insecure bool) (*Client, error) {
|
|
soapClient := soap.NewClient(u, insecure)
|
|
vimClient, err := vim25.NewClient(ctx, soapClient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c := &Client{
|
|
Client: vimClient,
|
|
SessionManager: session.NewManager(vimClient),
|
|
}
|
|
|
|
// Only login if the URL contains user information.
|
|
if u.User != nil {
|
|
err = c.Login(ctx, u.User)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return c, nil
|
|
}
|
|
|
|
// Login dispatches to the SessionManager.
|
|
func (c *Client) Login(ctx context.Context, u *url.Userinfo) error {
|
|
return c.SessionManager.Login(ctx, u)
|
|
}
|
|
|
|
// Logout dispatches to the SessionManager.
|
|
func (c *Client) Logout(ctx context.Context) error {
|
|
// Close any idle connections after logging out.
|
|
defer c.Client.CloseIdleConnections()
|
|
return c.SessionManager.Logout(ctx)
|
|
}
|
|
|
|
// PropertyCollector returns the session's default property collector.
|
|
func (c *Client) PropertyCollector() *property.Collector {
|
|
return property.DefaultCollector(c.Client)
|
|
}
|
|
|
|
// RetrieveOne dispatches to the Retrieve function on the default property collector.
|
|
func (c *Client) RetrieveOne(ctx context.Context, obj types.ManagedObjectReference, p []string, dst interface{}) error {
|
|
return c.PropertyCollector().RetrieveOne(ctx, obj, p, dst)
|
|
}
|
|
|
|
// Retrieve dispatches to the Retrieve function on the default property collector.
|
|
func (c *Client) Retrieve(ctx context.Context, objs []types.ManagedObjectReference, p []string, dst interface{}) error {
|
|
return c.PropertyCollector().Retrieve(ctx, objs, p, dst)
|
|
}
|
|
|
|
// Wait dispatches to property.Wait.
|
|
func (c *Client) Wait(ctx context.Context, obj types.ManagedObjectReference, ps []string, f func([]types.PropertyChange) bool) error {
|
|
return property.Wait(ctx, c.PropertyCollector(), obj, ps, f)
|
|
}
|
|
|
|
// IsVC returns true if we are connected to a vCenter
|
|
func (c *Client) IsVC() bool {
|
|
return c.Client.IsVC()
|
|
}
|