mirror of
https://github.com/ipfs/kubo.git
synced 2025-09-10 05:52:20 +08:00
116 lines
2.4 KiB
Go
116 lines
2.4 KiB
Go
package config
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
|
|
ci "gx/ipfs/QmUEUu1CM8bxBJxc3ZLojAi8evhTr4byQogWstABet79oY/go-libp2p-crypto"
|
|
peer "gx/ipfs/QmZwZjMVGss5rqYsJVGy18gNbkTJffFyq2x1uJ4e4p3ZAt/go-libp2p-peer"
|
|
)
|
|
|
|
func Init(out io.Writer, nBitsForKeypair int) (*Config, error) {
|
|
identity, err := identityConfig(out, nBitsForKeypair)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
bootstrapPeers, err := DefaultBootstrapPeers()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
datastore, err := datastoreConfig()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
conf := &Config{
|
|
|
|
// setup the node's default addresses.
|
|
// Note: two swarm listen addrs, one tcp, one utp.
|
|
Addresses: Addresses{
|
|
Swarm: []string{
|
|
"/ip4/0.0.0.0/tcp/4001",
|
|
// "/ip4/0.0.0.0/udp/4002/utp", // disabled for now.
|
|
"/ip6/::/tcp/4001",
|
|
},
|
|
API: "/ip4/127.0.0.1/tcp/5001",
|
|
Gateway: "/ip4/127.0.0.1/tcp/8080",
|
|
},
|
|
|
|
Datastore: datastore,
|
|
Bootstrap: BootstrapPeerStrings(bootstrapPeers),
|
|
Identity: identity,
|
|
Discovery: Discovery{MDNS{
|
|
Enabled: true,
|
|
Interval: 10,
|
|
}},
|
|
|
|
// setup the node mount points.
|
|
Mounts: Mounts{
|
|
IPFS: "/ipfs",
|
|
IPNS: "/ipns",
|
|
},
|
|
|
|
Ipns: Ipns{
|
|
ResolveCacheSize: 128,
|
|
},
|
|
|
|
Gateway: Gateway{
|
|
RootRedirect: "",
|
|
Writable: false,
|
|
PathPrefixes: []string{},
|
|
},
|
|
}
|
|
|
|
return conf, nil
|
|
}
|
|
|
|
func datastoreConfig() (Datastore, error) {
|
|
dspath, err := DataStorePath("")
|
|
if err != nil {
|
|
return Datastore{}, err
|
|
}
|
|
return Datastore{
|
|
Path: dspath,
|
|
Type: "leveldb",
|
|
StorageMax: "10GB",
|
|
StorageGCWatermark: 90, // 90%
|
|
GCPeriod: "1h",
|
|
}, nil
|
|
}
|
|
|
|
// identityConfig initializes a new identity.
|
|
func identityConfig(out io.Writer, nbits int) (Identity, error) {
|
|
// TODO guard higher up
|
|
ident := Identity{}
|
|
if nbits < 1024 {
|
|
return ident, errors.New("Bitsize less than 1024 is considered unsafe.")
|
|
}
|
|
|
|
fmt.Fprintf(out, "generating %v-bit RSA keypair...", nbits)
|
|
sk, pk, err := ci.GenerateKeyPair(ci.RSA, nbits)
|
|
if err != nil {
|
|
return ident, err
|
|
}
|
|
fmt.Fprintf(out, "done\n")
|
|
|
|
// currently storing key unencrypted. in the future we need to encrypt it.
|
|
// TODO(security)
|
|
skbytes, err := sk.Bytes()
|
|
if err != nil {
|
|
return ident, err
|
|
}
|
|
ident.PrivKey = base64.StdEncoding.EncodeToString(skbytes)
|
|
|
|
id, err := peer.IDFromPublicKey(pk)
|
|
if err != nil {
|
|
return ident, err
|
|
}
|
|
ident.PeerID = id.Pretty()
|
|
fmt.Fprintf(out, "peer identity: %s\n", ident.PeerID)
|
|
return ident, nil
|
|
}
|