// Logger retrieves an event logger by name func Logger(system string) EventLogger { // TODO if we would like to adjust log levels at run-time. Store this event // logger in a map (just like the util.Logger impl) return &eventLogger{system: system, Logger: util.Logger(system)} }
nOrDDTrWSjlF6Ms+dYGCheWIjKQcykn9IW021AzVN1P7Mt9qtmDNfZ0VQL3zl/fs zZ1IHBW7BzriQ4GzWXg5GWpTSz/REvUEfKNVuDV9jX7hv67B5H6qTL5+2zljPEKv lCas04cCMmEpJUj4qK95hdKQzKJ8b7MrRf/RFYyViRGdxvR+lgGqJ7Yca8es2kCe XV6c+i6a7X89YL6ZVU+1MlvPwngu0VG+VInH/w9KrNYrLFhfVRiruRbkBkHDXjnU b4kPqaus+7g0DynCk7A2kTMa3cgtO20CZ9MBJFEPqRRHHksjHVmlxPb42bB348aR UVsWkRRYOmRML7avTgkX8WFsmdZ1d7E7aQLYnCIel85+5iP7hWyNtEMsAHk02XCL AAb7RaEDNJOa7qvUFecB =mzPY -----END PGP SIGNATURE----- */ ) var log = u.Logger("updates") var currentVersion *semver.Version // ErrNoUpdateAvailable returned when a check fails to find a newer update. var ErrNoUpdateAvailable = check.NoUpdateAvailable func init() { var err error currentVersion, err = parseVersion() if err != nil { log.Errorf("invalid version number in code (must be semver): %q", Version) os.Exit(1) } log.Infof("go-ipfs Version: %s", currentVersion) }
// package kbucket implements a kademlia 'k-bucket' routing table. package kbucket import ( "container/list" "fmt" "sort" "sync" "time" peer "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/peer" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("table") // RoutingTable defines the routing table. type RoutingTable struct { // ID of the local peer local ID // Blanket lock, refine later for better performance tabLock sync.RWMutex // Maximum acceptable latency for peers in this cluster maxLatency time.Duration // kBuckets define all the fingers to other nodes. Buckets []*Bucket bucketsize int
package network import ( "errors" context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" bsmsg "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange/bitswap/message" inet "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net" netmsg "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net/message" peer "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/peer" util "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = util.Logger("bitswap_network") // NewFromIpfsNetwork returns a BitSwapNetwork supported by underlying IPFS // Dialer & Service func NewFromIpfsNetwork(s inet.Service, dialer inet.Dialer) BitSwapNetwork { bitswapNetwork := impl{ service: s, dialer: dialer, } s.SetHandler(&bitswapNetwork) return &bitswapNetwork } // impl transforms the ipfs network interface, which sends and receives // NetMessage objects, into the bitswap network interface. type impl struct { service inet.Service
// package config implements the ipfs config file datastructures and utilities. package config import ( "crypto" "crypto/x509" "encoding/base64" "os" "path/filepath" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util/debugerror" ) var log = u.Logger("config") // Identity tracks the configuration of the local node's identity. type Identity struct { PeerID string PrivKey string } // Logs tracks the configuration of the event logger type Logs struct { Filename string MaxSizeMB uint64 MaxBackups uint64 MaxAgeDays uint64 } // Datastore tracks the configuration of the datastore.
"crypto/elliptic" "crypto/hmac" "crypto/rand" "crypto/rsa" "crypto/sha1" "crypto/sha256" "crypto/sha512" "hash" proto "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto" pb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/crypto/internal/pb" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("crypto") var ErrBadKeyType = errors.New("invalid or unsupported key type") const ( RSA = iota ) // Key represents a crypto key that can be compared to another key type Key interface { // Bytes returns a serialized, storeable representation of this key Bytes() ([]byte, error) // Hash returns the hash of this key Hash() ([]byte, error)
context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" ds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-datastore" blocks "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blocks" blockstore "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blockstore" exchange "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange" bsmsg "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange/bitswap/message" bsnet "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange/bitswap/network" notifications "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange/bitswap/notifications" strategy "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange/bitswap/strategy" peer "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/peer" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("bitswap") // New initializes a BitSwap instance that communicates over the // provided BitSwapNetwork. This function registers the returned instance as // the network delegate. // Runs until context is cancelled func New(ctx context.Context, p peer.Peer, network bsnet.BitSwapNetwork, routing bsnet.Routing, d ds.ThreadSafeDatastore, nice bool) exchange.Interface { notif := notifications.New() go func() { <-ctx.Done() notif.Shutdown() }()
import ( "errors" "sync" conn "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net/conn" msg "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net/message" pb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net/mux/internal/pb" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ctxc "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util/ctxcloser" context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" proto "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto" ) var log = u.Logger("muxer") // ProtocolIDs used to identify each protocol. // These should probably be defined elsewhere. var ( ProtocolID_Routing = pb.ProtocolID_Routing ProtocolID_Exchange = pb.ProtocolID_Exchange ProtocolID_Diagnostic = pb.ProtocolID_Diagnostic ) // Protocol objects produce + consume raw data. They are added to the Muxer // with a ProtocolID, which is added to outgoing payloads. Muxer properly // encapsulates and decapsulates when interfacing with its Protocols. The // Protocols do not encounter their ProtocolID. type Protocol interface { GetPipe() *msg.Pipe
package mock import ( "errors" "math/rand" "sync" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" ds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-datastore" peer "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/peer" routing "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/routing" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("mockrouter") var _ routing.IpfsRouting = &MockRouter{} type MockRouter struct { datastore ds.Datastore hashTable RoutingServer peer peer.Peer } func NewMockRouter(local peer.Peer, dstore ds.Datastore) routing.IpfsRouting { return &MockRouter{ datastore: dstore, peer: local, hashTable: VirtualRoutingServer(), } }
package commands import ( cmds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/commands" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("core/commands") type TestOutput struct { Foo string Bar int } var Root = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "global p2p merkle-dag filesystem", Synopsis: ` ipfs [<flags>] <command> [<arg>] ... `, ShortDescription: ` Basic commands: init Initialize ipfs local configurationx add <path> Add an object to ipfs cat <ref> Show ipfs object data ls <ref> List links from an object Tool commands: config Manage configuration
// package path implements utilities for resolving paths within ipfs. package path import ( "fmt" "path" "strings" merkledag "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/merkledag" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" mh "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multihash" ) var log = u.Logger("path") // Resolver provides path resolution to IPFS // It has a pointer to a DAGService, which is uses to resolve nodes. type Resolver struct { DAG merkledag.DAGService } // ResolvePath fetches the node for given path. It uses the first // path component as a hash (key) of the first node, then resolves // all other components walking the links, with ResolveLinks. func (s *Resolver) ResolvePath(fpath string) (*merkledag.Node, error) { log.Debugf("Resolve: '%s'", fpath) fpath = path.Clean(fpath) parts := strings.Split(fpath, "/") // skip over empty first elem
// package mount provides a simple abstraction around a mount point package mount import ( "fmt" "time" context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ctxc "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util/ctxcloser" ) var log = u.Logger("mount") // Mount represents a filesystem mount type Mount interface { // MountPoint is the path at which this mount is mounted MountPoint() string // Mount function sets up a mount + registers the unmount func Mount(mount MountFunc, unmount UnmountFunc) // Unmount calls Close. Unmount() error ctxc.ContextCloser } // UnmountFunc is a function used to Unmount a mount
package merkledag import ( "fmt" "sync" "time" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" blocks "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blocks" bserv "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blockservice" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" mh "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multihash" ) var log = u.Logger("merkledag") var ErrNotFound = fmt.Errorf("merkledag: not found") // NodeMap maps u.Keys to Nodes. // We cannot use []byte/Multihash for keys :( // so have to convert Multihash bytes to string (u.Key) type NodeMap map[u.Key]*Node // Node represents a node in the IPFS Merkle DAG. // nodes have opaque data and a set of navigable links. type Node struct { Links []*Link Data []byte // cache encoded/marshaled value encoded []byte
package blockservice import ( "errors" "fmt" context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" ds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-datastore" mh "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multihash" blocks "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blocks" exchange "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/exchange" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("blockservice") var ErrNotFound = errors.New("blockservice: key not found") // BlockService is a block datastore. // It uses an internal `datastore.Datastore` instance to store values. type BlockService struct { Datastore ds.Datastore Remote exchange.Interface } // NewBlockService creates a BlockService with given datastore instance. func NewBlockService(d ds.Datastore, rem exchange.Interface) (*BlockService, error) { if d == nil { return nil, fmt.Errorf("BlockService requires valid datastore") } if rem == nil {
// and readers package importer import ( "fmt" "io" "os" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/importer/chunk" dag "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/merkledag" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/pin" ft "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = util.Logger("importer") // BlockSizeLimit specifies the maximum size an imported block can have. var BlockSizeLimit = int64(1048576) // 1 MB // ErrSizeLimitExceeded signals that a block is larger than BlockSizeLimit. var ErrSizeLimitExceeded = fmt.Errorf("object size limit exceeded") // todo: incremental construction with an ipfs node. dumping constructed // objects into the datastore, to avoid buffering all in memory // NewDagFromReader constructs a Merkle DAG from the given io.Reader. // size required for block construction. func NewDagFromReader(r io.Reader) (*dag.Node, error) { return NewDagFromReaderWithSplitter(r, chunk.DefaultSplitter) }
// package chunk implements streaming block splitters package chunk import ( "io" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = util.Logger("chunk") var DefaultSplitter = &SizeSplitter{Size: 1024 * 256} type BlockSplitter interface { Split(r io.Reader) chan []byte } type SizeSplitter struct { Size int } func (ss *SizeSplitter) Split(r io.Reader) chan []byte { out := make(chan []byte) go func() { defer close(out) // all-chunks loop (keep creating chunks) for { // log.Infof("making chunk with size: %d", ss.Size) chunk := make([]byte, ss.Size) nread, err := io.ReadFull(r, chunk)
package commands import ( "errors" "fmt" "reflect" "strings" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("command") // Function is the type of function that Commands use. // It reads from the Request, and writes results to the Response. type Function func(Request) (interface{}, error) // Marshaler is a function that takes in a Response, and returns a marshalled []byte // (or an error on failure) type Marshaler func(Response) ([]byte, error) // MarshalerMap is a map of Marshaler functions, keyed by EncodingType // (or an error on failure) type MarshalerMap map[EncodingType]Marshaler // HelpText is a set of strings used to generate command help text. The help // text follows formats similar to man pages, but not exactly the same. type HelpText struct { // required Tagline string // used in <cmd usage> ShortDescription string // used in DESCRIPTION
// package set contains various different types of 'BlockSet's package set import ( "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blocks/bloom" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = util.Logger("blockset") // BlockSet represents a mutable set of keyed blocks type BlockSet interface { AddBlock(util.Key) RemoveBlock(util.Key) HasKey(util.Key) bool GetBloomFilter() bloom.Filter GetKeys() []util.Key } func SimpleSetFromKeys(keys []util.Key) BlockSet { sbs := &simpleBlockSet{blocks: make(map[util.Key]struct{})} for _, k := range keys { sbs.blocks[k] = struct{}{} } return sbs } func NewSimpleBlockSet() BlockSet { return &simpleBlockSet{blocks: make(map[util.Key]struct{})} }
package namesys import ( "fmt" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto" ci "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/crypto" pb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/namesys/internal/pb" routing "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/routing" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" mh "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multihash" ) var log = u.Logger("namesys") // routingResolver implements NSResolver for the main IPFS SFS-like naming type routingResolver struct { routing routing.IpfsRouting } // NewRoutingResolver constructs a name resolver using the IPFS Routing system // to implement SFS-like naming on top. func NewRoutingResolver(route routing.IpfsRouting) Resolver { return &routingResolver{routing: route} } // CanResolve implements Resolver. Checks whether name is a b58 encoded string. func (r *routingResolver) CanResolve(name string) bool { _, err := mh.FromB58String(name)
package http import ( "errors" "io" "net/http" cmds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/commands" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("commands/http") type Handler struct { ctx cmds.Context root *cmds.Command origin string } var ErrNotFound = errors.New("404 page not found") const ( streamHeader = "X-Stream-Output" contentTypeHeader = "Content-Type" ) var mimeTypes = map[string]string{ cmds.JSON: "application/json", cmds.XML: "application/xml", cmds.Text: "text/plain", }
package handshake import ( "fmt" pb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net/handshake/pb" peer "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/peer" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ma "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multiaddr" ) var log = u.Logger("handshake") // Handshake3Msg constructs a Handshake3 msg. func Handshake3Msg(localPeer peer.Peer, remoteAddr ma.Multiaddr) *pb.Handshake3 { var msg pb.Handshake3 // don't need publicKey after secure channel. // msg.PublicKey = localPeer.PubKey().Bytes() // local listen addresses addrs := localPeer.Addresses() msg.ListenAddrs = make([][]byte, len(addrs)) for i, a := range addrs { msg.ListenAddrs[i] = a.Bytes() } // observed remote address msg.ObservedAddr = remoteAddr.Bytes() // services
// which objects a user wants to keep stored locally. package pin import ( "encoding/json" "errors" "sync" ds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-datastore" nsds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-datastore/namespace" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/blocks/set" mdag "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/merkledag" "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = util.Logger("pin") var recursePinDatastoreKey = ds.NewKey("/local/pins/recursive/keys") var directPinDatastoreKey = ds.NewKey("/local/pins/direct/keys") var indirectPinDatastoreKey = ds.NewKey("/local/pins/indirect/keys") type PinMode int const ( Recursive PinMode = iota Direct Indirect ) type Pinner interface { IsPinned(util.Key) bool Pin(*mdag.Node, bool) error
package io import ( "bytes" "errors" proto "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto" chunk "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/importer/chunk" mdag "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/merkledag" ft "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs" ftpb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs/pb" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("dagio") // DagModifier is the only struct licensed and able to correctly // perform surgery on a DAG 'file' // Dear god, please rename this to something more pleasant type DagModifier struct { dagserv mdag.DAGService curNode *mdag.Node pbdata *ftpb.Data splitter chunk.BlockSplitter } func NewDagModifier(from *mdag.Node, serv mdag.DAGService, spl chunk.BlockSplitter) (*DagModifier, error) { pbd, err := ft.FromBytes(from.Data) if err != nil {
fuse "github.com/maybebtc/interplanetary/Godeps/_workspace/src/bazil.org/fuse" fs "github.com/maybebtc/interplanetary/Godeps/_workspace/src/bazil.org/fuse/fs" proto "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto" core "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/core" ci "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/crypto" chunk "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/importer/chunk" mdag "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/merkledag" ft "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs" uio "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs/io" ftpb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs/pb" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("ipns") var ( shortRepublishTimeout = time.Millisecond * 5 longRepublishTimeout = time.Millisecond * 500 ) // FileSystem is the readwrite IPNS Fuse Filesystem. type FileSystem struct { Ipfs *core.IpfsNode RootNode *Root } // NewFileSystem constructs new fs using given core.IpfsNode instance. func NewIpns(ipfs *core.IpfsNode, ipfspath string) (*FileSystem, error) { root, err := CreateRoot(ipfs, []ci.PrivKey{ipfs.Identity.PrivKey()}, ipfspath)
package service import ( "errors" "fmt" "sync" msg "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/net/message" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ctxc "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util/ctxcloser" context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" ) var log = u.Logger("service") // ErrNoResponse is returned by Service when a Request did not get a response, // and no other error happened var ErrNoResponse = errors.New("no response to request") // Handler is an interface that objects must implement in order to handle // a service's requests. type Handler interface { // HandleMessage receives an incoming message, and potentially returns // a response message to send back. HandleMessage(context.Context, msg.NetMessage) msg.NetMessage } // Sender interface for network services. type Sender interface {
"runtime" "time" fuse "github.com/maybebtc/interplanetary/Godeps/_workspace/src/bazil.org/fuse" fs "github.com/maybebtc/interplanetary/Godeps/_workspace/src/bazil.org/fuse/fs" proto "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto" core "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/core" mount "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/fuse/mount" mdag "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/merkledag" uio "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs/io" ftpb "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs/pb" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("ipfs") // FileSystem is the readonly Ipfs Fuse Filesystem. type FileSystem struct { Ipfs *core.IpfsNode } // NewFileSystem constructs new fs using given core.IpfsNode instance. func NewFileSystem(ipfs *core.IpfsNode) *FileSystem { return &FileSystem{Ipfs: ipfs} } // Root constructs the Root of the filesystem, a Root object. func (f FileSystem) Root() (fs.Node, fuse.Error) { return &Root{Ipfs: f.Ipfs}, nil }
import ( "bytes" "errors" "fmt" "sync" "time" b58 "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-base58" ma "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multiaddr" mh "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multihash" ic "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/crypto" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ) var log = u.Logger("peer") // ID is a byte slice representing the identity of a peer. type ID mh.Multihash // String is utililty function for printing out peer ID strings. func (id ID) String() string { return id.Pretty() } // Equal is utililty function for comparing two peer ID's func (id ID) Equal(other ID) bool { return bytes.Equal(id, other) } // Pretty returns a b58-encoded string of the ID
import ( "fmt" "sync" "time" context "github.com/maybebtc/interplanetary/Godeps/_workspace/src/code.google.com/p/go.net/context" msgio "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-msgio" ma "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multiaddr" manet "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-multiaddr-net" peer "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/peer" u "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util" ctxc "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/util/ctxcloser" ) var log = u.Logger("conn") const ( // ChanBuffer is the size of the buffer in the Conn Chan ChanBuffer = 10 // MaxMessageSize is the size of the largest single message MaxMessageSize = 1 << 20 // HandshakeTimeout for when nodes first connect HandshakeTimeout = time.Second * 5 ) // global static buffer pool for byte arrays of size MaxMessageSize var BufferPool *sync.Pool