vmware / govcloudair / #83

pending completion

Build # #83

Build Type

Pull #22

drone.io

Committed by

casualjim

Commit Message

<a href="https://github.com/vmware/govcloudair/commit/<a class=hub.com/vmware/govcloudair/commit/97265d07e97de4b198dd8bfab9db2633c8c5b1a0">97265d07e<a href="https://github.com/vmware/govcloudair/commit/97265d07e97de4b198dd8bfab9db2633c8c5b1a0">">Merge </a><a class="double-link" href="https://github.com/vmware/govcloudair/commit/<a class="double-link" href="https://github.com/vmware/govcloudair/commit/ae17dee0b68200e8153a8f99fa724629f99e14c8">ae17dee0b</a>">ae17dee0b</a><a href="https://github.com/vmware/govcloudair/commit/97265d07e97de4b198dd8bfab9db2633c8c5b1a0"> into a1ebb7dd4">a1ebb7dd4</a>

Pull Request Pull Request #22: fix auth for v57

Run Details

27 of 27 new or added lines in 1 file covered. (100.0%)

1040 of 1502 relevant lines covered (69.24%)

4.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.0

/v57/client.go

package v57

import (
        "encoding/json"
        "encoding/xml"
        "fmt"
        "io"
        "net/http"
        "net/http/httputil"
        "net/url"
        "os"
        "strings"
        "time"

        types "github.com/vmware/govcloudair/types/v56"
)

const (
        // LoginPath for vCloud Air
        LoginPath = "/iam/login"
        // InstancesPath for vCloud Air
        InstancesPath = "/sc/instances"
        // HeaderAccept the HTTP accept header key
        HeaderAccept = "Accept"
        // JSONMimeV57 the json mime for version 5.7 of the API
        JSONMimeV57 = "application/json;version=5.7"
        // AnyXMLMime511 the wildcard xml mime for version 5.11 of the API
        AnyXMLMime511 = "application/*+xml;version=5.11"
        // Version511 the 5.11 version
        Version511 = "5.11"
        // Version is the default version number
        Version = Version511
)

// NewClient returns a new empty client to authenticate against the vCloud Air
// service, the vCloud Air endpoint can be overridden by setting the
// VCLOUDAIR_ENDPOINT environment variable.
func NewClient() (*Client, error) {
        var u *url.URL
        var err error

        if os.Getenv("VCLOUDAIR_ENDPOINT") != "" {
                u, err = url.ParseRequestURI(os.Getenv("VCLOUDAIR_ENDPOINT"))
                if err != nil {
                        return nil, fmt.Errorf("cannot parse endpoint coming from VCLOUDAIR_ENDPOINT")
                }
        } else {
                // Implicitly trust this URL parse.
                u, _ = url.ParseRequestURI("https://vca.vmware.com/api")
        }
        return &Client{
                VAEndpoint:    *u,
                Region:        os.Getenv("VCLOUDAIR_REGION"),
                VCDAuthHeader: "X-Vcloud-Authorization",
                http:          http.Client{Transport: &http.Transport{TLSHandshakeTimeout: 120 * time.Second}},
        }, nil
}

// Client provides a client to vCloud Air, values can be populated automatically using the Authenticate method.
type Client struct {
        VAToken       string  // vCloud Air authorization token
        VAEndpoint    url.URL // vCloud Air API endpoint
        Region        string  // Region where the compute resource lives.
        VCDToken      string  // Access Token (authorization header)
        VCDAuthHeader string  // Authorization header
        Links         types.LinkList
        vcdHREF       *url.URL    // HREF of the backend VDC you're using
        http          http.Client // HttpClient is the client to use. Default will be used if not provided.
}

// Authenticate is a helper function that performs a complete login in vCloud
// Air and in the backend vCloud Director instance.
func (c *Client) Authenticate(username, password string) error {
        if username == "" {
                username = os.Getenv("VCLOUDAIR_USERNAME")
        }
        if password == "" {
                password = os.Getenv("VCLOUDAIR_PASSWORD")
        }

        r, _ := http.NewRequest("POST", c.VAEndpoint.String()+LoginPath, nil)
        r.Header.Set("Accept", JSONMimeV57)
        r.SetBasicAuth(username, password)

        resp, err := c.http.Do(r)
        if err != nil {
                return err
        }
        defer resp.Body.Close()

        if resp.StatusCode/100 != 2 {
                return fmt.Errorf("Could not complete request with vca, because (status %d) %s\n", resp.StatusCode, resp.Status)
        }

        var result oAuthClient
        dec := json.NewDecoder(resp.Body)
        if err := dec.Decode(&result); err != nil {
                return err
        }
        result.AuthToken = resp.Header.Get("vchs-authorization")
        c.VAToken = result.AuthToken
        result.Config = c

        instances, err := result.instances()
        if err != nil {
                return err
        }

        var attrs *accountInstanceAttrs
        for _, inst := range instances {
                attrs = inst.Attrs()
                if attrs != nil && (c.Region == "" || strings.HasPrefix(inst.Region, c.Region)) {
                        c.Region = inst.Region
                        break
                }
        }

        if attrs == nil {
                return fmt.Errorf("unable to determine session url")
        }
        attrs.client = c

        return attrs.Authenticate(username, password)
}

// BaseURL the base uril for the vcloud director instance
func (c *Client) BaseURL() url.URL {
        if c.vcdHREF == nil {
                return url.URL{}
        }
        return *c.vcdHREF
}

// DoHTTP performs a http request
func (c *Client) DoHTTP(req *http.Request) (*http.Response, error) {
        if os.Getenv("VCLOUDAIR_DEBUG") != "" {
                dr, _ := httputil.DumpRequestOut(req, true)
                fmt.Println(string(dr))
        }
        resp, err := c.http.Do(req)
        if err != nil {
                return nil, err
        }
        if os.Getenv("VCLOUDAIR_DEBUG") != "" {
                dr, _ := httputil.DumpResponse(resp, true)
                fmt.Println(string(dr))
        }
        return resp, nil
}

// Disconnect performs a disconnection from the vCloud Air API endpoint.
func (c *Client) Disconnect() error {
        return nil
}

// NewRequest creates a new HTTP request and applies necessary auth headers if
// set.
func (c *Client) NewRequest(params map[string]string, method string, u *url.URL, body io.Reader) *http.Request {

        p := url.Values{}

        // Build up our request parameters
        for k, v := range params {
                p.Add(k, v)
        }

        // Add the params to our URL
        u.RawQuery = p.Encode()

        // Build the request, no point in checking for errors here as we're just
        // passing a string version of an url.URL struct and http.NewRequest returns
        // error only if can't process an url.ParseRequestURI().
        req, _ := http.NewRequest(method, u.String(), body)

        if c.VCDToken != "" {
                // Add the authorization header
                req.Header.Add(c.VCDAuthHeader, c.VCDToken)
                // Add the Accept header for VCD
                req.Header.Add("Accept", "application/*+xml;version="+Version)
        }
        return req

}

// NewAuthenticatedSession create a new vCloud Air authenticated client
func NewAuthenticatedSession(user, password string) (*Client, error) {
        client, err := NewClient()
        if err != nil {
                return nil, err
        }

        if err := client.Authenticate(user, password); err != nil {
                return nil, err
        }

        return client, nil
}

type oAuthClient struct {
        AuthToken       string   `json:"-"`
        Config          *Client  `json:"-"`
        ServiceGroupIDs []string `json:"serviceGroupIds"`
        Info            struct {
                Instances []accountInstance `json:"instances"`
        }
}

func (a *oAuthClient) instances() ([]accountInstance, error) {
        if err := a.JSONRequest("GET", InstancesPath, &a.Info); err != nil {
                return nil, err
        }
        return a.Info.Instances, nil
}

func (a *oAuthClient) JSONRequest(method, path string, result interface{}) error {
        r, _ := http.NewRequest(method, a.Config.VAEndpoint.String()+path, nil)
        r.Header.Set(HeaderAccept, JSONMimeV57)

        if a.AuthToken != "" {
                r.Header.Set("Authorization", "Bearer "+a.AuthToken)
        }

        resp, err := a.Config.http.Do(r)
        if err != nil {
                return err
        }
        defer resp.Body.Close()

        if resp.StatusCode/100 != 2 {
                return fmt.Errorf("Could not complete request with vca, because (status %d) %s\n", resp.StatusCode, resp.Status)
        }

        dec := json.NewDecoder(resp.Body)
        if err := dec.Decode(result); err != nil {
                return err
        }

        return nil
}

type accountInstance struct {
        APIURL             string   `json:"apiUrl"`
        DashboardURL       string   `json:"dashboardUrl"`
        Description        string   `json:"description"`
        ID                 string   `json:"id"`
        InstanceAttributes string   `json:"instanceAttributes"`
        InstanceVersion    string   `json:"instanceVersion"`
        Link               []string `json:"link"`
        Name               string   `json:"name"`
        PlanID             string   `json:"planId"`
        Region             string   `json:"region"`
        ServiceGroupID     string   `json:"serviceGroupId"`
}

func (a *accountInstance) Attrs() *accountInstanceAttrs {
        if !strings.HasPrefix(a.InstanceAttributes, "{") {
                return nil
        }

        var res accountInstanceAttrs
        if err := json.Unmarshal([]byte(a.InstanceAttributes), &res); err != nil {
                return nil
        }
        return &res
}

type accountInstanceAttrs struct {
        OrgName       string `json:"orgName"`
        SessionURI    string `json:"sessionUri"`
        APIVersionURI string `json:"apiVersionUri"`
        client        *Client
}

func (a *accountInstanceAttrs) Authenticate(user, password string) error {
        r, _ := http.NewRequest("POST", a.SessionURI, nil)
        r.Header.Set(HeaderAccept, AnyXMLMime511)
        r.SetBasicAuth(user+"@"+a.OrgName, password)

        resp, err := a.client.http.Do(r)
        if err != nil {
                return err
        }
        defer resp.Body.Close()

        if resp.StatusCode/100 != 2 {
                return fmt.Errorf("Could not complete authenticating with vCloud, because (status %d) %s\n", resp.StatusCode, resp.Status)
        }

        var ses session
        dec := xml.NewDecoder(resp.Body)
        if err := dec.Decode(&ses); err != nil {
                return err
        }

        a.client.VCDToken = resp.Header.Get("x-vcloud-authorization")
        a.client.Links = ses.Links

        return nil
}

// Session represents an authenticated session for the vCloud Air API
type session struct {
        // ResourceType
        HREF  string         `xml:"href,attr,omitempty"`
        Type  string         `xml:"type,attr,omitempty"`
        Links types.LinkList `xml:"Link,omitempty"`

        // SessionType
        Org    string `xml:"org,attr,omitempty"`
        Roles  string `xml:"roles,attr,omitempty"`
        User   string `xml:"user,attr,omitempty"`
        UserID string `xml:"userId,attr,omitempty"`
}

1	package v57
2
3	import (
4	"encoding/json"
5	"encoding/xml"
6	"fmt"
7	"io"
8	"net/http"
9	"net/http/httputil"
10	"net/url"
11	"os"
12	"strings"
13	"time"
14
15	types "github.com/vmware/govcloudair/types/v56"
16	)
17
18	const (
19	// LoginPath for vCloud Air
20	LoginPath = "/iam/login"
21	// InstancesPath for vCloud Air
22	InstancesPath = "/sc/instances"
23	// HeaderAccept the HTTP accept header key
24	HeaderAccept = "Accept"
25	// JSONMimeV57 the json mime for version 5.7 of the API
26	JSONMimeV57 = "application/json;version=5.7"
27	// AnyXMLMime511 the wildcard xml mime for version 5.11 of the API
28	AnyXMLMime511 = "application/*+xml;version=5.11"
29	// Version511 the 5.11 version
30	Version511 = "5.11"
31	// Version is the default version number
32	Version = Version511
33	)
34
35	// NewClient returns a new empty client to authenticate against the vCloud Air
36	// service, the vCloud Air endpoint can be overridden by setting the
37	// VCLOUDAIR_ENDPOINT environment variable.
38	func NewClient() (*Client, error) {	1✔
39	var u *url.URL	1✔
40	var err error	1✔
41		1✔
42	if os.Getenv("VCLOUDAIR_ENDPOINT") != "" {	1✔
43	u, err = url.ParseRequestURI(os.Getenv("VCLOUDAIR_ENDPOINT"))	1✔
44	if err != nil {	×
45	return nil, fmt.Errorf("cannot parse endpoint coming from VCLOUDAIR_ENDPOINT")	×
46	}	×
47	} else {	×
48	// Implicitly trust this URL parse.	×
49	u, _ = url.ParseRequestURI("https://vca.vmware.com/api")	×
50	}	×
51	return &Client{	1✔
52	VAEndpoint: *u,	1✔
53	Region: os.Getenv("VCLOUDAIR_REGION"),	1✔
54	VCDAuthHeader: "X-Vcloud-Authorization",	1✔
55	http: http.Client{Transport: &http.Transport{TLSHandshakeTimeout: 120 * time.Second}},	1✔
56	}, nil	1✔
57	}
58
59	// Client provides a client to vCloud Air, values can be populated automatically using the Authenticate method.
60	type Client struct {
61	VAToken string // vCloud Air authorization token
62	VAEndpoint url.URL // vCloud Air API endpoint
63	Region string // Region where the compute resource lives.
64	VCDToken string // Access Token (authorization header)
65	VCDAuthHeader string // Authorization header
66	Links types.LinkList
67	vcdHREF *url.URL // HREF of the backend VDC you're using
68	http http.Client // HttpClient is the client to use. Default will be used if not provided.
69	}
70
71	// Authenticate is a helper function that performs a complete login in vCloud
72	// Air and in the backend vCloud Director instance.
73	func (c *Client) Authenticate(username, password string) error {	1✔
74	if username == "" {	×
75	username = os.Getenv("VCLOUDAIR_USERNAME")	×
76	}	×
77	if password == "" {	×
78	password = os.Getenv("VCLOUDAIR_PASSWORD")	×
79	}	×
80
81	r, _ := http.NewRequest("POST", c.VAEndpoint.String()+LoginPath, nil)	1✔
82	r.Header.Set("Accept", JSONMimeV57)	1✔
83	r.SetBasicAuth(username, password)	1✔
84		1✔
85	resp, err := c.http.Do(r)	1✔
86	if err != nil {	×
87	return err	×
88	}	×
89	defer resp.Body.Close()	1✔
90		1✔
91	if resp.StatusCode/100 != 2 {	×
92	return fmt.Errorf("Could not complete request with vca, because (status %d) %s\n", resp.StatusCode, resp.Status)	×
93	}	×
94
95	var result oAuthClient	1✔
96	dec := json.NewDecoder(resp.Body)	1✔
97	if err := dec.Decode(&result); err != nil {	×
98	return err	×
99	}	×
100	result.AuthToken = resp.Header.Get("vchs-authorization")	1✔
101	c.VAToken = result.AuthToken	1✔
102	result.Config = c	1✔
103		1✔
104	instances, err := result.instances()	1✔
105	if err != nil {	×
106	return err	×
107	}	×
108
109	var attrs *accountInstanceAttrs	1✔
110	for _, inst := range instances {	2✔
111	attrs = inst.Attrs()	2✔
112	if attrs != nil && (c.Region == "" \|\| strings.HasPrefix(inst.Region, c.Region)) {	1✔
113	c.Region = inst.Region	1✔
114	break	1✔
115	}
116	}
117
118	if attrs == nil {	×
119	return fmt.Errorf("unable to determine session url")	×
120	}	×
121	attrs.client = c	1✔
122		1✔
123	return attrs.Authenticate(username, password)	1✔
124	}
125
126	// BaseURL the base uril for the vcloud director instance
127	func (c *Client) BaseURL() url.URL {	×
128	if c.vcdHREF == nil {	×
129	return url.URL{}	×
130	}	×
131	return *c.vcdHREF	×
132	}
133
134	// DoHTTP performs a http request
135	func (c Client) DoHTTP(req http.Request) (*http.Response, error) {	×
136	if os.Getenv("VCLOUDAIR_DEBUG") != "" {	×
137	dr, _ := httputil.DumpRequestOut(req, true)	×
138	fmt.Println(string(dr))	×
139	}	×
140	resp, err := c.http.Do(req)	×
141	if err != nil {	×
142	return nil, err	×
143	}	×
144	if os.Getenv("VCLOUDAIR_DEBUG") != "" {	×
145	dr, _ := httputil.DumpResponse(resp, true)	×
146	fmt.Println(string(dr))	×
147	}	×
148	return resp, nil	×
149	}
150
151	// Disconnect performs a disconnection from the vCloud Air API endpoint.
152	func (c *Client) Disconnect() error {	×
153	return nil	×
154	}	×
155
156	// NewRequest creates a new HTTP request and applies necessary auth headers if
157	// set.
158	func (c Client) NewRequest(params map[string]string, method string, u url.URL, body io.Reader) *http.Request {	×
159		×
160	p := url.Values{}	×
161		×
162	// Build up our request parameters	×
163	for k, v := range params {	×
164	p.Add(k, v)	×
165	}	×
166
167	// Add the params to our URL
168	u.RawQuery = p.Encode()	×
169		×
170	// Build the request, no point in checking for errors here as we're just	×
171	// passing a string version of an url.URL struct and http.NewRequest returns	×
172	// error only if can't process an url.ParseRequestURI().	×
173	req, _ := http.NewRequest(method, u.String(), body)	×
174		×
175	if c.VCDToken != "" {	×
176	// Add the authorization header	×
177	req.Header.Add(c.VCDAuthHeader, c.VCDToken)	×
178	// Add the Accept header for VCD	×
179	req.Header.Add("Accept", "application/*+xml;version="+Version)	×
180	}	×
181	return req	×
182
183	}
184
185	// NewAuthenticatedSession create a new vCloud Air authenticated client
186	func NewAuthenticatedSession(user, password string) (*Client, error) {	×
187	client, err := NewClient()	×
188	if err != nil {	×
189	return nil, err	×
190	}	×
191
192	if err := client.Authenticate(user, password); err != nil {	×
193	return nil, err	×
194	}	×
195
196	return client, nil	×
197	}
198
199	type oAuthClient struct {
200	AuthToken string `json:"-"`
201	Config *Client `json:"-"`
202	ServiceGroupIDs []string `json:"serviceGroupIds"`
203	Info struct {
204	Instances []accountInstance `json:"instances"`
205	}
206	}
207
208	func (a *oAuthClient) instances() ([]accountInstance, error) {	1✔
209	if err := a.JSONRequest("GET", InstancesPath, &a.Info); err != nil {	×
210	return nil, err	×
211	}	×
212	return a.Info.Instances, nil	1✔
213	}
214
215	func (a *oAuthClient) JSONRequest(method, path string, result interface{}) error {	1✔
216	r, _ := http.NewRequest(method, a.Config.VAEndpoint.String()+path, nil)	1✔
217	r.Header.Set(HeaderAccept, JSONMimeV57)	1✔
218		1✔
219	if a.AuthToken != "" {	1✔
220	r.Header.Set("Authorization", "Bearer "+a.AuthToken)	1✔
221	}	1✔
222
223	resp, err := a.Config.http.Do(r)	1✔
224	if err != nil {	×
225	return err	×
226	}	×
227	defer resp.Body.Close()	1✔
228		1✔
229	if resp.StatusCode/100 != 2 {	×
230	return fmt.Errorf("Could not complete request with vca, because (status %d) %s\n", resp.StatusCode, resp.Status)	×
231	}	×
232
233	dec := json.NewDecoder(resp.Body)	1✔
234	if err := dec.Decode(result); err != nil {	×
235	return err	×
236	}	×
237
238	return nil	1✔
239	}
240
241	type accountInstance struct {
242	APIURL string `json:"apiUrl"`
243	DashboardURL string `json:"dashboardUrl"`
244	Description string `json:"description"`
245	ID string `json:"id"`
246	InstanceAttributes string `json:"instanceAttributes"`
247	InstanceVersion string `json:"instanceVersion"`
248	Link []string `json:"link"`
249	Name string `json:"name"`
250	PlanID string `json:"planId"`
251	Region string `json:"region"`
252	ServiceGroupID string `json:"serviceGroupId"`
253	}
254
255	func (a accountInstance) Attrs() accountInstanceAttrs {	2✔
256	if !strings.HasPrefix(a.InstanceAttributes, "{") {	1✔
257	return nil	1✔
258	}	1✔
259
260	var res accountInstanceAttrs	1✔
261	if err := json.Unmarshal([]byte(a.InstanceAttributes), &res); err != nil {	×
262	return nil	×
263	}	×
264	return &res	1✔
265	}
266
267	type accountInstanceAttrs struct {
268	OrgName string `json:"orgName"`
269	SessionURI string `json:"sessionUri"`
270	APIVersionURI string `json:"apiVersionUri"`
271	client *Client
272	}
273
274	func (a *accountInstanceAttrs) Authenticate(user, password string) error {	1✔
275	r, _ := http.NewRequest("POST", a.SessionURI, nil)	1✔
276	r.Header.Set(HeaderAccept, AnyXMLMime511)	1✔
277	r.SetBasicAuth(user+"@"+a.OrgName, password)	1✔
278		1✔
279	resp, err := a.client.http.Do(r)	1✔
280	if err != nil {	×
281	return err	×
282	}	×
283	defer resp.Body.Close()	1✔
284		1✔
285	if resp.StatusCode/100 != 2 {	×
286	return fmt.Errorf("Could not complete authenticating with vCloud, because (status %d) %s\n", resp.StatusCode, resp.Status)	×
287	}	×
288
289	var ses session	1✔
290	dec := xml.NewDecoder(resp.Body)	1✔
291	if err := dec.Decode(&ses); err != nil {	×
292	return err	×
293	}	×
294
295	a.client.VCDToken = resp.Header.Get("x-vcloud-authorization")	1✔
296	a.client.Links = ses.Links	1✔
297		1✔
298	return nil	1✔
299	}
300
301	// Session represents an authenticated session for the vCloud Air API
302	type session struct {
303	// ResourceType
304	HREF string `xml:"href,attr,omitempty"`
305	Type string `xml:"type,attr,omitempty"`
306	Links types.LinkList `xml:"Link,omitempty"`
307
308	// SessionType
309	Org string `xml:"org,attr,omitempty"`
310	Roles string `xml:"roles,attr,omitempty"`
311	User string `xml:"user,attr,omitempty"`
312	UserID string `xml:"userId,attr,omitempty"`
313	}

vmware / govcloudair / #83

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous