hostname/hostname.go

// figures out if your hostname is valid
// then checks if your DNS is setup correctly
package linuxstatus

import (
	"fmt"
	"io/ioutil"
	"strings"

	"go.wit.com/lib/gui/shell"
	"go.wit.com/log"

	// will try to get this hosts FQDN
	"github.com/Showmax/go-fqdn"
)

func (ls *LinuxStatus) GetDomainName() string {
	if !me.Ready() {
		return ""
	}
	return me.domainname.String()
}

func (ls *LinuxStatus) setDomainName() {
	if !me.Ready() {
		return
	}

	dn := run("domainname")
	if me.domainname.String() != dn {
		log.Log(CHANGE, "domainname has changed from", me.GetDomainName(), "to", dn)
		me.domainname.SetText(dn)
		me.changed = true
	}
}

func (ls *LinuxStatus) GetHostname() string {
	if !me.Ready() {
		return ""
	}
	return me.hostname.String()
}

func (ls *LinuxStatus) ValidHostname() bool {
	if !me.Ready() {
		log.Info("ValidHostname() not ready")
		return false
	}
	if me.hostnameStatus.String() == "WORKING" {
		return true
	}
	return false
}

func (ls *LinuxStatus) setHostname(newname string) {
	if !me.Ready() {
		return
	}
	if newname == me.hostname.String() {
		return
	}
	log.Log(CHANGE, "hostname has changed from", me.GetHostname(), "to", newname)
	me.hostname.SetText(newname)
	me.changed = true
}

func (ls *LinuxStatus) GetHostShort() string {
	if !me.Ready() {
		return ""
	}
	return me.hostshort.String()
}

func (ls *LinuxStatus) setHostShort() {
	if !me.Ready() {
		return
	}
	hshort := run("hostname -s")
	if me.hostshort.String() != hshort {
		log.Log(CHANGE, "hostname -s has changed from", me.hostshort.String(), "to", hshort)
		me.hostshort.SetText(hshort)
		me.changed = true
	}
}

// getDomainName extracts the domain name from a given hostname
func getDomainName(hostname string) (string, error) {
	parts := strings.Split(hostname, ".")
	if len(parts) < 3 {
		return "", fmt.Errorf("hostname '%s' is too short to extract a domain name", hostname)
	}
	// Join all parts except the first one, which is assumed to be a subdomain
	domain := strings.Join(parts[1:], ".")
	return domain, nil
}

func lookupHostname() {
	if !me.Ready() {
		return
	}
	var err error
	var hostfqdn string = "broken"
	hostfqdn, err = fqdn.FqdnHostname()
	if err != nil {
		log.Error(err, "FQDN hostname error")
		return
	}
	log.Log(NET, "full hostname should be: ", hostfqdn)

	me.setDomainName()
	me.setHostShort()

	// these are authoritative
	// if they work wrong, your linux configuration is wrong.
	// Do not complain.
	// Fix your distro if your box is otherwise not working this way
	hshort := me.GetHostShort()  // from `hostname -s`
	dn := me.GetDomainName()     // from `domanname`
	hostname := me.GetHostname() // from `hostname -f`

	if hostfqdn != hostname {
		log.Log(WARN, "hostname", hostname, "does not equal fqdn.FqdnHostname()", hostfqdn)
		// TODO: figure out what is wrong
		if dn == "(none)" {
			realdn, err := getDomainName(hostfqdn)
			if err == nil {
				log.Log(WARN, "need to run: 'domainname", realdn, "' here")
				me.changed = true
				me.hostnameStatus.SetText("FIXING")
				shell.Run([]string{"domainname", realdn})
				return
			} else {
				log.Log(WARN, "getDomainName() err =", err)
				log.Log(WARN, "/etc/hostname is too short. let the user set the name here.")
				// me.changed = true
				me.hostnameStatus.SetText("INVALID DOMAIN NAME")
				// return
			}
		}
		log.Log(WARN, "don't know what to do here with domainname")
		log.Log(WARN, "check that /etc/hostname is valid?")
		// me.changed = true
		me.hostnameStatus.SetText("UNKNOWN")
		// return
	}

	var test string
	test = hshort + "." + dn

	me.setHostname(test)

	if hostname != test {
		log.Log(CHANGE, "hostname", hostname, "does not equal", test)
		if me.hostnameStatus.String() != "BROKEN" {
			log.Log(CHANGE, "hostname", hostname, "does not equal", test)
			me.changed = true
			me.hostnameStatus.SetText("BROKEN")
		}
	} else {
		if me.hostnameStatus.String() != "WORKING" {
			log.Log(CHANGE, "hostname", hostname, "is valid")
			me.hostnameStatus.SetText("WORKING")
			me.changed = true
		}
	}
}

// returns true if the hostname is good
// check that all the OS settings are correct here
// On Linux, /etc/hosts, /etc/hostname
//
//	and domainname and hostname
func goodHostname() bool {
	content, err := ioutil.ReadFile("/etc/hostname")
	if err != nil {
		// this needs to be a fixWindow() error
		log.Error(err)
	}

	hostname := string(content)

	log.Log(NOW, "hostname =", hostname)

	hs := run("hostname -s")
	dn := run("domainname")
	log.Log(NOW, "hostname short =", hs, "domainname =", dn)

	tmp := hs + "." + dn
	if hostname == tmp {
		log.Log(NOW, "hostname seems to be good", hostname)
		return true
	}

	return false
}