//StartListen starts listening and calls accept fucn if accepted.
func (m *Self) StartListen(accept func(net.Stream) error) error {
list, err := corenet.Listen(m.ipfsNode, "/app/"+m.RootPath)
if log.If(err) {
return err
}
log.Printf("starting to listen at peer: %s\n", m.ipfsNode.Identity.Pretty())
go func() {
for {
con, err := list.Accept()
defer func() {
log.If(con.Close())
}()
if log.If(err) {
continue
}
peer := con.Conn().RemotePeer()
log.Printf("Connection from: %s\n", peer)
p, err := FromBytes([]byte(peer), m)
if log.If(err) {
continue
}
if !p.IsAllowed() {
log.Println(p, "denifed")
continue
}
log.If(accept(con))
}
}()
return nil
}
func handleAdd(n *core.IpfsNode, ctx context.Context, index *Index, mtx *sync.Mutex, wg *sync.WaitGroup, dspath string, reloadindex chan *Entry, getCurIndex func() *Index) {
list, err := corenet.Listen(n, "/pack/add")
if err != nil {
panic(err)
}
//fmt.Printf("I am ready to add: %s\n", n.Identity)
for {
fmt.Println("Waiting for add...\n")
con, err := list.Accept()
if err != nil {
fmt.Println(err)
return
}
go func() {
defer con.Close()
index = getCurIndex()
fmt.Printf("Connection from: %s\n", con.Conn().RemotePeer())
if len(index.WriteList) != 0 {
present := false
for i := range index.WriteList {
if con.Conn().RemotePeer().Pretty() == index.WriteList[i] {
present = true
break
}
}
if !present {
fmt.Println("Not on write list", con.Conn().RemotePeer().Pretty())
} else {
fmt.Println("On write list", con.Conn().RemotePeer().Pretty())
}
}
serverReader := &serverContentReader{r: con}
fmt.Println("Add request:", serverReader.Name())
key, err := coreunix.Add(n, serverReader)
if err != nil {
panic(err)
}
fmt.Println("Added:", key)
entry := Entry{Timestamp: time.Now(), Size: serverReader.n - HEADER_SIZE, Name: serverReader.Name(), Hash: key}
reloadindex <- &entry
}()
}
wg.Done()
}
func handleIndex(n *core.IpfsNode, ctx context.Context, index *Index, wg *sync.WaitGroup, getCurIndex func() *Index) {
list, err := corenet.Listen(n, "/pack/index")
if err != nil {
panic(err)
}
for {
fmt.Printf("Waiting for index (ls) requests: %s\n", n.Identity)
con, err := list.Accept()
if err != nil {
fmt.Println(err)
return
}
go func() {
defer con.Close()
index = getCurIndex()
fmt.Printf("Connection from: %s\n", con.Conn().RemotePeer())
if len(index.ReadList) != 0 {
present := false
for i := range index.ReadList {
fmt.Println(index.ReadList[i])
if con.Conn().RemotePeer().Pretty() == index.ReadList[i] {
present = true
break
}
}
if !present {
fmt.Println("Not on read list", con.Conn().RemotePeer().Pretty())
} else {
fmt.Println("On read list", con.Conn().RemotePeer().Pretty())
}
}
indexbytes, err := json.Marshal(index)
if err != nil {
panic(err)
}
count, err := con.Write(indexbytes)
if err != nil {
fmt.Println(err)
}
fmt.Println("Wrote bytes:", count)
//con.Close()
}()
}
wg.Done()
}
func main() {
// Basic ipfsnode setup
r, err := fsrepo.Open("~/.ipfs")
if err != nil {
panic(err)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
cfg := &core.BuildCfg{
Repo: r,
Online: true,
}
nd, err := core.NewNode(ctx, cfg)
if err != nil {
panic(err)
}
list, err := corenet.Listen(nd, "/app/whyrusleeping")
if err != nil {
panic(err)
}
fmt.Printf("I am peer: %s\n", nd.Identity.Pretty())
for {
con, err := list.Accept()
if err != nil {
fmt.Println(err)
return
}
defer con.Close()
fmt.Fprintln(con, "Hello! This is whyrusleepings awesome ipfs service")
fmt.Printf("Connection from: %s\n", con.Conn().RemotePeer())
}
}
//Listen for connections from other peers
func (s *Service) Listen() error {
list, err := corenet.Listen(s.node, s.name)
if err != nil {
return err
}
fmt.Printf("I am peer: %s\n", s.node.Identity.Pretty())
defer s.cancel()
//node.Routing.PutValue()
// Loop of +1 listening
s.isListening = true
for {
select {
case <-s.stop:
s.isListening = false
return nil
default:
con, err := list.Accept()
if err != nil {
return err
}
if s.connections == nil {
s.connections = make(map[string]connection)
}
key := con.Conn().RemotePeer().Pretty()
s.connections[key] = connection{con, &sync.RWMutex{}, make(chan []byte), make(chan []byte), make(chan bool)}
go s.handleCon(s.connections[key])
defer func() {
delete(s.connections, key)
con.Close()
}()
fmt.Printf("Connection from: %s\n", key)
}
}
}
func (cs *cliqueService) listen(portName string) (<-chan *incomingMessage, error) {
portString := cs.servicePortString(portName)
listener, err := corenet.Listen(cs.ipfsNode, portString)
if err != nil {
return nil, err
}
messageOut := make(chan *incomingMessage)
go func() {
for {
stream, err := listener.Accept()
if err != nil {
// ipfsNode's context was canceled
close(messageOut)
return
}
reader := msgio.NewVarintReader(stream)
message, err := reader.ReadMsg()
if err != nil {
log.Printf("Cliqueservice failed to read message: %s\n", err)
continue
}
reader.Close()
if err != nil {
log.Printf("Cliqueservice failed to close stream: %s\n", err)
continue
}
messageOut <- &incomingMessage{id: stream.Conn().RemotePeer(), data: message}
}
}()
return messageOut, nil
}
return
}
proto := "/app/" + req.Arguments()[0]
if checkProtoExists(n.PeerHost.Mux().Protocols(), proto) {
res.SetError(errors.New("Protocol handler already registered."), cmds.ErrNormal)
return
}
addr, err := ma.NewMultiaddr(req.Arguments()[1])
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
listener, err := corenet.Listen(n, proto)
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
app := cnAppInfo{
identity: n.Identity,
protocol: proto,
address: addr,
closer: listener,
running: true,
}
go acceptStreams(&app, listener)
