// ParseMultiaddr parses a multiaddr into an IPFSAddr
func ParseMultiaddr(m ma.Multiaddr) (a IPFSAddr, err error) {
// never panic.
defer func() {
if r := recover(); r != nil {
log.Debug("recovered from panic: ", r)
a = nil
err = ErrInvalidAddr
}
}()
if m == nil {
return nil, ErrInvalidAddr
}
// make sure it's an ipfs addr
parts := ma.Split(m)
if len(parts) < 1 {
return nil, ErrInvalidAddr
}
ipfspart := parts[len(parts)-1] // last part
if ipfspart.Protocols()[0].Code != ma.P_IPFS {
return nil, ErrInvalidAddr
}
// make sure ipfs id parses as a peer.ID
peerIdParts := path.SplitList(ipfspart.String())
peerIdStr := peerIdParts[len(peerIdParts)-1]
id, err := peer.IDB58Decode(peerIdStr)
if err != nil {
return nil, err
}
return ipfsAddr{ma: m, id: id}, nil
}
func (service *OpenBazaarService) handleOfflineAck(p peer.ID, pmes *pb.Message) (*pb.Message, error) {
log.Debugf("Received OFFLINE_ACK message from %s", p.Pretty())
pid, err := peer.IDB58Decode(string(pmes.Payload.Value))
if err != nil {
return nil, err
}
err = service.datastore.Pointers().Delete(pid)
if err != nil {
return nil, err
}
return nil, nil
}
func (n *OpenBazaarNode) GetPeerStatus(peerId string) string {
p, err := peer.IDB58Decode(peerId)
if err != nil {
return "error parsing peerId"
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m := pb.Message{MessageType: pb.Message_PING}
_, err = n.Service.SendRequest(ctx, p, &m)
if err != nil {
return "offline"
}
return "online"
}
func ParsePeerParam(text string) (ma.Multiaddr, peer.ID, error) {
// to be replaced with just multiaddr parsing, once ptp is a multiaddr protocol
idx := strings.LastIndex(text, "/")
if idx == -1 {
pid, err := peer.IDB58Decode(text)
if err != nil {
return nil, "", err
}
return nil, pid, nil
}
addrS := text[:idx]
peeridS := text[idx+1:]
var maddr ma.Multiaddr
var pid peer.ID
// make sure addrS parses as a multiaddr.
if len(addrS) > 0 {
var err error
maddr, err = ma.NewMultiaddr(addrS)
if err != nil {
return nil, "", err
}
}
// make sure idS parses as a peer.ID
var err error
pid, err = peer.IDB58Decode(peeridS)
if err != nil {
return nil, "", err
}
return maddr, pid, nil
}
func (n *OpenBazaarNode) Follow(peerId string) error {
p, err := peer.IDB58Decode(peerId)
if err != nil {
return err
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m := pb.Message{MessageType: pb.Message_FOLLOW}
err = n.Service.SendMessage(ctx, p, &m)
if err != nil { // Couldn't connect directly to peer. Likely offline.
if err := n.SendOfflineMessage(p, &m); err != nil {
return err
}
}
n.Datastore.Following().Put(peerId)
return nil
}
func (n *OpenBazaarNode) Unfollow(peerId string) error {
p, err := peer.IDB58Decode(peerId)
if err != nil {
return err
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m := pb.Message{MessageType: pb.Message_UNFOLLOW}
err = n.Service.SendMessage(ctx, p, &m)
if err != nil {
if err := n.SendOfflineMessage(p, &m); err != nil {
return err
}
}
n.Datastore.Following().Delete(peerId)
return nil
}
func (n *OpenBazaarNode) SendOfflineAck(peerId string, pointerID peer.ID) error {
p, err := peer.IDB58Decode(peerId)
if err != nil {
return err
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
a := &any.Any{Value: []byte(pointerID.Pretty())}
m := pb.Message{
MessageType: pb.Message_OFFLINE_ACK,
Payload: a}
err = n.Service.SendMessage(ctx, p, &m)
if err != nil { // Couldn't connect directly to peer. Likely offline.
if err := n.SendOfflineMessage(p, &m); err != nil {
return err
}
}
return nil
}
func (p *PointersDB) GetAll() ([]ipfs.Pointer, error) {
p.lock.Lock()
defer p.lock.Unlock()
stm := "select * from pointers"
rows, err := p.db.Query(stm)
if err != nil {
log.Error(err)
return nil, err
}
var ret []ipfs.Pointer
for rows.Next() {
var pointerID string
var key string
var address string
var purpose int
var timestamp int
if err := rows.Scan(&pointerID, &key, &address, &purpose, ×tamp); err != nil {
log.Error(err)
}
maAddr, err := ma.NewMultiaddr(address)
if err != nil {
return ret, err
}
pid, err := peer.IDB58Decode(pointerID)
if err != nil {
return ret, err
}
pointer := ipfs.Pointer{
Key: keys.B58KeyDecode(key),
Value: peer.PeerInfo{
ID: pid,
Addrs: []ma.Multiaddr{maAddr},
},
Purpose: ipfs.Purpose(purpose),
Timestamp: time.Unix(int64(timestamp), 0),
}
ret = append(ret, pointer)
}
return ret, nil
}
func (qe *QueryEvent) UnmarshalJSON(b []byte) error {
temp := struct {
ID string
Type int
Responses []*peer.PeerInfo
Extra string
}{}
err := json.Unmarshal(b, &temp)
if err != nil {
return err
}
if len(temp.ID) > 0 {
pid, err := peer.IDB58Decode(temp.ID)
if err != nil {
return err
}
qe.ID = pid
}
qe.Type = QueryEventType(temp.Type)
qe.Responses = temp.Responses
qe.Extra = temp.Extra
return nil
}
return
}
tstr, tfound, err := req.Option("proto").String()
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
if pfound && tfound {
res.SetError(errors.New("please only specify peer OR protocol"), cmds.ErrClient)
return
}
var pid peer.ID
if pfound {
checkpid, err := peer.IDB58Decode(pstr)
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
pid = checkpid
}
timeS, _, err := req.Option("interval").String()
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
interval, err := time.ParseDuration(timeS)
if err != nil {
res.SetError(err, cmds.ErrNormal)
cmds.BoolOption("verbose", "v", "Write extra information.").Default(false),
},
Run: func(req cmds.Request, res cmds.Response) {
n, err := req.InvocContext().GetNode()
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
dht, ok := n.Routing.(*ipdht.IpfsDHT)
if !ok {
res.SetError(ErrNotDHT, cmds.ErrNormal)
return
}
pid, err := peer.IDB58Decode(req.Arguments()[0])
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
outChan := make(chan interface{})
res.SetOutput((<-chan interface{})(outChan))
events := make(chan *notif.QueryEvent)
ctx := notif.RegisterForQueryEvents(req.Context(), events)
go func() {
defer close(outChan)
for v := range events {
outChan <- v