add vendoring with go dep

vendor/github.com/vmware/govmomi/session/keep_alive.go

@@ -0,0 +1,127 @@
+/*
+Copyright (c) 2015 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.
+*/
+
+package session
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type keepAlive struct {
+	sync.Mutex
+
+	roundTripper    soap.RoundTripper
+	idleTime        time.Duration
+	notifyRequest   chan struct{}
+	notifyStop      chan struct{}
+	notifyWaitGroup sync.WaitGroup
+
+	// keepAlive executes a request in the background with the purpose of
+	// keeping the session active. The response for this request is discarded.
+	keepAlive func(soap.RoundTripper) error
+}
+
+func defaultKeepAlive(roundTripper soap.RoundTripper) error {
+	_, _ = methods.GetCurrentTime(context.Background(), roundTripper)
+	return nil
+}
+
+// KeepAlive wraps the specified soap.RoundTripper and executes a meaningless
+// API request in the background after the RoundTripper has been idle for the
+// specified amount of idle time. The keep alive process only starts once a
+// user logs in and runs until the user logs out again.
+func KeepAlive(roundTripper soap.RoundTripper, idleTime time.Duration) soap.RoundTripper {
+	return KeepAliveHandler(roundTripper, idleTime, defaultKeepAlive)
+}
+
+// KeepAliveHandler works as KeepAlive() does, but the handler param can decide how to handle errors.
+// For example, if connectivity to ESX/VC is down long enough for a session to expire, a handler can choose to
+// Login() on a types.NotAuthenticated error.  If handler returns non-nil, the keep alive go routine will be stopped.
+func KeepAliveHandler(roundTripper soap.RoundTripper, idleTime time.Duration, handler func(soap.RoundTripper) error) soap.RoundTripper {
+	k := &keepAlive{
+		roundTripper:  roundTripper,
+		idleTime:      idleTime,
+		notifyRequest: make(chan struct{}),
+	}
+
+	k.keepAlive = handler
+
+	return k
+}
+
+func (k *keepAlive) start() {
+	k.Lock()
+	defer k.Unlock()
+
+	if k.notifyStop != nil {
+		return
+	}
+
+	// This channel must be closed to terminate idle timer.
+	k.notifyStop = make(chan struct{})
+	k.notifyWaitGroup.Add(1)
+
+	go func() {
+		defer k.notifyWaitGroup.Done()
+
+		for t := time.NewTimer(k.idleTime); ; {
+			select {
+			case <-k.notifyStop:
+				return
+			case <-k.notifyRequest:
+				t.Reset(k.idleTime)
+			case <-t.C:
+				if err := k.keepAlive(k.roundTripper); err != nil {
+					k.stop()
+				}
+				t = time.NewTimer(k.idleTime)
+			}
+		}
+	}()
+}
+
+func (k *keepAlive) stop() {
+	k.Lock()
+	defer k.Unlock()
+
+	if k.notifyStop != nil {
+		close(k.notifyStop)
+		k.notifyWaitGroup.Wait()
+		k.notifyStop = nil
+	}
+}
+
+func (k *keepAlive) RoundTrip(ctx context.Context, req, res soap.HasFault) error {
+	err := k.roundTripper.RoundTrip(ctx, req, res)
+	if err != nil {
+		return err
+	}
+
+	// Start ticker on login, stop ticker on logout.
+	switch req.(type) {
+	case *methods.LoginBody, *methods.LoginExtensionByCertificateBody:
+		k.start()
+	case *methods.LogoutBody:
+		k.stop()
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/session/keep_alive_test.go

@@ -0,0 +1,280 @@
+/*
+Copyright (c) 2015 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.
+*/
+
+package session
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"os"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/vmware/govmomi/test"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type testKeepAlive int
+
+func (t *testKeepAlive) Func(soap.RoundTripper) error {
+	*t++
+	return nil
+}
+
+func newManager(t *testing.T) (*Manager, *url.URL) {
+	u := test.URL()
+	if u == nil {
+		t.SkipNow()
+	}
+
+	soapClient := soap.NewClient(u, true)
+	vimClient, err := vim25.NewClient(context.Background(), soapClient)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return NewManager(vimClient), u
+}
+
+func TestKeepAlive(t *testing.T) {
+	var i testKeepAlive
+	var j int
+
+	m, u := newManager(t)
+	k := KeepAlive(m.client.RoundTripper, time.Millisecond)
+	k.(*keepAlive).keepAlive = i.Func
+	m.client.RoundTripper = k
+
+	// Expect keep alive to not have triggered yet
+	if i != 0 {
+		t.Errorf("Expected i == 0, got i: %d", i)
+	}
+
+	// Logging in starts keep alive
+	err := m.Login(context.Background(), u.User)
+	if err != nil {
+		t.Error(err)
+	}
+
+	time.Sleep(2 * time.Millisecond)
+
+	// Expect keep alive to triggered at least once
+	if i == 0 {
+		t.Errorf("Expected i != 0, got i: %d", i)
+	}
+
+	j = int(i)
+	time.Sleep(2 * time.Millisecond)
+
+	// Expect keep alive to triggered at least once more
+	if int(i) <= j {
+		t.Errorf("Expected i > j, got i: %d, j: %d", i, j)
+	}
+
+	// Logging out stops keep alive
+	err = m.Logout(context.Background())
+	if err != nil {
+		t.Error(err)
+	}
+
+	j = int(i)
+	time.Sleep(2 * time.Millisecond)
+
+	// Expect keep alive to have stopped
+	if int(i) != j {
+		t.Errorf("Expected i == j, got i: %d, j: %d", i, j)
+	}
+}
+
+func testSessionOK(t *testing.T, m *Manager, ok bool) {
+	s, err := m.UserSession(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, file, line, _ := runtime.Caller(1)
+	prefix := fmt.Sprintf("%s:%d", file, line)
+
+	if ok && s == nil {
+		t.Fatalf("%s: Expected session to be OK, but is invalid", prefix)
+	}
+
+	if !ok && s != nil {
+		t.Fatalf("%s: Expected session to be invalid, but is OK", prefix)
+	}
+}
+
+// Run with:
+//
+//   env GOVMOMI_KEEPALIVE_TEST=1 go test -timeout=60m -run TestRealKeepAlive
+//
+func TestRealKeepAlive(t *testing.T) {
+	if os.Getenv("GOVMOMI_KEEPALIVE_TEST") != "1" {
+		t.SkipNow()
+	}
+
+	m1, u1 := newManager(t)
+	m2, u2 := newManager(t)
+
+	// Enable keepalive on m2
+	k := KeepAlive(m2.client.RoundTripper, 10*time.Minute)
+	m2.client.RoundTripper = k
+
+	// Expect both sessions to be invalid
+	testSessionOK(t, m1, false)
+	testSessionOK(t, m2, false)
+
+	// Logging in starts keep alive
+	if err := m1.Login(context.Background(), u1.User); err != nil {
+		t.Error(err)
+	}
+	if err := m2.Login(context.Background(), u2.User); err != nil {
+		t.Error(err)
+	}
+
+	// Expect both sessions to be valid
+	testSessionOK(t, m1, true)
+	testSessionOK(t, m2, true)
+
+	// Wait for m1 to time out
+	delay := 31 * time.Minute
+	fmt.Printf("%s: Waiting %d minutes for session to time out...\n", time.Now(), int(delay.Minutes()))
+	time.Sleep(delay)
+
+	// Expect m1's session to be invalid, m2's session to be valid
+	testSessionOK(t, m1, false)
+	testSessionOK(t, m2, true)
+}
+
+func isNotAuthenticated(err error) bool {
+	if soap.IsSoapFault(err) {
+		switch soap.ToSoapFault(err).VimFault().(type) {
+		case types.NotAuthenticated:
+			return true
+		}
+	}
+	return false
+}
+
+func isInvalidLogin(err error) bool {
+	if soap.IsSoapFault(err) {
+		switch soap.ToSoapFault(err).VimFault().(type) {
+		case types.InvalidLogin:
+			return true
+		}
+	}
+	return false
+}
+
+func TestKeepAliveHandler(t *testing.T) {
+	u := test.URL()
+	if u == nil {
+		t.SkipNow()
+	}
+
+	m1, u1 := newManager(t)
+	m2, u2 := newManager(t)
+
+	reauth := make(chan bool)
+
+	// Keep alive handler that will re-login.
+	// Real-world case: connectivity to ESX/VC is down long enough for the session to expire
+	// Test-world case: we call TerminateSession below
+	k := KeepAliveHandler(m2.client.RoundTripper, 2*time.Second, func(roundTripper soap.RoundTripper) error {
+		_, err := methods.GetCurrentTime(context.Background(), roundTripper)
+		if err != nil {
+			if isNotAuthenticated(err) {
+				err = m2.Login(context.Background(), u2.User)
+
+				if err != nil {
+					if isInvalidLogin(err) {
+						reauth <- false
+						t.Log("failed to re-authenticate, quitting keep alive handler")
+						return err
+					}
+				} else {
+					reauth <- true
+				}
+			}
+		}
+
+		return nil
+	})
+
+	m2.client.RoundTripper = k
+
+	// Logging in starts keep alive
+	if err := m1.Login(context.Background(), u1.User); err != nil {
+		t.Error(err)
+	}
+	if err := m2.Login(context.Background(), u2.User); err != nil {
+		t.Error(err)
+	}
+
+	// Terminate session for m2.  Note that self terminate fails, so we need 2 sessions for this test.
+	s, err := m2.UserSession(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = m1.TerminateSession(context.Background(), []string{s.Key})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = methods.GetCurrentTime(context.Background(), m2.client)
+	if err == nil {
+		t.Error("expected to fail")
+	}
+
+	// Wait for keepalive to re-authenticate
+	<-reauth
+
+	_, err = methods.GetCurrentTime(context.Background(), m2.client)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Clear credentials to test re-authentication failure
+	u2.User = nil
+
+	s, err = m2.UserSession(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = m1.TerminateSession(context.Background(), []string{s.Key})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Wait for keepalive re-authenticate attempt
+	result := <-reauth
+
+	_, err = methods.GetCurrentTime(context.Background(), m2.client)
+	if err == nil {
+		t.Error("expected to fail")
+	}
+
+	if result {
+		t.Errorf("expected reauth to fail")
+	}
+}

vendor/github.com/vmware/govmomi/session/manager.go

@@ -0,0 +1,201 @@
+/*
+Copyright (c) 2015 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.
+*/
+
+package session
+
+import (
+	"context"
+	"net/url"
+	"os"
+
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Locale defaults to "en_US" and can be overridden via this var or the GOVMOMI_LOCALE env var.
+// A value of "_" uses the server locale setting.
+var Locale = os.Getenv("GOVMOMI_LOCALE")
+
+func init() {
+	if Locale == "_" {
+		Locale = ""
+	} else if Locale == "" {
+		Locale = "en_US"
+	}
+}
+
+type Manager struct {
+	client      *vim25.Client
+	userSession *types.UserSession
+}
+
+func NewManager(client *vim25.Client) *Manager {
+	m := Manager{
+		client: client,
+	}
+
+	return &m
+}
+
+func (sm Manager) Reference() types.ManagedObjectReference {
+	return *sm.client.ServiceContent.SessionManager
+}
+
+func (sm *Manager) SetLocale(ctx context.Context, locale string) error {
+	req := types.SetLocale{
+		This:   sm.Reference(),
+		Locale: locale,
+	}
+
+	_, err := methods.SetLocale(ctx, sm.client, &req)
+	return err
+}
+
+func (sm *Manager) Login(ctx context.Context, u *url.Userinfo) error {
+	req := types.Login{
+		This:   sm.Reference(),
+		Locale: Locale,
+	}
+
+	if u != nil {
+		req.UserName = u.Username()
+		if pw, ok := u.Password(); ok {
+			req.Password = pw
+		}
+	}
+
+	login, err := methods.Login(ctx, sm.client, &req)
+	if err != nil {
+		return err
+	}
+
+	sm.userSession = &login.Returnval
+	return nil
+}
+
+func (sm *Manager) LoginExtensionByCertificate(ctx context.Context, key string, locale string) error {
+	req := types.LoginExtensionByCertificate{
+		This:         sm.Reference(),
+		ExtensionKey: key,
+		Locale:       locale,
+	}
+
+	login, err := methods.LoginExtensionByCertificate(ctx, sm.client, &req)
+	if err != nil {
+		return err
+	}
+
+	sm.userSession = &login.Returnval
+	return nil
+}
+
+func (sm *Manager) Logout(ctx context.Context) error {
+	req := types.Logout{
+		This: sm.Reference(),
+	}
+
+	_, err := methods.Logout(ctx, sm.client, &req)
+	if err != nil {
+		return err
+	}
+
+	sm.userSession = nil
+	return nil
+}
+
+// UserSession retrieves and returns the SessionManager's CurrentSession field.
+// Nil is returned if the session is not authenticated.
+func (sm *Manager) UserSession(ctx context.Context) (*types.UserSession, error) {
+	var mgr mo.SessionManager
+
+	pc := property.DefaultCollector(sm.client)
+	err := pc.RetrieveOne(ctx, sm.Reference(), []string{"currentSession"}, &mgr)
+	if err != nil {
+		// It's OK if we can't retrieve properties because we're not authenticated
+		if f, ok := err.(types.HasFault); ok {
+			switch f.Fault().(type) {
+			case *types.NotAuthenticated:
+				return nil, nil
+			}
+		}
+
+		return nil, err
+	}
+
+	return mgr.CurrentSession, nil
+}
+
+func (sm *Manager) TerminateSession(ctx context.Context, sessionId []string) error {
+	req := types.TerminateSession{
+		This:      sm.Reference(),
+		SessionId: sessionId,
+	}
+
+	_, err := methods.TerminateSession(ctx, sm.client, &req)
+	return err
+}
+
+// SessionIsActive checks whether the session that was created at login is
+// still valid. This function only works against vCenter.
+func (sm *Manager) SessionIsActive(ctx context.Context) (bool, error) {
+	if sm.userSession == nil {
+		return false, nil
+	}
+
+	req := types.SessionIsActive{
+		This:      sm.Reference(),
+		SessionID: sm.userSession.Key,
+		UserName:  sm.userSession.UserName,
+	}
+
+	active, err := methods.SessionIsActive(ctx, sm.client, &req)
+	if err != nil {
+		return false, err
+	}
+
+	return active.Returnval, err
+}
+
+func (sm *Manager) AcquireGenericServiceTicket(ctx context.Context, spec types.BaseSessionManagerServiceRequestSpec) (*types.SessionManagerGenericServiceTicket, error) {
+	req := types.AcquireGenericServiceTicket{
+		This: sm.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.AcquireGenericServiceTicket(ctx, sm.client, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (sm *Manager) AcquireLocalTicket(ctx context.Context, userName string) (*types.SessionManagerLocalTicket, error) {
+	req := types.AcquireLocalTicket{
+		This:     sm.Reference(),
+		UserName: userName,
+	}
+
+	res, err := methods.AcquireLocalTicket(ctx, sm.client, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/session/manager_test.go

@@ -0,0 +1,106 @@
+/*
+Copyright (c) 2015 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.
+*/
+
+package session
+
+import (
+	"context"
+	"net/url"
+	"testing"
+
+	"github.com/vmware/govmomi/test"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+func sessionClient(u *url.URL, t *testing.T) *Manager {
+	soapClient := soap.NewClient(u, true)
+	vimClient, err := vim25.NewClient(context.Background(), soapClient)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return NewManager(vimClient)
+}
+
+func TestLogin(t *testing.T) {
+	u := test.URL()
+	if u == nil {
+		t.SkipNow()
+	}
+
+	session := sessionClient(u, t)
+	err := session.Login(context.Background(), u.User)
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+}
+
+func TestLogout(t *testing.T) {
+	u := test.URL()
+	if u == nil {
+		t.SkipNow()
+	}
+
+	session := sessionClient(u, t)
+	err := session.Login(context.Background(), u.User)
+	if err != nil {
+		t.Error("Login Error: ", err)
+	}
+
+	err = session.Logout(context.Background())
+	if err != nil {
+		t.Errorf("Expected nil, got %v", err)
+	}
+
+	err = session.Logout(context.Background())
+	if err == nil {
+		t.Errorf("Expected NotAuthenticated, got nil")
+	}
+}
+
+func TestSessionIsActive(t *testing.T) {
+	u := test.URL()
+	if u == nil {
+		t.SkipNow()
+	}
+
+	session := sessionClient(u, t)
+
+	// Skip test against ESXi -- SessionIsActive is not implemented
+	if session.client.ServiceContent.About.ApiType != "VirtualCenter" {
+		t.Skipf("Talking to %s instead of %s", session.client.ServiceContent.About.ApiType, "VirtualCenter")
+	}
+
+	err := session.Login(context.Background(), u.User)
+	if err != nil {
+		t.Error("Login Error: ", err)
+	}
+
+	active, err := session.SessionIsActive(context.Background())
+	if err != nil || !active {
+		t.Errorf("Expected %t, got %t", true, active)
+		t.Errorf("Expected nil, got %v", err)
+	}
+
+	session.Logout(context.Background())
+
+	active, err = session.SessionIsActive(context.Background())
+	if err == nil || active {
+		t.Errorf("Expected %t, got %t", false, active)
+		t.Errorf("Expected NotAuthenticated, got %v", err)
+	}
+}