func (w *writecache) Put(b *blocks.Block) error { if _, ok := w.cache.Get(b.Key()); ok { return nil } w.cache.Add(b.Key(), struct{}{}) return w.blockstore.Put(b) }
// AddBlock adds a particular block to the service, Putting it into the datastore. // TODO pass a context into this if the remote.HasBlock is going to remain here. func (s *BlockService) AddBlock(b *blocks.Block) (key.Key, error) { k := b.Key() err := s.Blockstore.Put(b) if err != nil { return k, err } if err := s.Exchange.HasBlock(b); err != nil { return "", errors.New("blockservice is closed") } return k, nil }
func (bs *Bitswap) updateReceiveCounters(b *blocks.Block) error { bs.counterLk.Lock() defer bs.counterLk.Unlock() bs.blocksRecvd++ has, err := bs.blockstore.Has(b.Key()) if err != nil { log.Infof("blockstore.Has error: %s", err) return err } if err == nil && has { bs.dupBlocksRecvd++ bs.dupDataRecvd += uint64(len(b.Data)) } if has { return ErrAlreadyHaveBlock } return nil }
// Add adds a node to the dagService, storing the block in the BlockService func (n *dagService) Add(nd *Node) (key.Key, error) { if n == nil { // FIXME remove this assertion. protect with constructor invariant return "", fmt.Errorf("dagService is nil") } d, err := nd.Encoded(false) if err != nil { return "", err } b := new(blocks.Block) b.Data = d b.Multihash, err = nd.Multihash() if err != nil { return "", err } return n.Blocks.AddBlock(b) }
func (t *Batch) Add(nd *Node) (key.Key, error) { d, err := nd.Encoded(false) if err != nil { return "", err } b := new(blocks.Block) b.Data = d b.Multihash, err = nd.Multihash() if err != nil { return "", err } k := key.Key(b.Multihash) t.blocks = append(t.blocks, b) t.size += len(b.Data) if t.size > t.MaxSize { return k, t.Commit() } return k, nil }
func (m *impl) AddBlock(b *blocks.Block) { m.blocks[b.Key()] = b }
func (ps *impl) Publish(block *blocks.Block) { topic := string(block.Key()) ps.wrapped.Pub(block, topic) }