func SetupIpfs() (*core.IpfsNode, error) { // Assume the user has run 'ipfs init' r := fsrepo.At("~/.ipfs") if err := r.Open(); err != nil { return nil, err } builder := core.NewNodeBuilder().Online().SetRepo(r) return builder.Build(context.Background()) }
// create a new Service func NewService(name string, location string) (Service, error) { // Basic ipfsnode setup repo, err := fsrepo.Open(location) if err != nil { return Service{}, err } nodeBuilder := core.NewNodeBuilder().Online() nodeBuilder.SetRepo(repo) ctx, cancel := context.WithCancel(context.Background()) node, err := nodeBuilder.Build(ctx) if err != nil { return Service{}, err } return Service{name, node, cancel, ctx, nil, make(chan bool), false}, nil }
func main() { if len(os.Args) < 2 { fmt.Println("Please give a peer ID as an argument") return } target, err := peer.IDB58Decode(os.Args[1]) if err != nil { panic(err) } // Basic ipfsnode setup r := fsrepo.At("~/.ipfs") if err := r.Open(); err != nil { panic(err) } nb := core.NewNodeBuilder().Online() nb.SetRepo(r) ctx, cancel := context.WithCancel(context.Background()) defer cancel() nd, err := nb.Build(ctx) if err != nil { panic(err) } fmt.Printf("I am peer %s dialing %s\n", nd.Identity, target) con, err := corenet.Dial(nd, target, "/app/whyrusleeping") if err != nil { fmt.Println(err) return } io.Copy(os.Stdout, con) }
func main() { // Basic ipfsnode setup r, err := fsrepo.Open("~/.ipfs") if err != nil { panic(err) } nb := core.NewNodeBuilder().Online() nb.SetRepo(r) ctx, cancel := context.WithCancel(context.Background()) defer cancel() nd, err := nb.Build(ctx) 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()) } }
}, Run: func(req cmds.Request, res cmds.Response) { n, err := req.InvocContext().GetNode() if err != nil { res.SetError(err, cmds.ErrNormal) return } progress, _, _ := req.Option(progressOptionName).Bool() trickle, _, _ := req.Option(trickleOptionName).Bool() wrap, _, _ := req.Option(wrapOptionName).Bool() hash, _, _ := req.Option(onlyHashOptionName).Bool() hidden, _, _ := req.Option(hiddenOptionName).Bool() if hash { nilnode, err := core.NewNodeBuilder().NilRepo().Build(n.Context()) if err != nil { res.SetError(err, cmds.ErrNormal) return } n = nilnode } outChan := make(chan interface{}, 8) res.SetOutput((<-chan interface{})(outChan)) // addSingleFile is a function that adds a file given as a param. addSingleFile := func(file files.File) error { addParams := adder{ node: n, out: outChan,
func daemonFunc(req cmds.Request, res cmds.Response) { // let the user know we're going. fmt.Printf("Initializing daemon...\n") ctx := req.Context() go func() { select { case <-ctx.Context.Done(): fmt.Println("Received interrupt signal, shutting down...") } }() // check transport encryption flag. unencrypted, _, _ := req.Option(unencryptTransportKwd).Bool() if unencrypted { log.Warningf(`Running with --%s: All connections are UNENCRYPTED. You will not be able to connect to regular encrypted networks.`, unencryptTransportKwd) conn.EncryptConnections = false } // first, whether user has provided the initialization flag. we may be // running in an uninitialized state. initialize, _, err := req.Option(initOptionKwd).Bool() if err != nil { res.SetError(err, cmds.ErrNormal) return } if initialize { // now, FileExists is our best method of detecting whether IPFS is // configured. Consider moving this into a config helper method // `IsInitialized` where the quality of the signal can be improved over // time, and many call-sites can benefit. if !util.FileExists(req.Context().ConfigRoot) { err := initWithDefaults(os.Stdout, req.Context().ConfigRoot) if err != nil { res.SetError(err, cmds.ErrNormal) return } } } // acquire the repo lock _before_ constructing a node. we need to make // sure we are permitted to access the resources (datastore, etc.) repo, err := fsrepo.Open(req.Context().ConfigRoot) if err != nil { res.SetError(err, cmds.ErrNormal) return } cfg, err := ctx.GetConfig() if err != nil { res.SetError(err, cmds.ErrNormal) return } // Start assembling corebuilder nb := core.NewNodeBuilder().Online() nb.SetRepo(repo) routingOption, _, err := req.Option(routingOptionKwd).String() if err != nil { res.SetError(err, cmds.ErrNormal) return } if routingOption == routingOptionSupernodeKwd { servers, err := repo.Config().SupernodeRouting.ServerIPFSAddrs() if err != nil { res.SetError(err, cmds.ErrNormal) repo.Close() // because ownership hasn't been transferred to the node return } var infos []peer.PeerInfo for _, addr := range servers { infos = append(infos, peer.PeerInfo{ ID: addr.ID(), Addrs: []ma.Multiaddr{addr.Transport()}, }) } nb.SetRouting(corerouting.SupernodeClient(infos...)) } node, err := nb.Build(ctx.Context) if err != nil { log.Error("error from node construction: ", err) res.SetError(err, cmds.ErrNormal) return } printSwarmAddrs(node) defer func() { // We wait for the node to close first, as the node has children // that it will wait for before closing, such as the API server. node.Close() select { case <-ctx.Context.Done(): log.Info("Gracefully shut down daemon") default: } }() req.Context().ConstructNode = func() (*core.IpfsNode, error) { return node, nil } // construct api endpoint - every time err, apiErrc := serveHTTPApi(req) if err != nil { res.SetError(err, cmds.ErrNormal) return } // construct http gateway - if it is set in the config var gwErrc <-chan error if len(cfg.Addresses.Gateway) > 0 { var err error err, gwErrc = serveHTTPGateway(req) if err != nil { res.SetError(err, cmds.ErrNormal) return } } // construct fuse mountpoints - if the user provided the --mount flag mount, _, err := req.Option(mountKwd).Bool() if err != nil { res.SetError(err, cmds.ErrNormal) return } if mount { if err := mountFuse(req); err != nil { res.SetError(err, cmds.ErrNormal) return } } // collect long-running errors and block for shutdown // TODO(cryptix): our fuse currently doesnt follow this pattern for graceful shutdown for err := range merge(apiErrc, gwErrc) { if err != nil { res.SetError(err, cmds.ErrNormal) return } } }