Skip to content

Latest commit

 

History

History
5866 lines (5006 loc) · 416 KB

CHANGELOG.md

File metadata and controls

5866 lines (5006 loc) · 416 KB
Raw

go-ipfs changelog

0.5.1 2020-05-08

Hot on the heels of 0.5.0 is 0.5.1 with some important but small bug fixes. This release:

  1. Removes the 1 minute timeout for IPNS publishes (fixes #7244).
  2. Backport a DHT fix to reduce CPU usage for canceled requests.
  3. Fixes some timer leaks in the QUIC transport (ipfs/go-ipfs#2515).

Changelog

  • github.com/ipfs/go-ipfs:
  • github.com/libp2p/go-libp2p-core (v0.5.2 -> v0.5.3):
  • github.com/libp2p/go-libp2p-kad-dht (v0.7.10 -> v0.7.11):
  • github.com/libp2p/go-libp2p-routing-helpers (v0.2.2 -> v0.2.3):
  • github.com/lucas-clemente/quic-go (v0.15.5 -> v0.15.7):
    • reset the PTO when dropping a packet number space
    • move deadlineTimer declaration out of the Read loop
    • stop the deadline timer in Stream.Read and Write
    • fix buffer use after it was released when sending an INVALID_TOKEN error
    • create the session timer at the beginning of the run loop
    • stop the timer when the session's run loop returns

Contributors

Contributor Commits Lines ± Files Changed
Marten Seemann 10 +81/-62 19
Steven Allen 5 +42/-18 10
Adin Schmahmann 1 +2/-8 1
dependabot-preview[bot] 2 +6/-2 4

0.5.0 2020-04-28

We're excited to announce go-ipfs 0.5.0! This is by far the largest go-ipfs release with ~2500 commits, 98 contributors, and over 650 PRs across ipfs, libp2p, and multiformats.

Highlights

Content Routing

The primary focus of this release was on improving content routing. That is, advertising and finding content. To that end, this release heavily focuses on improving the DHT.

Improved DHT

The distributed hash table (DHT) is how IPFS nodes keep track of who has what data. The DHT implementation has been almost completely rewritten in this release. Providing, finding content, and resolving IPNS records are now all much faster. However, there are risks involved with this update due to the significant amount of changes that have gone into this feature.

The current DHT suffers from three core issues addressed in this release:

  • Most peers in the DHT cannot be dialed (e.g., due to firewalls and NATs). Much of a DHT query time is wasted trying to connect to peers that cannot be reached.
  • The DHT query logic doesn't properly terminate when it hits the end of the query and, instead, aggressively keeps on searching.
  • The routing tables are poorly maintained. This can cause search performance to slow down linearly with network size, instead of logarithmically as expected.
Reachability

We have addressed the problem of undialable nodes by having nodes wait to join the DHT as server nodes until they've confirmed that they are reachable from the public internet.

To ensure that nodes which are not publicly reachable (ex behind VPNs, offline LANs, etc.) can still coordinate and share data, go-ipfs 0.5 will run two DHTs: one for private networks and one for the public internet. Every node will participate in a LAN DHT and a public WAN DHT. See Dual DHT for more details.

Dual DHT

All IPFS nodes will now run two DHTs: one for the public internet WAN, and one for their local network LAN.

  1. When connected to the public internet, IPFS will use both DHTs for finding peers, content, and IPNS records. Nodes only publish provider and IPNS records to the WAN DHT to avoid flooding the local network.
  2. When not connected to the public internet, nodes publish provider and IPNS records to the LAN DHT.

The WAN DHT includes all peers with at least one public IP address. This release will only consider an IPv6 address public if it is in the public internet range 2000::/3.

This feature should not have any noticeable impact on go-ipfs, performance, or otherwise. Everything should continue to work in all the currently supported network configurations: VPNs, disconnected LANs, public internet, etc.

Query Logic

We've improved the DHT query logic to more closely follow Kademlia. This should significantly speed up:

  • Publishing IPNS & provider records.
  • Resolving IPNS addresses.

Previously, nodes would continue searching until they timed out or ran out of peers before stopping (putting or returning data found). Now, nodes will now stop as soon as they find the closest peers.

Routing Tables

Finally, we've addressed the poorly maintained routing tables by:

  • Reducing the likelihood that the connection manager will kill connections to peers in the routing table.
  • Keeping peers in the routing table, even if we get disconnected from them.
  • Actively and frequently querying the DHT to keep our routing table full.
  • Prioritizing useful peers that respond to queries quickly.
Testing

The DHT rewrite was made possible by Testground, our new testing framework. Testground allows us to spin up multi-thousand node tests with simulated real-world network conditions. By combining Testground and some custom analysis tools, we were able to gain confidence that the new DHT implementation behaves correctly.

Provider Record Changes

When you add content to your IPFS node, you advertise this content to the network by announcing it in the DHT. We call this providing.

However, go-ipfs has multiple ways to address the same underlying bytes. Specifically, we address content by content ID (CID) and the same underlying bytes can be addressed using (a) two different versions of CIDs (CIDv0 and CIDv1) and (b) with different codecs depending on how we're interpreting the data.

Prior to go-ipfs 0.5.0, we used the content id (CID) in the DHT when sending out provider records for content. Unfortunately, this meant that users trying to find data announced using one CID wouldn't find nodes providing the content under a different CID.

In go-ipfs 0.5.0, we're announcing data by multihash, not CID. This way, regardless of the CID version used by the peer adding the content, the peer trying to download the content should still be able to find it.

Warning: as part of the network, this could impact finding content added with CIDv1. Because go-ipfs 0.5.0 will announce and search for content using the bare multihash (equivalent to the v0 CID), go-ipfs 0.5.0 will be unable to find CIDv1 content published by nodes prior to go-ipfs 0.5.0 and vice-versa. As CIDv1 is not enabled by default so we believe this will have minimal impact. However, users are strongly encouraged to upgrade as soon as possible.

Content Transfer

A secondary focus in this release was improving content transfer, our data exchange protocols.

Refactored Bitswap

This release includes a major Bitswap refactor, running a new and backward compatible Bitswap protocol. We expect these changes to improve performance significantly.

With the refactored Bitswap, we expect:

  • Few to no duplicate blocks when fetching data from other nodes speaking the new protocol.
  • Better parallelism when fetching from multiple peers.

The new Bitswap won't magically make downloading content any faster until both seeds and leaches have updated. If you're one of the first to upgrade to 0.5.0 and try downloading from peers that haven't upgraded, you're unlikely to see much of a performance improvement.

Server-Side Graphsync Support (Experimental)

Graphsync is a new exchange protocol that operates at the IPLD Graph layer instead of the Block layer like bitswap.

For example, to download "/ipfs/QmExample/index.html":

  • Bitswap would download QmFoo, lookup "index.html" in the directory named by QmFoo, resolving it to a CID QmIndex. Finally, bitswap would download QmIndex.
  • Graphsync would ask peers for "/ipfs/QmFoo/index.html". Specifically, it would ask for the child named "index.html" of the object named by "QmFoo".

This saves us round-trips in exchange for some extra protocol complexity. Moreover, this protocol allows specifying more powerful queries like "give me everything under QmFoo". This can be used to quickly download a large amount of data with few round-trips.

At the moment, go-ipfs cannot use this protocol to download content from other peers. However, if enabled, go-ipfs can serve content to other peers over this protocol. This may be useful for pinning services that wish to quickly replicate client data.

To enable, run:

> ipfs config --json Experimental.GraphsyncEnabled true

Datastores

Continuing with the of improving our core data handling subsystems, both of the datastores used in go-ipfs, Badger and flatfs, have received important updates in this release:

Badger

Badger has been in go-ipfs for over a year as an experimental feature, and we're promoting it to stable (but not default). For this release, we've switched from writing to disk synchronously to explicitly syncing where appropriate, significantly increasing write throughput.

The current and default datastore used by go-ipfs is FlatFS. FlatFS essentially stores blocks of data as individual files on your file system. However, there are lots of optimizations a specialized database can do that a standard file system can not.

The benefit of Badger is that adding/fetching data to/from Badger is significantly faster than adding/fetching data to/from the default datastore, FlatFS. In some tests, adding data to Badger is 32x faster than FlatFS (in this release).

Enable Badger

In this release, we're marking the badger datastore as stable. However, we're not yet enabling it by default. You can enable it at initialization by running: ipfs init --profile=badgerds

Issues with Badger

While Badger is a great solution, there are some issues you should consider before enabling it.

Badger is complicated. FlatFS pushes all the complexity down into the filesystem itself. That means that FlatFS is only likely to lose your data if your underlying filesystem gets corrupted while there are more opportunities for Badger itself to get corrupted.

Badger can use a lot of memory. In this release, we've tuned Badger to use ~20MB of memory by default. However, it can still produce spikes as large as 1GiB of data in memory usage when garbage collecting.

Finally, Badger isn't very aggressive when it comes to garbage collection, and we're still investigating ways to get it to more aggressively clean up after itself.

We suggest you use Badger if:

  • Performance is your main requirement.
  • You rarely delete anything.
  • You have some memory to spare.
Flatfs

In the flatfs datastore, we've fixed an issue where temporary files could be left behind in some cases. While this release will avoid leaving behind temporary files, you may want to remove any left behind by previous releases:

> rm ~/.ipfs/blocks/*/put-*
> rm ~/.ipfs/blocks/du-*

We've also hardened several edge-cases in flatfs to reduce the impact of file descriptor limits, spurious crashes, etc.

Libp2p

Many improvements and bug fixes were made to libp2p over the course of this release. These release notes only include the most important and those most relevant to the content routing improvements.

Improved Backoff Logic

When we fail to connect to a peer, we "backoff" and refuse to re-connect to that peer for a short period of time. This prevents us from wasting resources repeatedly failing to connect to the same unreachable peer.

Unfortunately, the old backoff logic was flawed: if we failed to connect to a peer and entered the "backoff" state, we wouldn't try to re-connect to that peer even if we had learned new and potentially working addresses for the peer. We've fixed this by applying backoff to each address instead of to the peer as a whole. This achieves the same result as we'll stop repeatedly trying to connect to the peer at known-bad addresses, but it allows us to reach the peer if we later learn about a good address.

AutoNAT

This release uses Automatic NAT Detection (AutoNAT) - determining if the node is reachable from the public internet - to make decisions about how to participate in IPFS. This subsystem is used to determine if the node should store some of the public DHT, and if it needs to use relays to be reached by others. In short:

  1. An AutoNAT client asks a node running an AutoNAT service if it can be reached at one of a set of guessed addresses.
  2. The AutoNAT service attempts to dial back those addresses, with some restrictions. We won't dial back to a different IP address, for example.
  3. If the AutoNAT service succeeds, it reports back the address it successfully dialed, and the AutoNAT client knows that it is reachable from the public internet.

All nodes act as AutoNAT clients to determine if they should switch into DHT server mode. As of this release, nodes will by default run the service side of AutoNAT - verifying connectivity - for up to 30 peers every minute. This service should have minimal overhead and will be disabled for nodes in the lowpower configuration profile, and those which believe they are not publicly reachable.

In addition to enabling the AutoNAT service by default, this release changes the AutoNAT config options:

  1. The Swarm.EnableAutoNATService option has been removed.
  2. A new AutoNAT section has been added to the config. This section is empty by default.
IPFS/Libp2p Address Format

If you've ever run a command like ipfs swarm peers, you've likely seen paths that look like /ip4/193.45.1.24/tcp/4001/ipfs/QmSomePeerID. These paths are not file paths, they're multiaddrs; addresses of peers on the network.

Unfortunately, /ipfs/Qm... is also the same path format we use for files. This release, changes the multiaddr format from /ip4/193.45.1.24/tcp/4001/ipfs/QmSomePeerID to /ip4/193.45.1.24/tcp/4001/p2p/QmSomePeerID to make the distinction clear.

What this means for users:

  • Old-style multiaddrs will still be accepted as inputs to IPFS.
  • If you were using a multiaddr library (go, js, etc.) to name files because /ipfs/QmSomePeerID looks like /ipfs/QmSomeFile, your tool may break if you upgrade this library.
  • If you're manually parsing multiaddrs and are searching for the string /ipfs/..., you'll need to search for /p2p/....
Minimum RSA Key Size

Previously, IPFS did not enforce a minimum RSA key size. In this release, we've introduced a minimum 2048 bit RSA key size. IPFS generates 2048 bit RSA keys by default so this shouldn't be an issue for anyone in practice. However, users who explicitly chose a smaller key size will not be able to communicate with new nodes.

Unfortunately, some of the bootstrap peers did intentionally generate 1024 bit RSA keys so they'd have vanity peer addresses (starting with QmSoL for "solar net"). All IPFS nodes should also have peers with >= 2048 bit RSA keys in their bootstrap list, but we've introduced a migration to ensure this.

We implemented this change to follow security best practices and to remove a potential foot-gun. However, in practice, the security impact of allowing insecure RSA keys should have been next to none because IPFS doesn't trust other peers on the network anyways.

TLS By Default

In this release, we're switching TLS to be the default transport. This means we'll try to encrypt the connection with TLS before re-trying with SECIO.

Contrary to the announcement in the go-ipfs 0.4.23 release notes, this release does not remove SECIO support to maintain compatibility with js-ipfs.

Note: The Experimental.PreferTLS configuration option is now ignored.

SECIO Deprecation Notice

SECIO should be considered to be well on the way to deprecation and will be completely disabled in either the next release (0.6.0, ~mid May) or the one following that (0.7.0, ~end of June). Before SECIO is disabled, support will be added for the NOISE transport for compatibility with other IPFS implementations.

QUIC Upgrade

If you've been using the experimental QUIC support, this release upgrades to a new and incompatible version of the QUIC protocol (draft 27). Old and new go-ipfs nodes will still interoperate, but not over the QUIC transport.

We intend to standardize on this draft of the QUIC protocol and enable QUIC by default in the next release if all goes well.

NOTE: QUIC does not yet support private networks.

Gateway

In addition to a bunch of bug fixes, we've made two improvements to the gateway.

You can play with both of these features by visiting:

http://bafybeia6po64b6tfqq73lckadrhpihg2oubaxgqaoushquhcek46y3zumm.ipfs.localhost:8080

Subdomain Gateway

First up, we've changed how URLs in the IPFS gateway work for better browser security. The gateway will now redirect from http://localhost:8080/ipfs/CID/... to http://CID.ipfs.localhost:8080/... by default. This:

  • Ensures that every dapp gets its own browser origin.
  • Makes it easier to write websites that "just work" with IPFS because absolute paths will now work (though you should still use relative links because they're better).

Paths addressing the gateway by IP address (http://127.0.0.1:5001/ipfs/CID) will not be altered as IP addresses can't have subdomains.

Note: cURL doesn't follow redirects by default. To avoid breaking cURL and other clients that don't support redirects, go-ipfs will return the requested file along with the redirect. Browsers will follow the redirect and abort the download while cURL will ignore the redirect and finish the download.

Directory Listing

The second feature is a face-lift to the directory listing theme and color palette.

http://bafybeia6po64b6tfqq73lckadrhpihg2oubaxgqaoushquhcek46y3zumm.ipfs.localhost:8080

IPNS

This release includes several new IPNS and IPNS-related features.

ENS

IPFS now resolves ENS names (e.g., /ipns/ipfs.eth) via DNSLink provided by https://eth.link service.

IPNS over PubSub

IPFS has had experimental support for resolving IPNS over pubsub for a while. However, in the past, this feature was passive. When resolving an IPNS name, one would join a pubsub topic for the IPNS name and subscribe to future updates. Unfortunately, this wouldn't speed-up initial IPNS lookups.

In this release, we've introduced a new "record fetch" protocol to speedup the initial lookup. Now, after subscribing to the pubsub topic for the IPNS key, nodes will use this new protocol to "fetch" the last-seen IPNS record from all peers subscribed to the topic.

This feature will be enabled by default in 0.6.0.

IPNS with base32 PIDs

IPNS names can now be expressed as special multibase CIDs. E.g.,

/ipns/bafzbeibxfjp4gaxc4cdn57257cyvc7jfa4rlp4e5min6geg44m57g6nx7e

Importantly, this allows IPNS names to appear in subdomains in the new subdomain gateway feature.

PubSub

We have made two major changes to the pubsub subsystem in this release:

  1. Pubsub now more aggressively finds and connects to other peers subscribing to the same topic.
  2. Go-ipfs has switched its default pubsub router from "floodsub", an inefficient but simple "flooding" pubsub implementation, to "gossipsub".

PubSub will be stabilized in go-ipfs 0.6.0.

CLI & API

The IPFS CLI and API have a couple of new features and changes.

POST Only

IPFS has two HTTP APIs:

As of this release, the main IPFS API (port 5001) will only accept POST requests. This change is necessary to tighten cross origin security in browsers.

If you're using the go-ipfs API in your application, you may need to change GET calls to POST calls or upgrade your libraries and tools.

  • go - go-ipfs-api - v0.0.3
  • js-ipfs-http-api - v0.41.1
  • orbit-db - v0.24.0 (unreleased)
RIP "Error: api not running"

If you've ever seen the error:

Error: api not running

when trying to run a command without the daemon running, we have good news! You should never see this error again. The ipfs command now correctly detects that the daemon is not, in fact, running, and directly opens the IPFS repo.

RIP ipfs repo fsck

The ipfs repo fsck now does nothing but print an error message. Previously, it was used to cleanup some lock files: the "api" file that caused the aforementioned "api not running" error and the repo lock. However, this is no longer necessary.

Init with config

It's now possible to initialize an IPFS node with an existing IPFS config by running:

> ipfs init /path/to/existing/config

This will re-use the existing configuration in it's entirety (including the private key) and can be useful when:

  • Migrating a node's identity between machines without keeping the data.
  • Resetting the datastore.
Ignoring Files

Files can now be ignored on add by passing the --ignore and/or --ignore-rules-path flags.

  • --ignore=PATTERN will ignore all files matching the gitignore rule PATTERN.
  • --ignore-rules-path=FILENAME will apply the gitignore rules from the specified file.

For example, to add a git repo while ignoring all files git would ignore, you could run:

> cd path/to/some/repo
> ipfs add -r --hidden=false --ignore=.git --ignore-rules-path=.gitignore .
Named Pipes

It's now possible to add data directly from a named pipe:

> mkfifo foo
> echo -n "hello " > foo &
> echo -n "world" > bar &
> ipfs add foo bar

This can be useful when adding data from multiple streaming sources.

NOTE: To avoid surprising users, IPFS will only add data from FIFOs directly named on the command line, not FIFOs in a recursively added directory. Otherwise, ipfs add would halt whenever it encountered a FIFO with no data to be read leading to difficult to debug stalls.

DAG import/export (.car)

IPFS now allows rapid reading and writing of blocks in .car format. The functionality is accessible via the experimental dag import and dag export commands:

~$ ipfs dag export QmQPeNsJPyVWPFDVHb77w8G42Fvo15z4bG2X8D2GhfbSXc \
| xz > welcome_to_ipfs.car.xz

 0s  6.73 KiB / ? [-------=-------------------------------------] 5.16 MiB/s 0s

Then on another ipfs instance, not even connected to the network:

~$ xz -dc welcome_to_ipfs.car.xz | ipfs dag import

Pinned root	QmQPeNsJPyVWPFDVHb77w8G42Fvo15z4bG2X8D2GhfbSXc	success
Pins

We've made two minor changes to the pinning subsystem:

  1. ipfs pin ls --stream allows streaming a pin listing.
  2. ipfs pin update no longer holds the global pin lock while fetching files from the network. This should hopefully make it significantly more useful.

Daemon

Zap Logging

The go-ipfs daemon has switched to using Uber's Zap. Unlike our previous logging system, Zap supports structured logging which can make parsing, filtering, and analyzing go-ipfs logs much simpler.

To enable structured logging, set the IPFS_LOGGING_FMT environment variable to "json".

Note: while we've switched to using Zap as the logging backend, most of go-ipfs still logs strings.

Systemd Support

For Linux users, this release includes support for two systemd features: socket activation and startup/shutdown notifications. This makes it possible to:

  • Start IPFS on demand on first use.
  • Wait for IPFS to finish starting before starting services that depend on it.

You can find the new systemd units in the go-ipfs repo under misc/systemd.

IPFS API Over Unix Domain Sockets

This release supports exposing the IPFS API over a unix domain socket in the filesystem. You use this feature, run:

> ipfs config Addresses.API "/unix/path/to/socket/location"
Docker

We've made a few improvements to our docker image in this release:

  • It can now be cross-built for multiple architectures.
  • It now builds go-ipfs with OpenSSL support by default for faster libp2p handshakes.
  • A private-network "swarm" key can now be passed in to a docker image via either the IPFS_SWARM_KEY=<inline key> or IPFS_SWARM_KEY_FILE=<path/to/key/file> docker variables. Check out the Docker section of the README for more information.

Plugins

go-ipfs plugins allow users to extend go-ipfs without modifying the original source-code. This release includes a few important changes.

See docs/plugins.md for details.

MacOS Support

Plugins are now supported on MacOS, in addition to Linux. Unfortunately, Go still doesn't support plugins on Windows.

New Plugin Type: InternalPlugin

This release introduces a new InternalPlugin plugin type. When started, this plugin will be passed a raw *IpfsNode object, giving it access to all go-ipfs internals.

This plugin interface is permanently unstable as it has access to internals that can change frequently. However, it should allow power-users to develop deeply integrated extensions to go-ipfs, out-of-tree.

Plugin Config

BREAKING

Plugins can now be configured and/or disabled via the ipfs config file.

To make this possible, the plugin interface has changed. The Init function now takes an *Environment object. Specifically, the plugin signature has changed from:

type Plugin interface {
	Name() string
	Version() string
	Init() error
}

to

type Environment struct {
	// Path to the IPFS repo.
	Repo string

	// The plugin's config, if specified.
	Config interface{}
}

type Plugin interface {
	Name() string
	Version() string
	Init(env *Environment) error
}

Repo Migrations

IPFS uses repo migrations to make structural changes to the "repo" (the config, data storage, etc.) on upgrade.

This release includes two very simple repo migrations: a config migration to ensure that the config contains working bootstrap nodes and a keystore migration to base32 encode all key filenames.

In general, migrations should not require significant manual intervention. However, you should be aware of migrations and plan for them.

  • If you update go-ipfs with ipfs update, ipfs update will run the migration for you. Note: ipfs update will refuse to run the migrations while ipfs itself is running.
  • If you start the ipfs daemon with ipfs daemon --migrate, ipfs will migrate your repo for you on start.

Otherwise, if you want more control over the repo migration process, you can manually install and run the repo migration tool.

Bootstrap Peer Changes

AUTOMATIC MIGRATION REQUIRED

The first migration will update the bootstrap peer list to:

  1. Replace the old bootstrap nodes (ones with peer IDs starting with QmSoL), with new bootstrap nodes (ones with addresses that start with /dnsaddr/bootstrap.libp2p.io).
  2. Rewrite the address format from /ipfs/QmPeerID to /p2p/QmPeerID.

We're migrating addresses for a few reasons:

  1. We're using DNS to address the new bootstrap nodes so we can change the underlying IP addresses as necessary.
  2. The new bootstrap nodes use 2048 bit keys while the old bootstrap nodes use 1024 bit keys.
  3. We're normalizing the address format to /p2p/Qm....

Note: This migration won't add the new bootstrap peers to your config if you've explicitly removed the old bootstrap peers. It will also leave custom entries in the list alone. In other words, if you've customized your bootstrap list, this migration won't clobber your changes.

Keystore Changes

AUTOMATIC MIGRATION REQUIRED

go-ipfs stores additional keys (i.e., all keys other than the "identity" key) in the keystore. You can list these keys with ipfs key.

Currently, the keystore stores keys as regular files, named after the key itself. Unfortunately, filename restrictions and case-insensitivity are platform specific. To avoid platform specific issues, we're base32 encoding all key names and renaming all keys on-disk.

Windows

As usual, this release contains several Windows specific fixes and improvements:

  • Double-clicking ipfs.exe will now start the daemon inside a console window.
  • ipfs add -r now correctly recognizes and ignores hidden files on Windows.
  • The default datastore, flatfs, now takes extra precautions to avoid "file in use" errors caused by both go-ipfs and external programs like anti-viruses. If you've ever seen go-ipfs print out an "access denied" or "file in use" error on Windows, this issue was likely the cause.

Changelog

Contributors

Contributor Commits Lines ± Files Changed
Steven Allen 858 +27833/-15919 1906
Dirk McCormick 134 +18058/-8347 282
Aarsh Shah 83 +13458/-11883 241
Adin Schmahmann 144 +11878/-6236 397
Raúl Kripalani 94 +6894/-10214 598
vyzo 60 +8923/-1160 102
Will Scott 79 +3776/-1467 175
Michael Muré 29 +1734/-3290 104
dependabot[bot] 365 +3419/-361 728
Hector Sanjuan 64 +2053/-1321 132
Marten Seemann 52 +1922/-1268 147
Michael Avila 29 +828/-1733 70
Peter Rabbitson 53 +1073/-1197 100
Yusef Napora 36 +1610/-378 57
hannahhoward 16 +1342/-559 61
Łukasz Magiera 9 +277/-1623 41
Marcin Rataj 9 +1686/-99 32
Will 7 +936/-709 34
Alex Browne 27 +1019/-503 46
David Dias 30 +987/-431 43
Jakub Sztandera 43 +912/-436 77
Cole Brown 21 +646/-398 57
Oli Evans 29 +488/-466 43
Cornelius Toole 3 +827/-60 20
Hlib 15 +331/-185 28
Adrian Lanzafame 9 +123/-334 18
Petar Maymounkov 1 +385/-48 5
Alan Shaw 18 +262/-146 35
lnykww 1 +303/-52 6
Hannah Howard 1 +198/-27 3
Dominic Della Valle 9 +163/-52 14
Adam Uhlir 1 +211/-2 3
Dimitris Apostolou 1 +105/-105 64
Frrist 1 +186/-18 5
Henrique Dias 22 +119/-28 22
Gergely Tabiczky 5 +74/-60 7
Matt Joiner 2 +63/-62 4
@RubenKelevra 12 +46/-55 12
whyrusleeping 6 +87/-11 7
deepakgarg 4 +42/-43 4
protolambda 2 +49/-17 9
hucg 2 +47/-11 3
Arber Avdullahu 3 +31/-27 3
Sameer Puri 1 +46/-4 2
Hucg 3 +17/-33 3
Guilhem Fanton 2 +29/-10 7
Christian Muehlhaeuser 6 +20/-19 14
Djalil Dreamski 3 +27/-9 3
Caian 2 +36/-0 2
Topper Bowers 2 +31/-4 4
flowed 1 +16/-16 11
Vibhav Pant 4 +21/-10 5
frrist 1 +26/-4 1
Hlib Kanunnikov 1 +25/-3 1
george xie 3 +12/-15 11
optman 1 +13/-9 1
Roman Proskuryakov 1 +11/-11 2
Vasco Santos 1 +10/-10 5
Pretty Please Mark Darkly 2 +16/-2 2
Piotr Dyraga 2 +15/-2 2
Andrew Nesbitt 1 +5/-11 5
postables 4 +19/-8 4
Jim McDonald 2 +13/-1 2
PoorPockets McNewHold 1 +12/-0 1
Henri S 1 +6/-6 1
Igor Velkov 1 +8/-3 1
swedneck 4 +7/-3 4
Devin 2 +5/-5 4
iulianpascalau 1 +5/-3 2
MollyM 3 +7/-1 3
Jorropo 2 +5/-3 3
lukesolo 1 +6/-1 2
Wes Morgan 1 +3/-3 1
Kishan Mohanbhai Sagathiya 1 +3/-3 2
songjiayang 1 +4/-0 1
Terry Ding 1 +2/-2 1
Preston Van Loon 2 +3/-1 2
Jim Pick 2 +2/-2 2
Jakub Kaczmarzyk 1 +2/-2 1
Simon Menke 2 +2/-1 2
Jessica Schilling 2 +1/-2 2
Edgar Aroutiounian 1 +2/-1 1
hikerpig 1 +1/-1 1
ZenGround0 1 +1/-1 1
Thomas Preindl 1 +1/-1 1
Sander Pick 1 +1/-1 1
Ronsor 1 +1/-1 1
Roman Khafizianov 1 +1/-1 1
Rod Vagg 1 +1/-1 1
Max Inden 1 +1/-1 1
Leo Arias 1 +1/-1 1
Kuro1 1 +1/-1 1
Kirill Goncharov 1 +1/-1 1
John B Nelson 1 +1/-1 1
George Masgras 1 +1/-1 1
Aliabbas Merchant 1 +1/-1 1
Lorenzo Setale 1 +1/-0 1
Boris Mann 1 +1/-0 1

0.4.23 2020-01-29

Given the large number of fixes merged since 0.4.22, we've decided to cut another patch release.

This release contains critical fixes. Please upgrade ASAP. Importantly, we're strongly considering switching to TLS by default in go-ipfs 0.5.0 and dropping SECIO support. However, the current TLS transport in go-ipfs 0.4.22 has a bug that can cause connections to spontaneously disconnect during the handshake.

This release fixes that bug, among many other issues. Users that don't upgrade may experience connectivity issues when the network upgrades to go-ipfs 0.5.0.

Highlights

  • Fixes build on go 1.13
  • Fixes an issue where we may not connect to providers in bitswap.
  • Fixes an issue on the TLS transport where we may abort a handshake unintentionally.
  • Fixes a common panic in the websocket transport.
  • Adds support for recursively resolving dnsaddrs (makes go-ipfs compatible with the new bootstrappers).
  • Fixes several potential panics/crashes.
  • Switches to using pre-defined autorelays instead of trying to find them in the DHT:
    • Avoids selecting random, potentially poor, relays.
    • Avoids spamming the DHT with requests trying to find relays.
    • Reduces the impact of accidentally enabling AutoRelay + RelayHop. I.e., the network won't try to DoS you.
  • Modifies the connection manager to not count connections in the grace period towards the connection limit.
    • Pro: New connections don't cause us to close useful, existing connections.
    • Con: Libp2p will keep more connections. Consider reducing your HighWater after applying this patch.
  • Improved peer usefulness tracking in bitswap. Frequently used peers will be marked as "important" and the connection manager will avoid closing connections to these peers.
  • Includes a new version of the WebUI to fix some issues with the peers map.

Changelog

Other:

Update bloom filter libraries to remove unsound usage of the unsafe package.

Contributors

Contributor Commits Lines ± Files Changed
Steven Allen 52 +1866/-578 102
vyzo 12 +167/-90 22
whyrusleeping 5 +136/-52 7
Roman Proskuryakov 7 +94/-7 10
Jakub Sztandera 3 +58/-13 7
hcg1314 2 +31/-11 2
Raúl Kripalani 2 +7/-33 6
Marten Seemann 3 +27/-10 5
Marcin Rataj 2 +26/-0 5
b5 1 +2/-22 1
Hector Sanjuan 1 +11/-0 1
Yusef Napora 1 +4/-0 1

0.4.22 2019-08-06

We're releasing a PATCH release of go-ipfs based on 0.4.21 containing some critical fixes.

The IPFS network has scaled to the point where small changes can have a wide-reaching impact on the entire network. To keep this situation from escalating, we've put a hold on releasing new features until we can improve our release process (which we've trialed in this release) and testing procedures.

This release includes fixes for the following regressions:

  1. A major bitswap throughput regression introduced in 0.4.21 (ipfs/go-ipfs#6442).
  2. High bitswap CPU usage when connected to many (e.g. 10,000) peers. See ipfs/go-bitswap#154.
  3. The local network discovery service sometimes initializes before the networking module, causing it to announce the wrong addresses and sometimes complain about not being able to determine the IP address (ipfs/go-ipfs#6415).

It also includes fixes for:

  1. Pins not being persisted after ipfs block add --pin (ipfs/go-ipfs#6441).
  2. Panic due to concurrent map access when adding and listing pins at the same time (ipfs/go-ipfs#6419).
  3. Potential pin-set corruption given a concurrent ipfs repo gc and ipfs pin rm (ipfs/go-ipfs#6444).
  4. Build failure due to a deleted git tag in one of our dependencies (ipfs/go-ds-badger#64).

Thanks to:

0.4.21 2019-05-30

We're happy to announce go-ipfs 0.4.21. This release has some critical bug fixes and a handful of new features so every user should upgrade.

Key bug fixes:

  • Too many open file descriptors/too many peers (#6237).
  • Adding multiple files at the same time doesn't work (#6254).
  • CPU utilization spikes and then holds at 100% (#5613).

Key features:

  • Experimental TLS1.3 support (to eventually replace secio).
  • OpenSSL support for SECIO handshakes (performance improvement).

IMPORTANT: This release fixes a bug in our security transport that could potentially drop data from the channel. Note: This issue affects neither the privacy nor the integrity of the data with respect to a third-party attacker. Only the peer sending us data could trigger this bug.

ALL USERS MUST UPGRADE. We intended to introduce a feature this release that, unfortunately, reliably triggered this bug. To avoid partitioning the network, we've decided to postpone this feature for a release or two.

Specifically, we're going to provide a minimum one month upgrade period. After that, we'll start testing the impact of deploying the proposed changes.

If you're running the mainline go-ipfs, please upgrade ASAP. If you're building a separate app or working on a forked go-ipfs, make sure to upgrade github.com/libp2p/go-libp2p-secio to at least v0.0.3.

Contributors

First off, we'd like to give a shout-out to all contributors that participated in this release (including contributions to ipld, libp2p, and multiformats):

Contributor Commits Lines ± Files Changed
Steven Allen 220 +6078/-4211 520
Łukasz Magiera 53 +5039/-4557 274
vyzo 179 +2929/-1704 238
Raúl Kripalani 44 +757/-1895 134
hannahhoward 11 +755/-1005 49
Marten Seemann 16 +862/-203 44
keks 10 +359/-110 12
Jan Winkelmann 8 +368/-26 16
Jakub Sztandera 4 +361/-8 7
Adrian Lanzafame 1 +287/-18 5
Erik Ingenito 4 +247/-28 8
Reid 'arrdem' McKenzie 1 +220/-20 3
Yusef Napora 26 +98/-130 26
Michael Avila 3 +116/-59 8
Raghav Gulati 13 +145/-26 13
tg 1 +41/-33 1
Matt Joiner 6 +41/-30 7
Cole Brown 1 +37/-25 1
Dominic Della Valle 2 +12/-40 4
Overbool 1 +50/-0 2
Christopher Buesser 3 +29/-16 10
myself659 1 +38/-5 2
Alex Browne 3 +30/-8 3
jmank88 1 +27/-4 2
Vikram 1 +25/-1 2
MollyM 7 +17/-9 7
Marcin Rataj 1 +17/-1 1
requilence 1 +11/-4 1
Teran McKinney 1 +8/-2 1
Oli Evans 1 +5/-5 1
Masashi Salvador Mitsuzawa 1 +5/-1 1
chenminjian 1 +4/-0 1
Edgar Lee 1 +3/-1 1
Dirk McCormick 1 +2/-2 2
ia 1 +1/-1 1
Alan Shaw 1 +1/-1 1

Bug Fixes And Enhancements

This release includes quite a number of critical bug fixes and performance/reliability enhancements.

Error when adding multiple files

The last release broke the simple command ipfs add file1 file2. It turns out we simply lacked a test case for this. Both of these issues (the bug and the lack of a test case) have now been fixed.

SECIO

As noted above, we've fixed a bug that could cause data to be dropped from a SECIO connection on read. Specifically, this happens when:

  1. The capacity of the read buffer is greater than the length.
  2. The remote peer sent more than the length but less than the capacity in a single secio "frame".

In this case, we'd fill the read buffer to it's capacity instead of its length.

Too many open files, too many peers, etc.

Go-ipfs automatically closes the least useful connections when it accumulates too many connections. Unfortunately, some relayed connections were blocking in Close(), halting the entire process.

Out of control CPU usage

Many users noted out of control CPU usage this release. This turned out to be a long-standing issue with how the DHT handled provider records (records recording which peers have what content):

  1. It wasn't removing provider records for content until the set of providers completely emptied.
  2. It was loading every provider record into memory whenever we updated the set of providers.

Combined, these two issues were trashing the provider record cache, forcing the DHT to repeatedly load and discard provider records.

More Reliable Connection Management

Go-ipfs has a subsystem called the "connection manager" to close the least-useful connections when go-ipfs runs low on resources.

Unfortunately, other IPFS subsystems may learn about connections before the connection manager. Previously, if some IPFS subsystem tried to mark a connection as useful before the connection manager learned about it, the connection manager would discard this information. We believe this was causing #6271. It no longer does that.

Improved Bitswap Connection Management

Bitswap now uses the connection manager to mark all peers downloading blocks as important (while downloading). Previously, it only marked peers from which it was downloading blocks.

Reduced Memory Usage

The most noticeable memory reduction in this release comes from fixing connection closing. However, we've made a few additional improvements:

  • Bitswap's "work queue" no longer remembers every peer it has seen indefinitely.
  • The peerstore now interns protocol names.
  • The per-peer goroutine count has been reduced.
  • The DHT now wastes less memory on idle peers by pooling buffered writers and returning them to the pool when not actively using them.

Increased File Descriptor Limit

The default file descriptor limit has been raised to 8192 (from 2048). Unfortunately, go-ipfs behaves poorly when it runs out of file descriptors and it uses a lot of file descriptors.

Luckily, most modern kernels can handle thousands of file descriptors without any difficulty.

Decreased Connection Handshake Latency

Libp2p now shaves off a couple of round trips when initiating connections by beginning the protocol negotiation before the remote peer responds to the initial handshake message.

In the optimal case (when the target peer speaks our preferred protocol), this reduces the number of handshake round-trips from 6 to 4 (including the TCP handshake).

Commands

This release brings no new commands but does introduce a few changes, bugfixes, and enhancements. This section is hardly complete but it lists the most noticeable changes.

Take note: this release also introduces a few breaking changes.

[DEPRECATION] The URLStore Command Deprecated

The experimental ipfs urlstore command is now deprecated. Please use ipfs add --nocopy URL instead.

[BREAKING] The DHT Command Base64 Encodes Values

When responding to an ipfs dht get command, the daemon now encodes the returned value using base64. The ipfs command will automatically decode this value before returning it to the user so this change should only affect those using the HTTP API directly.

Unfortunately, this change was necessary as DHT records are arbitrary binary blobs which can't be directly stored in JSON strings.

[BREAKING] Base32 Encoded v1 CIDs By Default

Both js-ipfs and go-ipfs now encode CIDv1 CIDs using base32 by default, instead of base58. Unfortunately, base58 is case-sensitive and doesn't play well with browsers (see #4143.

Human Readable Numbers

The ipfs bitswap stat and and ipfs object stat commands now support a --humanize flag that formats numbers with human-readable units (GiB, MiB, etc.).

Improved Errors

This release improves two types of errors:

  1. Commands that take paths/multiaddrs now include the path/multiaddr in the error message when it fails to parse.
  2. ipfs swarm connect now returns a detailed error describing which addresses were tried and why the dial failed.

Ping Improvements

The ping command has received some small improvements and fixes:

  1. It now exits with a non-zero exit status on failure.
  2. It no longer succeeds with zero successful pings if we have a zombie but non-functional connection to the peer being pinged (#6298).
  3. It now prints out the average latency when canceled with ^C (like the unix ping command).

Improved Help Text

Go-ipfs now intelligently wraps help text for easier reading. On an 80 character wide terminal,

Before

USAGE
  ipfs add <path>... - Add a file or directory to ipfs.

SYNOPSIS
  ipfs add [--recursive | -r] [--dereference-args] [--stdin-name=<stdin-name>] [
--hidden | -H] [--quiet | -q] [--quieter | -Q] [--silent] [--progress | -p] [--t
rickle | -t] [--only-hash | -n] [--wrap-with-directory | -w] [--chunker=<chunker
> | -s] [--pin=false] [--raw-leaves] [--nocopy] [--fscache] [--cid-version=<cid-
version>] [--hash=<hash>] [--inline] [--inline-limit=<inline-limit>] [--] <path>
...

ARGUMENTS

  <path>... - The path to a file to be added to ipfs.

OPTIONS

  -r,               --recursive           bool   - Add directory paths recursive
ly.
  --dereference-args                      bool   - Symlinks supplied in argument
s are dereferenced.
  --stdin-name                            string - Assign a name if the file sou
rce is stdin.
  -H,               --hidden              bool   - Include files that are hidden
. Only takes effect on recursive add.
  -q,               --quiet               bool   - Write minimal output.
  -Q,               --quieter             bool   - Write only final hash.
  --silent                                bool   - Write no output.
  -p,               --progress            bool   - Stream progress data.
  -t,               --trickle             bool   - Use trickle-dag format for da
g generation.
  -n,               --only-hash           bool   - Only chunk and hash - do not 
write to disk.
  -w,               --wrap-with-directory bool   - Wrap files with a directory o
bject.
  -s,               --chunker             string - Chunking algorithm, size-[byt
es] or rabin-[min]-[avg]-[max]. Default: size-262144.
  --pin                                   bool   - Pin this object when adding. 
Default: true.
  --raw-leaves                            bool   - Use raw blocks for leaf nodes
. (experimental).
  --nocopy                                bool   - Add the file using filestore.
 Implies raw-leaves. (experimental).
  --fscache                               bool   - Check the filestore for pre-e
xisting blocks. (experimental).
  --cid-version                           int    - CID version. Defaults to 0 un
less an option that depends on CIDv1 is passed. (experimental).
  --hash                                  string - Hash function to use. Implies
 CIDv1 if not sha2-256. (experimental). Default: sha2-256.
  --inline                                bool   - Inline small blocks into CIDs
. (experimental).
  --inline-limit                          int    - Maximum block size to inline.
 (experimental). Default: 32.

After

USAGE
  ipfs add <path>... - Add a file or directory to ipfs.

SYNOPSIS
  ipfs add [--recursive | -r] [--dereference-args] [--stdin-name=<stdin-name>]
           [--hidden | -H] [--quiet | -q] [--quieter | -Q] [--silent]
           [--progress | -p] [--trickle | -t] [--only-hash | -n]
           [--wrap-with-directory | -w] [--chunker=<chunker> | -s] [--pin=false]
           [--raw-leaves] [--nocopy] [--fscache] [--cid-version=<cid-version>]
           [--hash=<hash>] [--inline] [--inline-limit=<inline-limit>] [--]
           <path>...

ARGUMENTS

  <path>... - The path to a file to be added to ipfs.

OPTIONS

  -r, --recursive            bool   - Add directory paths recursively.
  --dereference-args         bool   - Symlinks supplied in arguments are
                                      dereferenced.
  --stdin-name               string - Assign a name if the file source is stdin.
  -H, --hidden               bool   - Include files that are hidden. Only takes
                                      effect on recursive add.
  -q, --quiet                bool   - Write minimal output.
  -Q, --quieter              bool   - Write only final hash.
  --silent                   bool   - Write no output.
  -p, --progress             bool   - Stream progress data.
  -t, --trickle              bool   - Use trickle-dag format for dag generation.
  -n, --only-hash            bool   - Only chunk and hash - do not write to
                                      disk.
  -w, --wrap-with-directory  bool   - Wrap files with a directory object.
  -s, --chunker              string - Chunking algorithm, size-[bytes] or
                                      rabin-[min]-[avg]-[max]. Default:
                                      size-262144.
  --pin                      bool   - Pin this object when adding. Default:
                                      true.
  --raw-leaves               bool   - Use raw blocks for leaf nodes.
                                      (experimental).
  --nocopy                   bool   - Add the file using filestore. Implies
                                      raw-leaves. (experimental).
  --fscache                  bool   - Check the filestore for pre-existing
                                      blocks. (experimental).
  --cid-version              int    - CID version. Defaults to 0 unless an
                                      option that depends on CIDv1 is passed.
                                      (experimental).
  --hash                     string - Hash function to use. Implies CIDv1 if
                                      not sha2-256. (experimental). Default:
                                      sha2-256.
  --inline                   bool   - Inline small blocks into CIDs.
                                      (experimental).
  --inline-limit             int    - Maximum block size to inline.
                                      (experimental). Default: 32.

Features

This release is primarily a bug fix release but it still includes two nice features from libp2p.

Experimental TLS1.3 support

Go-ipfs now has experimental TLS1.3 support. Currently, libp2p (IPFS's networking library) uses a custom TLS-like protocol we call SECIO. However, the conventional wisdom concerning custom security transports is "just don't" so we are working on replacing it with TLS1.3

To choose this protocol by default, set the Experimental.PreferTLS config variable:

> ipfs config --bool Experimental.PreferTLS true

Why TLS1.3 and not X (noise, etc.)?

  1. Libp2p allows negotiating transports so there's no reason not to add noise support to libp2p as well.
  2. TLS has wide language support which should make implementing libp2p for new languages significantly simpler.

OpenSSL Support

Go-ipfs can now (optionally) be built with OpenSSL support for improved performance when establishing connections. This is primarily useful for nodes receiving multiple inbound connections per second.

To enable openssl support, rebuild go-ipfs with:

> make build GOTAGS=openssl

CoreAPI

The CoreAPI refactor is still underway and we've made significant progress towards a usable ipfs-as-a-library constructor. Specifically, we've integrated the fx dependency injection system and are now working on cleaning up our initialization logic. This should make it easier to inject new services into a go-ipfs process without messing with the core internals.

Build: GOCC Environment Variable

Build system now uses GOCC environment variable allowing for use of specific go versions during builds.

Changelog

0.4.20 2019-04-16

We're happy to release go-ipfs 0.4.20. This release includes some critical performance and stability fixes so all users should upgrade ASAP.

This is also the first release to use go modules instead of GX. While GX has been a great way to dogfood an IPFS-based package manager, building and maintaining a custom package manager is a lot of work and we haven't been able to dedicate enough time to bring the user experience of gx to an acceptable level. You can read #5850 for some discussion on this matter.

Docker

As of this release, it's now much easier to run arbitrary IPFS commands within the docker container:

> docker run --name my-ipfs ipfs/go-ipfs:v0.4.20 config profile apply server # apply the server profile
> docker start my-ipfs # start the daemon

This release also reverts a change that caused some significant trouble in 0.4.19. If you've been running into Docker permission errors in 0.4.19, please upgrade.

WebUI

This release contains a major WebUI release with some significant improvements to the file browser and new opt-in, privately hosted, anonymous usage analytics.

Commands

As usual, we've made several changes and improvements to our commands. The most notable changes are listed in this section.

New: ipfs version deps

This release includes a new command, ipfs version deps, to list all dependencies (with versions) of the current go-ipfs build. This should make it easy to tell exactly how go-ipfs was built when tracking down issues.

New: ipfs add URL

The ipfs add command has gained support for URLs. This means you can:

  1. Add files with ipfs add URL instead of downloading the file first.
  2. Replace all uses of the ipfs urlstore command with a call to ipfs add --nocopy. The ipfs urlstore command will be deprecated in a future release.

Changed: ipfs swarm connect

The ipfs swarm connect command has a few new features:

It now marks the newly created connection as "important". This should ensure that the connection manager won't come along later and close the connection if it doesn't think it's being used.

It can now resolve /dnsaddr addresses that don't end in a peer ID. For example, you can now run ipfs swarm connect /dnsaddr/bootstrap.libp2p.io to connect to one of the bootstrap peers at random. NOTE: This could connect you to an arbitrary peer as DNS is not secure (by default). Please do not rely on this except for testing or unless you know what you're doing.

Finally, ipfs swarm connect now returns all errors on failure. This should make it much easier to debug connectivity issues. For example, one might see an error like:

Error: connect QmYou failure: dial attempt failed: 6 errors occurred:
	* <peer.ID Qm*Me> --> <peer.ID Qm*You> (/ip4/127.0.0.1/tcp/4001) dial attempt failed: dial tcp4 127.0.0.1:4001: connect: connection refused
	* <peer.ID Qm*Me> --> <peer.ID Qm*You> (/ip6/::1/tcp/4001) dial attempt failed: dial tcp6 [::1]:4001: connect: connection refused
	* <peer.ID Qm*Me> --> <peer.ID Qm*You> (/ip6/2604::1/tcp/4001) dial attempt failed: dial tcp6 [2604::1]:4001: connect: network is unreachable
	* <peer.ID Qm*Me> --> <peer.ID Qm*You> (/ip6/2602::1/tcp/4001) dial attempt failed: dial tcp6 [2602::1]:4001: connect: network is unreachable
	* <peer.ID Qm*Me> --> <peer.ID Qm*You> (/ip4/150.0.1.2/tcp/4001) dial attempt failed: dial tcp4 0.0.0.0:4001->150.0.1.2:4001: i/o timeout
	* <peer.ID Qm*Me> --> <peer.ID Qm*You> (/ip4/200.0.1.2/tcp/4001) dial attempt failed: dial tcp4 0.0.0.0:4001->200.0.1.2:4001: i/o timeout

Changed: ipfs bitswap stat

ipfs bitswap stat no longer lists bitswap partners unless the -v flag is passed. That is, it will now return:

> ipfs bitswap stat
bitswap status
	provides buffer: 0 / 256
	blocks received: 0
	blocks sent: 79
	data received: 0
	data sent: 672706
	dup blocks received: 0
	dup data received: 0 B
	wantlist [0 keys]
	partners [197]

Instead of:

> ipfs bitswap stat -v
bitswap status
	provides buffer: 0 / 256
	blocks received: 0
	blocks sent: 79
	data received: 0
	data sent: 672706
	dup blocks received: 0
	dup data received: 0 B
	wantlist [0 keys]
	partners [203]
		QmNQTTTRCDpCYCiiu6TYWCqEa7ShAUo9jrZJvWngfSu1mL
		QmNWaxbqERvdcgoWpqAhDMrbK2gKi3SMGk3LUEvfcqZcf4
		QmNgSVpgZVEd41pBX6DyCaHRof8UmUJLqQ3XH2qNL9xLvN
        ... omitting 200 lines ...

Changed: ipfs repo stat --human

The --human flag in the ipfs repo stat command now intelligently picks a size unit instead of always using MiB.

Changed: ipfs resolve (ipfs dns, ipfs name resolve)

All of the resolve commands now:

  1. Resolve recursively (up to 32 steps) by default to better match user expectations (these commands used to be non-recursive by default). To turn recursion off, pass -r false.
  2. When resolving non-recursively, these commands no longer fail when partially resolving a name. Instead, they simply return the intermediate result.

Changed: ipfs files flush

The ipfs files flush command now returns the CID of the flushed file.

Performance And Reliability

This release has the usual collection of performance and reliability improvements.

Badger Memory Usage

Those of you using the badger datastore should notice reduced memory usage in this release due to some upstream changes. Badger still uses significantly more memory than the default datastore configuration but this will hopefully continue to improve.

Bitswap

We fixed some critical CPU utilization regressions in bitswap for this release. If you've been noticing CPU regressions in go-ipfs 0.4.19, especially when running a public gateway, upgrading to 0.4.20 will likely fix them.

Relays

After AutoRelay was introduced in go-ipfs 0.4.19, the number of peers connecting through relays skyrocketed to over 120K concurrent peers. This highlighted some performance issues that we've now fixed in this release. Specifically:

  • We've significantly reduced the amount of memory allocated per-peer.
  • We've fixed a bug where relays might, in rare cases, try to actively dial a peer to relay traffic. By default, relays only forward traffic between peers already connected to the relay.
  • We've fixed quite a number of performance issues that only show up when rapidly forming new connections. This will actually help all nodes but will especially help relays.

If you've enabled relay hop (Swarm.EnableRelayHop) in go-ipfs 0.4.19 and it hasn't burned down your machine yet, this release should improve things significantly. However, relays are still under heavy load so running an open relay will continue to be resource intensive.

We're continuing to investigate this issue and have a few more patches on the way that, unfortunately, won't make it into this release.

Panics

We've fixed two notable panics in this release:

  • We've fixed a frequent panic in the DHT.
  • We've fixed an occasional panic in the experimental QUIC transport.

Content Routing

IPFS announces and finds content by sending and retrieving content routing ("provider") records to and from the DHT. Unfortunately, sending out these records can be quite resource intensive.

This release has two changes to alleviate this: a reduced number of initial provide workers and a persistent provider queue.

We've reduced the number of parallel initial provide workers (workers that send out provider records when content is initially added to go-ipfs) from 512 to 6. Each provide request (currently, due to some issues in our DHT) tries to establish hundreds of connections, significantly impacting the performance of go-ipfs and crashing some routers.

We've introduced a new persistent provider queue for files added via ipfs add and ipfs pin add. When new directory trees are added to go-ipfs, go-ipfs will add the root/final CID to this queue. Then, in the background, go-ipfs will walk the queue, sequentially sending out provider records for each CID.

This ensures that root CIDs are sent out as soon as possible and are sent even when files are added when the go-ipfs daemon isn't running.

By example, let's add a directory tree to go-ipfs:

> # We're going to do this in "online" mode first so let's start the daemon.
> ipfs daemon &
...
Daemon is ready
> # Now, we're going to create a directory to add.
> mkdir foo
> for i in {0..1000}; do echo do echo $i > foo/$i; done
> # finally, we're going to add it.
> ipfs add -r foo
added QmUQcSjQx2bg4cSe2rUZyQi6F8QtJFJb74fWL7D784UWf9 foo/0
...
added QmQac2chFyJ24yfG2Dfuqg1P5gipLcgUDuiuYkQ5ExwGap foo/990
added QmQWwz9haeQ5T2QmQeXzqspKdowzYELShBCLzLJjVa2DuV foo/991
added QmQ5D4MtHUN4LTS4n7mgyHyaUukieMMyCfvnzXQAAbgTJm foo/992
added QmZq4n4KRNq3k1ovzxJ4qdQXZSrarfJjnoLYPR3ztHd7EY foo/993
added QmdtrsuVf8Nf1s1MaSjLAd54iNqrn1KN9VoFNgKGnLgjbt foo/994
added QmbstvU9mnW2hsE94WFmw5WbrXdLTu2Sf9kWWSozrSDscL foo/995
added QmXFd7f35gAnmisjfFmfYKkjA3F3TSpvUYB9SXr6tLsdg8 foo/996
added QmV5BxS1YQ9V227Np2Cq124cRrFDAyBXNMqHHa6kpJ9cr6 foo/997
added QmcXsccUtwKeQ1SuYC3YgyFUeYmAR9CXwGGnT3LPeCg5Tx foo/998
added Qmc4mcQcpaNzyDQxQj5SyxwFg9ZYz5XBEeEZAuH4cQirj9 foo/999
added QmXpXzUhcS9edmFBuVafV5wFXKjfXkCQcjAUZsTs7qFf3G foo

In 0.4.19, we would have sent out provider records for files foo/{0..1000} before sending out a provider record for foo. If you were ask a friend to download /ipfs/QmUQcSjQx2bg4cSe2rUZyQi6F8QtJFJb74fWL7D784UWf9, they would (baring other issues) be able to find it pretty quickly as this is the first CID you'll have announced to the network. However, if you ask your friend to download /ipfs/QmXpXzUhcS9edmFBuVafV5wFXKjfXkCQcjAUZsTs7qFf3G/0, they'll have to wait for you to finish telling the network about every file in foo first.

In 0.4.20, we immediately tell the network about QmXpXzUhcS9edmFBuVafV5wFXKjfXkCQcjAUZsTs7qFf3G (the foo directory) as soon as we finish adding the directory to go-ipfs without waiting to finish announcing foo/{0..1000}. This is especially important in this release because we've drastically reduced the number of provide workers.

The second benefit is that this queue is persistent. That means go-ipfs won't forget to send out this record, even if it was offline when the content was initially added. NOTE: go-ipfs does continuously re-send provider records in the background twice a day, it just might be a while before it gets around to sending one out any specific one.

Bitswap

Bitswap now periodically re-sends its wantlist to connected peers. This should help work around some race conditions we've seen in bitswap where one node wants a block but the other doesn't know for some reason.

You can track this issue here: ipfs#5183.

Improved NAT Traversal

While NATs are still p2p enemy #1, this release includes slightly improved support for traversing them.

Specifically, this release now:

  1. Better detects the "gateway" NAT, even when multiple devices on the network claim to be NATs.
  2. Better guesses the external IP address when port mapping, even when the gateway lies.

Reduced AutoRelay Boot Time

The experimental AutoRelay feature can now detect NATs much faster as we've reduced initial NAT detection delay to 15 seconds. There's still room for improvement but this should make nodes that have enabled this feature dialable earlier on start.

Changelogs

0.4.19 2019-03-01

We're happy to announce go 0.4.19. This release contains a bunch of important fixes and a slew of new and improved features. Get pumped and upgrade ASAP to benefit from all the new goodies! 🎁

Features

🔌 Initializing With Random Ports

Go-ipfs can now be configured to listen on a random but stable port (across restarts) using the new randomports configuration profile. This should be helpful when testing and/or running multiple go-ipfs instances on a single machine.

To initialize a go-ipfs instance with a randomly chosen port, run:

> ipfs init --profile=randomports

👂 Gateway Directory Listing

IPNS (and/or DNSLink) directory listings on the gateway, e.g. https://ipfs.io/ipns/dist.ipfs.io/go-ipfs/, will now display the ipfs hash of the current directory. This way users can more easily create permanent links to otherwise mutable data.

📡 AutoRelay and AutoNAT

This release introduces two new experimental features (courtesy of libp2p): AutoRelay and AutoNAT.

AutoRelay is a new service that automatically chooses a public relay when it detects that the go-ipfs node is behind a NAT. While relaying connections through a third-party node isn't the most efficient way to route around NATs, it's a reliable fallback.

To enable AutoRelay, set the Swarm.EnableAutoRelay option in the config.

AutoNAT is the service AutoRelay uses to detect if the node is behind a NAT. You don't have to set any special config flags to enable it.

In this same config section, you may also notice options like EnableRelayHop, EnableAutoNATService, etc. You do not need to enable these:

  • EnableRelayHop -- Allow other nodes to use your node as a relay (disabled by default).
  • EnableAutoNATService -- Help other nodes detect if they're behind a NAT (disabled by default).

📵 Offline Operation

There are two new "offline" features in this release: a global --offline flag and an option to configure the gateway to not fetch files.

Most go-ipfs commands now support the --offline flag. This causes IPFS to avoid network operations when performing the requested operation. If you've ever used the --local flag, the --offline flag is the (almost) universally supported replacement.

For example:

  • If the daemon is started with ipfs daemon --offline, it won't even connect to the network. (note: this feature isn't new, just an example).
  • ipfs add --offline some_file won't send out provider records.
  • ipfs cat --offline Qm... won't fetch any blocks from the network.
  • ipfs block stat --offline Qm... is a great way to tell if a block is locally available.

Note: It doesn't yet work with the refs, urlstore, or tar commands (#6002).

On to the gateway, there's a new Gateway.NoFetch option to configure the gateway to only serve locally present files. This makes it possible to run an IPFS node as a gateway to serve content of your choosing without acting like a public proxy. 🤫

📍 Adding And Pinning Content

There's a new --pin flag for both ipfs block put and ipfs urlstore add to match the --pin flag in ipfs add. This allows one to atomically add and pin content with these APIs.

NOTE 1: For ipfs urlstore add, --pin has been enabled by default to match the behavior in ipfs add. However, ipfs block put does not pin by default to match the current behavior.

NOTE 2: If you had previously used the urlstore and weren't explicitly pinning content after adding it, it isn't pinned and running the garbage collector will delete it. While technically documented in the ipfs urlstore add helptext, this behavior was non-obvious and bears mentioning.

🗂 File Listing

The ipfs ls command has two significant changes this release: it reports file sizes instead of dag sizes and has gained a new --stream flag.

First up, ipfs ls now reports file sizes instead of dag sizes. Previously, for historical reasons, ipfs ls would report the size of a file/directory as seen by IPFS including all the filesystem datastructures and metadata. However, this meant that ls -l and ipfs ls would print different sizes:

> ipfs ls /ipfs/QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv

QmZTR5bcpQD7cFgTorqxZDYaew1Wqgfbd2ud9QqGPAkK2V 1688 about
QmYCvbfNbCwFR45HiNP45rwJgvatpiW38D961L5qAhUM5Y 200  contact
QmY5heUM5qgRubMDD1og9fhCPA6QdkMp3QCwd4s7gJsyE7 322  help
QmejvEPop4D7YUadeGqYWmZxHhLc4JBUCzJJHWMzdcMe2y 12   ping
QmXgqKTbzdh83pQtKFb19SpMCpDDcKR2ujqk3pKph9aCNF 1692 quick-start
QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB 1102 readme
QmQ5vhrL7uv6tuoN9KeVBwd4PwfQkXdVVmDLUZuTNxqgvm 1173 security-notes

> ipfs get /ipfs/QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv
Saving file(s) to QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv
 6.39 KiB / 6.39 KiB [================================] 100.00% 0s

> ls -l QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv
total 28
-rw------- 1 user group 1677 Feb 14 17:03 about
-rw------- 1 user group  189 Feb 14 17:03 contact
-rw------- 1 user group  311 Feb 14 17:03 help
-rw------- 1 user group    4 Feb 14 17:03 ping
-rw------- 1 user group 1681 Feb 14 17:03 quick-start
-rw------- 1 user group 1091 Feb 14 17:03 readme
-rw------- 1 user group 1162 Feb 14 17:03 security-notes

This is now no longer the case. ipfs ls and ls -l now return the same sizes. 🙌

Second up, ipfs ls now has a new --stream flag. In IPFS, very large directories (e.g., Wikipedia) are split up into multiple chunks (shards) as there are too many entries to fit in a single block. Unfortunately, ipfs ls buffers the entire file list in memory and then sorts it. This means that ipfs ls /ipfs/QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco/wiki (wikipedia) will take a very long time to return anything (it'll also use quite a bit of memory).

However, the new --stream flag makes it possible to stream a directory listing as new chunks are fetched from the network. To test this, you can run ipfs ls --stream --size=false --resolve-type=false /ipfs/QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco/wiki. You probably won't want to wait for that command to finish, Wikipedia has a lot of entries. 😉

🔁 HTTP Proxy

This release sees a new (experimental) feature contributed by our friends at Peergos: HTTP proxy over libp2p. When enabled, the local gateway can act as an HTTP proxy and forward HTTP requests to libp2p peers. When combined with the ipfs p2p command, users can use this to expose HTTP services to other go-ipfs nodes via their gateways. For details, check out the documentation.

Performance And Reliability

This release introduces quite a few performance/reliability improvements and, as usual, fixes several memory leaks. Below is a non-exhaustive list of noticeable changes.

📞 DHT

This release includes an important DHT fix that should significantly:

  1. Reduce dialing.
  2. Speed up DHT queries.
  3. Improve performance of the gateways.

Basically, in the worst case, a DHT query would turn into a random walk of the entire IPFS network. Yikes!

Relevant PR: libp2p/go-libp2p-kad-dht#237

🕸 Bitswap

Bitswap sessions have improved and are now used for all requests. Sessions allow us to group related content and ask peers most likely to have the content instead of broadcasting the request to all connected peers. This gives us two significant benefits:

  1. Less wasted upload bandwidth. Instead of broadcasting which blocks we want to everyone, we can ask fewer peers thus reducing the number of requests we send out.
  2. Less wasted download bandwidth. Because we know which peers likely have content, we can ask an individual peer for a block and expect to get an answer. In the past, we'd ask every peer at the same time to optimize for latency at the expense of bandwidth (getting the same block from multiple peers). We had to do this because we had to assume that most peers didn't have the requested block.

‼️ Pubsub

This release includes some significant reliability improvements in pubsub subscription handling. If you've previously had issues with connected pubsub peers not seeing each-other's messages, please upgrade ASAP.

♻️ Reuseport

In this release, we've rewritten our previously error-prone go-reuseport library to not duplicate a significant portion of Go's low-level networking code. This was made possible by Go's new Control net.Dialer option.

In the past, our first suggestion to anyone experiencing weird resource or connectivity issues was to disable REUSEPORT (set IPFS_REUSEPORT to false). This should no longer be necessary.

🐺 Badger Datastore

Badger has reached 1.0. This release brings an audit and numerous reliability fixes. We are now reasonably confident that badger will become the default datastore in a future release. 👍

This release also adds a new Truncate configuration option for the badger datastore (enabled by default for new IPFS nodes). When enabled, badger will delete any un-synced data on start instead of simply refusing to start. This should be safe on all filesystems where the sync operation is safe and removes the need for manual intervention when restarting an IPFS node after a crash.

Assuming you initialized your badger repo with ipfs init --profile=badgerds, you can enable truncate on an existing repo by running: ipfs config --json "Datastore.Spec.child.truncate" true.

Refactors and Endeavors

🕹 Commands Library

The legacy commands library shim has now been completely removed. This won't mean much for many users but the go-ipfs team is happy to have this behind them.

🌐 Base32 CIDs

This release can now encode CIDs in responses in bases other than base58. This is primarily useful for web-browser integration as it allows us to (a) encode CIDs in a lower-case base (e.g., base32) and then use them in the origin part of URLs. The take away is: this release brings us a step closer to better browser integration.

Specifically, this release adds two flags:

  1. --cid-base: When specified, the IPFS CLI will encode all CIDv1 CIDs using the requested base.
  2. --upgrade-cidv0-in-output: When specified, the IPFS CLI will upgrade CIDv0 CIDs to CIDv1 CIDs when returning them to the user. This upgrade is necessary because CIDv0 doesn't support multibase however, it's off by default as it changes the binary representation of the CIDs (which could have unintended consequences).

🎛 CoreAPI

The work on the CoreAPI refactor (ipfs/go-ipfs#4498) has progressed leaps and bounds this release. The CoreAPI is a comprehensive programmatic interface designed to allow go-ipfs be used as a daemon or a library interchangeably.

As of this release, go-ipfs now has:

  • External interface definitions in ipfs/interface-go-ipfs-core.
  • A work-in-progress implementation (ipfs/go-ipfs-http-client) of these interfaces that uses the IPFS HTTP API. This will replace the (ipfs/go-ipfs-api) library.
  • A new plugin type "Daemon". Daemon plugins are started and stopped along with the go-ipfs daemon and are instantiated with a copy of the CoreAPI. This allows them to control and extend the go-ipfs daemon from within the daemon itself.

The next steps are:

  1. Finishing the remaining API surface area. At the moment, the two key missing parts are:
  2. Config manipulation.
  3. The ipfs files API.
  4. Finalizing the ipfs/go-ipfs-http-client implementation.
  5. Creating a simple way to construct and initialize a go-ipfs node when using go-ipfs as a library.

Changelogs

0.4.18 2018-10-26

This is probably one of the largest go-ipfs releases in recent history, 3 months in the making.

Features

The headline features this release are experimental QUIC support, the gossipsub pubsub routing algorithm, pubsub message signing, and a refactored ipfs p2p command. However, that's just scratching the surface.

QUIC

First up, on the networking front, this release has also introduced experimental support for the QUIC protocol. QUIC is a new UDP-based network transport that solves many of the long standing issues with TCP.

For us, this means (eventually):

  • Fewer local resources. TCP requires a file-descriptor per connection while QUIC (and most UDP based transports) can share a single file descriptor between all connections. This should allow us to dial faster and keep more connections open.
  • Faster connection establishment. When client authentication is included, QUIC has a three-way handshake like TCP. However, unlike TCP, this handshake brings us from all the way from 0 to a fully encrypted, authenticated, and multiplexed connection. In theory (not yet in practice), this should significantly reduce the latency of DHT queries.
  • Behaves better on lossy networks. When multiplexing multiple requests over a single TCP connection, a single dropped packet will bring the entire connection to a halt while the packet is re-transmitted. However, because QUIC handles multiplexing internally, dropping a single packets affects only the related stream.
  • Better NAT traversal. TL;DR: NAT hole-punching is significantly easier and, in many cases, more reliable with UDP than with TCP.

However, we still have a long way to go. While we encourage users to test this, the IETF QUIC protocol is still being actively developed and will change. You can find instructions for enabling it here.

Pubsub

In terms of pubsub, go-ipfs now supports the gossipsub routing algorithm and message signing.

The gossipsub routing algorithm is significantly more efficient than the current floodsub routing algorithm. Even better, it's fully backwards compatible so you can enable it and still talk to nodes using the floodsub algorithm. You can find instructions to enable gossipsub in go-ipfs here.

Messages are now signed by their authors. While signing has now been enabled by default, strict signature verification has not been and will not be for at least one release (probably multiple) to avoid breaking existing applications. You can read about how to configure this feature here.

Commands

In terms of new toys, this release introduces a new ipfs cid subcommand for working with CIDs, a completely refactored ipfs p2p command, streaming name resolution, and complete inline block support.

The new ipfs cid command allows users to both inspect CIDs and convert them between various formats and versions. For example:

# Print out the CID metadata (prefix)
> ipfs cid format -f %P QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o
cidv0-protobuf-sha2-256-32

# Get the hex sha256 hash from the CID.
> ipfs cid format -b base16 -f '0x%D' QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o
0x46d44814b9c5af141c3aaab7c05dc5e844ead5f91f12858b021eba45768b4c0e

# Convert a base58 v0 CID to a base32 v1 CID.
> ipfs cid base32 QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o
bafybeicg2rebjoofv4kbyovkw7af3rpiitvnl6i7ckcywaq6xjcxnc2mby

The refactored ipfs p2p command allows forwarding TCP streams through two IPFS nodes from one host to another. It's ssh -L but for IPFS. You can find documentation here. It's still experimental but we don't expect too many breaking changes at this point (it will very likely be stabilized in the next release). Quick summary of breaking changes:

  • We don't stop listening for local (forwarded) connections after accepting a single connection.
  • ipfs p2p stream ls output now returns more useful output, first address is always the initiator address.
  • ipfs p2p listener ls is renamed to ipfs p2p ls
  • ipfs p2p listener close is renamed to ipfs p2p close
  • Protocol names have to be prefixed with /x/ and are now just passed to libp2p as handler name. Previous version did this 'under the hood' and with /p2p/ prefix. There is a --allow-custom-protocol flag which allows you to use any libp2p handler name.
  • ipfs p2p listener open and ipfs p2p stream dial got renamed:
    • ipfs p2p listener open p2p-test /ip4/127.0.0.1/tcp/10101 new becomes ipfs p2p listen /x/p2p-test /ip4/127.0.0.1/tcp/10101
    • ipfs p2p stream dial $NODE_A_PEERID p2p-test /ip4/127.0.0.1/tcp/10102 is now ipfs p2p forward /x/p2p-test /ip4/127.0.0.1/tcp/10102 /ipfs/$NODE_A_PEERID

There is now a new flag for ipfs name resolve - --stream. When the command is invoked with the flag set, it will start returning results as soon as they are discovered in the DHT and other routing mechanisms. This enables certain applications to start prefetching/displaying data while the discovery is still running. Note that this command will likely return many outdated records before it finding and returning the latest. However, it will always return valid records (even if a bit stale).

Finally, in the previous release, we added support for extracting blocks inlined into CIDs. In this release, we've added support for creating these CIDs. You can now run ipfs add with the --inline flag to inline blocks less than or equal to 32 bytes in length into a CID, instead of writing an actual block. This should significantly reduce the size of filesystem trees with many empty directories and tiny files.

IPNS

You can now publish and resolve paths with namespaces other than /ipns and /ipfs through IPNS. Critically, IPNS can now be used with IPLD paths (paths starting with /ipld).

WebUI

Finally, this release includes the shiny updated webui. You can view it by installing go-ipfs and visiting http://localhost:5001/webui.

Performance

This release includes some significant performance improvements, both in terms of resource utilization and speed. This section will go into some technical details so feel free to skip it if you're just looking for shiny new features.

Resource Utilization

In this release, we've (a) fixed a slow memory leak in libp2p and (b) significantly reduced the allocation load. Together, these should improve both memory and CPU usage.

Datastructures

We've changed two of our most frequently used datastructures, CIDs and Multiaddrs, to reduce allocation load.

First, we now store CIDs encode as strings, instead of decoded in structs (behind pointers). In addition to being more compact, our Cid type is now a valid map key so we no longer have to encode CIDs every time we want to use them in a map/set. Allocations when inserting CIDs into maps/sets was showing up as a significant source of allocations under heavy load so this change should improve memory usage.

Second, we've changed many of our multiaddr parsing/processing/formatting functions to allocate less. Much of our DHT related-work includes processing multiaddrs so this should reduce CPU utilization when heavily using the DHT.

Streams and Yamux

Streams have always plagued us in terms of memory utilization. This was partially solved by introducing the connection manager, keeping our maximum connection count to a reasonable number but they're still a major memory sink.

This release sees two improvements on this front:

  1. A memory leak in identify has been fixed. This was slowly causing us to leak connections (locking up the memory used by the connections' streams).
  2. Yamux streams now use a buffer-pool backed, auto shrinking read buffer. Before, this read buffer would grow to its maximum size (a few megabytes) and never shrink but these buffers now shrink as they're emptied.

Bitswap Performance

Bitswap will now pack multiple small blocks into a single message thanks ipfs/go-bitswap#5. While this won't help when transferring large files (with large blocks), this should help when transferring many tiny files.

Refactors and Endeavors

This release saw yet another commands-library refactor, work towards the CoreAPI, and the first step towards reliable base32 CID support.

Commands Lib

We've completely refactored our commands library (again). While it still needs quite a bit of work, it now requires significantly less boilerplate and should be significantly more robust. The refactor immediately found two broken tests and probably fixed quite a few bugs around properly returning and handling errors.

CoreAPI

CoreAPI is a new way to interact with IPFS from Go. While it's still not final, most things you can do via the CLI or HTTP interfaces, can now be done through the new API.

Currently there is only one implementation, backed by go-ipfs node, and there are plans to start http-api backed one soon. We are also looking into creating RPC interface using this API, which could help performance in some use cases.

You can track progress in ipfs#4498

IPLD paths

We introduced new path type which introduces distinction between IPLD and IPFS (unixfs) paths. From now on paths prefixed with /ipld/ will always use IPLD link traversal and /ipfs/ will use unixfs path resolver, which takes things like shardnig into account.

Note that this is only initial support and there likely are some bugs in how the paths are handled internally, so consider this feature experimental for now.

CIDv1/Base32 Migration

Currently, IPFS is usually used in browsers by browsing to https://SOME_GATEWAY/ipfs/CID/.... There are two significant drawbacks to this approach:

  1. From a browser security standpoint, all IPFS "sites" will live under the same origin (SOME_GATEWAY).
  2. From a UX standpoint, this doesn't feel very "native" (even if the gateway is a local IPFS node).

To fix the security issue, we intend to switch IPFS gateway links https://ipfs.io/ipfs/CID to to https://CID.ipfs.dweb.link. This way, the CID will be a part of the "origin" so each IPFS website will get a separate security origin.

To fix the UX issue, we've been working on adding support for ipfs://CID/... to web browsers through our ipfs-companion add-on and some new, experimental extension APIs from Mozilla. This has the same effect of putting the CID in the URL origin but has the added benefit of looking "native".

Unfortunately, origins must be case insensitive. Currently, most CIDs users see are CIDv0 CIDs (those starting with Qm) which are always base58 encoded and are therefore case-sensitive.

Fortunately, CIDv1 (the latest CID format) supports arbitrary bases using the multibase standard. Unfortunately, IPFS has always treated equivalent CIDv0 and CIDv1 CIDs as distinct. This means that files added with CIDv0 CIDs (the default) can't be looked up using the equivalent CIDv1.

This release makes some significant progress towards solving this issue by introducing two features:

(1) The previous mentioned ipfs cid base32 command for converting CID to a case intensive encoding required by domain names. This command converts a CID to version 1 and encodes it using base32.

(2) A hack to allow locally looking up blocks associated with a CIDv0 CID using the equivalent CIDv1 CID (or the reverse). This hack will eventually be replaced with a multihash indexed blockstore, which is agnostic to both the CID version and multicodec content type.

go-ipfs changelog

Features (i.e., users take heed):

Fixes (i.e., users take note):

Regressions Fixes (fixes for bugs introduced since the last release):

Extractions:

Documentation:

Testing:

Internal:

Cleanup:

related changelogs

Changes to sub-packages go-ipfs depends on. This does not include libp2p or multiformats.

github.com/ipfs/go-log

github.com/ipfs/go-datastore

github.com/ipfs/go-cid

github.com/ipfs/go-ds-flatfs

github.com/ipfs/go-ds-measure

github.com/ipfs/go-ds-leveldb

github.com/ipfs/go-metrics-prometheus

github.com/ipfs/go-metrics-interface

github.com/ipfs/go-ipld-format

github.com/ipfs/go-ipld-cbor

github.com/ipfs/go-ipfs-cmds

github.com/ipfs/go-ipfs-cmdkit

github.com/ipfs/go-ds-badger

github.com/ipfs/go-ipfs-addr

github.com/ipfs/go-ipfs-chunker

github.com/ipfs/go-ipfs-routing

github.com/ipfs/go-ipfs-blockstore

github.com/ipfs/go-ipns

github.com/ipfs/go-bitswap

github.com/ipfs/go-cidutil

github.com/ipfs/go-ipfs-config

github.com/ipfs/go-merkledag

github.com/ipfs/go-mfs

github.com/ipfs/go-path

  • fix: don't dag.Get in ResolveToLastNode when not needed (ipfs/go-path#1)

github.com/ipfs/go-unixfs

0.4.17 2018-07-27

Ipfs 0.4.17 is a quick release to fix a major performance regression in bitswap (mostly affecting go-ipfs -> js-ipfs transfers). However, while motivated by this fix, this release contains a few other goodies that will excite some users.

The headline feature in this release is urlstore support. Urlstore is a generalization of the filestore backend that can fetch file blocks from remote URLs on-demand instead of storing them in the local datastore.

Additionally, we've added support for extracting inline blocks from CIDs (blocks inlined into CIDs using the identity hash function). However, go-ipfs won't yet create such CIDs so you're unlikely to see any in the wild.

Features:

Changes/Fixes:

Documentation:

General refactorings and internal bug fixes:

0.4.16 2018-07-13

Ipfs 0.4.16 is a fairly small release in terms of changes to the ipfs codebase, but it contains a huge amount of changes and improvements from the libraries we depend on, notably libp2p.

This release includes small a repo migration to account for some changes to the DHT. It should only take a second to run but, depending on your configuration, you may need to run it manually.

You can run a migration by either:

  1. Selecting "Yes" when the daemon prompts you to migrate.
  2. Running the daemon with the --migrate=true flag.
  3. Manually running the migration.

Libp2p

This version of ipfs contains the changes made in libp2p from v5.0.14 through v6.0.5. In that time, we have made significant changes to the codebase to allow for easier integration of future transports and modules along with the usual performance and reliability improvements. You can find many of these improvements in the libp2p 6.0 release blog post.

The primary motivation for this refactor was adding support for network transports like QUIC that have built-in support for encryption, authentication, and stream multiplexing. It will also allow us to plug-in new security transports (like TLS) without hard-coding them.

For example, our QUIC transport currently works, and can be plugged into libp2p manually (though note that it is still experimental, as the upstream spec is still in flux). Further work is needed to make enabling this inside ipfs easy and not require recompilation.

On the user-visible side of things, we've improved our dialing logic and timeouts. We now abort dials to local subnets after 5 seconds and abort all dials if the TCP handshake takes longer than 5 seconds. This should significantly improve performance in some cases as we limit the number of concurrent dials and slow dials to non-responsive peers have been known to clog the dialer, blocking dials to reachable peers. Importantly, this should improve DHT performance as it tends to spend a disproportional amount of time connecting to peers.

We have also made a few noticeable changes to the DHT: we've significantly improved the chances of finding a value on the DHT, tightened up some of our validation logic, and fixed some issues that should reduce traffic to nodes running in dhtclient mode over time.

Of these, the first one will likely see the most impact. In the past, when putting a value (e.g., an IPNS entry) into the DHT, we'd try to put the value to K peers (where K for us is 20). However, we'd often fail to connect to many of these peers so we'd end up putting the value to significantly fewer than K peers. We now try to put the value to the K peers we can actually connect to.

Finally, we've fixed JavaScript interoperability in go-multiplex, the one stream muxer that both go-libp2p and js-libp2p implement. This should significantly improve go-libp2p and js-libp2p interoperability.

Multiformats

We are also changing the way that people write 'ipfs' multiaddrs. Currently, ipfs multiaddrs look something like /ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ. However, calling them 'ipfs' multiaddrs is a bit misleading, as this is actually the multiaddr of a libp2p peer that happens to run ipfs. Other protocols built on libp2p right now still have to use multiaddrs that say 'ipfs', even if they have nothing to do with ipfs. Therefore, we are renaming them to 'p2p' multiaddrs. Moving forward, these addresses will be written as: /ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ.

This release adds support for parsing both types of addresses (.../ipfs/... and .../p2p/...) into the same network format, and the network format is remaining exactly the same. A future release will have the ipfs daemon switch to printing out addresses this way once a large enough portion of the network has upgraded.

N.B., these addresses are not related to IPFS file names (/ipfs/Qm...). Disambiguating the two was yet another motivation to switch the protocol name to /p2p/.

IPFS

On the ipfs side of things, we've started embedding public keys inside IPNS records and have enabled the Git plugin by default.

Embedding public keys inside IPNS records allows lookups to be faster as we only need to fetch the record itself (and not the public key separately). It also fixes an issue where DHT peers wouldn't store a record for a peer if they didn't have their public key already. Combined with some of the DHT and dialing fixes, this should improve the performance of IPNS (once a majority of the network updates).

Second, our public builds now include the Git plugin (in past builds, you could add it yourself, but doing so was not easy). With this, ipfs can ingest and operate over Git repositories and commit graphs directly. For more information on this, see the go-ipld-git repo.

Finally, we've included many smaller bugfixes, refactorings, improved documentation, and a good bit more. For the full details, see the changelog below.

0.4.16-rc3 2018-07-09

0.4.16-rc2 2018-07-05

0.4.16-rc1 2018-06-27

0.4.15 2018-05-09

This release is significantly smaller than the last as much of the work on improving our datastores, and other libraries libp2p has yet to be merged. However, it still includes many welcome improvements.

As with 0.4.12 and 0.4.14 (0.4.13 was a patch), this release has a negative diff-stat. Unfortunately, much of this code isn't actually going away but at least it's being moved out into separate repositories.

Much of the work that made it into this release is under the hood. We've cleaned up some code, extracted several packages into their own repositories, and made some long neglected optimizations (e.g., handling of sharded directories). Additionally, this release includes a bunch of tests for our CLI commands that should help us avoid some of the issues we've seen in the past few releases.

More visibly, thanks to @djdv's efforts, this release includes some significant Windows improvements (with more on the way). Specifically, this release includes better handling of repo lockfiles (no more ipfs repo fsck), stdin command-line support, and, last but not least, IPFS no longer writes random files with scary garbage in the drive root. To read more about future windows improvements, take a look at this blog post.

To better support low-power devices, we've added a low-power config profile. This can be enabled when initializing a repo by running ipfs init with the --profile=lowpower flag or later by running ipfs config profile apply lowpower.

Finally, with this release we have begun distributing self-contained source archives of go-ipfs and its dependencies. This should be a welcome improvement for both packagers and those living in countries with harmonized internet access.

0.4.14 2018-03-22

Ipfs 0.4.14 is a big release with a large number of improvements and bugfixes. It is also the first release of 2018, and our first release in over three months. The release took longer than expected due to our refactoring and extracting of our commands library. This refactor had two stages. The first round of the refactor disentangled the commands code from core ipfs code, allowing us to move it out into a separate repository. The code was previously very entangled with the go-ipfs codebase and not usable for other projects. The second round of the refactor had the goal of fixing several major issues around streaming outputs, progress bars, and error handling. It also paved the way for us to more easily provide an API over other transports, such as websockets and unix domain sockets. It took a while to flush out all the kinks on such a massive change. We're pretty sure we've got most of them, but if you notice anything weird, please let us know.

Beyond that, we've added a new experimental way to use IPNS. With the new pubsub IPNS resolver and publisher, you can subscribe to updates of an IPNS entry, and the owner can publish out changes in real time. With this, IPNS can become nearly instantaneous. To make use of this, simply start your ipfs daemon with the --enable-namesys-pubsub option, and all IPNS resolution and publishing will use pubsub. Note that resolving an IPNS name via pubsub without someone publishing it via pubsub will result in a fallback to using the DHT. Please give this a try and let us know how it goes!

Memory and CPU usage should see a noticeable improvement in this release. We have spent considerable time fixing excess memory usage throughout the codebase and down into libp2p. Fixes in peer tracking, bitswap allocation, pinning, and many other places have brought down both peak and average memory usage. An upgraded hashing library, base58 encoding library, and improved allocation patterns all contribute to overall lower CPU usage across the board. See the full changelist below for more memory and CPU usage improvements.

This release also brings the beginning of the ipfs 'Core API'. Once finished, the Core API will be the primary way to interact with go-ipfs using go. Both embedded nodes and nodes accessed over the http API will have the same interface. Stay tuned for future updates and documentation.

These are only a sampling of the changes that made it into this release, the full list (almost 100 PRs!) is below.

Finally, I'd like to thank everyone who contributed to this release, whether you're just contributing a typo fix or driving new features. We are really grateful to everyone who has spent their their time pushing ipfs forward.

SECURITY NOTE:

This release of ipfs disallows the usage of insecure hash functions and lengths. Ipfs does not create these insecure objects for any purpose, but it did allow manually creating them and fetching them from other peers. If you currently have objects using insecure hashes in your local ipfs repo, please remove them before updating.

Changes from rc2 to rc3

Changes from rc1 to rc2

0.4.13 2017-11-16

Ipfs 0.4.13 is a patch release that fixes two high priority issues that were discovered in the 0.4.12 release.

Bugfixes:

0.4.12 2017-11-09

Ipfs 0.4.12 brings with it many important fixes for the huge spike in network size we've seen this past month. These changes include the Connection Manager, faster batching in ipfs add, libp2p fixes that reduce CPU usage, and a bunch of new documentation.

The most critical change is the 'Connection Manager': it allows an ipfs node to maintain a limited set of connections to other peers in the network. By default (and with no config changes required by the user), ipfs nodes will now try to maintain between 600 and 900 open connections. These limits are still likely higher than needed, and future releases may lower the default recommendation, but for now we want to make changes gradually. The rationale for this selection of numbers is as follows:

  • The DHT routing table for a large network may rise to around 400 peers
  • Bitswap connections tend to be separate from the DHT
  • PubSub connections also generally are another distinct set of peers (including js-ipfs nodes)

Because of this, we selected 600 as a 'LowWater' number, and 900 as a 'HighWater' number to avoid having to clear out connections too frequently. You can configure different numbers as you see fit via the Swarm.ConnMgr field in your ipfs config file. See here for more details.

Disk utilization during ipfs add has been optimized for large files by doing batch writes in parallel. Previously, when adding a large file, users might have noticed that the add progressed by about 8MB at a time, with brief pauses in between. This was caused by quickly filling up the batch, then blocking while it was writing to disk. We now write to disk in the background while continuing to add the remainder of the file.

Other changes in this release have noticeably reduced memory consumption and CPU usage. This was done by optimising some frequently called functions in libp2p that were expensive in terms of both CPU usage and memory allocations. We also lowered the yamux accept buffer sizes which were raised over a year ago to combat a separate bug that has since been fixed.

And finally, thank you to everyone who filed bugs, tested out the release candidates, filed pull requests, and contributed in any other way to this release!

0.4.11 2017-09-14

Ipfs 0.4.11 is a larger release that brings many long-awaited features and performance improvements. These include new datastore options, more efficient bitswap transfers, greatly improved resource consumption, circuit relay support, ipld plugins, and more! Take a look at the full changelog below for a detailed list of every change.

The ipfs datastore has, until now, been a combination of leveldb and a custom git-like storage backend called 'flatfs'. This works well enough for the average user, but different ipfs usecases demand different backend configurations. To address this, we have changed the configuration file format for datastores to be a modular way of specifying exactly how you want the datastore to be structured. You will now be able to configure ipfs to use flatfs, leveldb, badger, an in-memory datastore, and more to suit your needs. See the new datastore documentation for more information.

Bitswap received some much needed attention during this release cycle. The concept of 'Bitswap Sessions' allows bitswap to associate requests for different blocks to the same underlying session, and from that infer better ways of requesting that data. In more concrete terms, parts of the ipfs codebase that take advantage of sessions (currently, only ipfs pin add) will cause much less extra traffic than before. This is done by making optimistic guesses about which nodes might be providing given blocks and not sending wantlist updates to every connected bitswap partner, as well as searching the DHT for providers less frequently. In future releases we will migrate over more ipfs commands to take advantage of bitswap sessions. As nodes update to this and future versions, expect to see idle bandwidth usage on the ipfs network go down noticeably.

The never ending effort to reduce resource consumption had a few important updates this release. First, the bitswap sessions changes discussed above will help with improving bandwidth usage. Aside from that there are two important libp2p updates that improved things significantly. The first was a fix to a bug in the dial limiter code that was causing it to not limit outgoing dials correctly. This resulted in ipfs running out of file descriptors very frequently (as well as incurring a decent amount of excess outgoing bandwidth), this has now been fixed. Users who previously received "too many open files" errors should see this much less often in 0.4.11. The second change was a memory leak in the DHT that was identified and fixed. Streams being tracked in a map in the DHT weren't being cleaned up after the peer disconnected leading to the multiplexer session not being cleaned up properly. This issue has been resolved, and now memory usage appears to be stable over time. There is still a lot of work to be done improving memory usage, but we feel this is a solid victory.

It is often said that NAT traversal is the hardest problem in peer to peer technology, we tend to agree with this. In an effort to provide a more ubiquitous p2p mesh, we have implemented a relay mechanism that allows willing peers to relay traffic for other peers who might not otherwise be able to communicate with each other. This feature is still pretty early, and currently users have to manually connect through a relay. The next step in this endeavour is automatic relaying, and research for this is currently in progress. We expect that when it lands, it will improve the perceived performance of ipfs by spending less time attempting connections to hard to reach nodes. A short guide on using the circuit relay feature can be found here.

The last feature we want to highlight (but by no means the last feature in this release) is our new plugin system. There are many different workflows and usecases that ipfs should be able to support, but not everyone wants to be able to use every feature. We could simply merge in all these features, but that causes problems for several reasons: first off, the size of the ipfs binary starts to get very large very quickly. Second, each of these different pieces needs to be maintained and updated independently, which would cause significant churn in the codebase. To address this, we have come up with a system that allows users to install plugins to the vanilla ipfs daemon that augment its capabilities. The first of these plugins are a git plugin that allows ipfs to natively address git objects and an ethereum plugin that lets ipfs ingest and operate on all ethereum blockchain data. Soon to come are plugins for the bitcoin and zcash data formats. In the future, we will be adding plugins for other things like datastore backends and specialized libp2p network transports. You can read more on this topic in Plugin docs

In order to simplify its integration with fs-repo-migrations, we've switched the ipfs/go-ipfs docker image from a musl base to a glibc base. For most users this will not be noticeable, but if you've been building your own images based off this image, you'll have to update your dockerfile. We recommend a multi-stage dockerfile, where the build stage is based off of a regular Debian or other glibc-based image, and the assembly stage is based off of the ipfs/go-ipfs image, and you copy build artifacts from the build stage to the assembly stage. Note, if you are using the docker image and see a deprecation message, please update your usage. We will stop supporting the old method of starting the dockerfile in the next release.

Finally, I would like to thank all of our contributors, users, supporters, and friends for helping us along the way. Ipfs would not be where it is without you.

0.4.10 - 2017-06-27

Ipfs 0.4.10 is a patch release that contains several exciting new features, bugfixes and general improvements. Including new commands, easier corruption recovery, and a generally cleaner codebase.

The ipfs pin command has two new subcommands, verify and update. ipfs pin verify is used to scan the repo for pinned object graphs and check their integrity. Any issues are reported back with helpful error text to make error recovery simpler. This subcommand was added to help recover from datastore corruptions, particularly if using the experimental filestore and accidentally deleting tracked files. ipfs pin update was added to make the task of keeping a large, frequently changing object graph pinned. Previously users had to call ipfs pin rm on the old pin, and ipfs pin add on the new one. The 'new' ipfs pin add call would be very expensive as it would need to verify the entirety of the graph again. The ipfs pin update command takes shortcuts, portions of the graph that were covered under the old pin are assumed to be fine, and the command skips checking them.

Next up, we have finally implemented an ipfs shutdown command so users can shut down their ipfs daemons via the API. This is especially useful on platforms that make it difficult to control processes (Android, for example), and is also useful when needing to shut down a node remotely and you do not have access to the machine itself.

ipfs add has gained a new flag; the --hash flag allows you to select which hash function to use and we have given it the ability to select blake2b-256. This pushes us one step closer to shifting over to using blake2b as the default. Blake2b is significantly faster than sha2-256, and also is conjectured to provide superior security.

We have also finally implemented a very early (and experimental) ipfs p2p. This command and its subcommands will allow you to open up arbitrary streams to other ipfs peers through libp2p. The interfaces are a little bit clunky right now, but shouldn't get in the way of anyone wanting to try building a fully peer to peer application on top of ipfs and libp2p. For more info on this command, to ask questions, or to provide feedback, head over to the feedback issue for the command.

A few other subcommands and flags were added around the API, as well as many other requested improvements. See below for the full list of changes.

0.4.9 - 2017-04-30

Ipfs 0.4.9 is a maintenance release that contains several useful bugfixes and improvements. Notably, ipfs add has gained the ability to select which CID version will be output. The common ipfs hash that looks like this: QmRjNgF2mRLDT8AzCPsQbw1EYF2hDTFgfUmJokJPhCApYP is a multihash. Multihashes allow us to specify the hashing algorithm that was used to verify the data, but it doesn't give us any indication of what format that data might be. To address that issue, we are adding another couple of bytes to the prefix that will allow us to indicate the format of the data referenced by the hash. This new format is called a Content ID, or CID for short. The previous bare multihashes will still be fully supported throughout the entire application as CID version 0. The new format with the type information will be CID version 1. To give an example, the content referenced by the hash above is "Hello Ipfs!". That same content, in the same format (dag-protobuf) using CIDv1 is zb2rhkgXZVkT2xvDiuUsJENPSbWJy7fdYnsboLBzzEjjZMRoG.

CIDv1 hashes are supported in ipfs versions back to 0.4.5. Nodes running 0.4.4 and older will not be able to load content via CIDv1 and we recommend that they update to a newer version.

There are many other use cases for CIDs. Plugins can be written to allow ipfs to natively address content from any other merkletree based system, such as git, bitcoin, zcash and ethereum -- a few systems we've already started work on.

Aside from the CID flag, there were many other changes as noted below:

0.4.8 - 2017-03-29

Ipfs 0.4.8 brings with it several improvements, bugfixes, documentation improvements, and the long awaited directory sharding code.

Currently, when too many items are added into a unixfs directory, the object gets too large and you may experience issues. To pervent this problem, and generally make working really large directories more efficient, we have implemented a HAMT structure for unixfs. To enable this feature, run:

ipfs config --json Experimental.ShardingEnabled true

And restart your daemon if it was running.

Note: With this setting enabled, the hashes of any newly added directories will be different than they previously were, as the new code will use the sharded HAMT structure for all directories. Also, nodes running ipfs 0.4.7 and earlier will not be able to access directories created with this option.

That said, please do give it a try, let us know how it goes, and then take a look at all the other cool things added in 0.4.8 below.

0.4.7 - 2017-03-15

Ipfs 0.4.7 contains several exciting new features! First off, The long awaited filestore feature has been merged, allowing users the option to not have ipfs store chunked copies of added files in the blockstore, pushing to burden of ensuring those files are not changed to the user. The filestore feature is currently still experimental, and must be enabled in your config with:

ipfs config --json Experimental.FilestoreEnabled true

before it can be used. Please see this issue for more details.

Next up, We have merged initial support for ipfs 'Private Networks'. This feature allows users to run ipfs in a mode that will only connect to other peers in the private network. This feature, like the filestore is being released experimentally, but if you're interested please try it out. Instructions for setting it up can be found here.

This release also enables support for the 'mplex' stream muxer by default. This stream multiplexing protocol was available previously via the --enable-mplex-experiment daemon flag, but has now graduated to being 'less experimental' and no longer requires the flag to use it.

Aside from those, we have a good number of bugfixes, perf improvements and new tests. Heres a list of highlights:

0.4.6 - 2017-02-21

Ipfs 0.4.6 contains several bugfixes related to migrations and also contains a few other improvements to other parts of the codebase. Notably:

0.4.5 - 2017-02-11

Changes from rc3 to rc4

Changes from rc2 to rc3

Changes from rc1 to rc2

Changes since 0.4.4

0.4.4 - 2016-10-11

This release contains an important hotfix for a bug we discovered in how pinning works. If you had a large number of pins, new pins would overwrite existing pins. Apart from the hotfix, this release is equal to the previous release 0.4.3.

  • Fix bug in pinsets fanout, and add stress test. (@whyrusleeping, ipfs/go-ipfs#3273)

We published a detailed account of the bug and fix in a blog post.

0.4.3 - 2016-09-20

There have been no changes since the last release candidate 0.4.3-rc4. \o/

0.4.3-rc4 - 2016-09-09

This release candidate fixes issues in Bitswap and the ipfs add command, and improves testing. We plan for this to be the last release candidate before the release of go-ipfs v0.4.3.

With this release candidate, we're also moving go-ipfs to Go 1.7, which we expect will yield improvements in runtime performance, memory usage, build time and size of the release binaries.

  • Require Go 1.7. (@whyrusleeping, @Kubuxu, @lgierth, ipfs/go-ipfs#3163)
    • For this purpose, switch Docker image from Alpine 3.4 to Alpine Edge.
  • Fix cancellation of Bitswap wantlist entries. (@whyrusleeping, ipfs/go-ipfs#3182)
  • Fix clearing of active state of Bitswap provider queries. (@whyrusleeping, ipfs/go-ipfs#3169)
  • Fix a panic in the DHT code. (@Kubuxu, ipfs/go-ipfs#3200)
  • Improve handling of Identity field in ipfs config command. (@Kubuxu, @whyrusleeping, ipfs/go-ipfs#3141)
  • Fix explicit adding of symlinked files and directories. (@kevina, ipfs/go-ipfs#3135)
  • Fix bash auto-completion of ipfs daemon --unrestricted-api option. (@lgierth, ipfs/go-ipfs#3159)
  • Introduce a new timeout tool for tests to avoid licensing issues. (@Kubuxu, ipfs/go-ipfs#3152)
  • Improve output for migrations of fs-repo. (@lgierth, ipfs/go-ipfs#3158)
  • Fix info notice of commands taking input from stdin. (@Kubuxu, ipfs/go-ipfs#3134)
  • Bring back a few tests for stdin handling of ipfs cat and ipfs add. (@Kubuxu, ipfs/go-ipfs#3144)
  • Improve sharness tests for ipfs repo verify command. (@whyrusleeping, ipfs/go-ipfs#3148)
  • Improve sharness tests for CORS headers on the gateway. (@Kubuxu, ipfs/go-ipfs#3142)
  • Improve tests for pinning within ipfs files. (@kevina, ipfs/go-ipfs#3151)
  • Improve tests for the automatic raising of file descriptor limits. (@whyrusleeping, ipfs/go-ipfs#3149)

0.4.3-rc3 - 2016-08-11

This release candidate fixes a panic that occurs when input from stdin was expected, but none was given: ipfs/go-ipfs#3050

0.4.3-rc2 - 2016-08-04

This release includes bugfixes and fixes for regressions that were introduced between 0.4.2 and 0.4.3-rc1.

  • Regressions
    • Fix daemon panic when there is no multipart input provided over the HTTP API. (@whyrusleeping, ipfs/go-ipfs#2989)
    • Fix ipfs refs --edges not printing edges. (@Kubuxu, ipfs/go-ipfs#3007)
    • Fix progress option for ipfs add defaulting to true on the HTTP API. (@whyrusleeping, ipfs/go-ipfs#3025)
    • Fix erroneous printing of stdin reading message. (@whyrusleeping, ipfs/go-ipfs#3033)
    • Fix panic caused by passing --mount and --offline flags to ipfs daemon. (@Kubuxu, ipfs/go-ipfs#3022)
    • Fix symlink path resolution on windows. (@Kubuxu, ipfs/go-ipfs#3023)
    • Add in code to prevent issue 3032 from crashing the daemon. (@whyrusleeping, ipfs/go-ipfs#3037)

0.4.3-rc1 - 2016-07-23

This is a maintenance release which comes with a couple of nice enhancements, and improves the performance of Storage, Bitswap, as well as Content and Peer Routing. It also introduces a handful of new commands and options, and fixes a good bunch of bugs.

This is the first Release Candidate. Unless there are vulnerabilities or regressions discovered, the final 0.4.3 release will happen about one week from now.

0.4.2 - 2016-05-17

This is a patch release which fixes performance and networking bugs in go-libp2p, You should see improvements in CPU and RAM usage, as well as speed of object lookups. There are also a few other nice improvements.

  • Notable Fixes

    • Set a deadline for dialing attempts. This prevents a node from accumulating failed connections. (@whyrusleeping)
    • Avoid unnecessary string/byte conversions in go-multihash. (@whyrusleeping)
    • Fix a deadlock around the yamux stream muxer. (@whyrusleeping)
    • Fix a bug that left channels open, causing hangs. (@whyrusleeping)
    • Fix a bug around yamux which caused connection hangs. (@whyrusleeping)
    • Fix a crash caused by nil multiaddrs. (@whyrusleeping)

  • Enhancements

    • Add NetBSD support. (@erde74)
    • Set Cache-Control: immutable on /ipfs responses. (@kpcyrd)
    • Have ipfs init optionally accept a default configuration from stdin. (@sivachandran)
    • Add ipfs log ls command for listing logging subsystems. (@hsanjuan)
    • Allow bitswap to read multiple messages per stream. (@whyrusleeping)
    • Remove make toolkit_upgrade step. (@chriscool)

  • Documentation

    • Add a debug-guidelines document. (@richardlitt)
    • Update the contribute document. (@richardlitt)
    • Fix documentation of many ipfs commands. (@richardlitt)
    • Fall back to ShortDesc if LongDesc is missing. (@Kubuxu)

  • Removals

    • Remove -f option from ipfs init command. (@whyrusleeping)

  • Bugfixes

    • Fix ipfs object patch argument handling and validation. (@jbenet)
    • Fix ipfs config edit command by running it client-side. (@Kubuxu)
    • Set default value for ipfs refs arguments. (@richardlitt)
    • Fix parsing of incorrect command and argument permutations. (@thomas-gardner)
    • Update Dockerfile to latest go1.5.4-r0. (@chriscool)
    • Allow passing IPFS_LOGGING to Docker image. (@lgierth)
    • Fix dot path parsing on Windows. (@djdv)
    • Fix formatting of ipfs log ls output. (@richardlitt)

  • General Codebase

    • Refactor Makefile. (@kevina)
    • Wire context into bitswap requests more deeply. (@whyrusleeping)
    • Use gx for iptb. (@chriscool)
    • Update gx and gx-go. (@chriscool)
    • Make blocks.Block an interface. (@kevina)
    • Silence check for Docker existance. (@chriscool)
    • Add dist_get script for fetching tools from dist.ipfs.io. (@whyrusleeping)
    • Add proper defaults to all ipfs commands. (@richardlitt)
    • Remove dead count option from ipfs pin ls. (@richardlitt)
    • Initialize pin mode strings only once. (@chriscool)
    • Add changelog for v0.4.2. (@lgierth)
    • Specify a dist.ipfs.io hash for tool downloads instead of trusting DNS. (@lgierth)

  • CI

    • Fix t0170-dht sharness test. (@chriscool)
    • Increase timeout in t0060-daemon sharness test. (@Kubuxu)
    • Have CircleCI use make deps instead of gx directly. (@whyrusleeping)

0.4.1 - 2016-04-25

This is a patch release that fixes a few bugs, and adds a few small (but not insignificant) features. The primary reason for this release is the listener hang bugfix that was shipped in the 0.4.0 release.

  • Features

    • implemented ipfs object diff (@whyrusleeping)
    • allow promises (used in get, refs) to fail (@whyrusleeping)

  • Tool changes

    • Adds 'toolkit_upgrade' to the makefile help target (@achin)

  • General Codebase

    • Use extracted go-libp2p-crypto, -secio, -peer packages (@lgierth)
    • Update go-libp2p (@lgierth)
    • Fix package manifest fields (@lgierth)
    • remove incfusever dead-code (@whyrusleeping)
    • remove a ton of unused godeps (@whyrusleeping)
    • metrics: add prometheus back (@lgierth)
    • clean up dead code and config fields (@whyrusleeping)
    • Add log events when blocks are added/removed from the blockstore (@michealmure)
    • repo: don't create logs directory, not used any longer (@lgierth)

  • Bugfixes

    • fixed ipfs name resolve --local multihash error (@pfista)
    • ipfs patch commands won't return null links field anymore (@whyrusleeping)
    • Make non recursive resolve print the result (@Kubuxu)
    • Output dirs on ipfs add -rn (@noffle)
    • update libp2p dep to fix hanging listeners problem (@whyrusleeping)
    • Fix Swarm.AddrFilters config setting with regard to /ip6 addresses (@lgierth)
    • fix dht command key escaping (@whyrusleeping)

  • Testing

    • Adds tests to make sure 'object patch' writes. (@noffle)
    • small sharness test for promise failure checking (@whyrusleeping)
    • sharness/Makefile: clean all BINS when cleaning (@chriscool)

  • Documentation

    • Fix disconnect argument description (@richardlitt)
    • Added a note about swarm disconnect (@richardlitt)
    • Also fixed syntax for comment (@richardlitt)
    • Alphabetized swarm subcmds (@richardlitt)
    • Added note to ipfs stats bw interval option (@richardlitt)
    • Small syntax changes to repo stat man (@richardlitt)
    • update log command help text (@pfista)
    • Added a long description to add (@richardlitt)
    • Edited object patch set-data doc (@richardlitt)
    • add roadmap.md (@Jeromy)
    • Adds files api cmd to helptext (@noffle)

0.4.0 - 2016-04-05

This is a major release with plenty of new features and bugfixes. It also includes breaking changes which make it incompatible with v0.3.x on the networking layer.

  • Major Changes
    • Multistream
      • The addition of multistream is a breaking change on the networking layer, but gives IPFS implementations the ability to mix and match different stream multiplexers, e.g. yamux, spdystream, or muxado. This adds a ton of flexibility on one of the lower layers of the protocol, and will help us avoid further breaking protocol changes in the future.
    • Files API
      • The new files command and API allow a program to interact with IPFS using familiar filesystem operations, namely: creating directories, reading, writing, and deleting files, listing out different directories, and so on. This feature enables any other application that uses a filesystem-like backend for storage, to use IPFS as its storage driver without having change the application logic at all.
    • Gx
      • go-ipfs now uses gx to manage its dependencies. This means that under the hood, go-ipfs's dependencies are backed by IPFS itself! It also means that go-ipfs is no longer installed using go get. Use make install instead.
  • New Features
    • Web UI
      • Update to new version which is compatible with 0.4.0. (@dignifiedquire)
    • Networking
      • Implement uTP transport. (@whyrusleeping)
      • Allow multiple addresses per configured bootstrap node. (@whyrusleeping)
    • IPNS
      • Improve IPNS resolution performance. (@whyrusleeping)
      • Have dnslink prefer TXT _dnslink.example.com, allows usage of CNAME records. (@Kubuxu)
      • Prevent ipfs name publish when /ipns is mounted. (@noffle)
    • Repo
      • Improve performance of ipfs add. (@whyrusleeping)
      • Add Datastore.NoSync config option for flatfs. (@rht)
      • Implement mark-and-sweep GC. (@whyrusleeping)
      • Allow for GC during ipfs add. (@whyrusleeping)
      • Add ipfs repo stat command. (@tmg, @diasdavid)
    • General
      • Add support for HTTP OPTIONS requests. (@lidel)
      • Add ipfs diag cmds to view active API requests (@whyrusleeping)
      • Add an IPFS_LOW_MEM environment variable which relaxes Bitswap's memory usage. (@whyrusleeping)
      • The Docker image now lives at ipfs/go-ipfs and has been completely reworked. (@lgierth)
  • Security fixes
    • The gateway path prefix added in v0.3.10 was vulnerable to cross-site scripting attacks. This release introduces a configurable list of allowed path prefixes. It's called Gateway.PathPrefixes and takes a list of strings, e.g. ["/blog", "/foo/bar"]. The v0.3.x line will not receive any further updates, so please update to v0.4.0 as soon as possible. (@lgierth)
  • Incompatible Changes
    • Install using make install instead of go get (@whyrusleeping)
    • Rewrite pinning to store pins in IPFS objects. (@tv42)
    • Bump fs-repo version to 3. (@whyrusleeping)
    • Use multistream muxer (@whyrusleeping)
    • The default for --type in ipfs pin ls is now all. (@chriscool)
  • Bug Fixes
    • Remove msgio double wrap. (@jbenet)
    • Buffer msgio. (@whyrusleeping)
    • Perform various fixes to the FUSE code. (@tv42)
    • Compute ipfs add size in background to not stall add operation. (@whyrusleeping)
    • Add option to have ipfs add include top-level hidden files. (@noffle)
    • Fix CORS checks on the API. (@rht)
    • Fix ipfs update error message. (@tomgg)
    • Resolve paths in ipfs pin rm without network lookup. (@noffle)
    • Detect FUSE unmounts and track mount state. (@noffle)
    • Fix go1.6rc2 panic caused by CloseNotify being called from wrong goroutine. (@rwcarlsen)
    • Bump DHT kvalue from 10 to 20. (@whyrusleeping)
    • Put public key and IPNS entry to DHT in parallel. (@whyrusleeping)
    • Fix panic in CLI argument parsing. (@whyrusleeping)
    • Fix range error by using larger-than-zero-length buffer. (@noffle)
    • Fix yamux hanging issue by increasing AcceptBacklog. (@whyrusleeping)
    • Fix double Transport-Encoding header bug. (@whyrusleeping)
    • Fix uTP panic and file descriptor leak. (@whyrusleeping)
  • Tool Changes
    • Add --pin option to ipfs add, which defaults to true and allows --pin=false. (@eminence)
    • Add arguments to ipfs pin ls. (@chriscool)
    • Add dns and resolve commands to read-only API. (@Kubuxu)
    • Add option to display headers for ipfs object links. (@palkeo)
  • General Codebase Changes
    • Check Golang version in Makefile. (@chriscool)
    • Improve Makefile. (@tomgg)
    • Remove dead Jenkins CI code. (@lgierth)
    • Add locking interface to blockstore. (@whyrusleeping)
    • Add Merkledag FetchGraph and EnumerateChildren. (@whyrusleeping)
    • Rename Lock/RLock to GCLock/PinLock. (@jbenet)
    • Implement pluggable datastore types. (@tv42)
    • Record datastore metrics for non-default datastores. (@tv42)
    • Allow multistream to have zero-rtt stream opening. (@whyrusleeping)
    • Refactor ipnsfs into a more generic and well tested mfs. (@whyrusleeping)
    • Grab more peers if bucket doesn't contain enough. (@whyrusleeping)
    • Use CloseNotify in gateway. (@whyrusleeping)
    • Flatten multipart file transfers. (@whyrusleeping)
    • Send updated DHT record fixes to peers who sent outdated records. (@whyrusleeping)
    • Replace go-psutil with go-sysinfo. (@whyrusleeping)
    • Use ServeContent for index.html. (@AtnNn)
    • Refactor object patch API to not store data in URL. (@whyrusleeping)
    • Use mfs for ipfs add. (@whyrusleeping)
    • Add Server header to API responses. (@Kubuxu)
    • Wire context directly into HTTP requests. (@rht)
    • Wire context directly into GetDAG operations within GC. (@rht)
    • Vendor libp2p using gx. (@whyrusleeping)
    • Use gx vendored packages instead of Godeps. (@whyrusleeping)
    • Simplify merkledag package interface to ease IPLD inclusion. (@mildred)
    • Add default option value support to commands lib. (@whyrusleeping)
    • Refactor merkledag fetching methods. (@whyrusleeping)
    • Use net/url to escape paths within Web UI. (@noffle)
    • Deprecated key.Pretty(). (@MichealMure)
  • Documentation
    • Fix and update help text for every ipfs command. (@RichardLitt)
    • Change sample API origin settings from wildcard (*) to example.com. (@Kubuxu)
    • Improve documentation of installation process in README. (@whyrusleeping)
    • Improve windows.md. (@chriscool)
    • Clarify instructions for installing from source. (@noffle)
    • Make version checking more robust. (@jedahan)
    • Assert the source code is located within GOPATH. (@whyrusleeping)
    • Remove mentions of /dns from ipfs dns command docs. (@lgierth)
  • Testing
    • Refactor iptb tests. (@chriscool)
    • Improve t0240 sharness test. (@chriscool)
    • Make bitswap tests less flaky. (@whyrusleeping)
    • Use TCP port zero for ipfs daemon in sharness tests. (@whyrusleeping)
    • Improve sharness tests on AppVeyor. (@chriscool)
    • Add a pause to fix timing on t0065. (@whyrusleeping)
    • Add support for arbitrary TCP ports to t0060-daemon.sh. (@noffle)
    • Make t0060 sharness test use TCP port zero. (@whyrusleeping)
    • Randomized ipfs stress testing via randor (@dignifiedquire)
    • Stress test pinning and migrations (@whyrusleeping)

0.3.11 - 2016-01-12

This is the final ipfs version before the transition to v0.4.0. It introduces a few stability improvements, bugfixes, and increased test coverage.

  • Features

    • Add 'get' and 'patch' to the allowed gateway commands (@whyrusleeping)
    • Updated webui version (@dignifiedquire)

  • BugFixes

    • Fix path parsing for add command (@djdv)
    • namesys: Make paths with multiple segments work. Fixes #2059 (@Kubuxu)
    • Fix up panic catching in http handler funcs (@whyrusleeping)
    • Add correct access control headers to the default api config (@dignifiedquire)
    • Fix closenotify by not sending empty file set (@whyrusleeping)

  • Tool Changes

    • Have install.sh use the full path to ipfs binary if detected (@jedahan)
    • Install daemon system-wide if on El Capitan (@jedahan)
    • makefile: add -ldflags to install and nofuse tasks (@lgierth)

  • General Codebase

    • Clean up http client code (@whyrusleeping)
    • Move api version check to header (@rht)

  • Documentation

    • Improved release checklist (@jbenet)
    • Added quotes around command in long description (@RichardLitt)
    • Added a shutdown note to daemon description (@RichardLitt)

  • Testing

    • t0080: improve last tests (@chriscool)
    • t0080: improve 'ipfs refs --unique' test (@chriscool)
    • Fix t.Fatal usage in goroutines (@chriscool)
    • Add docker testing support to sharness (@chriscool)
    • sharness: add t0300-docker-image.sh (@chriscool)
    • Included more namesys tests. (@Kubuxu)
    • Add sharness test to verify requests look good (@whyrusleeping)
    • Re-enable ipns sharness test now that iptb is fixed (@whyrusleeping)
    • Force use of ipv4 in test (@whyrusleeping)
    • Travis-CI: use go 1.5.2 (@jbenet)

0.3.10 - 2015-12-07

This patch update introduces the 'ipfs update' command which will be used for future ipfs updates along with a few other bugfixes and documentation improvements.

  • Features

    • support for 'ipfs update' to call external binary (@whyrusleeping)
    • cache ipns entries to speed things up a little (@whyrusleeping)
    • add option to version command to print repo version (@whyrusleeping)
    • Add in some more notifications to help profile queries (@whyrusleeping)
    • gateway: add path prefix for directory listings (@lgierth)
    • gateway: add CurrentCommit to /version (@lgierth)

  • BugFixes

    • set data and links nil if not present (@whyrusleeping)
    • fix log hanging issue, and implement close-notify for commands (@whyrusleeping)
    • fix dial backoff (@whyrusleeping)
    • proper ndjson implementation (@whyrusleeping)
    • seccat: fix secio context (@lgierth)
    • Add newline to end of the output for a few commands. (@nham)
    • Add fixed period repo GC + test (@rht)

  • Tool Changes

    • Allow ipfs cat on ipns path (@rht)

  • General Codebase

    • rewrite of backoff mechanism (@whyrusleeping)
    • refactor net code to use transports, in rough accordance with libp2p (@whyrusleeping)
    • disable building fuse stuff on windows (@whyrusleeping)
    • repo: remove Log config (@lgierth)
    • commands: fix description of --api (@lgierth)

  • Documentation

    • --help: Add a note on using IPFS_PATH to the footer of the helptext. (@sahib)
    • Moved email juan to ipfs/contribute (@richardlitt)
    • Added commit sign off section (@richardlitt)
    • Added a security section (@richardlitt)
    • Moved TODO doc to issue #1929 (@richardlitt)

  • Testing

    • gateway: add tests for /version (@lgierth)
    • Add gc auto test (@rht)
    • t0020: cleanup dir with bad perms (@chriscool)

Note: this commit introduces fixed-period repo gc, which will trigger gc after a fixed period of time. This feature is introduced now, disabled by default, and can be enabled with ipfs daemon --enable-gc. If all goes well, in the future, it will be enabled by default.

0.3.9 - 2015-10-30

This patch update includes a good number of bugfixes, notably, it fixes builds on windows, and puts newlines between streaming json objects for a proper ndjson format.

  • Features

    • Writable gateway enabled again (@cryptix)

  • Bugfixes

    • fix windows builds (@whyrusleeping)
    • content type on command responses default to text (@whyrusleeping)
    • add check to makefile to ensure windows builds don't fail silently (@whyrusleeping)
    • put newlines between streaming json output objects (@whyrusleeping)
    • fix streaming output to flush per write (@whyrusleeping)
    • purposely fail builds pre go1.5 (@whyrusleeping)
    • fix ipfs id (@whyrusleeping)
    • fix a few race conditions in mocknet (@whyrusleeping)
    • fix makefile failing when not in a git repo (@whyrusleeping)
    • fix cli flag orders (long, short) (@rht)
    • fix races in http cors (@miolini)
    • small webui update (some bugfixes) (@jbenet)

  • Tool Changes

    • make swarm connect return an error when it fails (@whyrusleeping)
    • Add short flag for ipfs ls --headers (v for verbose) (@rht)

  • General Codebase

    • bitswap: clean log printf and humanize dup data count (@cryptix)
    • config: update pluto's peerID (@lgierth)
    • config: update bootstrap list hostname (@lgierth)

  • Documentation

    • Pared down contribute to link to new go guidelines (@richardlitt)

  • Testing

    • t0010: add tests for 'ipfs commands --flags' (@chriscool)
    • ipns_test: fix namesys.NewNameSystem() call (@chriscool)
    • t0060: fail if no nc (@chriscool)

0.3.8 - 2015-10-09

This patch update includes changes to make ipns more consistent and reliable, symlink support in unixfs, mild performance improvements, new tooling features, a plethora of bugfixes, and greatly improved tests.

NOTICE: Version 0.3.8 also requires golang version 1.5.1 or higher.

  • Bugfixes

    • refactor ipns to be more consistent and reliable (@whyrusleeping)
    • fix 'ipfs refs' json output (@whyrusleeping)
    • fix setting null config maps (@rht)
    • fix output of dht commands (@whyrusleeping)
    • fix NAT spam dialing (@whyrusleeping)
    • fix random panics on 32 bit systems (@whyrusleeping)
    • limit total number of network fd's (@whyrusleeping)
    • fix http api content type (@WeMeetAgain)
    • fix writing of api file for port zero daemons (@whyrusleeping)
    • windows connection refused fixes (@mjanczyk)
    • use go1.5's built in trailers, no more failures (@whyrusleeping)
    • fix random bitswap hangs (@whyrusleeping)
    • rate limit fd usage (@whyrusleeping)
    • fix panic in bitswap ratelimiting (@whyrusleeping)

  • Tool Changes

    • --empty-repo option for init (@prusnak)
    • implement symlinks (@whyrusleeping)
    • improve cmds lib files processing (@rht)
    • properly return errors through commands (@whyrusleeping)
    • bitswap unwant command (@whyrusleeping)
    • tar add/cat commands (@whyrusleeping)
    • fix gzip compression in get (@klauspost)
    • bitswap stat logs wasted bytes (@whyrusleeping)
    • resolve command now uses core.Resolve (@rht)
    • add --local flag to 'name resolve' (@whyrusleeping)
    • add ipfs diag sys command for debugging help (@whyrusleeping)

  • General Codebase

    • improvements to dag editor (@whyrusleeping)
    • swarm IPv6 in default config (Baptiste Jonglez)
    • improve dir listing css (@rht)
    • removed elliptic.P224 usage (@prusnak)
    • improve bitswap providing speed (@jbenet)
    • print panics that occur in cmds lib (@whyrusleeping)
    • ipfs api check test fixes (@rht)
    • update peerstream and datastore (@whyrusleeping)
    • cleaned up tar-reader code (@jbenet)
    • write context into coreunix.Cat (@rht)
    • move assets to separate repo (@rht)
    • fix proc/ctx wiring in bitswap (@jbenet)
    • rabin fingerprinting chunker (@whyrusleeping)
    • better notification on daemon ready (@rht)
    • coreunix cat cleanup (@rht)
    • extract logging into go-log (@whyrusleeping)
    • blockservice.New no longer errors (@whyrusleeping)
    • refactor ipfs get (@rht)
    • readonly api on gateway (@rht)
    • cleanup context usage all over (@rht)
    • add xml decoding to 'object put' (@ForrestWeston)
    • replace nodebuilder with NewNode method (@whyrusleeping)
    • add metrics to http handlers (@lgierth)
    • rm blockservice workers (@whyrusleeping)
    • decompose maybeGzWriter (@rht)
    • makefile sets git commit sha on build (@CaioAlonso)

  • Documentation

    • add contribute file (@RichardLitt)
    • add go devel guide to contribute.md (@whyrusleeping)

  • Testing

    • fix mock notifs test (@whyrusleeping)
    • test utf8 with object cmd (@chriscool)
    • make mocknet conn close idempotent (@jbenet)
    • fix fuse tests (@pnelson)
    • improve sharness test quoting (@chriscool)
    • sharness tests for chunker and add-cat (@rht)
    • generalize peerid check in sharness (@chriscool)
    • test_cmp argument cleanup (@chriscool)

0.3.7 - 2015-08-02

This patch update fixes a problem we introduced in 0.3.6 and did not catch: the webui failed to work with out-of-the-box CORS configs. This has been fixed and now should work correctly. @jbenet

0.3.6 - 2015-07-30

This patch improves the resource consumption of go-ipfs, introduces a few new options on the CLI, and also fixes (yet again) windows builds.

  • Resource consumption:

    • fixed goprocess memory leak @rht
    • implement batching on datastore @whyrusleeping
    • Fix bitswap memory leak @whyrusleeping
    • let bitswap ignore temporary write errors @whyrusleeping
    • remove logging to disk in favor of api endpoint @whyrusleeping
    • --only-hash option for add to skip writing to disk @whyrusleeping

  • Tool changes

    • improved ipfs daemon output with all addresses @jbenet
    • improved ipfs id -f output, added <addrs> and \n \t support @jbenet
    • ipfs swarm addrs local now shows the local node's addrs @jbenet
    • improved config json parsing @rht
    • improved Dockerfile to use alpine linux @Luzifer @lgierth
    • improved bash completion @MichaelMure
    • Improved 404 for gateway @cryptix
    • add unixfs ls to list correct filesizes @wking
    • ignore hidden files by default @gatesvp
    • global --timeout flag @whyrusleeping
    • fix random API failures by closing resp bodies @whyrusleeping
    • ipfs swarm filters @whyrusleeping
    • api returns errors in http trailers @whyrusleeping @jbenet
    • ipfs patch learned to create intermediate nodes @whyrusleeping
    • ipfs object stat now shows Hash @whyrusleeping
    • ipfs cat now clears progressbar on exit @rht
    • ipfs add -w -r <dir> now wraps directories @jbenet
    • ipfs add -w <file1> <file2> now wraps with one dir @jbenet
    • API + Gateway now support arbitrary HTTP Headers from config @jbenet
    • API now supports CORS properly from config @jbenet
    • Deprecated: API_ORIGIN env var (use config, see ipfs daemon --help) @jbenet

  • General Codebase

    • nofuse tag for windows @Luzifer
    • improved ipfs add code @gatesvp
    • started requiring license trailers @chriscool @jbenet
    • removed CtxCloser for goprocess @rht
    • remove deadcode @lgierth @whyrusleeping
    • reduced number of logging libs to 2 (soon to be 1) @rht
    • dial address filtering @whyrusleeping
    • prometheus metrics @lgierth
    • new index page for gateway @krl @cryptix
    • move ping to separate protocol @whyrusleeping
    • add events to bitswap for a dashboard @whyrusleeping
    • add latency and bandwidth options to mocknet @heems
    • levenshtein distance cmd autosuggest @sbruce
    • refactor/cleanup of cmds http handler @whyrusleeping
    • cmds http stream reports errors in trailers @whyrusleeping

  • Bugfixes

    • fixed path resolution and validation @rht
    • fixed ipfs get -C output and progress bar @rht
    • Fixed install pkg dist bug @jbenet @Luzifer
    • Fix ipfs get silent failure @whyrusleeping
    • ipfs get tarx no longer times out @jbenet
    • ipfs refs -r -u is now correct @gatesvp
    • Fix ipfs add -w -r <dir> wrapping bugs @jbenet
    • Fixed FUSE unmount failures @jbenet
    • Fixed ipfs log tail command (api + cli) @whyrusleeping

  • Testing

    • sharness updates @chriscool
    • ability to disable secio for testing @jbenet
    • fixed many random test failures, more reliable CI @whyrusleeping
    • Fixed racey notifier failures @whyrusleeping
    • ipfs refs -r -u test cases @jbenet
    • Fix failing pinning test @jbenet
    • Better CORS + Referer tests @jbenet
    • Added reversible gc test @rht
    • Fixed bugs in FUSE IPNS tests @whyrusleeping
    • Fixed bugs in FUSE IPFS tests @jbenet
    • Added random-files tool for easier sharness tests @jbenet

  • Documentation

    • Add link to init system examples @slang800
    • Add CORS documentation to daemon init @carver (Note: this will change soon)

0.3.5 - 2015-06-11

This patch improves overall stability and performance

  • added 'object patch' and 'object new' commands @whyrusleeping
  • improved symmetric NAT avoidance @jbenet
  • move util.Key to blocks.Key @whyrusleeping
  • fix memory leak in provider store @whyrusleeping
  • updated webui to 0.2.0 @krl
  • improved bitswap performance @whyrusleeping
  • update fuse lib @cryptix
  • fix path resolution @wking
  • implement test_seq() in sharness @chriscool
  • improve parsing of stdin for commands @chriscool
  • fix 'ipfs refs' failing silently @whyrusleeping
  • fix serial dialing bug @jbenet
  • improved testing @chriscool @rht @jbenet
  • fixed domain resolving @luzifer
  • fix parsing of unwanted stdin @lgierth
  • added CORS handlers to gateway @NodeGuy
  • added ipfs daemon --unrestricted-api option @krl
  • general cleanup of dependencies

0.3.4 - 2015-05-10

  • fix ipns append bug @whyrusleeping
  • fix out of memory panic @whyrusleeping
  • add in expvar metrics @tv42
  • bitswap improvements @whyrusleeping
  • fix write-cache in blockstore @tv42
  • vendoring cleanup @cryptix
  • added launchctl plist for OSX @grncdr
  • improved Dockerfile, changed root and mount paths @ehd
  • improved pin ls output to show types @vitorbaptista

0.3.3 - 2015-04-28

This patch update fixes various issues, in particular:

  • windows support (0.3.0 had broken it)
  • commandline parses spaces correctly.
  • much improved commandline parsing by @AtnNn
  • improved dockerfile by @luzifer
  • add cmd cleanup by @wking
  • fix flatfs windows support by @tv42 and @gatesvp
  • test case improvements by @chriscool
  • ipns resolution timeout bug fix by @whyrusleeping
  • new cluster tests with iptb by @whyrusleeping
  • fix log callstack printing bug by @whyrusleeping
  • document bash completion by @dylanPowers

0.3.2 - 2015-04-22

This patch update implements multicast dns as well as fxing a few test issues.

  • implement mdns peer discovery @whyrusleeping
  • fix mounting issues in sharness tests @chriscool

0.3.1 - 2015-04-21

This patch update fixes a few bugs:

  • harden shutdown logic by @torarnv
  • daemon locking fixes by @travisperson
  • don't re-add entire dirs by @whyrusleeping
  • tests now wait for graceful shutdown by @jbenet
  • default key size is now 2048 by @jbenet

0.3.0 - 2015-04-20

We've just released version 0.3.0, which contains many performance improvements, bugfixes, and new features. Perhaps the most noticeable change is moving block storage from leveldb to flat files in the filesystem.

What to expect:

  • much faster performance

  • Repo format 2

    • moved default location from ~/.go-ipfs -> ~/.ipfs
    • renamed lock filename daemon.lock -> repo.lock
    • now using a flat-file datastore for local blocks

  • Fixed lots of bugs

    • proper ipfs-path in various commands
    • fixed two pinning bugs (recursive pins)
    • increased yamux streams window (for speed)
    • increased bitswap workers (+ env var)
    • fixed memory leaks
    • ipfs add error returns
    • daemon exit bugfix
    • set proper UID and GID on fuse mounts

  • Gateway

    • Added support for HEAD requests

  • configuration

    • env var to turn off SO_REUSEPORT: IPFS_REUSEPORT=false
    • env var to increase bitswap workers: IPFS_BITSWAP_TASK_WORKERS=n

  • other

    • bash completion is now available
    • ipfs stats bw -- bandwidth meetering

And many more things.

0.2.3 - 2015-03-01

  • Alpha Release

2015-01-31:

  • bootstrap addresses now have .../ipfs/... in format config file Bootstrap field changed accordingly. users can upgrade cleanly with:

    ipfs bootstrap >boostrap_peers
ipfs bootstrap rm --all
<install new ipfs>
<manually add .../ipfs/... to addrs in bootstrap_peers>
ipfs bootstrap add <bootstrap_peers