go-ipfs-config: github.com/ipfs/go-ipfs-config Index | Files | Directories

package config

import "github.com/ipfs/go-ipfs-config"

package config implements the ipfs config file datastructures and utilities.

Index

Package Files

addresses.go api.go bootstrap_peers.go config.go datastore.go discovery.go experiments.go gateway.go identity.go init.go ipns.go mounts.go plugins.go profile.go provider.go pubsub.go reprovider.go routing.go swarm.go types.go

Constants

const (
    // DefaultPathName is the default config dir name
    DefaultPathName = ".ipfs"
    // DefaultPathRoot is the path to the default config dir location.
    DefaultPathRoot = "~/" + DefaultPathName
    // DefaultConfigFile is the filename of the configuration file
    DefaultConfigFile = "config"
    // EnvDir is the environment variable used to change the path root.
    EnvDir = "IPFS_PATH"
)
const DefaultConnMgrGracePeriod = time.Second * 20

DefaultConnMgrGracePeriod is the default value for the connection managers grace period

const DefaultConnMgrHighWater = 900

DefaultConnMgrHighWater is the default value for the connection managers 'high water' mark

const DefaultConnMgrLowWater = 600

DefaultConnMgrLowWater is the default value for the connection managers 'low water' mark

const DefaultDataStoreDirectory = "datastore"

DefaultDataStoreDirectory is the directory to store all the local IPFS data.

const IdentityTag = "Identity"
const PrivKeySelector = IdentityTag + "." + PrivKeyTag
const PrivKeyTag = "PrivKey"

Variables

var DefaultBootstrapAddresses = []string{
    "/dnsaddr/bootstrap.libp2p.io/ipfs/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
    "/dnsaddr/bootstrap.libp2p.io/ipfs/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa",
    "/dnsaddr/bootstrap.libp2p.io/ipfs/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
    "/dnsaddr/bootstrap.libp2p.io/ipfs/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt",
    "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
    "/ip4/104.236.179.241/tcp/4001/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM",
    "/ip4/128.199.219.111/tcp/4001/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu",
    "/ip4/104.236.76.40/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64",
    "/ip4/178.62.158.247/tcp/4001/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd",
    "/ip6/2604:a880:1:20::203:d001/tcp/4001/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM",
    "/ip6/2400:6180:0:d0::151:6001/tcp/4001/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu",
    "/ip6/2604:a880:800:10::4a:5001/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64",
    "/ip6/2a03:b0c0:0:1010::23:1001/tcp/4001/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd",
}

DefaultBootstrapAddresses are the hardcoded bootstrap addresses for IPFS. they are nodes run by the IPFS team. docs on these later. As with all p2p networks, bootstrap is an important security concern.

NOTE: This is here -- and not inside cmd/ipfs/init.go -- because of an import dependency issue. TODO: move this into a config/default/ package.

var ErrInvalidPeerAddr = errors.New("invalid peer address")

ErrInvalidPeerAddr signals an address is not a valid peer address.

var Profiles = map[string]Profile{
    "server": {
        Description: `Disables local host discovery, recommended when
running IPFS on machines with public IPv4 addresses.`,

        Transform: func(c *Config) error {
            c.Addresses.NoAnnounce = appendSingle(c.Addresses.NoAnnounce, defaultServerFilters)
            c.Swarm.AddrFilters = appendSingle(c.Swarm.AddrFilters, defaultServerFilters)
            c.Discovery.MDNS.Enabled = false
            c.Swarm.DisableNatPortMap = true
            return nil
        },
    },

    "local-discovery": {
        Description: `Sets default values to fields affected by the server
profile, enables discovery in local networks.`,

        Transform: func(c *Config) error {
            c.Addresses.NoAnnounce = deleteEntries(c.Addresses.NoAnnounce, defaultServerFilters)
            c.Swarm.AddrFilters = deleteEntries(c.Swarm.AddrFilters, defaultServerFilters)
            c.Discovery.MDNS.Enabled = true
            c.Swarm.DisableNatPortMap = false
            return nil
        },
    },
    "test": {
        Description: `Reduces external interference of IPFS daemon, this
is useful when using the daemon in test environments.`,

        Transform: func(c *Config) error {
            c.Addresses.API = Strings{"/ip4/127.0.0.1/tcp/0"}
            c.Addresses.Gateway = Strings{"/ip4/127.0.0.1/tcp/0"}
            c.Addresses.Swarm = []string{
                "/ip4/127.0.0.1/tcp/0",
            }

            c.Swarm.DisableNatPortMap = true

            c.Bootstrap = []string{}
            c.Discovery.MDNS.Enabled = false
            return nil
        },
    },
    "default-networking": {
        Description: `Restores default network settings.
Inverse profile of the test profile.`,

        Transform: func(c *Config) error {
            c.Addresses = addressesConfig()

            bootstrapPeers, err := DefaultBootstrapPeers()
            if err != nil {
                return err
            }
            c.Bootstrap = appendSingle(c.Bootstrap, BootstrapPeerStrings(bootstrapPeers))

            c.Swarm.DisableNatPortMap = false
            c.Discovery.MDNS.Enabled = true
            return nil
        },
    },
    "badgerds": {
        Description: "" /* 408 byte string literal not displayed */,

        Transform: func(c *Config) error {
            c.Datastore.Spec = map[string]interface{}{
                "type":   "measure",
                "prefix": "badger.datastore",
                "child": map[string]interface{}{
                    "type":       "badgerds",
                    "path":       "badgerds",
                    "syncWrites": true,
                    "truncate":   true,
                },
            }
            return nil
        },
    },
    "default-datastore": {
        Description: "" /* 288 byte string literal not displayed */,

        Transform: func(c *Config) error {
            c.Datastore.Spec = DefaultDatastoreConfig().Spec
            return nil
        },
    },
    "lowpower": {
        Description: "" /* 141 byte string literal not displayed */,

        Transform: func(c *Config) error {
            c.Routing.Type = "dhtclient"
            c.Reprovider.Interval = "0"

            c.Swarm.ConnMgr.LowWater = 20
            c.Swarm.ConnMgr.HighWater = 40
            c.Swarm.ConnMgr.GracePeriod = time.Minute.String()
            return nil
        },
    },
    "randomports": {
        Description: `Use a random port number for swarm.`,

        Transform: func(c *Config) error {
            port, err := getAvailablePort()
            if err != nil {
                return err
            }
            c.Addresses.Swarm = []string{
                fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", port),
                fmt.Sprintf("/ip6/::/tcp/%d", port),
            }
            return nil
        },
    },
}

Profiles is a map holding configuration transformers. Docs are in docs/config.md

func BootstrapPeerStrings Uses

func BootstrapPeerStrings(bps []peer.AddrInfo) []string

BootstrapPeerStrings formats a list of AddrInfos as a bootstrap peer list suitable for serialization.

func DataStorePath Uses

func DataStorePath(configroot string) (string, error)

DataStorePath returns the default data store path given a configuration root (set an empty string to have the default configuration root)

func DefaultBootstrapPeers Uses

func DefaultBootstrapPeers() ([]peer.AddrInfo, error)

DefaultBootstrapPeers returns the (parsed) set of default bootstrap peers. if it fails, it returns a meaningful error for the user. This is here (and not inside cmd/ipfs/init) because of module dependency problems.

func Filename Uses

func Filename(configroot string) (string, error)

Filename returns the configuration file path given a configuration root directory. If the configuration root directory is empty, use the default one

func HumanOutput Uses

func HumanOutput(value interface{}) ([]byte, error)

HumanOutput gets a config value ready for printing

func Marshal Uses

func Marshal(value interface{}) ([]byte, error)

Marshal configuration with JSON

func ParseBootstrapPeers Uses

func ParseBootstrapPeers(addrs []string) ([]peer.AddrInfo, error)

ParseBootstrapPeer parses a bootstrap list into a list of AddrInfos.

func Path Uses

func Path(configroot, extension string) (string, error)

Path returns the path `extension` relative to the configuration root. If an empty string is provided for `configroot`, the default root is used.

func PathRoot Uses

func PathRoot() (string, error)

PathRoot returns the default configuration root directory

func ToMap Uses

func ToMap(conf *Config) (map[string]interface{}, error)

type API Uses

type API struct {
    HTTPHeaders map[string][]string // HTTP headers to return with the API.
}

type Addresses Uses

type Addresses struct {
    Swarm      []string // addresses for the swarm to listen on
    Announce   []string // swarm addresses to announce to the network
    NoAnnounce []string // swarm addresses not to announce to the network
    API        Strings  // address for the local API (RPC)
    Gateway    Strings  // address to listen on for IPFS HTTP object gateway
}

Addresses stores the (string) multiaddr addresses for the node.

type Config Uses

type Config struct {
    Identity  Identity  // local node's peer identity
    Datastore Datastore // local node's storage
    Addresses Addresses // local node's addresses
    Mounts    Mounts    // local node's mount points
    Discovery Discovery // local node's discovery mechanisms
    Routing   Routing   // local node's routing settings
    Ipns      Ipns      // Ipns settings
    Bootstrap []string  // local nodes's bootstrap peer addresses
    Gateway   Gateway   // local node's gateway server options
    API       API       // local node's API settings
    Swarm     SwarmConfig
    Pubsub    PubsubConfig

    Provider     Provider
    Reprovider   Reprovider
    Experimental Experiments
    Plugins      Plugins
}

Config is used to load ipfs config files.

func FromMap Uses

func FromMap(v map[string]interface{}) (*Config, error)

func Init Uses

func Init(out io.Writer, nBitsForKeypair int) (*Config, error)

func (*Config) BootstrapPeers Uses

func (c *Config) BootstrapPeers() ([]peer.AddrInfo, error)

func (*Config) Clone Uses

func (c *Config) Clone() (*Config, error)

Clone copies the config. Use when updating.

func (*Config) SetBootstrapPeers Uses

func (c *Config) SetBootstrapPeers(bps []peer.AddrInfo)

type ConnMgr Uses

type ConnMgr struct {
    Type        string
    LowWater    int
    HighWater   int
    GracePeriod string
}

ConnMgr defines configuration options for the libp2p connection manager

type Datastore Uses

type Datastore struct {
    StorageMax         string // in B, kB, kiB, MB, ...
    StorageGCWatermark int64  // in percentage to multiply on StorageMax
    GCPeriod           string // in ns, us, ms, s, m, h

    // deprecated fields, use Spec
    Type   string           `json:",omitempty"`
    Path   string           `json:",omitempty"`
    NoSync bool             `json:",omitempty"`
    Params *json.RawMessage `json:",omitempty"`

    Spec map[string]interface{}

    HashOnRead      bool
    BloomFilterSize int
}

Datastore tracks the configuration of the datastore.

func DefaultDatastoreConfig Uses

func DefaultDatastoreConfig() Datastore

DefaultDatastoreConfig is an internal function exported to aid in testing.

type Discovery Uses

type Discovery struct {
    MDNS MDNS
}

type Experiments Uses

type Experiments struct {
    FilestoreEnabled     bool
    UrlstoreEnabled      bool
    ShardingEnabled      bool
    Libp2pStreamMounting bool
    P2pHttpProxy         bool
    QUIC                 bool
    PreferTLS            bool
    StrategicProviding   bool
}

type Gateway Uses

type Gateway struct {
    HTTPHeaders  map[string][]string // HTTP headers to return with the gateway
    RootRedirect string
    Writable     bool
    PathPrefixes []string
    APICommands  []string
    NoFetch      bool
}

Gateway contains options for the HTTP gateway server.

type Identity Uses

type Identity struct {
    PeerID  string
    PrivKey string `json:",omitempty"`
}

Identity tracks the configuration of the local node's identity.

func (*Identity) DecodePrivateKey Uses

func (i *Identity) DecodePrivateKey(passphrase string) (ic.PrivKey, error)

DecodePrivateKey is a helper to decode the users PrivateKey

type Ipns Uses

type Ipns struct {
    RepublishPeriod string
    RecordLifetime  string

    ResolveCacheSize int
}

type MDNS Uses

type MDNS struct {
    Enabled bool

    // Time in seconds between discovery rounds
    Interval int
}

type Mounts Uses

type Mounts struct {
    IPFS           string
    IPNS           string
    FuseAllowOther bool
}

Mounts stores the (string) mount points

type Plugin Uses

type Plugin struct {
    Disabled bool
    Config   interface{}
}

type Plugins Uses

type Plugins struct {
    Plugins map[string]Plugin
}

type Profile Uses

type Profile struct {
    // Description briefly describes the functionality of the profile
    Description string

    // Transform takes ipfs configuration and applies the profile to it
    Transform Transformer
}

Profile contains the profile transformer the description of the profile

type Provider Uses

type Provider struct {
    Strategy string // Which keys to announce
}

type PubsubConfig Uses

type PubsubConfig struct {
    // Router can be either floodsub (legacy) or gossipsub (new and
    // backwards compatible).
    Router string

    // DisableSigning disables message signing. Message signing is *enabled*
    // by default.
    DisableSigning bool

    // StrictSignatureVerification enables strict signature verification.
    // When enabled, unsigned messages will be rejected. Eventually, this
    // will be made the default and this option will disappear. Once this
    // happens, networks will either need to completely disable or
    // completely enable message signing.
    StrictSignatureVerification bool
}

type Reprovider Uses

type Reprovider struct {
    Interval string // Time period to reprovide locally stored objects to the network
    Strategy string // Which keys to announce
}

type Routing Uses

type Routing struct {
    // Type sets default daemon routing mode.
    Type string
}

Routing defines configuration options for libp2p routing

type Strings Uses

type Strings []string

Strings is a helper type that (un)marshals a single string to/from a single JSON string and a slice of strings to/from a JSON array of strings.

func (Strings) MarshalJSON Uses

func (o Strings) MarshalJSON() ([]byte, error)

MarshalJSON conforms to the json.Marshaler interface.

func (*Strings) UnmarshalJSON Uses

func (o *Strings) UnmarshalJSON(data []byte) error

UnmarshalJSON conforms to the json.Unmarshaler interface.

type SwarmConfig Uses

type SwarmConfig struct {
    AddrFilters             []string
    DisableBandwidthMetrics bool
    DisableNatPortMap       bool
    DisableRelay            bool
    EnableRelayHop          bool

    // autorelay functionality
    // if true, then the libp2p host will be constructed with autorelay functionality.
    EnableAutoRelay bool
    // if true, then an AutoNATService will be instantiated to facilitate autorelay
    EnableAutoNATService bool

    ConnMgr ConnMgr
}

type Transformer Uses

type Transformer func(c *Config) error

Transformer is a function which takes configuration and applies some filter to it

Directories

PathSynopsis
serialize

Package config imports 16 packages (graph) and is imported by 70 packages. Updated 2019-11-13. Refresh now. Tools for package owners.