func RunServer(flags *app.Flags, conf *app.ConfigColl) {
hostname := flags.Hostname
if hostname == conf.Hosts[0] {
dbg.Lvlf3("Tree is %+v", conf.Tree)
}
dbg.Lvl3(hostname, "Starting to run")
app.RunFlags.StartedUp(len(conf.Hosts))
peer := conode.NewPeer(hostname, conf.ConfigConode)
if app.RunFlags.AmRoot {
for {
setupRound := sign.NewRoundSetup(peer.Node)
peer.StartAnnouncementWithWait(setupRound, 5*time.Second)
counted := <-setupRound.Counted
dbg.Lvl1("Number of peers counted:", counted)
if counted == len(conf.Hosts) {
dbg.Lvl1("All hosts replied")
break
}
time.Sleep(time.Second)
}
}
RegisterRoundMeasure(peer.Node.LastRound())
peer.LoopRounds(RoundMeasureType, conf.Rounds)
dbg.Lvlf3("Done - flags are %+v", app.RunFlags)
monitor.End()
}
func createPeer(conf *app.ConfigConode, id int) *conode.Peer {
// Read the private / public keys + binded address
keybase := "testdata/key" + strconv.Itoa(id)
address := ""
if sec, err := cliutils.ReadPrivKey(suite, keybase+".priv"); err != nil {
dbg.Fatal("Error reading private key file :", err)
} else {
conf.Secret = sec
}
if pub, addr, err := cliutils.ReadPubKey(suite, keybase+".pub"); err != nil {
dbg.Fatal("Error reading public key file :", err)
} else {
conf.Public = pub
address = addr
}
return conode.NewPeer(address, conf)
}
func main() {
conf := &app.ConfigColl{}
app.ReadConfig(conf)
// we must know who we are
if app.RunFlags.Hostname == "" {
dbg.Fatal("Hostname empty: Abort")
}
// Do some common setup
if app.RunFlags.Mode == "client" {
app.RunFlags.Hostname = app.RunFlags.Name
}
hostname := app.RunFlags.Hostname
if hostname == conf.Hosts[0] {
dbg.Lvlf3("Tree is %+v", conf.Tree)
}
dbg.Lvl3(hostname, "Starting to run")
app.RunFlags.StartedUp(len(conf.Hosts))
peer := conode.NewPeer(hostname, conf.ConfigConode)
if app.RunFlags.AmRoot {
for {
time.Sleep(time.Second)
setupRound := sign.NewRoundSetup(peer.Node)
peer.StartAnnouncementWithWait(setupRound, 5*time.Second)
counted := <-setupRound.Counted
dbg.Lvl1("Number of peers counted:", counted)
if counted == len(conf.Hosts) {
dbg.Lvl1("All hosts replied")
break
}
}
}
RegisterRoundMeasure(peer.Node.LastRound())
peer.LoopRounds(RoundMeasureType, conf.Rounds)
dbg.Lvlf3("Done - flags are %+v", app.RunFlags)
monitor.End()
}
// Run will launch the conode server. It takes a config file and a key file
// First parse the key + config file and then run the actual server
func Run(configFile, key string) {
var address string
// Read the global config
conf := &app.ConfigConode{}
if err := app.ReadTomlConfig(conf, configFile); err != nil {
dbg.Fatal("Could not read toml config:", err)
}
dbg.Lvl1("Configuration file read")
// Read the private / public keys + binded address
if sec, err := cliutils.ReadPrivKey(suite, namePriv(key)); err != nil {
dbg.Fatal("Error reading private key file:", err)
} else {
conf.Secret = sec
}
if pub, addr, err := cliutils.ReadPubKey(suite, namePub(key)); err != nil {
dbg.Fatal("Error reading public key file:", err)
} else {
conf.Public = pub
address = addr
}
peer := conode.NewPeer(address, conf)
peer.LoopRounds(RoundStatsType, maxRounds)
}
func main() {
conf := &app.ConfigColl{}
app.ReadConfig(conf)
// we must know who we are
if app.RunFlags.Hostname == "" {
dbg.Fatal("Hostname empty: Abort")
}
// Do some common setup
if app.RunFlags.Mode == "client" {
app.RunFlags.Hostname = app.RunFlags.Name
}
hostname := app.RunFlags.Hostname
if hostname == conf.Hosts[0] {
dbg.Lvlf3("Tree is %+v", conf.Tree)
}
dbg.Lvl3(hostname, "Starting to run")
app.RunFlags.StartedUp(len(conf.Hosts))
peer := conode.NewPeer(hostname, conf.ConfigConode)
Releases = make(map[string]CommitEntry)
//ReleaseInformation()
ReadRelease(PolicyFile, SignaturesFile, CommitIdFile)
if app.RunFlags.AmRoot {
err := peer.WaitRoundSetup(len(conf.Hosts), 5, 2)
if err != nil {
dbg.Fatal(err)
}
dbg.Lvl1("Starting the rounds")
}
if app.RunFlags.AmRoot {
for round := 0; round < conf.Rounds; round++ {
dbg.Lvl1("Doing round", round, "of", conf.Rounds)
wallTime := monitor.NewMeasure("round")
hashToSign, _ := CommitScanner(CommitIdFile) // retrieve commitid/hash that the root is willing to get signed
entry := Releases[hashToSign]
if entry.policy != "" && entry.signatures != "" {
rootpgpTime := monitor.NewMeasure("rootpgp")
decision, err := ApprovalCheck(entry.policy, entry.signatures, hashToSign)
rootpgpTime.Measure()
if decision && err == nil {
round := NewRoundSwsign(peer.Node)
round.Hash = []byte(hashToSign) // passing hash of the file that we want to produce a signature for
peer.StartAnnouncement(round)
wallTime.Measure()
Signature := <-round.Signature
dbg.Lvlf1("Received signature %+v", Signature)
} else {
dbg.Fatal("Developers related to the root haven't approved the release so the root didn't start signing process")
}
} else {
dbg.Error("There is no input with such commitid", hashToSign)
}
}
peer.SendCloseAll()
} else {
peer.LoopRounds(RoundSwsignType, conf.Rounds)
}
dbg.Lvlf3("Done - flags are %+v", app.RunFlags)
monitor.End()
}
func main() {
// First, let's read our config
// You should create your own config in lib/app.
// TOML is a pretty simple and readable format
// Whatever information needed, supply it in the simulation/.toml file that
// will be parsed into your ConfigSkeleton struct.
conf := &app.ConfigSkeleton{}
app.ReadConfig(conf)
// we must know who we are
if app.RunFlags.Hostname == "" {
dbg.Fatal("Hostname empty: Abort")
}
// Do some common setup
if app.RunFlags.Mode == "client" {
app.RunFlags.Hostname = app.RunFlags.Name
}
hostname := app.RunFlags.Hostname
// i.e. we are root
if hostname == conf.Hosts[0] {
dbg.Lvlf3("Tree is %+v", conf.Tree)
}
dbg.Lvl3(hostname, "Starting to run")
// Connect to the monitor process. This monitor process is run on your
// machine and accepts connections from any node, usually you only connect
// with the root for readability and performance reasons (don't connect to
// your machine from 8000 nodes .. !)
if app.RunFlags.Logger != "" {
monitor.ConnectSink(app.RunFlags.Logger)
} else {
dbg.Fatal("No logger specified")
}
// Here you create a "Peer",that's the struct that will create a new round
// each seconds and handle other subtleties for you
peer := conode.NewPeer(hostname, conf.ConfigConode)
// The root waits everyone's to be up
if app.RunFlags.AmRoot {
for {
time.Sleep(time.Second)
setupRound := sign.NewRoundSetup(peer.Node)
peer.StartAnnouncementWithWait(setupRound, 5*time.Second)
counted := <-setupRound.Counted
dbg.Lvl1("Number of peers counted:", counted)
if counted == len(conf.Hosts) {
dbg.Lvl1("All hosts replied")
break
}
}
}
// You register by giving the type, and a function that takes a sign.Node in
// input (basically the underlying protocol) and returns a Round.
sign.RegisterRoundFactory(RoundSkeletonType,
func(node *sign.Node) sign.Round {
return NewRoundSkeleton(node)
})
// Here it will create a new round each seconds automatically.
// If you need more fined grained control, you must implement yourself the
// conode.Peer struct (it's quite easy).
peer.LoopRounds(RoundSkeletonType, conf.Rounds)
// Notify the monitor that we finished so that the simulation can be stopped
monitor.End()
}