Restructure sdewan solution folders.
Signed-off-by: Huifeng Le <huifeng.le@intel.com>
Change-Id: I6ac8e1bfc8e92e1bdd36d523ffd048c6c77d4e89
--- /dev/null
+# Akraino ICN SDEWAN solution
+A general description can be found at: https://www.linkedin.com/pulse/software-defined-edge-wan-edges-srinivasa-addepalli/
+
+* platform
+SDEWAN platform features include cnf, cr definition and controller.
+
+* traffic-hub
+traffic-hub's high level design can be found at: https://www.linkedin.com/pulse/software-defined-edge-wan-central-control-traffic-hub-addepalli/
+
+* central-controller
+central-controller's high level design can be found at: https://www.linkedin.com/pulse/software-defined-edge-wan-central-control-traffic-hub-addepalli/
--- /dev/null
+# Akraino ICN SDEWAN central controller
+++ /dev/null
-package openwrt
-
-import (
- "openwrt"
- "reflect"
- "testing"
- "flag"
- "encoding/json"
- "fmt"
- "os"
-)
-
-var fw openwrt.FirewallClient
-var available_zone_1 string
-var available_zone_2 string
-
-func TestMain(m *testing.M) {
- servIp := flag.String("ip", "10.244.0.18", "SDEWAN CNF Management IP Address")
- flag.Parse()
-
- client := openwrt.NewOpenwrtClient(*servIp, "root", "")
- fw = openwrt.FirewallClient{client}
- available_zone_1 = "wan"
- available_zone_2 = "lan"
-
- os.Exit(m.Run())
-}
-
-// Error handler
-func handleError(t *testing.T, err error, name string, expectedErr bool, errorCode int) {
- if (err != nil) {
- if (expectedErr) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- if(errorCode != err.(*openwrt.OpenwrtError).Code) {
- t.Errorf("Test case '%s': expected '%d', but got '%d'", name, errorCode, err.(*openwrt.OpenwrtError).Code)
- } else {
- fmt.Printf("%s\n", err.(*openwrt.OpenwrtError).Message)
- }
- default:
- t.Errorf("Test case '%s': expected openwrt.OpenwrtError, but got '%s'", name, reflect.TypeOf(err).String())
- }
- } else {
- t.Errorf("Test case '%s': expected success, but got '%s'", name, reflect.TypeOf(err).String())
- }
- } else {
- if (expectedErr) {
- t.Errorf("Test case '%s': expected error code '%d', but success", name, errorCode)
- }
- }
-}
-
-func printError(err error) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("%s\n", err.(*openwrt.OpenwrtError).Message)
- default:
- fmt.Printf("%s\n", reflect.TypeOf(err).String())
- }
-}
-
-// Firewall Zone API Test
-func TestGetZones(t *testing.T) {
- res, err := fw.GetZones()
- if res == nil {
- printError(err)
- t.Errorf("Test case GetZones: can not get firewall zones")
- return
- }
-
- if len(res.Zones) == 0 {
- fmt.Printf("Test case GetZones: no zone defined")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetZone(t *testing.T) {
- tcases := []struct {
- name string
- zone string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetAvailableZone",
- zone: available_zone_1,
- },
- {
- name: "GetFoolRule",
- zone: "foo_zone",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.GetZone(tcase.zone)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolZone(t *testing.T) {
- tcases := []struct {
- name string
- zone openwrt.SdewanFirewallZone
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- zone: openwrt.SdewanFirewallZone{Name:" "},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidNetwork",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Network:[]string{"fool_name"}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidMasq",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Masq:"2"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidMasqSrc",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", MasqSrc:[]string{"256.0.0.0/0"}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidMasqDest",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", MasqDest:[]string{"256.0.0.0/0"}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidMasqAllowInvalid",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", MasqAllowInvalid:"2"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidMtuFix",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", MtuFix:"2"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidInput",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Input:"FOOL"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidForward",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Forward:"FOOL"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidOutput",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Output:"FOOL"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidFamily",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Family:"FOOL"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidSubnet",
- zone: openwrt.SdewanFirewallZone{Name:"test_zone", Subnet:[]string{"256.0.0.0/0"}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.CreateZone(tcase.zone)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolZone(t *testing.T) {
- tcases := []struct {
- name string
- zone string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- zone: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- zone: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := fw.DeleteZone(tcase.zone)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteAvailableZone(t *testing.T) {
- var err error
- var zone_name = "test_zone_1"
- var redirect_name = "test_redirect_1"
- var zone = openwrt.SdewanFirewallZone{Name:zone_name, Network:[]string{"wan", "lan"}, Input:"REJECT", Masq:"1"}
- var redirect = openwrt.SdewanFirewallRedirect{Name:redirect_name, Src:zone_name, SrcDPort:"22000", Dest:"lan", DestPort:"22", Proto:"tcp", Target:"DNAT"}
-
- // create zone
- _, err = fw.GetZone(zone_name)
- if (err == nil) {
- err = fw.DeleteZone(zone_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestDeleteAvailableZone: failed to delete zone '%s'", zone_name)
- return
- }
- }
-
- _, err = fw.CreateZone(zone)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestDeleteAvailableZone: failed to create zone '%s'", zone_name)
- return
- }
-
- // create redirect
- _, err = fw.GetRedirect(redirect_name)
- if (err == nil) {
- err = fw.DeleteRedirect(redirect_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestDeleteAvailableZone: failed to delete redirect '%s'", redirect_name)
- return
- }
- }
-
- _, err = fw.CreateRedirect(redirect)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestDeleteAvailableZone: failed to create redirect '%s'", redirect_name)
- return
- }
-
- // try to delete a used zone
- err = fw.DeleteZone(zone_name)
- if (err != nil) {
- printError(err)
- } else {
- t.Errorf("Test case TestDeleteAvailableZone: error to delete zone '%s'", zone_name)
- return
- }
-
- // clean
- err = fw.DeleteRedirect(redirect_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestDeleteAvailableZone: failed to delete redirect '%s'", redirect_name)
- return
- }
-
- err = fw.DeleteZone(zone_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestDeleteAvailableZone: failed to delete zone '%s'", zone_name)
- return
- }
-}
-
-func TestUpdateFoolZone(t *testing.T) {
- tcases := []struct {
- name string
- zone openwrt.SdewanFirewallZone
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- zone: openwrt.SdewanFirewallZone{Name:"fool_name"},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.UpdateZone(tcase.zone)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestZone(t *testing.T) {
- var err error
- var ret_zone *openwrt.SdewanFirewallZone
-
- var zone_name = "test_zone"
- var zone = openwrt.SdewanFirewallZone{Name:zone_name, Network:[]string{"wan", "lan"}, Input:"REJECT", Masq:"1"}
- var update_zone = openwrt.SdewanFirewallZone{Name:zone_name, Network:[]string{"lan"}, Input:"ACCEPT", MasqSrc:[]string{"!0.0.0.0/0", "172.16.1.1"}, Subnet:[]string{"172.16.0.1/24"}}
-
- _, err = fw.GetZone(zone_name)
- if (err == nil) {
- err = fw.DeleteZone(zone_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestZone: failed to delete zone '%s'", zone_name)
- return
- }
- }
-
- // Create zone
- ret_zone, err = fw.CreateZone(zone)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestZone: failed to create zone '%s'", zone_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_zone)
- fmt.Printf("Created Zone: %s\n", string(p_data))
- }
-
- ret_zone, err = fw.GetZone(zone_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestZone: failed to get created zone")
- return
- } else {
- if( ret_zone.Input != "REJECT" ) {
- t.Errorf("Test case TestZone: failed to create zone")
- return
- }
- }
-
- // Update zone
- ret_zone, err = fw.UpdateZone(update_zone)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestZone: failed to update zone '%s'", zone_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_zone)
- fmt.Printf("Updated Zone: %s\n", string(p_data))
- }
-
- ret_zone, err = fw.GetZone(zone_name)
- if (err != nil) {
- t.Errorf("Test case TestZone: failed to get updated zone")
- return
- } else {
- if( ret_zone.Input != "ACCEPT" ) {
- t.Errorf("Test case TestZone: failed to update zone")
- return
- }
- }
-
- // Delete zone
- err = fw.DeleteZone(zone_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestZone: failed to delete zone '%s'", zone_name)
- return
- }
-
- ret_zone, err = fw.GetZone(zone_name)
- if (err == nil) {
- t.Errorf("Test case TestZone: failed to delete zone")
- return
- }
-}
-
-// Firewall Forwarding API Test
-func TestGetForwardings(t *testing.T) {
- res, err := fw.GetForwardings()
- if res == nil {
- printError(err)
- t.Errorf("Test case GetForwardings: can not get firewall forwardings")
- return
- }
-
- if len(res.Forwardings) == 0 {
- fmt.Printf("Test case GetForwardings: no forwarding defined")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetForwarding(t *testing.T) {
- tcases := []struct {
- name string
- forwarding string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetFoolForwarding",
- forwarding: "foo_forwarding",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.GetForwarding(tcase.forwarding)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolForwarding(t *testing.T) {
- tcases := []struct {
- name string
- forwarding openwrt.SdewanFirewallForwarding
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- forwarding: openwrt.SdewanFirewallForwarding{Name:" "},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "NoSrc",
- forwarding: openwrt.SdewanFirewallForwarding{Name:"test_forwarding", Dest: available_zone_1},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidSrc",
- forwarding: openwrt.SdewanFirewallForwarding{Name:"test_forwarding", Src:"fool_zone", Dest: available_zone_1},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "NoDest",
- forwarding: openwrt.SdewanFirewallForwarding{Name:"test_forwarding", Src: available_zone_1},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidDest",
- forwarding: openwrt.SdewanFirewallForwarding{Name:"test_forwarding", Src:available_zone_1, Dest:"fool_zone"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidFamily",
- forwarding: openwrt.SdewanFirewallForwarding{Name:"test_forwarding", Family:"fool_family", Src:available_zone_1, Dest:available_zone_2},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.CreateForwarding(tcase.forwarding)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolForwarding(t *testing.T) {
- tcases := []struct {
- name string
- forwarding string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- forwarding: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- forwarding: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := fw.DeleteForwarding(tcase.forwarding)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolForwarding(t *testing.T) {
- tcases := []struct {
- name string
- forwarding openwrt.SdewanFirewallForwarding
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- forwarding: openwrt.SdewanFirewallForwarding{Name:"fool_name", Src:available_zone_1, Dest:available_zone_2},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.UpdateForwarding(tcase.forwarding)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestForwarding(t *testing.T) {
- var err error
- var ret_forwarding *openwrt.SdewanFirewallForwarding
-
- var forwarding_name = "test_forwarding"
- var forwarding = openwrt.SdewanFirewallForwarding{Name:forwarding_name, Src:available_zone_1, Dest:available_zone_2}
- var update_forwarding = openwrt.SdewanFirewallForwarding{Name:forwarding_name, Src:available_zone_2, Dest:available_zone_1}
-
- _, err = fw.GetForwarding(forwarding_name)
- if (err == nil) {
- err = fw.DeleteForwarding(forwarding_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestForwarding: failed to delete forwarding '%s'", forwarding_name)
- return
- }
- }
-
- // Create forwarding
- ret_forwarding, err = fw.CreateForwarding(forwarding)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestForwarding: failed to create forwarding '%s'", forwarding_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_forwarding)
- fmt.Printf("Created Forwarding: %s\n", string(p_data))
- }
-
- ret_forwarding, err = fw.GetForwarding(forwarding_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestForwarding: failed to get created forwarding")
- return
- } else {
- if( ret_forwarding.Dest != available_zone_2 ) {
- t.Errorf("Test case TestForwarding: failed to create forwarding")
- return
- }
- }
-
- // Update forwarding
- ret_forwarding, err = fw.UpdateForwarding(update_forwarding)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestForwarding: failed to update forwarding '%s'", forwarding_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_forwarding)
- fmt.Printf("Updated Forwarding: %s\n", string(p_data))
- }
-
- ret_forwarding, err = fw.GetForwarding(forwarding_name)
- if (err != nil) {
- t.Errorf("Test case TestForwarding: failed to get updated forwarding")
- return
- } else {
- if( ret_forwarding.Dest != available_zone_1 ) {
- t.Errorf("Test case TestForwarding: failed to update forwarding")
- return
- }
- }
-
- // Delete forwarding
- err = fw.DeleteForwarding(forwarding_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestForwarding: failed to delete forwarding '%s'", forwarding_name)
- return
- }
-
- ret_forwarding, err = fw.GetForwarding(forwarding_name)
- if (err == nil) {
- t.Errorf("Test case TestForwarding: failed to delete forwarding")
- return
- }
-}
-
-// Firewall Redirect API Test
-func TestGetRedirects(t *testing.T) {
- res, err := fw.GetRedirects()
- if res == nil {
- printError(err)
- t.Errorf("Test case GetRedirects: can not get firewall redirects")
- return
- }
-
- if len(res.Redirects) == 0 {
- fmt.Printf("Test case GetRedirects: no redirect defined")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetRedirect(t *testing.T) {
- tcases := []struct {
- name string
- redirect string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetFoolRedirect",
- redirect: "foo_redirect",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.GetRedirect(tcase.redirect)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolRedirect(t *testing.T) {
- tcases := []struct {
- name string
- redirect openwrt.SdewanFirewallRedirect
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- redirect: openwrt.SdewanFirewallRedirect{Name:" "},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "No Src for DNAT",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Dest:available_zone_2, DestPort:"22", Proto:"tcp", Target:"DNAT"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "No SrcDIp for SNAT",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Dest:available_zone_2, DestPort:"22", Proto:"tcp", Target:"SNAT"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "No Dest for SNAT",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", SrcDIp:"192.168.1.1", DestPort:"22", Proto:"tcp", Target:"SNAT"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Src",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Src:"fool_zone"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcIp",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", SrcIp:"192.168.1.300"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcDIp",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", SrcDIp:"192.168.1.300"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcMac",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", SrcMac:"00:00"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcPort",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", SrcPort:"1a"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcDPort",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", SrcDPort:"1a"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Proto",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Proto:"fool_protocol"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Dest",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Dest:"fool_zone"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid DestIp",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", DestIp:"192.168.1a.1"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid DestPort",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", DestPort:"0"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Target",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Target:"fool_NAT"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Family",
- redirect: openwrt.SdewanFirewallRedirect{Name:"test_redirect", Family:"fool_family"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.CreateRedirect(tcase.redirect)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolRedirect(t *testing.T) {
- tcases := []struct {
- name string
- redirect string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- redirect: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- redirect: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := fw.DeleteRedirect(tcase.redirect)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolRedirect(t *testing.T) {
- tcases := []struct {
- name string
- redirect openwrt.SdewanFirewallRedirect
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- redirect: openwrt.SdewanFirewallRedirect{Name:"fool_name", Src:available_zone_1, SrcDPort:"22000", Dest:available_zone_2, DestPort:"22", Proto:"tcp", Target:"DNAT"},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.UpdateRedirect(tcase.redirect)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestRedirect(t *testing.T) {
- var err error
- var ret_redirect *openwrt.SdewanFirewallRedirect
-
- var redirect_name = "test_redirect"
- var redirect = openwrt.SdewanFirewallRedirect{Name:redirect_name, Src:available_zone_1, SrcDPort:"22000", Dest:available_zone_2, DestPort:"22", Proto:"tcp", Target:"DNAT"}
- var update_redirect = openwrt.SdewanFirewallRedirect{Name:redirect_name, Src:available_zone_1, SrcDPort:"22001", Dest:available_zone_2, DestPort:"22", Proto:"tcp", Target:"DNAT"}
-
- _, err = fw.GetRedirect(redirect_name)
- if (err == nil) {
- err = fw.DeleteRedirect(redirect_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRedirect: failed to delete redirect '%s'", redirect_name)
- return
- }
- }
-
- // Create redirect
- ret_redirect, err = fw.CreateRedirect(redirect)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRedirect: failed to create redirect '%s'", redirect_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_redirect)
- fmt.Printf("Created Redirect: %s\n", string(p_data))
- }
-
- ret_redirect, err = fw.GetRedirect(redirect_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRedirect: failed to get created redirect")
- return
- } else {
- if( ret_redirect.SrcDPort != "22000" ) {
- t.Errorf("Test case TestRedirect: failed to create redirect")
- return
- }
- }
-
- // Update redirect
- ret_redirect, err = fw.UpdateRedirect(update_redirect)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRedirect: failed to update redirect '%s'", redirect_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_redirect)
- fmt.Printf("Updated Redirect: %s\n", string(p_data))
- }
-
- ret_redirect, err = fw.GetRedirect(redirect_name)
- if (err != nil) {
- t.Errorf("Test case TestRedirect: failed to get updated redirect")
- return
- } else {
- if( ret_redirect.SrcDPort != "22001" ) {
- t.Errorf("Test case TestRedirect: failed to update redirect")
- return
- }
- }
-
- // Delete redirect
- err = fw.DeleteRedirect(redirect_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRedirect: failed to delete redirect '%s'", redirect_name)
- return
- }
-
- ret_redirect, err = fw.GetRedirect(redirect_name)
- if (err == nil) {
- t.Errorf("Test case TestRedirect: failed to delete redirect")
- return
- }
-}
-
-// Firewall Rule API Test
-func TestGetRules(t *testing.T) {
- res, err := fw.GetRules()
- if res == nil {
- printError(err)
- t.Errorf("Test case GetRules: can not get firewall rules")
- return
- }
-
- if len(res.Rules) == 0 {
- fmt.Printf("Test case GetRules: no rule defined")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetRule(t *testing.T) {
- tcases := []struct {
- name string
- rule string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetFoolRule",
- rule: "foo_rule",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.GetRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolRule(t *testing.T) {
- tcases := []struct {
- name string
- rule openwrt.SdewanFirewallRule
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- rule: openwrt.SdewanFirewallRule{Name:" "},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "No SetMark and SetXmark for DNAT",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", Target:"MARK"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SRC",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", Src:"fool_zone"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcIp",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", SrcIp:"191.11.aa.10"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Valid SrcMac",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", SrcMac:"01:02:a0:0F:aC:EE"},
- },
- {
- name: "Invalid SrcMac",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", SrcMac:"11:rt:00:00:00:00"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid SrcPort",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", SrcPort:"0"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Proto",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", Proto:"fool_proto"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid IcmpType",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", IcmpType:[]string{"network-unreachable", "address-mask-reply", "fool_icmp_type"}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Dest",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", Dest:"fool_zone"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid DestIp",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", DestIp:"192.168.1.2.1"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid DestPort",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", DestPort:"aa"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Target",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", Target:"fool_target"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Invalid Family",
- rule: openwrt.SdewanFirewallRule{Name:"test_rule", Family:"fool_family"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.CreateRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolRule(t *testing.T) {
- tcases := []struct {
- name string
- rule string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- rule: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- rule: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := fw.DeleteRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolRule(t *testing.T) {
- tcases := []struct {
- name string
- rule openwrt.SdewanFirewallRule
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- rule: openwrt.SdewanFirewallRule{Name:"fool_name", Src:available_zone_1, Proto:"udp", DestPort:"68", Target:"REJECT", Family:"ipv4"},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := fw.UpdateRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestRule(t *testing.T) {
- var err error
- var ret_rule *openwrt.SdewanFirewallRule
-
- var rule_name = "test_rule"
- var rule = openwrt.SdewanFirewallRule{Name:rule_name, Src:available_zone_1, Proto:"udp", DestPort:"68", Target:"REJECT", Family:"ipv4"}
- var update_rule = openwrt.SdewanFirewallRule{Name:rule_name, Src:available_zone_1, IcmpType:[]string{"host-redirect", "echo-request"}, Proto:"udp", DestPort:"68", Target:"ACCEPT", Family:"ipv4"}
-
- _, err = fw.GetRule(rule_name)
- if (err == nil) {
- err = fw.DeleteRule(rule_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to delete rule '%s'", rule_name)
- return
- }
- }
-
- // Create rule
- ret_rule, err = fw.CreateRule(rule)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to create rule '%s'", rule_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_rule)
- fmt.Printf("Created Rule: %s\n", string(p_data))
- }
-
- ret_rule, err = fw.GetRule(rule_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to get created rule")
- return
- } else {
- if( ret_rule.Target != "REJECT" ) {
- t.Errorf("Test case TestRule: failed to create rule")
- return
- }
- }
-
- // Update rule
- ret_rule, err = fw.UpdateRule(update_rule)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to update rule '%s'", rule_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_rule)
- fmt.Printf("Updated Rule: %s\n", string(p_data))
- }
-
- ret_rule, err = fw.GetRule(rule_name)
- if (err != nil) {
- t.Errorf("Test case TestRule: failed to get updated rule")
- return
- } else {
- if( ret_rule.Target != "ACCEPT" ) {
- t.Errorf("Test case TestRule: failed to update rule")
- return
- }
- }
-
- // Delete rule
- err = fw.DeleteRule(rule_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to delete rule '%s'", rule_name)
- return
- }
-
- ret_rule, err = fw.GetRule(rule_name)
- if (err == nil) {
- t.Errorf("Test case TestRule: failed to delete rule")
- return
- }
-}
+++ /dev/null
-package openwrt
-
-import (
- "openwrt"
- "reflect"
- "testing"
- "flag"
- "encoding/json"
- "fmt"
- "os"
-)
-
-var ic openwrt.IpsecClient
-var available_proposal_1 string
-var available_proposal_2 string
-var available_site string
-
-func TestMain(m *testing.M) {
- servIp := flag.String("ip", "10.244.0.18", "SDEWAN CNF Management IP Address")
- flag.Parse()
-
- var err error
- client := openwrt.NewOpenwrtClient(*servIp, "root", "")
- ic = openwrt.IpsecClient{client}
- available_proposal_1 = "test_proposal1"
- available_proposal_2 = "test_proposal2"
- available_site = "test_default_site"
-
- // create default proposals
- var proposall = openwrt.SdewanIpsecProposal{Name:available_proposal_1, EncryptionAlgorithm:"aes128", HashAlgorithm:"sha256", DhGroup:"modp3072",}
- var proposal2 = openwrt.SdewanIpsecProposal{Name:available_proposal_2, EncryptionAlgorithm:"aes256", HashAlgorithm:"sha128", DhGroup:"modp4096",}
-
- _, err = ic.GetProposal(available_proposal_1)
- if (err != nil) {
- // Create proposal
- _, err = ic.CreateProposal(proposall)
- if (err != nil) {
- printError(err)
- return
- }
- }
-
- _, err = ic.GetProposal(available_proposal_2)
- if (err != nil) {
- // Create proposal
- _, err = ic.CreateProposal(proposal2)
- if (err != nil) {
- printError(err)
- return
- }
- }
-
- // create default site
- var site = openwrt.SdewanIpsecSite{
- Name:available_site,
- Gateway:"10.0.1.2",
- PreSharedKey:"test_key",
- AuthenticationMethod:"psk",
- LocalIdentifier:"C=CH, O=strongSwan, CN=peer",
- RemoteIdentifier:"C=CH, O=strongSwan, CN=peerB",
- ForceCryptoProposal:"true",
- LocalPublicCert:"public cert\npublic cert value",
- CryptoProposal:[]string{available_proposal_1},
- Connections:[]openwrt.SdewanIpsecConnection{{
- Name:available_site+"_conn",
- Type:"tunnel",
- Mode:"start",
- LocalSubnet:"192.168.1.1/24",
- LocalSourceip:"10.0.1.1",
- RemoteSubnet:"192.168.0.1/24",
- RemoteSourceip:"10.0.1.2",
- CryptoProposal:[]string{available_proposal_1, available_proposal_2},
- },
- },
- }
-
- _, err = ic.GetSite(available_site)
- if (err == nil) {
- // Update site
- _, err = ic.UpdateSite(site)
- if (err != nil) {
- printError(err)
- return
- }
- } else {
- // Create site
- _, err = ic.CreateSite(site)
- if (err != nil) {
- printError(err)
- return
- }
- }
-
- var ret = m.Run()
-
- // clean
- ic.DeleteSite(available_site)
- ic.DeleteProposal(available_proposal_1)
- ic.DeleteProposal(available_proposal_2)
-
- os.Exit(ret)
-}
-
-// Error handler
-func handleError(t *testing.T, err error, name string, expectedErr bool, errorCode int) {
- if (err != nil) {
- if (expectedErr) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- if(errorCode != err.(*openwrt.OpenwrtError).Code) {
- t.Errorf("Test case '%s': expected '%d', but got '%d'", name, errorCode, err.(*openwrt.OpenwrtError).Code)
- } else {
- fmt.Printf("%s\n", err.(*openwrt.OpenwrtError).Message)
- }
- default:
- t.Errorf("Test case '%s': expected openwrt.OpenwrtError, but got '%s'", name, reflect.TypeOf(err).String())
- }
- } else {
- t.Errorf("Test case '%s': expected success, but got '%s'", name, reflect.TypeOf(err).String())
- }
- } else {
- if (expectedErr) {
- t.Errorf("Test case '%s': expected error code '%d', but success", name, errorCode)
- }
- }
-}
-
-func printError(err error) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("%s\n", err.(*openwrt.OpenwrtError).Message)
- default:
- fmt.Printf("%s\n", reflect.TypeOf(err).String())
- }
-}
-
-// IpSec Site API Test
-func TestGetSites(t *testing.T) {
- res, err := ic.GetSites()
- if res == nil {
- printError(err)
- t.Errorf("Test case GetSites: can not get IpSec sites")
- return
- }
-
- if len(res.Sites) == 0 {
- fmt.Printf("Test case GetSites: no site found")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetSite(t *testing.T) {
- tcases := []struct {
- name string
- site string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetAvailableSite",
- site: available_site,
- },
- {
- name: "GetFoolSite",
- site: "foo_site",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := ic.GetSite(tcase.site)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolSite(t *testing.T) {
- tcases := []struct {
- name string
- site openwrt.SdewanIpsecSite
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- site: openwrt.SdewanIpsecSite{Name:" "},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidConnectionType",
- site: openwrt.SdewanIpsecSite{Name:"test_site",
- Connections:[]openwrt.SdewanIpsecConnection{{Name:"test_connection_name", Type:"fool_type",},},},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidCryptoProtocolInConnection",
- site: openwrt.SdewanIpsecSite{Name:"test_site",
- Connections:[]openwrt.SdewanIpsecConnection{{Name:"test_connection_name", Type:"tunnel", CryptoProposal:[]string{available_proposal_1, "fool_protocol"}},},},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "InvalidCryptoProtocolInSite",
- site: openwrt.SdewanIpsecSite{Name:"test_site", CryptoProposal:[]string{available_proposal_1, "fool_protocol"},},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := ic.CreateSite(tcase.site)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolSite(t *testing.T) {
- tcases := []struct {
- name string
- site string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- site: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- site: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := ic.DeleteSite(tcase.site)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolSite(t *testing.T) {
- tcases := []struct {
- name string
- site openwrt.SdewanIpsecSite
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- site: openwrt.SdewanIpsecSite{Name:"fool_name"},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := ic.UpdateSite(tcase.site)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestSite(t *testing.T) {
- var err error
- var ret_site *openwrt.SdewanIpsecSite
-
- var site_name = "test_site"
- var conn_name1 = "test_name1"
- var conn_name2 = "test_name2"
- var conn_name3 = "test_name3"
- var site = openwrt.SdewanIpsecSite{
- Name:site_name,
- Gateway:"10.0.1.2",
- PreSharedKey:"test_key",
- AuthenticationMethod:"psk",
- LocalIdentifier:"C=CH, O=strongSwan, CN=peer",
- RemoteIdentifier:"C=CH, O=strongSwan, CN=peerB",
- ForceCryptoProposal:"true",
- CryptoProposal:[]string{available_proposal_1},
- Connections:[]openwrt.SdewanIpsecConnection{{
- Name:conn_name1,
- Type:"tunnel",
- Mode:"start",
- LocalSubnet:"192.168.1.1/24",
- LocalSourceip:"10.0.1.1",
- RemoteSubnet:"192.168.0.1/24",
- RemoteSourceip:"10.0.1.2",
- CryptoProposal:[]string{available_proposal_1, available_proposal_2},
- },
- },
- }
-
- var update_site = openwrt.SdewanIpsecSite{
- Name:site_name,
- Gateway:"10.0.21.2",
- PreSharedKey:"test_key_2",
- AuthenticationMethod:"psk",
- LocalIdentifier:"C=CH, O=strongSwan, CN=peer",
- RemoteIdentifier:"C=CH, O=strongSwan, CN=peerB",
- ForceCryptoProposal:"true",
- CryptoProposal:[]string{available_proposal_1, available_proposal_2},
- Connections:[]openwrt.SdewanIpsecConnection{{
- Name:conn_name1,
- Type:"tunnel",
- Mode:"start",
- LocalSubnet:"192.168.21.1/24",
- LocalSourceip:"10.0.1.1",
- RemoteSubnet:"192.168.0.1/24",
- RemoteSourceip:"10.0.21.2",
- CryptoProposal:[]string{available_proposal_2},
- },
- {
- Name:conn_name2,
- Type:"transport",
- Mode:"start",
- LocalSubnet:"192.168.31.1/24",
- LocalSourceip:"10.0.11.1",
- RemoteSubnet:"192.168.10.1/24",
- RemoteSourceip:"10.0.31.2",
- CryptoProposal:[]string{available_proposal_1, available_proposal_2},
- },
- {
- Name:conn_name3,
- Type:"tunnel",
- Mode:"start",
- LocalSubnet:"192.168.41.1/24",
- LocalSourceip:"10.0.11.1",
- RemoteSubnet:"192.168.10.1/24",
- RemoteSourceip:"10.0.41.2",
- CryptoProposal:[]string{available_proposal_1},
- },
- },
- }
-
- _, err = ic.GetSite(site_name)
- if (err == nil) {
- err = ic.DeleteSite(site_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestSite: failed to delete site '%s'", site_name)
- return
- }
- }
-
- // Create site
- ret_site, err = ic.CreateSite(site)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestSite: failed to create site '%s'", site_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_site)
- fmt.Printf("Created Site: %s\n", string(p_data))
- }
-
- ret_site, err = ic.GetSite(site_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestSite: failed to get created site")
- return
- } else {
- if( len(ret_site.Connections) != 1 || ret_site.Connections[0].LocalSubnet != "192.168.1.1/24" ) {
- t.Errorf("Test case TestSite: failed to create site")
- return
- }
- }
-
- // Update site
- ret_site, err = ic.UpdateSite(update_site)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestSite: failed to update site '%s'", site_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_site)
- fmt.Printf("Updated Site: %s\n", string(p_data))
- }
-
- ret_site, err = ic.GetSite(site_name)
- if (err != nil) {
- t.Errorf("Test case TestSite: failed to get updated site")
- return
- } else {
- if( len(ret_site.Connections) != 3 || ret_site.Connections[0].LocalSubnet != "192.168.21.1/24" ) {
- t.Errorf("Test case TestSite: failed to update site")
- return
- }
- }
-
- // Delete site
- err = ic.DeleteSite(site_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestSite: failed to delete site '%s'", site_name)
- return
- }
-
- ret_site, err = ic.GetSite(site_name)
- if (err == nil) {
- t.Errorf("Test case TestSite: failed to delete site")
- return
- }
-}
-
-// IpSec Proposal API Test
-func TestGetProposals(t *testing.T) {
- res, err := ic.GetProposals()
- if res == nil {
- printError(err)
- t.Errorf("Test case TestGetProposals: can not get IpSec proposals")
- return
- }
-
- if len(res.Proposals) == 0 {
- fmt.Printf("Test case TestGetProposals: no proposal found")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetProposal(t *testing.T) {
- tcases := []struct {
- name string
- proposal string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetAvailableProposal",
- proposal: available_proposal_1,
- },
- {
- name: "GetFoolProposal",
- proposal: "foo_proposal",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := ic.GetProposal(tcase.proposal)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolProposal(t *testing.T) {
- tcases := []struct {
- name string
- proposal openwrt.SdewanIpsecProposal
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- proposal: openwrt.SdewanIpsecProposal{Name:" "},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := ic.CreateProposal(tcase.proposal)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolProposal(t *testing.T) {
- tcases := []struct {
- name string
- proposal string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- proposal: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "DeleteInUsedProposal",
- proposal: available_proposal_1,
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- proposal: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := ic.DeleteProposal(tcase.proposal)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolProposal(t *testing.T) {
- tcases := []struct {
- name string
- proposal openwrt.SdewanIpsecProposal
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- proposal: openwrt.SdewanIpsecProposal{Name:"fool_name"},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := ic.UpdateProposal(tcase.proposal)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestProposal(t *testing.T) {
- var err error
- var ret_proposal *openwrt.SdewanIpsecProposal
-
- var proposal_name = "test_proposal"
- var proposal = openwrt.SdewanIpsecProposal{Name:proposal_name,EncryptionAlgorithm:"aes128", HashAlgorithm:"sha256", DhGroup:"modp3072",}
- var update_proposal = openwrt.SdewanIpsecProposal{Name:proposal_name,EncryptionAlgorithm:"aes256", HashAlgorithm:"sha128", DhGroup:"modp3072",}
-
- _, err = ic.GetProposal(proposal_name)
- if (err == nil) {
- err = ic.DeleteProposal(proposal_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestProposal: failed to delete proposal '%s'", proposal_name)
- return
- }
- }
-
- // Create proposal
- ret_proposal, err = ic.CreateProposal(proposal)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestProposal: failed to create proposal '%s'", proposal_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_proposal)
- fmt.Printf("Created Proposal: %s\n", string(p_data))
- }
-
- ret_proposal, err = ic.GetProposal(proposal_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestProposal: failed to get created proposal")
- return
- } else {
- if( ret_proposal.EncryptionAlgorithm != "aes128" ) {
- t.Errorf("Test case TestProposal: failed to create proposal")
- return
- }
- }
-
- // Update proposal
- ret_proposal, err = ic.UpdateProposal(update_proposal)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestProposal: failed to update proposal '%s'", proposal_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_proposal)
- fmt.Printf("Updated Proposal: %s\n", string(p_data))
- }
-
- ret_proposal, err = ic.GetProposal(proposal_name)
- if (err != nil) {
- t.Errorf("Test case TestProposal: failed to get updated proposal")
- return
- } else {
- if( ret_proposal.EncryptionAlgorithm != "aes256" ) {
- t.Errorf("Test case TestProposal: failed to update proposal")
- return
- }
- }
-
- // Delete proposal
- err = ic.DeleteProposal(proposal_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestProposal: failed to delete proposal '%s'", proposal_name)
- return
- }
-
- ret_proposal, err = ic.GetProposal(proposal_name)
- if (err == nil) {
- t.Errorf("Test case TestProposal: failed to delete proposal")
- return
- }
-}
+++ /dev/null
-package openwrt
-
-import (
- "openwrt"
- "reflect"
- "testing"
- "flag"
- "encoding/json"
- "fmt"
- "os"
-)
-
-var mwan3 openwrt.Mwan3Client
-var service openwrt.ServiceClient
-var available_policy string
-var available_interface string
-var available_interfaceb string
-
-func TestMain(m *testing.M) {
- servIp := flag.String("ip", "10.244.0.18", "SDEWAN CNF Management IP Address")
- flag.Parse()
-
- client := openwrt.NewOpenwrtClient(*servIp, "root", "")
- mwan3 = openwrt.Mwan3Client{client}
- service = openwrt.ServiceClient{client}
- available_policy = "balanced"
- available_interface = "wan"
- available_interfaceb = "wanb"
-
- os.Exit(m.Run())
-}
-
-// Error handler
-func handleError(t *testing.T, err error, name string, expectedErr bool, errorCode int) {
- if (err != nil) {
- if (expectedErr) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- if(errorCode != err.(*openwrt.OpenwrtError).Code) {
- t.Errorf("Test case '%s': expected '%d', but got '%d'", name, errorCode, err.(*openwrt.OpenwrtError).Code)
- } else {
- fmt.Printf("%s\n", err.(*openwrt.OpenwrtError).Message)
- }
- default:
- t.Errorf("Test case '%s': expected openwrt.OpenwrtError, but got '%s'", name, reflect.TypeOf(err).String())
- }
- } else {
- t.Errorf("Test case '%s': expected success, but got '%s'", name, reflect.TypeOf(err).String())
- }
- } else {
- if (expectedErr) {
- t.Errorf("Test case '%s': expected error code '%d', but success", name, errorCode)
- }
- }
-}
-
-func printError(err error) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("%s\n", err.(*openwrt.OpenwrtError).Message)
- default:
- fmt.Printf("%s\n", reflect.TypeOf(err).String())
- }
-}
-
-// Service API Test
-func TestGetServices(t *testing.T) {
- res, _ := service.GetAvailableServices()
-
- if res == nil {
- t.Errorf("Test case GetServices: no available services")
- return
- }
-
- if !reflect.DeepEqual(res.Services, []string{"mwan3", "firewall", "ipsec"}) {
- t.Errorf("Test case GetServices: error available services returned")
- }
-}
-
-func TestExecuteService(t *testing.T) {
- tcases := []struct {
- name string
- service string
- action string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "Foo_Service",
- service: "foo_service",
- action: "restart",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Foo_action",
- service: "mwan3",
- action: "foo_action",
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
- for _, tcase := range tcases {
- _, err := service.ExecuteService(tcase.service, tcase.action)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-// MWAN3 Rule API Test
-func TestGetInterfaceStatus(t *testing.T) {
- res, _ := mwan3.GetInterfaceStatus()
- if res == nil {
- t.Errorf("Test case GetInterfaceStatus: can not get interfaces status")
- }
-}
-
-func TestGetRules(t *testing.T) {
- res, _ := mwan3.GetRules()
- if res == nil {
- t.Errorf("Test case GetRules: can not get mwan3 rules")
- return
- }
-
- if len(res.Rules) == 0 {
- t.Errorf("Test case GetRules: no rule defined")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetRule(t *testing.T) {
- tcases := []struct {
- name string
- rule string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetAvailableRule",
- rule: "default_rule",
- },
- {
- name: "GetFoolRule",
- rule: "foo_rule",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := mwan3.GetRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolRule(t *testing.T) {
- tcases := []struct {
- name string
- rule openwrt.SdewanRule
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolPolicy",
- rule: openwrt.SdewanRule{Name:" ", Policy: "fool_policy"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_src_ip",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, SrcIp: "10.200.200.500"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_src_port",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, SrcPort: "-1"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_dest_ip",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, DestIp: "10.200"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_dest_port",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, DestPort: "0"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_proto",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, Proto: "fool_protocol"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_family",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, Family: "fool_family"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_sticky",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, Sticky: "2"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Wrong_timeout",
- rule: openwrt.SdewanRule{Name:" ", Policy: available_policy, Timeout: "-1"},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := mwan3.CreateRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolRule(t *testing.T) {
- tcases := []struct {
- name string
- rule string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- rule: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- rule: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- err := mwan3.DeleteRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolRule(t *testing.T) {
- tcases := []struct {
- name string
- rule openwrt.SdewanRule
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- rule: openwrt.SdewanRule{Name:"fool_name", Policy: available_policy},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := mwan3.UpdateRule(tcase.rule)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestRule(t *testing.T) {
- var err error
- var ret_rule *openwrt.SdewanRule
-
- var rule_name = "test_rule"
- var rule = openwrt.SdewanRule{Name:rule_name, Policy: available_policy, SrcIp: "10.10.10.10/24", SrcPort: "80"}
- var update_rule = openwrt.SdewanRule{Name:rule_name, Policy: available_policy, SrcIp: "100.100.100.100/24", SrcPort: "8000", DestIp: "172.172.172.172/16", DestPort: "8080"}
-
- _, err = mwan3.GetRule(rule_name)
- if (err == nil) {
- err = mwan3.DeleteRule(rule_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to delete rule '%s'", rule_name)
- return
- }
- }
-
- // Create rule
- ret_rule, err = mwan3.CreateRule(rule)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to create rule '%s'", rule_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_rule)
- fmt.Printf("Created Rule: %s\n", string(p_data))
- }
-
- ret_rule, err = mwan3.GetRule(rule_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to get created rule")
- return
- } else {
- if( ret_rule.SrcPort != "80" ) {
- t.Errorf("Test case TestRule: failed to create rule")
- return
- }
- }
-
- // Update rule
- ret_rule, err = mwan3.UpdateRule(update_rule)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to update rule '%s'", rule_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_rule)
- fmt.Printf("Updated Rule: %s\n", string(p_data))
- }
-
- ret_rule, err = mwan3.GetRule(rule_name)
- if (err != nil) {
- t.Errorf("Test case TestRule: failed to get updated rule")
- return
- } else {
- if( ret_rule.SrcIp != "100.100.100.100/24" ) {
- t.Errorf("Test case TestRule: failed to update rule")
- return
- }
- }
-
- // Delete rule
- err = mwan3.DeleteRule(rule_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestRule: failed to delete rule '%s'", rule_name)
- return
- }
-
- ret_rule, err = mwan3.GetRule(rule_name)
- if (err == nil) {
- t.Errorf("Test case TestRule: failed to delete rule")
- return
- }
-}
-
-// MWAN3 Policy API Tests
-func TestGetPolicies(t *testing.T) {
- res, _ := mwan3.GetPolicies()
- if res == nil {
- t.Errorf("Test case GetPolicies: can not get mwan3 policies")
- return
- }
-
- if len(res.Policies) == 0 {
- t.Errorf("Test case GetPolicies: no policy defined")
- return
- }
-
- p_data, _ := json.Marshal(res)
- fmt.Printf("%s\n", string(p_data))
-}
-
-func TestGetPolicy(t *testing.T) {
- tcases := []struct {
- name string
- policy string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "GetAvailablePolicy",
- policy: available_policy,
- },
- {
- name: "GetFoolPolicy",
- policy: "foo_policy",
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := mwan3.GetPolicy(tcase.policy)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestCreateFoolPolicy(t *testing.T) {
- tcases := []struct {
- name string
- policy openwrt.SdewanPolicy
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- policy: openwrt.SdewanPolicy{Name:" ", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"1", Weight:"2"}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "EmptyMember",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "Policy-Conflict",
- policy: openwrt.SdewanPolicy{Name:"wan_only", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"1", Weight:"2"}}},
- expectedErr: true,
- expectedErrCode: 409,
- },
- {
- name: "WrongMember-interface",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:""}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "WrongMember-interface-name",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:"fool-name", Metric:"1", Weight:"2"}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "WrongMember-duplicate-interface",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"1", Weight:"2"}, {Interface:available_interface, Metric:"2", Weight:"3"}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "WrongMember-Metric",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:""}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "WrongMember-Weight",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"2"}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "WrongMember-Metric",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"-1", Weight:"2"}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "WrongMember-Weight",
- policy: openwrt.SdewanPolicy{Name:"policy1", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"2", Weight:"0"}}},
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- _, err := mwan3.CreatePolicy(tcase.policy)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestDeleteFoolPolicy(t *testing.T) {
- tcases := []struct {
- name string
- policy string
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "EmptyName",
- policy: "",
- expectedErr: true,
- expectedErrCode: 400,
- },
- {
- name: "FoolName",
- policy: "fool_name",
- expectedErr: true,
- expectedErrCode: 404,
- },
- {
- name: "Delete-InUsePolicy",
- policy: available_policy,
- expectedErr: true,
- expectedErrCode: 400,
- },
- }
-
- for _, tcase := range tcases {
- err := mwan3.DeletePolicy(tcase.policy)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestUpdateFoolPolicy(t *testing.T) {
- tcases := []struct {
- name string
- policy openwrt.SdewanPolicy
- expectedErr bool
- expectedErrCode int
- }{
- {
- name: "FoolName",
- policy: openwrt.SdewanPolicy{Name:"fool_name", Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"1", Weight:"2"}}},
- expectedErr: true,
- expectedErrCode: 404,
- },
- }
-
- for _, tcase := range tcases {
- _, err := mwan3.UpdatePolicy(tcase.policy)
- handleError(t, err, tcase.name, tcase.expectedErr, tcase.expectedErrCode)
- }
-}
-
-func TestPolicy(t *testing.T) {
- var err error
- var ret_policy *openwrt.SdewanPolicy
-
- var policy_name = "test_policy"
- var policy = openwrt.SdewanPolicy{Name:policy_name, Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"1", Weight:"2"}}}
- var update_policy = openwrt.SdewanPolicy{Name:policy_name, Members:[]openwrt.SdewanMember{{Interface:available_interface, Metric:"2", Weight:"3"}, {Interface:available_interfaceb, Metric:"2", Weight:"3"}}}
-
- _, err = mwan3.GetPolicy(policy_name)
- if (err == nil) {
- err = mwan3.DeletePolicy(policy_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestPolicy: failed to delete policy '%s'", policy_name)
- return
- }
- }
-
- // Create policy
- ret_policy, err = mwan3.CreatePolicy(policy)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestPolicy: failed to create policy '%s'", policy_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_policy)
- fmt.Printf("Created Policy: %s\n", string(p_data))
- }
-
- ret_policy, err = mwan3.GetPolicy(policy_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestPolicy: failed to get created policy")
- return
- } else {
- if( len(ret_policy.Members) != 1 || ret_policy.Members[0].Metric != "1" ) {
- t.Errorf("Test case TestPolicy: failed to create policy")
- return
- }
- }
-
- // Update policy
- ret_policy, err = mwan3.UpdatePolicy(update_policy)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestPolicy: failed to update policy '%s'", policy_name)
- return
- } else {
- p_data, _ := json.Marshal(ret_policy)
- fmt.Printf("Updated Policy: %s\n", string(p_data))
- }
-
- ret_policy, err = mwan3.GetPolicy(policy_name)
- if (err != nil) {
- t.Errorf("Test case TestPolicy: failed to get updated policy")
- return
- } else {
- if( len(ret_policy.Members) != 2 || ret_policy.Members[1].Metric != "2" ) {
- t.Errorf("Test case TestPolicy: failed to update policy")
- return
- }
- }
-
- // Delete policy
- err = mwan3.DeletePolicy(policy_name)
- if (err != nil) {
- printError(err)
- t.Errorf("Test case TestPolicy: failed to delete policy '%s'", policy_name)
- return
- }
-
- ret_policy, err = mwan3.GetPolicy(policy_name)
- if (err == nil) {
- t.Errorf("Test case TestPolicy: failed to delete policy")
- return
- }
-}
+++ /dev/null
-package main
-
-import (
- "openwrt"
- "fmt"
- "encoding/json"
- "strconv"
-)
-
-func testGetServices(serv *openwrt.ServiceClient) {
- res, err := serv.GetAvailableServices()
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- servs, err := json.Marshal(res)
- if(err != nil) {
- fmt.Printf("%s\n", err.Error())
- } else {
- fmt.Printf("%s\n", string(servs))
- }
- }
-}
-
-func testPutService(serv *openwrt.ServiceClient) {
- res, err := serv.ExecuteService("mwan3", "start")
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- fmt.Printf("Result: %s\n", strconv.FormatBool(res))
- }
-}
-
-func testGetInterfaceStatus(mwan3 *openwrt.Mwan3Client) {
- is, err := mwan3.GetInterfaceStatus()
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- fmt.Printf("Wan interface status: %s\n", is.Interfaces["wan"].Status)
- is_data, err := json.Marshal(is)
- if(err != nil) {
- fmt.Printf("%s\n", err.Error())
- } else {
- fmt.Printf("%s\n", string(is_data))
- }
- }
-
- is = nil
-}
-
-func testGetPolicies(mwan3 *openwrt.Mwan3Client) {
- res, err := mwan3.GetPolicies()
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- p_data, err := json.Marshal(res)
- if(err != nil) {
- fmt.Printf("%s\n", err.Error())
- } else {
- fmt.Printf("%s\n", string(p_data))
- }
- }
-}
-
-func testGetPolicy(mwan3 *openwrt.Mwan3Client, policy string) {
- res, err := mwan3.GetPolicy(policy)
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- p_data, err := json.Marshal(res)
- if(err != nil) {
- fmt.Printf("%s\n", err.Error())
- } else {
- fmt.Printf("%s\n", string(p_data))
- }
- }
-}
-
-func testGetRules(mwan3 *openwrt.Mwan3Client) {
- res, err := mwan3.GetRules()
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- p_data, err := json.Marshal(res)
- if(err != nil) {
- fmt.Printf("%s\n", err.Error())
- } else {
- fmt.Printf("%s\n", string(p_data))
- }
- }
-}
-
-func testGetRule(mwan3 *openwrt.Mwan3Client, rule string) {
- res, err := mwan3.GetRule(rule)
- if(err != nil) {
- switch err.(type) {
- case *openwrt.OpenwrtError:
- fmt.Printf("Openwrt Error: %s\n", err.Error())
- fmt.Printf("Openwrt Error: %d\n", err.(*openwrt.OpenwrtError).Code)
- default:
- fmt.Printf("%s\n", err.Error())
- }
- } else {
- p_data, err := json.Marshal(res)
- if(err != nil) {
- fmt.Printf("%s\n", err.Error())
- } else {
- fmt.Printf("%s\n", string(p_data))
- }
- }
-}
-
-func main() {
- client := openwrt.NewOpenwrtClient("10.244.0.18", "root", "")
- mwan3 := openwrt.Mwan3Client{OpenwrtClient: client}
- service := openwrt.ServiceClient{client}
-
- testGetServices(&service)
-
- testGetInterfaceStatus(&mwan3)
- testGetPolicies(&mwan3)
- testGetPolicy(&mwan3, "balanced")
- testGetPolicy(&mwan3, "foo_policy")
-
- testGetRules(&mwan3)
- testGetRule(&mwan3, "https")
- testGetRule(&mwan3, "foo_rule")
-}
--- /dev/null
+# Akraino ICN SDEWAN platform
+
+Akraino ICN SDEWAN platform includes below files/folders:
+
+* crd-ctrlr
+includes source code of sdewan controller, CR definition and sample yaml file to define the CR
+
+* cnf
+includes source code of sdewan cnf
+
+* test
+includes test steps and scripts for an E2E test scenario
+
+* README.md: this file
--- /dev/null
+# cnf
+
+sdewan cnf docker image for Akraino ICN SDEWAN solution
+
+# folder structure
+
+* src: includes all file to generate sdewan docker image
+* examples: sample yaml file to create CNF
+* doc: documents
+* README.md: this file
+
+# Build
+
+Requirements:
+* docker
+
+Steps:
+
+* Set proxy:
+If proxy is required in build environment, edit `build/set_proxy` file:
+docker_proxy={proxy}
+
+* Build docker image
+cd src
+./build_image.sh
+
+Note: After build, the docker image will be imported as openwrt-1806-mwan3
--- /dev/null
+# SDEWAN CNF documents
--- /dev/null
+# SDEWAN CNF examples
--- /dev/null
+# sdewan-controller
--- /dev/null
+# SDEWAN crd-ctrlr document
--- /dev/null
+# SDEWAN crd-ctrlr examples
--- /dev/null
+# sdewan solution e2e test
--- /dev/null
+# Akraino ICN SDEWAN traffic hub
Code Review / icn / sdwan.git / commitdiff