main.go

package main

import (
	"bsc-shamir/election"
	"bsc-shamir/network"
	"fmt"
	"log"
	"math/big"
	"os"
	"strings"
	"time"

	"github.com/jessevdk/go-flags"
)

var opts struct {
	Port int `short:"p" long:"port" description:"This specifies the port where the server listens" value-name:"port" default:"27000"`
}

var server struct {
	// Server enables this authority to listen for incomming connections.
	Server *network.Server
	// The election being held
	Election *election.Election

	Config *network.Config

	Address string

	Closed chan bool
	Done   chan bool

	Connections map[string]*network.Conn
}

func init() {
	_, err := flags.Parse(&opts)
	if err != nil {
		os.Exit(0)
	}

	server.Closed = make(chan bool, 1)
	server.Done = make(chan bool, 1)

	// Load configuration to get election parameters and server list.
	server.Config, err = network.LoadConfig()
	if err != nil {
		log.Fatal("fatal:", err)
	}

	// Find our current port and server id
	portStr := fmt.Sprintf(":%d", opts.Port)
	var serialNumber *big.Int = nil
	for address, sn := range server.Config.Servers {
		if strings.HasSuffix(address, portStr) {
			server.Address = address
			serialNumber = sn
			break
		}
	}
	if serialNumber == nil {
		log.Fatal("fatal: server is not on server list")
	}

	// Initialize server using correct certificates
	server.Config.CertPath = fmt.Sprintf("config/cert/server/s%d.crt", serialNumber)
	server.Config.KeyPath = fmt.Sprintf("config/cert/server/s%d.key", serialNumber)
	server.Server = network.NewServer(server.Config)
	server.Server.OnClientMessage(election.MsgBallot, func(conn *network.Conn, data network.MessageData) *network.Message {
		var ballot election.Ballot
		err := data.Unmarshal(&ballot)
		if err != nil {
			log.Println("Main: error:", err)
		} else {
			go server.Election.HandleBallot(conn.SerialNumber(), &ballot)
		}
		return network.NewMessage(election.MsgBallotAck, nil)
	})
	server.Server.OnServerMessage(election.MsgClosing, func(conn *network.Conn, data network.MessageData) *network.Message {
		server.Election.HandleClosing(conn.SerialNumber())
		return nil
	})
	server.Server.OnServerMessage(election.MsgTally, func(conn *network.Conn, data network.MessageData) *network.Message {
		var tally election.Tally
		err := data.Unmarshal(&tally)
		if err != nil {
			log.Println("Main: error:", err)
		} else {
			go server.Election.HandleTally(conn.SerialNumber(), &tally)
		}
		return nil
	})

	// Initialize election
	servers := len(server.Config.Servers)
	required := (servers / 2) + 1
	config := &election.Config{
		ServerID:        election.UniqueID(serialNumber.String()),
		Voters:          10,
		Servers:         servers,
		RequiredServers: required,
		Deadline:        time.Now().Add(30 * time.Second),
		CloseCallback:   closeCallback,
		TallyCallback:   tallyCallback,
		ResultCallback:  resultCallback,
	}
	server.Election = election.NewElection(config)
}

func startServer() {
	err := server.Server.Start(opts.Port)
	if err != nil {
		log.Fatal("Main: fatal:", err)
	}
}

func conenctServers() {
	connections := 0
	for address := range server.Config.Servers {
		if address != server.Address {
			_, err := server.Server.Connect(address)
			if err != nil {
				log.Println("Main: error:", err)
				continue
			}
			connections++
		}
	}
	if connections == 0 {
		log.Fatal("Main: fatal: could not connect to servers")
	}
}

func startElection() {
	err := server.Election.Start()
	if err != nil {
		log.Fatal("Main: fatal:", err)
	}
}

func main() {
	startServer()
	time.Sleep(2 * time.Second) // Give servers time to start before connecting
	conenctServers()
	time.Sleep(1 * time.Second) // To let servers connect before starting election
	startElection()

	<-server.Done // Closed
	<-server.Done // Result

	time.Sleep(1 * time.Second) // Grace period

	server.Server.Close()
}

func closeCallback(reason election.Reason) {
	msgClosed := network.NewMessage(election.MsgClosing, nil)
	server.Server.Broadcast(msgClosed)

	server.Done <- true
}

func tallyCallback(tally *election.Tally) {
	msgTally := network.NewMessage(election.MsgTally, tally)
	server.Server.Broadcast(msgTally)
}

func resultCallback(result *election.Result) {
	if result == nil {
		log.Printf("Main: no votes received")
	} else {
		percentage := (float64(result.Tally) / float64(result.Votes)) * 100
		log.Printf("Main: final result: %d of %d (%.2f%%) voted 1\n", result.Tally, result.Votes, percentage)
	}

	server.Done <- true
}