refactor backend and frontend, migrate structs, organize front view, add mtu

core/client.go

@@ -16,7 +16,6 @@ import (
 	"path/filepath"
 	"sort"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -49,8 +48,8 @@ func CreateClient(client *model.Client) (*model.Client, error) {
 	}
 
 	ips := make([]string, 0)
-	for _, network := range strings.Split(client.Address, ",") {
-		ip, err := util.GetAvailableIp(strings.TrimSpace(network), reserverIps)
+	for _, network := range client.Address {
+		ip, err := util.GetAvailableIp(network, reserverIps)
 		if err != nil {
 			return nil, err
 		}
@@ -61,7 +60,7 @@ func CreateClient(client *model.Client) (*model.Client, error) {
 		}
 		ips = append(ips, ip)
 	}
-	client.Address = strings.Join(ips, ",")
+	client.Address = ips
 	client.Created = time.Now().UTC()
 	client.Updated = client.Created
 

core/migrate.go

@@ -0,0 +1,189 @@
+package core
+
+import (
+	"encoding/json"
+	uuid "github.com/satori/go.uuid"
+	log "github.com/sirupsen/logrus"
+	"gitlab.127-0-0-1.fr/vx3r/wg-gen-web/model"
+	"gitlab.127-0-0-1.fr/vx3r/wg-gen-web/storage"
+	"gitlab.127-0-0-1.fr/vx3r/wg-gen-web/util"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// Migrate all changes, current struct fields change
+func Migrate() error {
+	clients, err := readClients()
+	if err != nil {
+		return err
+	}
+
+	s, err := deserialize("server.json")
+	if err != nil {
+		return err
+	}
+
+	for _, client := range clients {
+		switch v := client["allowedIPs"].(type) {
+		case []interface{}:
+			log.Infof("client %s has been already migrated", client["id"])
+			continue
+		default:
+			log.Infof("unexpected type %T, mus be migrated", v)
+		}
+
+		c := &model.Client{}
+		c.Id = client["id"].(string)
+		c.Name = client["name"].(string)
+		c.Email = client["email"].(string)
+		c.Enable = client["enable"].(bool)
+		c.AllowedIPs = make([]string, 0)
+		for _, address := range strings.Split(client["allowedIPs"].(string), ",") {
+			if util.IsValidCidr(strings.TrimSpace(address)) {
+				c.AllowedIPs = append(c.AllowedIPs, strings.TrimSpace(address))
+			}
+		}
+		c.Address = make([]string, 0)
+		for _, address := range strings.Split(client["address"].(string), ",") {
+			if util.IsValidCidr(strings.TrimSpace(address)) {
+				c.Address = append(c.Address, strings.TrimSpace(address))
+			}
+		}
+		c.PrivateKey = client["privateKey"].(string)
+		c.PublicKey = client["publicKey"].(string)
+		created, err := time.Parse(time.RFC3339, client["created"].(string))
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to parse time")
+			continue
+		}
+		c.Created = created
+		updated, err := time.Parse(time.RFC3339, client["updated"].(string))
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to parse time")
+			continue
+		}
+		c.Updated = updated
+
+		err = storage.Serialize(c.Id, c)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to Serialize client")
+		}
+	}
+
+	switch v := s["address"].(type) {
+	case []interface{}:
+		log.Info("server has been already migrated")
+		return nil
+	default:
+		log.Infof("unexpected type %T, mus be migrated", v)
+	}
+
+	server := &model.Server{}
+
+	server.Address = make([]string, 0)
+	for _, address := range strings.Split(s["address"].(string), ",") {
+		if util.IsValidCidr(strings.TrimSpace(address)) {
+			server.Address = append(server.Address, strings.TrimSpace(address))
+		}
+	}
+	server.ListenPort = int(s["listenPort"].(float64))
+	server.PrivateKey = s["privateKey"].(string)
+	server.PublicKey = s["publicKey"].(string)
+	server.PresharedKey = s["presharedKey"].(string)
+	server.Endpoint = s["endpoint"].(string)
+	server.PersistentKeepalive = int(s["persistentKeepalive"].(float64))
+	server.Dns = make([]string, 0)
+	for _, address := range strings.Split(s["dns"].(string), ",") {
+		if util.IsValidIp(strings.TrimSpace(address)) {
+			server.Dns = append(server.Dns, strings.TrimSpace(address))
+		}
+	}
+	if val, ok := s["preUp"]; ok {
+		server.PreUp = val.(string)
+	}
+	if val, ok := s["postUp"]; ok {
+		server.PostUp = val.(string)
+	}
+	if val, ok := s["preDown"]; ok {
+		server.PreDown = val.(string)
+	}
+	if val, ok := s["postDown"]; ok {
+		server.PostDown = val.(string)
+	}
+	created, err := time.Parse(time.RFC3339, s["created"].(string))
+	if err != nil {
+		log.WithFields(log.Fields{
+			"err": err,
+		}).Errorf("failed to parse time")
+	}
+	server.Created = created
+	updated, err := time.Parse(time.RFC3339, s["updated"].(string))
+	if err != nil {
+		log.WithFields(log.Fields{
+			"err": err,
+		}).Errorf("failed to parse time")
+	}
+	server.Updated = updated
+
+	err = storage.Serialize("server.json", server)
+	if err != nil {
+		log.WithFields(log.Fields{
+			"err": err,
+		}).Errorf("failed to Serialize server")
+	}
+
+	return nil
+}
+
+func readClients() ([]map[string]interface{}, error) {
+	clients := make([]map[string]interface{}, 0)
+
+	files, err := ioutil.ReadDir(filepath.Join(os.Getenv("WG_CONF_DIR")))
+	if err != nil {
+		return nil, err
+	}
+
+	for _, f := range files {
+		// clients file name is an uuid
+		_, err := uuid.FromString(f.Name())
+		if err == nil {
+			c, err := deserialize(f.Name())
+			if err != nil {
+				log.WithFields(log.Fields{
+					"err":  err,
+					"path": f.Name(),
+				}).Error("failed to deserialize client")
+			} else {
+				clients = append(clients, c)
+			}
+		}
+	}
+
+	return clients, nil
+}
+
+func deserialize(id string) (map[string]interface{}, error) {
+	path := filepath.Join(os.Getenv("WG_CONF_DIR"), id)
+
+	data, err := util.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	var d map[string]interface{}
+	err = json.Unmarshal(data, &d)
+	if err != nil {
+		return nil, err
+	}
+
+	return d, nil
+}

core/server.go

@@ -10,7 +10,6 @@ import (
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"
 )
 
@@ -32,12 +31,19 @@ func ReadServer() (*model.Server, error) {
 		}
 		server.PresharedKey = presharedKey.String()
 
-		server.Name = "Created with default values"
 		server.Endpoint = "wireguard.example.com:123"
 		server.ListenPort = 51820
-		server.Address = "fd9f:6666::10:6:6:1/112, 10.6.6.1/24"
-		server.Dns = "fd9f::10:0:0:2, 10.0.0.2"
+
+		server.Address = make([]string, 0)
+		server.Address = append(server.Address, "fd9f:6666::10:6:6:1/64")
+		server.Address = append(server.Address, "10.6.6.1/24")
+
+		server.Dns = make([]string, 0)
+		server.Dns = append(server.Dns, "fd9f::10:0:0:2")
+		server.Dns = append(server.Dns, "10.0.0.2")
+
 		server.PersistentKeepalive = 16
+		server.Mtu = 0
 		server.PreUp = "echo WireGuard PreUp"
 		server.PostUp = "echo WireGuard PostUp"
 		server.PreDown = "echo WireGuard PreDown"
@@ -131,12 +137,12 @@ func GetAllReservedIps() ([]string, error) {
 	reserverIps := make([]string, 0)
 
 	for _, client := range clients {
-		for _, cidr := range strings.Split(client.Address, ",") {
-			ip, err := util.GetIpFromCidr(strings.TrimSpace(cidr))
+		for _, cidr := range client.Address {
+			ip, err := util.GetIpFromCidr(cidr)
 			if err != nil {
 				log.WithFields(log.Fields{
 					"err":  err,
-					"cidr": err,
+					"cidr": cidr,
 				}).Error("failed to ip from cidr")
 			} else {
 				reserverIps = append(reserverIps, ip)
@@ -144,8 +150,8 @@ func GetAllReservedIps() ([]string, error) {
 		}
 	}
 
-	for _, cidr := range strings.Split(server.Address, ",") {
-		ip, err := util.GetIpFromCidr(strings.TrimSpace(cidr))
+	for _, cidr := range server.Address {
+		ip, err := util.GetIpFromCidr(cidr)
 		if err != nil {
 			log.WithFields(log.Fields{
 				"err":  err,