Merge pull request #21 from pescetto/add_tunnels

Add tunnels

Author: scshitole

.gitignore

@@ -1,3 +1,4 @@
 .idea
 *.iml
 *.back
+*.swp

app.go

@@ -130,15 +130,15 @@ func (b *BigIP) CreateAppsvc01(p *Appsvc01) error {
 	log.Printf("++++++ Here is what terraform is sending to bigip ................ : %+v ", p)
 	err := b.post(p, uriMgmt, uriSha, uriAppsvcs, uriDecl)
 	if err != nil {
-		log.Println(" API call not successfull  %v ", err)
+		log.Println(" API call not successfull  ", err)
 	}
 	return nil
 }
 func (b *BigIP) CreateAppsvc02(p *Appsvc02) error {
 	log.Printf("++++++ Here is what terraform is sending to bigip ................ : %+v ", p)
 	err := b.post(p, uriMgmt, uriSha, uriAppsvcs, uriDecl)
 	if err != nil {
-		log.Println(" API call not successfull  %v ", err)
+		log.Println(" API call not successfull  ", err)
 	}
 	return nil
 }
@@ -152,17 +152,17 @@ func (b *BigIP) DeleteAppsvc02() error {
 func (b *BigIP) ModifyAppsvc01(p *Appsvc01) error {
 	log.Printf("++++++ Here is what terraform is sending to bigip ................ : %+v ", p)
 	err := b.patch(p, uriMgmt, uriSha, uriAppsvcs, uriDecl)
-	log.Printf("value of p in modify +++++++++++++++", p)
+	log.Println("value of p in modify +++++++++++++++", p)
 	if err != nil {
-		log.Println(" API call not successfull  %v ", err)
+		log.Println(" API call not successfull  ", err)
 	}
 	return nil
 }
 func (b *BigIP) ModifyAppsvc02(p *Appsvc02) error {
 	log.Printf("++++++ Here is what terraform is sending to bigip ................ : %+v ", p)
 	err := b.patch(p, uriMgmt, uriSha, uriAppsvcs, uriDecl)
 	if err != nil {
-		log.Println(" API call not successfull  %v ", err)
+		log.Println(" API call not successfull  ", err)
 	}
 	return nil
 }

net.go

@@ -163,11 +163,42 @@ type RouteDomain struct {
 	Vlans      []string `json:"vlans,omitempty"`
 }
 
+// Tunnels contains a list of tunnel objects on the BIG-IP system.
+type Tunnels struct {
+	Tunnels []Tunnel `json:"items"`
+}
+
+// Tunnel contains information on the tunnel.
+// https://devcentral.f5.com/wiki/iControlREST.APIRef_tm_net_tunnels_tunnel.ashx
+type Tunnel struct {
+	Name             string `json:"name,omitempty"`
+	AppService       string `json:"appService,omitempty"`
+	AutoLasthop      string `json:"autoLasthop,omitempty"`
+	Description      string `json:"description,omitempty"`
+	IdleTimeout      int    `json:"idleTimeout,omitempty"`
+	IfIndex          int    `json:"ifIndex,omitempty"`
+	Key              int    `json:"key,omitempty"`
+	LocalAddress     string `json:"localAddress,omitempty"`
+	Mode             string `json:"mode,omitempty"`
+	Mtu              int    `json:"mtu,omitempty"`
+	Partition        string `json:"partition,omitempty"`
+	Profile          string `json:"profile,omitempty"`
+	RemoteAddress    string `json:"remoteAddress,omitempty"`
+	SecondaryAddress string `json:"secondaryAddress,omitempty"`
+	Tos              string `json:"tos,omitempty"`
+	TrafficGroup     string `json:"trafficGroup,omitempty"`
+	Transparent      string `json:"transparent,omitempty"`
+	UsePmtu          string `json:"usePmtu,omitempty"`
+}
+
 const (
 	uriNet            = "net"
 	uriInterface      = "interface"
 	uriSelf           = "self"
 	uriTrunk          = "trunk"
+	uriTunnels        = "tunnels"
+	uriTunnel         = "tunnel"
+	uriVxlan          = "vxlan"
 	uriVlan           = "vlan"
 	uriVlanInterfaces = "interfaces"
 	uriRoute          = "route"
@@ -448,3 +479,57 @@ func (b *BigIP) DeleteRouteDomain(name string) error {
 func (b *BigIP) ModifyRouteDomain(name string, config *RouteDomain) error {
 	return b.put(config, uriNet, uriRouteDomain, name)
 }
+
+// Tunnels returns a list of tunnels.
+func (b *BigIP) Tunnels() (*Tunnels, error) {
+	var tunnels Tunnels
+	err, _ := b.getForEntity(&tunnels, uriNet, uriTunnels, uriTunnel)
+	if err != nil {
+		return nil, err
+	}
+
+	return &tunnels, nil
+}
+
+// GetTunnel fetches the tunnel by it's name.
+func (b *BigIP) GetTunnel(name string) (*Tunnel, error) {
+	var tunnel Tunnel
+	values := []string{}
+	regex := regexp.MustCompile(`^(\/.+\/)?(.+)`)
+	match := regex.FindStringSubmatch(name)
+	if match[1] == "" {
+		values = append(values, "~Common~")
+	}
+	values = append(values, name)
+	// Join the strings into one.
+	result := strings.Join(values, "")
+	err, ok := b.getForEntity(&tunnel, uriNet, uriTunnels, uriTunnel, result)
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		return nil, nil
+	}
+
+	return &tunnel, nil
+}
+
+// CreateTunnel adds a new tunnel to the BIG-IP system.
+func (b *BigIP) CreateTunnel(name, profile string) error {
+	config := &Tunnel{
+		Name:    name,
+		Profile: profile,
+	}
+
+	return b.post(config, uriNet, uriTunnels, uriTunnel)
+}
+
+// DeleteTunnel removes a tunnel.
+func (b *BigIP) DeleteTunnel(name string) error {
+	return b.delete(uriNet, uriTunnels, uriTunnel, name)
+}
+
+// ModifyTunnel allows you to change any attribute of a tunnel.
+func (b *BigIP) ModifyTunnel(name string, config *Tunnel) error {
+	return b.put(config, uriNet, uriTunnels, uriTunnel, name)
+}

net_test.go

@@ -380,3 +380,132 @@ func assertRestCall(s *NetTestSuite, method, path, body string) {
 		assert.JSONEq(s.T(), body, s.LastRequestBody)
 	}
 }
+
+func (s *NetTestSuite) TestTunnels() {
+	s.ResponseFunc = func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(`{
+  "kind": "tm:net:tunnels:tunnel:tunnelcollectionstate",
+  "selfLink": "https://localhost/mgmt/tm/net/tunnels/tunnel?ver=13.1.1.2",
+  "items": [
+    {
+      "kind": "tm:net:tunnels:tunnel:tunnelstate",
+      "name": "http-tunnel",
+      "partition": "Common",
+      "fullPath": "/Common/http-tunnel",
+      "generation": 1,
+      "selfLink": "https://localhost/mgmt/tm/net/tunnels/tunnel/~Common~http-tunnel?ver=13.1.1.2",
+      "autoLasthop": "default",
+      "description": "Tunnel for http-explicit profile",
+      "idleTimeout": 300,
+      "ifIndex": 912,
+      "key": 0,
+      "localAddress": "any6",
+      "mode": "bidirectional",
+      "mtu": 0,
+      "profile": "/Common/tcp-forward",
+      "profileReference": {
+        "link": "https://localhost/mgmt/tm/net/tunnels/tcp-forward/~Common~tcp-forward?ver=13.1.1.2"
+      },
+      "remoteAddress": "any6",
+      "secondaryAddress": "any6",
+      "tos": "preserve",
+      "transparent": "disabled",
+      "usePmtu": "enabled"
+    },
+    {
+      "kind": "tm:net:tunnels:tunnel:tunnelstate",
+      "name": "socks-tunnel",
+      "partition": "Common",
+      "fullPath": "/Common/socks-tunnel",
+      "generation": 1,
+      "selfLink": "https://localhost/mgmt/tm/net/tunnels/tunnel/~Common~socks-tunnel?ver=13.1.1.2",
+      "autoLasthop": "default",
+      "description": "Tunnel for socks profile",
+      "idleTimeout": 300,
+      "ifIndex": 928,
+      "key": 0,
+      "localAddress": "any6",
+      "mode": "bidirectional",
+      "mtu": 0,
+      "profile": "/Common/tcp-forward",
+      "profileReference": {
+        "link": "https://localhost/mgmt/tm/net/tunnels/tcp-forward/~Common~tcp-forward?ver=13.1.1.2"
+      },
+      "remoteAddress": "any6",
+      "secondaryAddress": "any6",
+      "tos": "preserve",
+      "transparent": "disabled",
+      "usePmtu": "enabled"
+    }
+  ]
+}`))
+	}
+
+	tunnels, err := s.Client.Tunnels()
+
+	assert.Nil(s.T(), err)
+	assertRestCall(s, "GET", "/mgmt/tm/net/tunnels/tunnel", "")
+	assert.Equal(s.T(), 2, len(tunnels.Tunnels))
+	assert.Equal(s.T(), "http-tunnel", tunnels.Tunnels[0].Name)
+	assert.Equal(s.T(), "socks-tunnel", tunnels.Tunnels[1].Name)
+}
+
+func (s *NetTestSuite) TestGetTunnel() {
+	s.ResponseFunc = func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(`{
+    "autoLasthop": "default",
+    "description": "Tunnel for http-explicit profile",
+    "fullPath": "/Common/http-tunnel",
+    "generation": 1,
+    "idleTimeout": 300,
+    "ifIndex": 112,
+    "key": 0,
+    "kind": "tm:net:tunnels:tunnel:tunnelstate",
+    "localAddress": "any6",
+    "mode": "bidirectional",
+    "mtu": 0,
+    "name": "http-tunnel",
+    "partition": "Common",
+    "profile": "/Common/tcp-forward",
+    "profileReference": {
+        "link": "https://localhost/mgmt/tm/net/tunnels/tcp-forward/~Common~tcp-forward?ver=14.1.0.3"
+    },
+    "remoteAddress": "any6",
+    "secondaryAddress": "any6",
+    "selfLink": "https://localhost/mgmt/tm/net/tunnels/tunnel/~Common~http-tunnel?ver=14.1.0.3",
+    "tos": "preserve",
+    "transparent": "disabled",
+    "usePmtu": "enabled"
+}`))
+	}
+
+	tunnel, err := s.Client.GetTunnel("http-tunnel")
+
+	assert.Nil(s.T(), err)
+	assertRestCall(s, "GET", "/mgmt/tm/net/tunnels/tunnel/~Common~http-tunnel", "")
+	assert.Equal(s.T(), "http-tunnel", tunnel.Name)
+	assert.Equal(s.T(), "/Common/tcp-forward", tunnel.Profile)
+}
+
+func (s *NetTestSuite) TestCreateTunnel() {
+	err := s.Client.CreateTunnel("some-foo-tunnel", "/Common/some-foo-profile")
+
+	assert.Nil(s.T(), err)
+	assertRestCall(s, "POST", "/mgmt/tm/net/tunnels/tunnel", `{"name":"some-foo-tunnel", "profile":"/Common/some-foo-profile"}`)
+}
+
+func (s *NetTestSuite) TestDeleteTunnel() {
+	err := s.Client.DeleteTunnel("some-foo-tunnel")
+
+	assert.Nil(s.T(), err)
+	assertRestCall(s, "DELETE", "/mgmt/tm/net/tunnels/tunnel/some-foo-tunnel", "")
+}
+
+func (s *NetTestSuite) TestModifyTunnel() {
+	tunnel := &Tunnel{Transparent: "enabled"}
+
+	err := s.Client.ModifyTunnel("some-foo-tunnel", tunnel)
+
+	assert.Nil(s.T(), err)
+	assertRestCall(s, "PUT", "/mgmt/tm/net/tunnels/tunnel/some-foo-tunnel", `{"transparent":"enabled"}`)
+}