func (m *MlagEntity) SetDomainIDDefault() bool {
	return m.ConfigureMlag("domain-id", "", true, false)
}
SetDomainIDDefault Configures the default mlag domain-id value

Returns:
bool: Returns True if the commands complete successfully
package module
import (
	"regexp"
	"strconv"
	"github.com/aristanetworks/goeapi"
)
type GlobalMlagConfig map[string]string
type InterfaceMlagConfig map[string]string
type MlagConfig struct {
	config     GlobalMlagConfig
	interfaces InterfaceMlagConfig
}
func (m MlagConfig) DomainID() string {
	return m.config["domain_id"]
}
func (m MlagConfig) LocalInterface() string {
	return m.config["local_interface"]
}
func (m MlagConfig) PeerAddress() string {
	return m.config["peer_address"]
}
func (m MlagConfig) PeerLink() string {
	return m.config["peer_link"]
}
func (m MlagConfig) Shutdown() string {
	return m.config["shutdown"]
}
func (m MlagConfig) InterfaceConfig(intf string) string {
	return m.interfaces[intf]
}
func (m MlagConfig) isEqual(dest MlagConfig) bool {
	if (len(m.config) != len(dest.config)) ||
		(len(m.interfaces) != len(dest.interfaces)) {
		return false
	}
	for k, v := range m.config {
		val, found := dest.config[k]
		if !found || val != v {
			return false
		}
	}
	for k, v := range m.interfaces {
		val, found := dest.interfaces[k]
		if !found || val != v {
			return false
		}
	}
	return true
}
type MlagEntity struct {
	*AbstractBaseEntity
}
func Mlag(node *goeapi.Node) *MlagEntity {
	return &MlagEntity{&AbstractBaseEntity{node}}
}
func (m *MlagEntity) Get() *MlagConfig {
	config := m.parseConfig()
	interfaces := m.parseInterfaces()
	return &MlagConfig{config: config, interfaces: interfaces}
}
func (m *MlagEntity) parseConfig() GlobalMlagConfig {
	config, _ := m.GetBlock("mlag configuration")
	return GlobalMlagConfig{
		"domain_id":       m.parseDomainID(config),
		"local_interface": m.parseLocalInterface(config),
		"peer_address":    m.parsePeerAddress(config),
		"peer_link":       m.parsePeerLink(config),
		"shutdown":        strconv.FormatBool(m.parseShutdown(config)),
	}
}
func (m *MlagEntity) parseDomainID(config string) string {
	if config == "" {
		return ""
	}
	re := regexp.MustCompile(`(?m)domain-id (\w+)`)
	match := re.FindStringSubmatch(config)
	if match == nil {
		return ""
	}
	return match[1]
}
func (m *MlagEntity) parseLocalInterface(config string) string {
	if config == "" {
		return ""
	}
	re := regexp.MustCompile(`(?m)local-interface (\w+)`)
	match := re.FindStringSubmatch(config)
	if match == nil {
		return ""
	}
	return match[1]
}
func (m *MlagEntity) parsePeerAddress(config string) string {
	if config == "" {
		return ""
	}
	re := regexp.MustCompile(`(?m)peer-address ([^\s]+)`)
	match := re.FindStringSubmatch(config)
	if match == nil {
		return ""
	}
	return match[1]
}
func (m *MlagEntity) parsePeerLink(config string) string {
	if config == "" {
		return ""
	}
	re := regexp.MustCompile(`(?m)peer-link (\S+)`)
	match := re.FindStringSubmatch(config)
	if match == nil {
		return ""
	}
	return match[1]
}
func (m *MlagEntity) parseShutdown(config string) bool {
	if config == "" {
		return false
	}
	matched, _ := regexp.MatchString(`(?m)no shutdown`, config)
	if matched {
		return false
	}
	return !matched
}
func (m *MlagEntity) parseInterfaces() InterfaceMlagConfig {
	config := m.Config()
	var resource = make(InterfaceMlagConfig)
	reIntf := regexp.MustCompile(`(?m)^interface (Po.+)$`)
	reMlag := regexp.MustCompile(`(?m)mlag (\d+)`)
	interfaces := reIntf.FindAllStringSubmatch(config, -1)
	for _, intf := range interfaces {
		parent := "interface " + intf[1]
		config, _ := m.GetBlock(parent)
		match := reMlag.FindStringSubmatch(config)
		if match != nil {
			resource[intf[1]] = match[1]
		}
	}
	return resource
}
func (m *MlagEntity) GetSection() string {
	config, err := m.GetBlock("mlag configuration")
	if err != nil {
		return ""
	}
	return config
}
func (m *MlagEntity) ConfigureMlag(cmd string, value string, def bool, enable bool) bool {
	cfg := m.CommandBuilder(cmd, value, def, enable)
	var commands = []string{"mlag configuration", cfg}
	return m.Configure(commands...)
}
func (m *MlagEntity) SetDomainID(value string) bool {
	if value == "" {
		return m.ConfigureMlag("domain-id", value, false, false)
	}
	return m.ConfigureMlag("domain-id", value, false, true)
}