All Versions
81
Latest Version
Avg Release Cycle
36 days
Latest Release
-

Changelog History
Page 5

  • v0.4.19 Changes

    March 01, 2019

    🚀 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 helpQmejvEPop4D7YUadeGqYWmZxHhLc4JBUCzJJHWMzdcMe2y 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

  • v0.4.19-rc2

    February 27, 2019

  • v0.4.18 Changes

    October 26, 2018

    🚀 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 0️⃣ 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:

  • v0.4.17 Changes

    July 27, 2018

    🚀 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.

    📄 [urlstore]: https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#ipfs-urlstore

    🔋 Features:

    🔄 Changes/Fixes:

    📚 Documentation:

    • 👌 Improve documentation about the bloomfilter config options (ipfs/go-ipfs#4924)

    🔨 General refactorings and internal bug fixes:

  • v0.4.16 Changes

    July 13, 2018

    🚀 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 0️⃣ 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.

  • v0.4.16-rc3 Changes

    July 09, 2018

  • v0.4.16-rc2 Changes

    July 05, 2018

  • v0.4.16-rc1 Changes

    June 27, 2018

  • v0.4.15 Changes

    May 09, 2018

    🚀 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.

  • v0.4.14 Changes

    March 22, 2018

    🛠 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