func main() {
kListenStr := flag.String("l", "localhost:8000", "the address:port the kademlia instance will operate over")
htmlDirPath := flag.String("d", "/home/jch570/public_html/", "the path to the directory where html files are served. file is written out to this dir")
htmlFileName := flag.String("f", "dms.html", "filename where drymartini info will be written out")
flag.Parse()
listenStr := *kListenStr
log.Printf("dmTracker listening on:%s\n", listenStr)
var junk = "junk"
kademInst, _ := kademlia.NewKademlia(listenStr, &junk)
log.Printf("dmTracker checking querying initial core: %+v\n", coreKadems)
// commenting out, for testing just going to use localhost:8000-8004
for _, apPair := range coreKadems {
ipList, err := net.LookupIP(apPair.addr)
if err != nil {
log.Printf("error looking up addr:%s. Err:%s\n", apPair.addr, err)
}
kademlia.MakePingCall(kademInst, ipList[0], apPair.port)
}
//test should trash soon
for i := 0; i < 5; i++ {
ipList, err := net.LookupIP("localhost")
if err != nil {
log.Printf("error looking up addr\n")
}
kademlia.MakePingCall(kademInst, ipList[0], uint16(8000+i))
}
//end junk
kademlia.DoJoin(kademInst)
var contacts []kademlia.Contact
contacts = kademlia.BucketsAsArray(kademInst)
log.Printf("local buckets as array:\n %+v\n", contacts)
f, err := os.Create(*htmlDirPath + *htmlFileName)
if err != nil { //"./testoutput"); if(err!=nil){//
log.Printf("error creating file:%s\n", err)
os.Exit(1)
}
f.Write([]byte("DryMartinis found:\n"))
var c kademlia.Contact
for _, c = range contacts {
f.Write([]byte(c.AsString() + "\n"))
}
f.Write([]byte("last updated: " + time.Now().String()))
f.Close()
}
func main() {
// By default, Go seeds its RNG with 1. This would cause every program to
// generate the same sequence of IDs.
// rand.seed()
rand.Seed(time.Now().UnixNano())
// Get the bind and connect connection strings from command-line arguments.
flag.Parse()
args := flag.Args()
if len(args) != 2 {
log.Fatal("Must be invoked with exactly two arguments!\n")
}
listenStr := args[0]
firstPeerStr := args[1]
fmt.Printf("kademlia starting up!\n")
kadem := kademlia.NewKademlia()
//------------------------------------
// fmt.Println(kadem.NodeID)
// myNodeID := kadem.WhoAmI()
// fmt.Println(myNodeID)
//------------------------------------
//-----initializing MyContact---------
addr, err := net.ResolveTCPAddr("tcp4", listenStr)
if err != nil {
log.Fatal("Call: ", err)
}
host1 := addr.IP
port1 := uint16(addr.Port)
kadem.MyContact.NodeID = kademlia.WhoAmI(kadem)
kadem.MyContact.Host = host1
kadem.MyContact.Port = port1
//puttin Mycontact in the bucket
kadem.KademBuckets.Update_Contact(kadem.MyContact, kadem.MyContact)
//-----registering kadem object and it's functionalities----------
rpc.Register(kadem)
rpc.HandleHTTP()
l, err := net.Listen("tcp", listenStr) //telling the server is ON
if err != nil {
log.Fatal("Listen: ", err)
}
//---------------------------------------------------------------
// Serve forever.
go http.Serve(l, nil)
//---------------------------------------------------------------
// Confirm our server is up with a PING request and then exit.
// Your code should loop forever, reading instructions from stdin and
// printing their results to stdout. See README.txt for more details.
client, err := rpc.DialHTTP("tcp", firstPeerStr)
if err != nil {
log.Fatal("DialHTTP: ", err)
}
addr1, err := net.ResolveTCPAddr("tcp4", firstPeerStr)
if err != nil {
log.Fatal("Call: ", err)
}
host2 := addr1.IP
ping := new(kademlia.Ping) //creating a ping object of the ping structure in the kademlia package
// net.LookupHost(127.0.0.1)
// a, err := net.LookupIP("www.google.com")
ping.MsgID = kademlia.NewRandomID()
ping.Sender = kadem.MyContact
//--------------------------------------------------------------------
var pong kademlia.Pong //declaring a pong object of the pong structure in the kademlia package, but not initializing it
// calling Kademlia.Ping method passing ping as request object and pong as response object
err = client.Call("Kademlia.Ping", ping, &pong)
if err != nil {
log.Fatal("Call: ", err)
}
//------------------------------------------------------------------------
// log.Printf("ping msgID: %s\n", ping.MsgID.AsString())
// log.Printf("pong msgID: %s\n", pong.MsgID.AsString())
fmt.Println("connecting server NodeID:", pong.Sender.NodeID.AsString())
// fmt.Println("connecting server host:",pong.Sender.Host)
// fmt.Println("connecting server Port:",pong.Sender.Port)
pong.Sender.Host = host2
kadem.KademBuckets.Update_Contact(pong.Sender, kadem.MyContact)
//--------------------------------------------------------------
/* //---taking a string and getting the key for that string---
a := "my name is rishabh"
fmt.Println(a)
h := sha1.New()
io.WriteString(h,a)
b:=h.Sum(nil)
fmt.Println(b)
c := hex.EncodeToString(b)
f, err := kademlia.FromString(c)
if err != nil {
log.Fatal("Call: ", err)
}
fmt.Println(f)
*/
//--------------------------------------------------------------
/*
a := "my name is rishabh"
f :=kademlia.StringToKey(a)
// fmt.Println(f)
//--------------------------------------------------------------
sreq := new(kademlia.StoreRequest)
sreq.MsgID = kademlia.NewRandomID()
sreq.Sender = kadem.MyContact
sreq.Key = f
sreq.Value = []byte(a)
var sres kademlia.StoreResult
fmt.Println(".....ii'm here......1")
err = client.Call("Kademlia.Store", sreq, &sres)
if err != nil {
log.Fatal("Call: ", err)
}
fmt.Println(".....ii'm here......2")
//------------------------------------------------------------------------
log.Printf("ping msgID: %s\n", sreq.MsgID.AsString())
log.Printf("pong msgID: %s\n", sres.MsgID.AsString())
fmt.Println(".....ii'm here......3")
err = client.Call("Kademlia.Store", sreq, &sres)
if err != nil {
log.Fatal("Call: ", err)
}
fmt.Println(".....ii'm here......4")
//------------------------------------------------------------------------
log.Printf("ping msgID: %s\n", sreq.MsgID.AsString())
log.Printf("pong msgID: %s\n", sres.MsgID.AsString())
*/
/*
a1 := new(kademlia.StoreRequest) //creating a ping object of the
b1 := new(kademlia.StoreResult) //creating a ping object of the
//---------------------------------------------------
a2 := new(kademlia.StoreRequest) //creating a ping object of the
b2 := new(kademlia.StoreResult) //creating a ping object of the
//----------------------------------------------------
err = client.Call("Kademlia.Ping", ping, &pong)
if err != nil {
log.Fatal("Call: ", err)
}
*/
//---------find value-------------------------
/*
fvreq := new(kademlia.FindValueRequest)
fvreq.MsgID = kademlia.NewRandomID()
fvreq.Sender = kadem.MyContact
fvreq.Key = f
var fvres kademlia.FindValueResult
fmt.Println(".....ii'm here......1")
err = client.Call("Kademlia.FindValue", fvreq, &fvres)
if err != nil {
log.Fatal("Call: ", err)
}
fmt.Println(".....ii'm here......2")
fmt.Println(string(fvres.Value))
*/
//--------------------------------------------------------------------
//--------------------------------------------------------------------
r := bufio.NewReader(os.Stdin)
// println("enter string:")
line, err := r.ReadString(delim)
if err != nil {
// fmt.Println(err)
// os.Exit(1)
}
// fmt.Println(line)
token := strings.Fields(line)
for token[0] != "exit" || token[0] == "" {
switch token[0] {
case "whoami":
// fmt.Println("this is 1")
a := kademlia.Whoami(kadem)
fmt.Println(a)
case "local_find_value":
// fmt.Println("this is 2")
key, err := kademlia.FromString(token[1])
// fmt.Println(id)
if err == nil {
kademlia.Local_find_value(kadem, key)
}
case "get_contact":
// fmt.Println("this is 3")
id, err := kademlia.FromString(token[1])
fmt.Println(id)
var c kademlia.Contact
if err == nil {
c = kademlia.Get_contact(kadem, id)
fmt.Println("Node id: ", c.NodeID)
fmt.Println("IP Addr: ", c.Host)
fmt.Println("Port : ", c.Port)
}
case "iterativeStore":
// fmt.Println("this is 4")
case "iterativeFindNode":
// fmt.Println("this is 5")
case "iterativeFindValue":
// fmt.Println("this is 6")
case "ping":
// fmt.Println("this is 7")
id, err := kademlia.FromString(token[1])
if err == nil {
ping, pong, s := kademlia.Pingnode(kadem, id)
client, err := rpc.DialHTTP("tcp", s) //REFPEER
// s = s + ":"
if err != nil {
log.Fatal("DialHTTP: ", err)
}
err = client.Call("Kademlia.Ping", ping, &pong)
if err != nil {
log.Fatal("Call: ", err)
}
log.Printf("ping msgID: %s\n", ping.MsgID.AsString())
log.Printf("pong msgID: %s\n", pong.MsgID.AsString())
}
case "store":
// fmt.Println("this is 8")
id, err := kademlia.FromString(token[1])
if err != nil {
}
key, err := kademlia.FromString(token[2])
if err != nil {
}
// val:=token[3]
val := ""
for t := 3; t < len(token); t++ {
val = val + string(token[t]) + " "
}
sreq, sres, s := kademlia.Storenode(kadem, id, key, val)
// s = s + ":"
client, err := rpc.DialHTTP("tcp", s) //REFPEER) //s
if err != nil {
log.Fatal("DialHTTP: ", err)
}
err = client.Call("Kademlia.Store", sreq, &sres)
if err != nil {
log.Fatal("Call: ", err)
}
// log.Printf("sreq msgID: %s\n", sreq.MsgID.AsString())
// log.Printf("sres msgID: %s\n", sres.MsgID.AsString())
case "find_node":
// fmt.Println("this is 9")
id, err := kademlia.FromString(token[1])
if err != nil {
}
key, err := kademlia.FromString(token[2])
if err != nil {
}
fnreq, fnres, s := kademlia.Findnode(kadem, id, key)
// s = s + ":"
client, err := rpc.DialHTTP("tcp", s) //REFPEER) //s
if err != nil {
log.Fatal("DialHTTP: ", err)
}
err = client.Call("Kademlia.FindNode", fnreq, &fnres)
if err != nil {
log.Fatal("Call: ", err)
}
log.Printf("fnreq msgID: %s\n", fnreq.MsgID.AsString())
log.Printf("fnres msgID: %s\n", fnres.MsgID.AsString())
var temp_contact kademlia.Contact
l := len(fnres.Nodes)
for j := 0; j < l; j++ {
if fnres.Nodes[j].NodeID.AsString() != "0" {
fmt.Println("NodeID : ", fnres.Nodes[j].IPAddr)
fmt.Println("Port : ", fnres.Nodes[j].Port)
fmt.Println("Host : ", fnres.Nodes[j].NodeID.AsString())
peer3 := fmt.Sprintf("%s:%d", fnres.Nodes[j].IPAddr, fnres.Nodes[j].Port)
addr3, err := net.ResolveTCPAddr("tcp4", peer3)
if err != nil {
log.Fatal("Call: ", err)
}
temp_contact.NodeID = fnres.Nodes[j].NodeID
temp_contact.Host = addr3.IP //net.IP(fnres.Nodes[j].IPAddr)
temp_contact.Port = fnres.Nodes[j].Port
kadem.KademBuckets.Update_Contact(temp_contact, kadem.MyContact)
}
} //for
case "find_value":
// fmt.Println("this is 10")
id, err := kademlia.FromString(token[1])
if err != nil {
}
key, err := kademlia.FromString(token[2])
if err != nil {
}
fvreq, fvres, s := kademlia.Findvalue(kadem, id, key)
// s = s + ":"
client, err := rpc.DialHTTP("tcp", s) //REFPEER) //s
if err != nil {
log.Fatal("DialHTTP: ", err)
}
err = client.Call("Kademlia.FindValue", fvreq, &fvres)
if err != nil {
log.Fatal("Call: ", err)
}
// log.Printf("fvreq msgID: %s\n", fvreq.MsgID.AsString())
// log.Printf("fvres msgID: %s\n", fvres.MsgID.AsString())
fmt.Println(string(fvres.Value))
case "exit":
break
default:
fmt.Println("enter the correct input")
} //switch
line, err := r.ReadString(delim)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
token = strings.Fields(line)
} //for
} //main