vmware / govcloudair / #98

pending completion

Build # #98

Build Type

Pull #29

drone.io

Committed by

robcoward

Commit Message

<a href="https://github.com/vmware/govcloudair/commit/<a class=hub.com/vmware/govcloudair/commit/98aca3a746a52c26013d429ef28753769ed8a7c2">98aca3a74<a href="https://github.com/vmware/govcloudair/commit/98aca3a746a52c26013d429ef28753769ed8a7c2">">Merge </a><a class="double-link" href="https://github.com/vmware/govcloudair/commit/<a class="double-link" href="https://github.com/vmware/govcloudair/commit/5c83878c0790c538904ca40d1320cf156d01291f">5c83878c0</a>">5c83878c0</a><a href="https://github.com/vmware/govcloudair/commit/98aca3a746a52c26013d429ef28753769ed8a7c2"> into f95175490">f95175490</a>

Pull Request Pull Request #29: [WIP] Add vCloud Director support

Run Details

1060 of 1060 new or added lines in 14 files covered. (100.0%)

1386 of 2046 relevant lines covered (67.74%)

7.78 hits per line

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

20.69

/orgvdcnetwork.go

/*
 * Copyright 2014 VMware, Inc.  All rights reserved.  Licensed under the Apache v2 License.
 */

package govcloudair

import (
        "bytes"
        "encoding/xml"
        "fmt"
        types "github.com/vmware/govcloudair/types/v56"
        "log"
        "net/http"
        "net/url"
        "regexp"
        "strings"
        "time"
)

// OrgVDCNetwork an org vdc network client
type OrgVDCNetwork struct {
        OrgVDCNetwork *types.OrgVDCNetwork
        c             *Client
}

// NewOrgVDCNetwork creates an org vdc network client
func NewOrgVDCNetwork(c *Client) *OrgVDCNetwork {
        return &OrgVDCNetwork{
                OrgVDCNetwork: new(types.OrgVDCNetwork),
                c:             c,
        }
}

func (o *OrgVDCNetwork) Refresh() error {
        if o.OrgVDCNetwork.HREF == "" {
                return fmt.Errorf("cannot refresh, Object is empty")
        }

        u, _ := url.ParseRequestURI(o.OrgVDCNetwork.HREF)

        req := o.c.NewRequest(map[string]string{}, "GET", *u, nil)

        resp, err := checkResp(o.c.Http.Do(req))
        if err != nil {
                return fmt.Errorf("error retrieving task: %s", err)
        }

        // Empty struct before a new unmarshal, otherwise we end up with duplicate
        // elements in slices.
        o.OrgVDCNetwork = &types.OrgVDCNetwork{}

        if err = decodeBody(resp, o.OrgVDCNetwork); err != nil {
                return fmt.Errorf("error decoding task response: %s", err)
        }

        // The request was successful
        return nil
}

func (o *OrgVDCNetwork) Delete() (Task, error) {
        err := o.Refresh()
        if err != nil {
                return Task{}, fmt.Errorf("Error refreshing network: %s", err)
        }
        pathArr := strings.Split(o.OrgVDCNetwork.HREF, "/")
        s, _ := url.ParseRequestURI(o.OrgVDCNetwork.HREF)
        s.Path = "/api/admin/network/" + pathArr[len(pathArr)-1]

        var resp *http.Response
        for {
                req := o.c.NewRequest(map[string]string{}, "DELETE", *s, nil)
                resp, err = checkResp(o.c.Http.Do(req))
                if err != nil {
                        if v, _ := regexp.MatchString("is busy, cannot proceed with the operation.$", err.Error()); v {
                                time.Sleep(3 * time.Second)
                                continue
                        }
                        return Task{}, fmt.Errorf("error deleting Network: %s", err)
                }
                break
        }

        task := NewTask(o.c)

        if err = decodeBody(resp, task.Task); err != nil {
                return Task{}, fmt.Errorf("error decoding Task response: %s", err)
        }

        // The request was successful
        return *task, nil
}

func (v *Vdc) CreateOrgVDCNetwork(networkConfig *types.OrgVDCNetwork) error {
        for _, av := range v.Vdc.Link {
                if av.Rel == "add" && av.Type == "application/vnd.vmware.vcloud.orgVdcNetwork+xml" {
                        u, err := url.ParseRequestURI(av.HREF)
                        //return fmt.Errorf("Test output: %#v")

                        if err != nil {
                                return fmt.Errorf("error decoding vdc response: %s", err)
                        }

                        output, err := xml.MarshalIndent(networkConfig, "  ", "    ")
                        if err != nil {
                                return fmt.Errorf("error marshaling OrgVDCNetwork compose: %s", err)
                        }

                        //return fmt.Errorf("Test output: %s\n%#v", b, v.c)

                        var resp *http.Response
                        for {
                                b := bytes.NewBufferString(xml.Header + string(output))
                                log.Printf("[DEBUG] VCD Client configuration: %s", b)
                                req := v.c.NewRequest(map[string]string{}, "POST", *u, b)
                                req.Header.Add("Content-Type", av.Type)
                                resp, err = checkResp(v.c.Http.Do(req))
                                if err != nil {
                                        if v, _ := regexp.MatchString("is busy, cannot proceed with the operation.$", err.Error()); v {
                                                time.Sleep(3 * time.Second)
                                                continue
                                        }
                                        return fmt.Errorf("error instantiating a new OrgVDCNetwork: %s", err)
                                }
                                break
                        }
                        newstuff := NewOrgVDCNetwork(v.c)
                        if err = decodeBody(resp, newstuff.OrgVDCNetwork); err != nil {
                                return fmt.Errorf("error decoding orgvdcnetwork response: %s", err)
                        }
                        task := NewTask(v.c)
                        for _, t := range newstuff.OrgVDCNetwork.Tasks.Task {
                                task.Task = t
                                err = task.WaitTaskCompletion()
                                if err != nil {
                                        return fmt.Errorf("Error performing task: %#v", err)
                                }
                        }
                }
        }
        return nil
}

1	/*
2	* Copyright 2014 VMware, Inc. All rights reserved. Licensed under the Apache v2 License.
3	*/
4
5	package govcloudair
6
7	import (
8	"bytes"
9	"encoding/xml"
10	"fmt"
11	types "github.com/vmware/govcloudair/types/v56"
12	"log"
13	"net/http"
14	"net/url"
15	"regexp"
16	"strings"
17	"time"
18	)
19
20	// OrgVDCNetwork an org vdc network client
21	type OrgVDCNetwork struct {
22	OrgVDCNetwork *types.OrgVDCNetwork
23	c *Client
24	}
25
26	// NewOrgVDCNetwork creates an org vdc network client
27	func NewOrgVDCNetwork(c Client) OrgVDCNetwork {	16✔
28	return &OrgVDCNetwork{	16✔
29	OrgVDCNetwork: new(types.OrgVDCNetwork),	16✔
30	c: c,	16✔
31	}	16✔
32	}	16✔
33
34	func (o *OrgVDCNetwork) Refresh() error {	2✔
35	if o.OrgVDCNetwork.HREF == "" {	2✔
36	return fmt.Errorf("cannot refresh, Object is empty")	×
37	}	×
38
39	u, _ := url.ParseRequestURI(o.OrgVDCNetwork.HREF)	2✔
40		2✔
41	req := o.c.NewRequest(map[string]string{}, "GET", *u, nil)	2✔
42		2✔
43	resp, err := checkResp(o.c.Http.Do(req))	2✔
44	if err != nil {	2✔
45	return fmt.Errorf("error retrieving task: %s", err)	×
46	}	×
47
48	// Empty struct before a new unmarshal, otherwise we end up with duplicate
49	// elements in slices.
50	o.OrgVDCNetwork = &types.OrgVDCNetwork{}	2✔
51		2✔
52	if err = decodeBody(resp, o.OrgVDCNetwork); err != nil {	2✔
53	return fmt.Errorf("error decoding task response: %s", err)	×
54	}	×
55
56	// The request was successful
57	return nil	2✔
58	}
59
60	func (o *OrgVDCNetwork) Delete() (Task, error) {	×
61	err := o.Refresh()	×
62	if err != nil {	×
63	return Task{}, fmt.Errorf("Error refreshing network: %s", err)	×
64	}	×
65	pathArr := strings.Split(o.OrgVDCNetwork.HREF, "/")	×
66	s, _ := url.ParseRequestURI(o.OrgVDCNetwork.HREF)	×
67	s.Path = "/api/admin/network/" + pathArr[len(pathArr)-1]	×
68		×
69	var resp *http.Response	×
70	for {	×
71	req := o.c.NewRequest(map[string]string{}, "DELETE", *s, nil)	×
72	resp, err = checkResp(o.c.Http.Do(req))	×
73	if err != nil {	×
74	if v, _ := regexp.MatchString("is busy, cannot proceed with the operation.$", err.Error()); v {	×
75	time.Sleep(3 * time.Second)	×
76	continue	×
77	}
78	return Task{}, fmt.Errorf("error deleting Network: %s", err)	×
79	}
80	break	×
81	}
82
83	task := NewTask(o.c)	×
84		×
85	if err = decodeBody(resp, task.Task); err != nil {	×
86	return Task{}, fmt.Errorf("error decoding Task response: %s", err)	×
87	}	×
88
89	// The request was successful
90	return *task, nil	×
91	}
92
93	func (v Vdc) CreateOrgVDCNetwork(networkConfig types.OrgVDCNetwork) error {	×
94	for _, av := range v.Vdc.Link {	×
95	if av.Rel == "add" && av.Type == "application/vnd.vmware.vcloud.orgVdcNetwork+xml" {	×
96	u, err := url.ParseRequestURI(av.HREF)	×
97	//return fmt.Errorf("Test output: %#v")	×
98		×
99	if err != nil {	×
100	return fmt.Errorf("error decoding vdc response: %s", err)	×
101	}	×
102
103	output, err := xml.MarshalIndent(networkConfig, " ", " ")	×
104	if err != nil {	×
105	return fmt.Errorf("error marshaling OrgVDCNetwork compose: %s", err)	×
106	}	×
107
108	//return fmt.Errorf("Test output: %s\n%#v", b, v.c)
109
110	var resp *http.Response	×
111	for {	×
112	b := bytes.NewBufferString(xml.Header + string(output))	×
113	log.Printf("[DEBUG] VCD Client configuration: %s", b)	×
114	req := v.c.NewRequest(map[string]string{}, "POST", *u, b)	×
115	req.Header.Add("Content-Type", av.Type)	×
116	resp, err = checkResp(v.c.Http.Do(req))	×
117	if err != nil {	×
118	if v, _ := regexp.MatchString("is busy, cannot proceed with the operation.$", err.Error()); v {	×
119	time.Sleep(3 * time.Second)	×
120	continue	×
121	}
122	return fmt.Errorf("error instantiating a new OrgVDCNetwork: %s", err)	×
123	}
124	break	×
125	}
126	newstuff := NewOrgVDCNetwork(v.c)	×
127	if err = decodeBody(resp, newstuff.OrgVDCNetwork); err != nil {	×
128	return fmt.Errorf("error decoding orgvdcnetwork response: %s", err)	×
129	}	×
130	task := NewTask(v.c)	×
131	for _, t := range newstuff.OrgVDCNetwork.Tasks.Task {	×
132	task.Task = t	×
133	err = task.WaitTaskCompletion()	×
134	if err != nil {	×
135	return fmt.Errorf("Error performing task: %#v", err)	×
136	}	×
137	}
138	}
139	}
140	return nil	×
141	}

vmware / govcloudair / #98

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