mirror of
https://github.com/luscis/openlan.git
synced 2025-12-24 11:10:54 +08:00
394 lines
8.2 KiB
Go
Executable File
394 lines
8.2 KiB
Go
Executable File
package config
|
|
|
|
import (
|
|
"flag"
|
|
"path/filepath"
|
|
|
|
"github.com/luscis/openlan/pkg/libol"
|
|
)
|
|
|
|
type Perf struct {
|
|
Access int `json:"access" yaml:"access"`
|
|
Neighbor int `json:"neighbor" yaml:"neighbor"`
|
|
OnLine int `json:"online" yaml:"online"`
|
|
Link int `json:"link" yaml:"link"`
|
|
User int `json:"user" yaml:"user"`
|
|
Esp int `json:"esp" yaml:"esp"`
|
|
State int `json:"state" yaml:"state"`
|
|
Policy int `json:"policy" yaml:"policy"`
|
|
VxLAN int `json:"vxlan" yaml:"vxlan"`
|
|
}
|
|
|
|
func (p *Perf) Correct() {
|
|
if p.Access == 0 {
|
|
p.Access = 64
|
|
}
|
|
if p.Neighbor == 0 {
|
|
p.Neighbor = 64
|
|
}
|
|
if p.OnLine == 0 {
|
|
p.OnLine = 64
|
|
}
|
|
if p.Link == 0 {
|
|
p.Link = 64
|
|
}
|
|
if p.User == 0 {
|
|
p.User = 1024
|
|
}
|
|
if p.Esp == 0 {
|
|
p.Esp = 64
|
|
}
|
|
if p.State == 0 {
|
|
p.State = 64 * 4
|
|
}
|
|
if p.Policy == 0 {
|
|
p.Policy = 64 * 8
|
|
}
|
|
if p.VxLAN == 0 {
|
|
p.VxLAN = 64
|
|
}
|
|
}
|
|
|
|
type Switch struct {
|
|
File string `json:"-" yaml:"-"`
|
|
Alias string `json:"alias" yaml:"alias"`
|
|
Perf Perf `json:"limit,omitempty" yaml:"limit,omitempty"`
|
|
Protocol string `json:"protocol" yaml:"protocol"` // tcp, tls, udp, kcp, ws and wss.
|
|
Listen string `json:"listen" yaml:"listen"`
|
|
Timeout int `json:"timeout" yaml:"timeout"`
|
|
Http *Http `json:"http,omitempty" yaml:"http,omitempty"`
|
|
Log Log `json:"log" yaml:"log"`
|
|
Cert *Cert `json:"cert,omitempty" yaml:"cert,omitempty"`
|
|
Crypt *Crypt `json:"crypt,omitempty" yaml:"crypt,omitempty"`
|
|
Network map[string]*Network `json:"network,omitempty" yaml:"network,omitempty"`
|
|
Acl map[string]*ACL `json:"acl,omitempty" yaml:"acl,omitempty"`
|
|
Qos map[string]*Qos `json:"qos,omitempty" yaml:"qos,omitempty"`
|
|
FireWall []FlowRule `json:"firewall,omitempty" yaml:"firewall,omitempty"`
|
|
Queue Queue `json:"queue" yaml:"queue"`
|
|
PassFile string `json:"password" yaml:"password"`
|
|
Ldap *LDAP `json:"ldap,omitempty" yaml:"ldap,omitempty"`
|
|
AddrPool string `json:"pool,omitempty" yaml:"pool,omitempty"`
|
|
ConfDir string `json:"-" yaml:"-"`
|
|
TokenFile string `json:"-" yaml:"-"`
|
|
}
|
|
|
|
func NewSwitch() *Switch {
|
|
s := &Switch{
|
|
Acl: make(map[string]*ACL, 32),
|
|
Qos: make(map[string]*Qos, 1024),
|
|
Network: make(map[string]*Network, 32),
|
|
}
|
|
s.Parse()
|
|
s.Initialize()
|
|
return s
|
|
}
|
|
|
|
func (s *Switch) Parse() {
|
|
flag.StringVar(&s.Log.File, "log:file", "", "Configure log file")
|
|
flag.StringVar(&s.ConfDir, "conf:dir", "", "Configure switch's directory")
|
|
flag.IntVar(&s.Log.Verbose, "log:level", 20, "Configure log level")
|
|
flag.Parse()
|
|
}
|
|
|
|
func (s *Switch) IsYaml() bool {
|
|
return libol.IsYaml(s.File)
|
|
}
|
|
|
|
func (s *Switch) Initialize() {
|
|
s.File = s.Dir("switch.json", "")
|
|
if err := libol.FileExist(s.File); err != nil {
|
|
s.File = s.Dir("switch.yaml", "")
|
|
}
|
|
if err := s.Load(); err != nil {
|
|
libol.Error("Switch.Initialize %s", err)
|
|
}
|
|
s.Correct()
|
|
s.LoadExtend()
|
|
libol.Debug("Switch.Initialize %v", s)
|
|
}
|
|
|
|
func (s *Switch) LoadExtend() {
|
|
s.LoadAcl()
|
|
s.LoadQos()
|
|
s.LoadNetworks()
|
|
}
|
|
|
|
func (s *Switch) Correct() {
|
|
s.Log.Correct()
|
|
s.Queue.Correct()
|
|
|
|
if s.Alias == "" {
|
|
s.Alias = GetAlias()
|
|
}
|
|
|
|
SetListen(&s.Listen, 10002)
|
|
if s.Http == nil {
|
|
s.Http = &Http{}
|
|
}
|
|
s.Http.Correct()
|
|
|
|
vpn := DefaultOpenVPN()
|
|
vpn.Url = s.Http.GetUrl()
|
|
|
|
if s.Timeout == 0 {
|
|
s.Timeout = 120
|
|
}
|
|
s.TokenFile = s.Dir("token", "")
|
|
if s.Cert == nil {
|
|
s.Cert = &Cert{}
|
|
}
|
|
s.Cert.Correct()
|
|
|
|
if s.Crypt == nil {
|
|
s.Crypt = &Crypt{}
|
|
}
|
|
s.Crypt.Correct()
|
|
s.Perf.Correct()
|
|
|
|
s.PassFile = s.Dir("password", "")
|
|
if s.Protocol == "" {
|
|
s.Protocol = "tcp"
|
|
}
|
|
if s.AddrPool == "" {
|
|
s.AddrPool = "100.255"
|
|
}
|
|
}
|
|
|
|
func (s *Switch) Dir(elem0, elem1 string) string {
|
|
var file string
|
|
|
|
if elem1 == "" {
|
|
return filepath.Join(s.ConfDir, elem0)
|
|
}
|
|
|
|
if s.IsYaml() {
|
|
file = elem1 + ".yaml"
|
|
} else {
|
|
file = elem1 + ".json"
|
|
}
|
|
|
|
return filepath.Join(s.ConfDir, elem0, file)
|
|
}
|
|
|
|
func (s *Switch) RemarshalNetwork(obj *Network, format string) {
|
|
context := obj.Specifies
|
|
|
|
obj.NewSpecifies()
|
|
if obj.Specifies == nil {
|
|
return
|
|
}
|
|
if format == "" {
|
|
format = "json"
|
|
if s.IsYaml() {
|
|
format = "yaml"
|
|
}
|
|
}
|
|
|
|
if format == "yaml" {
|
|
if data, err := libol.MarshalYaml(context); err != nil {
|
|
libol.Warn("Switch.Format %s", err)
|
|
} else if err := libol.UnmarshalYaml(obj.Specifies, data); err != nil {
|
|
libol.Warn("Switch.Format %s", err)
|
|
}
|
|
} else {
|
|
if data, err := libol.Marshal(context, true); err != nil {
|
|
libol.Warn("Switch.Format %s", err)
|
|
} else if err := libol.Unmarshal(obj.Specifies, data); err != nil {
|
|
libol.Warn("Switch.Format %s", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Switch) UnmarshalNetwork(data []byte) (*Network, error) {
|
|
libol.Debug("Switch.UnmarshalNetwork %s", data)
|
|
obj := &Network{
|
|
Alias: s.Alias,
|
|
ConfDir: s.ConfDir,
|
|
}
|
|
if s.IsYaml() {
|
|
if err := libol.UnmarshalYaml(obj, data); err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
if err := libol.Unmarshal(obj, data); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if _, ok := s.Network[obj.Name]; ok {
|
|
return nil, libol.NewErr("already existed")
|
|
}
|
|
if obj.Bridge == nil {
|
|
obj.Bridge = &Bridge{}
|
|
}
|
|
|
|
obj.LoadLink()
|
|
obj.LoadRoute()
|
|
obj.LoadOutput()
|
|
obj.LoadFindHop()
|
|
|
|
s.Network[obj.Name] = obj
|
|
return obj, nil
|
|
}
|
|
|
|
func (s *Switch) RemarshalNetworks(format string) {
|
|
for _, obj := range s.Network {
|
|
s.RemarshalNetwork(obj, format)
|
|
}
|
|
}
|
|
|
|
func (s *Switch) CorrectNetwork(obj *Network, format string) {
|
|
s.RemarshalNetwork(obj, format)
|
|
for _, link := range obj.Links {
|
|
link.Correct()
|
|
}
|
|
obj.Correct(s)
|
|
obj.Alias = s.Alias
|
|
if obj.File == "" {
|
|
obj.File = s.Dir("network", obj.Name)
|
|
}
|
|
if _, ok := s.Acl[obj.Name]; !ok {
|
|
obj := &ACL{
|
|
Name: obj.Name,
|
|
}
|
|
obj.Correct(s)
|
|
s.Acl[obj.Name] = obj
|
|
}
|
|
if _, ok := s.Qos[obj.Name]; !ok {
|
|
obj := &Qos{
|
|
Name: obj.Name,
|
|
}
|
|
obj.Correct(s)
|
|
s.Qos[obj.Name] = obj
|
|
}
|
|
}
|
|
|
|
func (s *Switch) CorrectNetworks() {
|
|
for _, obj := range s.Network {
|
|
s.CorrectNetwork(obj, "")
|
|
}
|
|
}
|
|
|
|
func (s *Switch) AddNetwork(data []byte) (*Network, error) {
|
|
obj, err := s.UnmarshalNetwork(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return obj, nil
|
|
}
|
|
|
|
func (s *Switch) LoadNetworks() {
|
|
files, err := filepath.Glob(s.Dir("network", "*"))
|
|
if err != nil {
|
|
libol.Error("Switch.LoadNetwork %s", err)
|
|
}
|
|
for _, file := range files {
|
|
data, err := libol.LoadFile(file)
|
|
if err != nil {
|
|
libol.Warn("Switch.LoadNetwork %s", err)
|
|
continue
|
|
}
|
|
if _, err := s.UnmarshalNetwork(data); err != nil {
|
|
libol.Warn("Switch.LoadNetwork %s", err)
|
|
}
|
|
|
|
}
|
|
s.CorrectNetworks()
|
|
}
|
|
|
|
func (s *Switch) LoadQos() {
|
|
files, err := filepath.Glob(s.Dir("qos", "*"))
|
|
if err != nil {
|
|
libol.Error("Switch.LoadQos %s", err)
|
|
}
|
|
|
|
for _, file := range files {
|
|
obj := &Qos{
|
|
File: file,
|
|
}
|
|
if err := libol.UnmarshalLoad(obj, file); err != nil {
|
|
libol.Error("Switch.LoadQos %s", err)
|
|
continue
|
|
}
|
|
|
|
s.Qos[obj.Name] = obj
|
|
}
|
|
for _, obj := range s.Qos {
|
|
for _, rule := range obj.Config {
|
|
rule.Correct()
|
|
}
|
|
obj.Correct(s)
|
|
}
|
|
}
|
|
|
|
func (s *Switch) LoadAcl() {
|
|
files, err := filepath.Glob(s.Dir("acl", "*"))
|
|
if err != nil {
|
|
libol.Error("Switch.LoadAcl %s", err)
|
|
}
|
|
for _, file := range files {
|
|
obj := &ACL{
|
|
File: file,
|
|
}
|
|
if err := libol.UnmarshalLoad(obj, file); err != nil {
|
|
libol.Error("Switch.LoadAcl %s", err)
|
|
continue
|
|
}
|
|
obj.Correct(s)
|
|
s.Acl[obj.Name] = obj
|
|
}
|
|
}
|
|
|
|
func (s *Switch) Load() error {
|
|
return libol.UnmarshalLoad(s, s.File)
|
|
}
|
|
|
|
func (s *Switch) Save() {
|
|
tmp := *s
|
|
tmp.Acl = nil
|
|
tmp.Qos = nil
|
|
tmp.Network = nil
|
|
if err := libol.MarshalSave(&tmp, tmp.File, true); err != nil {
|
|
libol.Error("Switch.Save %s", err)
|
|
}
|
|
s.SaveAcl()
|
|
s.SaveQos()
|
|
s.SaveNetwork()
|
|
}
|
|
|
|
func (s *Switch) SaveQos() {
|
|
for _, obj := range s.Qos {
|
|
obj.Save()
|
|
}
|
|
}
|
|
|
|
func (s *Switch) SaveAcl() {
|
|
for _, obj := range s.Acl {
|
|
obj.Save()
|
|
}
|
|
}
|
|
|
|
func (s *Switch) SaveNetwork() {
|
|
for _, obj := range s.Network {
|
|
obj.Save()
|
|
}
|
|
}
|
|
|
|
func (s *Switch) Reload() {
|
|
for _, obj := range s.Network {
|
|
obj.Reload()
|
|
}
|
|
}
|
|
|
|
func (s *Switch) GetNetwork(name string) *Network {
|
|
return s.Network[name]
|
|
}
|
|
|
|
func (s *Switch) GetACL(name string) *ACL {
|
|
return s.Acl[name]
|
|
}
|
|
|
|
func (s *Switch) GetQos(name string) *Qos {
|
|
return s.Qos[name]
|
|
}
|