main.go_

// Copyright 2018 Axel Etcheverry. All rights reserved.
// Use of this source code is governed by a MIT
// license that can be found in the LICENSE file.

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"os"
	"os/signal"
	"time"

	"github.com/hashicorp/memberlist"
	"github.com/rs/zerolog/log"
)

func main() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	hostname, _ := os.Hostname()

	ip, err := externalIP()
	if err != nil {
		log.Panic().Err(err).Msg("externalIP")
	}
	fmt.Printf("IP: %s\n", ip)

	addrs, err := net.LookupHost("hyperfs-index")
	if err != nil {
		log.Panic().Err(err).Msg("LookupHost")
	}

	fmt.Printf("LookupHost: %+v\n", addrs)

	ips, err := net.LookupIP("hyperfs-index")
	if err != nil {
		log.Panic().Err(err).Msg("LookupIP")
	}

	fmt.Printf("LookupIP: %+v\n", ips)

	resp, err := http.Get("http://hyperfs-index:8000/ip")
	if err != nil {
		log.Error().Err(err).Msg("http.Get ip")
	}

	iplookuped, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Error().Err(err).Msg("ioutil.ReadAll")
	}

	fmt.Printf("peer: %+v\n", string(iplookuped))

	cfg := memberlist.DefaultLANConfig()
	cfg.Name = hostname

	list, err := memberlist.Create(cfg)
	if err != nil {
		log.Error().Err(err).Msg("memberlist.Create")
	}

	if len(iplookuped) > 0 {
		// Join an existing cluster by specifying at least one known member.
		if _, err := list.Join([]string{string(iplookuped)}); err != nil {
			log.Error().Err(err).Msg("Failed to join cluster")
		}
	}

	// Ask for members of the cluster
	for _, member := range list.Members() {
		fmt.Printf("Member: %s %s\n", member.Name, member.Addr)
	}

	healthHandler := func(w http.ResponseWriter, req *http.Request) {
		w.WriteHeader(http.StatusOK)
		io.WriteString(w, "Hello, world!\n")
	}

	http.HandleFunc("/health", healthHandler)

	http.HandleFunc("/members", func(w http.ResponseWriter, req *http.Request) {
		json.NewEncoder(w).Encode(list.Members())
	})

	http.HandleFunc("/ip", func(w http.ResponseWriter, req *http.Request) {
		w.WriteHeader(http.StatusOK)
		io.WriteString(w, ip)
	})

	go func() {
		if err := http.ListenAndServe(":8000", nil); err != nil {
			log.Panic().Err(err).Msg("ListenAndServe")
		}
	}()

	node := list.LocalNode()
	fmt.Printf("Local member %s:%d\n", node.Addr, node.Port)

	<-c

	list.Leave(2 * time.Second)

	list.Shutdown()
}

func externalIP() (string, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return "", err
	}
	for _, iface := range ifaces {
		if iface.Flags&net.FlagUp == 0 {
			continue // interface down
		}
		if iface.Flags&net.FlagLoopback != 0 {
			continue // loopback interface
		}
		addrs, err := iface.Addrs()
		if err != nil {
			return "", err
		}
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip == nil || ip.IsLoopback() {
				continue
			}
			ip = ip.To4()
			if ip == nil {
				continue // not an ipv4 address
			}
			return ip.String(), nil
		}
	}
	return "", errors.New("are you connected to the network?")
}