coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-02-21 10:27:46 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

docs: remove snap and chocolatey packages

Browse Source 
See
https://github.com/ipfs/kubo/issues/8688
https://github.com/ipfs/kubo/issues/9341
This commit is contained in:
Marcin Rataj 2022-11-28 15:47:40 +01:00
parent 4648cb6456
commit 3b00c81c8d
4 changed files with 2 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Dockerfile
View File

@ -1,4 +1,3 @@
# Note: when updating the go minor version here, also update the go-channel in snap/snapcraft.yml
FROM golang:1.19.1-buster
LABEL maintainer="Steven Allen <steven@stebalien.com>"

23
README.md
View File

@ -216,22 +216,7 @@ $ guix package -i go-ipfs
#### Snap
> ⚠️ **SNAP USE IS DISCOURAGED**
>
> If you want something more sophisticated to escape the Snap confinement, we recommend using a different method to install Kubo so that it is not subject to snap confinement.
With snap, in any of the [supported Linux distributions](https://snapcraft.io/docs/core/install):
```
$ sudo snap install ipfs
```
The snap sets `IPFS_PATH` to `SNAP_USER_COMMON`, which is usually `~/snap/ipfs/common`. If you want to use `~/.ipfs` instead, you can bind-mount it to `~/snap/ipfs/common` like this:
```
$ sudo mount --bind ~/.ipfs ~/snap/ipfs/common
```
No longer supported, see rationale in [kubo#8688](https://github.com/ipfs/kubo/issues/8688).
#### MacPorts
@ -266,11 +251,7 @@ $ brew install --formula ipfs
#### Chocolatey
[![Chocolatey Version](https://img.shields.io/chocolatey/v/go-ipfs?color=00a4ef&label=go-ipfs&logo=windows&style=flat-square&cacheSeconds=3600)](https://chocolatey.org/packages/go-ipfs)
```Powershell
PS> choco install go-ipfs
```
No longer supported, see rationale in [kubo#9341](https://github.com/ipfs/kubo/issues/9341).
#### Scoop

2
docs/PATCH_RELEASE_TEMPLATE.md
View File

@ -24,8 +24,6 @@ This process handles patch releases from version `vX.Y.Z` to `vX.Y.Z+1` assuming
- [ ] Release published
- [ ] to [dist.ipfs.tech](https://dist.ipfs.tech)
- [ ] to [npm-go-ipfs](https://www.npmjs.com/package/go-ipfs) (should be done by [ipfs/npm-go-ipfs](https://github.com/ipfs/npm-go-ipfs), but ok to dispatch [this job](https://github.com/ipfs/npm-go-ipfs/actions/workflows/main.yml) manually)
- [ ] to [chocolatey](https://chocolatey.org/packages/go-ipfs) (should be done by [ipfs/choco-go-ipfs](https://github.com/ipfs/choco-go-ipfs/), but ok to dispatch [this job](https://github.com/ipfs/choco-go-ipfs/actions/workflows/main.yml) manually)
- [ ] to [snap](https://snapcraft.io/ipfs) (should happen automatically, see [snap/snapcraft.yaml](https://github.com/ipfs/kubo/blob/master/snap/snapcraft.yaml))
- [ ] to [github](https://github.com/ipfs/kubo/releases)
- [ ] to [arch](https://www.archlinux.org/packages/community/x86_64/go-ipfs/) (flag it out of date)
- [ ] Cut a new ipfs-desktop release

201
docs/snap.md
View File

@ -1,201 +0,0 @@
# Publishing Kubo as a snap
> Snap is the default package manager for ubuntu since the release of 20.04. This doc captures what we know about building Kubo as a snap package and publishing it to the snapstore.
The Kubo snap is defined in [snap/snapcraft.yaml](https://github.com/ipfs/go-ipfs/blob/master/snap/snapcraft.yaml). For more detail on our snapcraft.yaml see: https://github.com/ipfs-shipyard/ipfs-snap
- Kubo is published as `ipfs` to the snapcraft store, see: https://snapcraft.io/ipfs
- ipfs-desktop is published as `ipfs-desktop`, from CI, here: https://github.com/ipfs-shipyard/ipfs-desktop/blob/master/.github/workflows/snapcraft.yml
For Kubo we deliberately lean on the Canonical lauchpad.net build environment so as it simplifies creating builds for more architectures, which has been requested by user numerous times.
Linux user can install Kubo with:
```
$ snap install ipfs
```
Apps installed via Snapcraft are auto-updating by default. Snapcraft uses 'Release Channels' to let the user pick their stability level, with channels for `stable`, `candidate`, `beta` and `edge`. Snap will install the latest release from the `stable` channel by default. A user that wants to test out the bleeding edge can opt in by passing the `--edge` flag
```
$ snap install --edge ipfs
```
<img width="1072" alt="Dashboard for managaing Kubo snap release channels for go-ipfs" src="https://user-images.githubusercontent.com/58871/95761096-bcb34580-0ca3-11eb-8ce7-2496b2456335.png">
## Known issues
- `ipfs mount` fails as fusermount is not included in the snap, and cannot work from a snap as it is not able to create non-root mounts, see: https://github.com/elopio/ipfs-snap/issues/6
```console
ubuntu@primary:~$ ipfs mount
2020-07-10T09:54:17.458+0100 ERROR node node/mount_unix.go:91 error mounting: fusermount: exec: "fusermount": executable file not found in $PATH
2020-07-10T09:54:17.463+0100 ERROR node node/mount_unix.go:95 error mounting: fusermount: exec: "fusermount": executable file not found in $PATH
```
## Developing
We let launchpad.net build our snap for us, but if you need to edit the snapcraft.yml you can test it locally
### Requirements
You need `snapcraft` installed locally
```console
# ubuntu or similar
$ snap install snapcraft --classic
# macos
$ brew install snapcraft
```
### Build and test
**Build** out a snap package for Kubo by running the following from this project
```console
$ snapcraft
```
**Test** the built snap package by installing it on a system that has `snapd`
```
$ snap install ipfs_<snap details here>.snap
# then kick the tires
$ ubuntu@primary:~$ ipfs daemon
Initializing daemon...
go-ipfs version: 0.7.0-dev
```
You can test it out on mac too. By installing and using `snapcraft`, it'll pull in `multipass` which is a quick way to run an ubuntu vm, and it has a notion of a primary container, which gets nice things like automounting your home dir in the vm, so you can:
```console
# install your .snap in a multipass vm
$ multipass shell
ubuntu@primary:~$ cd ~/Home/path/to/snap/on/host/filesystem
ubuntu@primary:~$ snap install ipfs_<snap details>.snap --devmode --dangerous
ubuntu@primary:~$ ipfs daemon
Initializing daemon...
go-ipfs version: 0.7.0-dev
```
### Building in Docker
[ipfs-shipyard/ipfs-snap](https://github.com/ipfs-shipyard/ipfs-snap) includes a Dockerfile that creates an image that can build Kubo from source and package it as a snap. It starts with `snapcore/snapcraft:stable` and adds in `go` and just enough tools to allow snapcraft to build go-ipfs. It is published to dockerhub as `ipfs/ipfs-snap-builder`.
```console
$ docker run -v $(pwd):/my-snap ipfs/ipfs-snap-builder:latest sh -c "apt update && cd /my-snap && snapcraft --debug"
```
## Publishing the Snap
The following snap release channels are published automatically:
| Git branch | Snap channel |
|------------|--------------|
| `release` | `stable`
| `master` | `edge`
### Edge via snapcraft.io
The snapcraft store watches the default branch of the Kubo repo, and updates the snap for the `edge` channel. This service is configured automatically by snapcraft. It's neat, but it doesn't allow us to watch any branch other than the default.
<img width="1072" alt="Screenshot 2020-10-12 at 15 56 07" src="https://user-images.githubusercontent.com/58871/95761075-b755fb00-0ca3-11eb-99d4-95e5f42cb48a.png">
### Stable via launchpad.net
The `stable` channel is published automatically via launchpad.net. There is a mirror of the Kubo repo at https://launchpad.net/go-ipfs that is sync'd with the github repo every few hours (at canonical's leisure).
A snap build configuration called `ipfs-stable` is set up to watch the `release` branch on Kubo and publish it to the `stable` snap channel.
The key configuration points are:
```yaml
# What flavour VM to build on.
Series: infer from snapcraft.yml
Source:
Git:
# the launchpad mirror of go-ipfs
Git repository: ~ipfs/go-ipfs/+git/go-ipfs
Git branch: refs/heads/release
Automatically build when branch changes: true
Source snap channels for automatic builds:
# tell snapcraft what version of snapcraft to use when building.
# NOTE: At time of writing we use the default `core18` platform for the
# Kubo snap. If you specify others here, a build error occurs, which
# I think is mainly due to a launchpad ux bug here.
core: ""
core18: stable
core20: ""
snapcraft: stable
Automatically upload to store:
Registered store package name: ipfs
Store channels:
Risk:
Stable: true
# What architectures to build for. this selection is chosen to match the auto
# configured build provided by snapcraft for the edge channel, for neatness, so
# that all architectures that currently have builds in snap continue to get
# updates, even though some of them would be tough for use to test on.
Processors:
amd64: true
# raspi 4
arm64: true
# older raspi
armhf: true
# sure ok i guess.
i386: true
# hmmm... PowerPC!?
ppc64el: true
# wat. IBM system Z mainframes!?
s390x: true
```
![Screenshot_2020-10-12 Edit ipfs-stable Snap packages “IPFS Maintainers” team](https://user-images.githubusercontent.com/58871/95762510-b4f4a080-0ca5-11eb-8148-d208f891d202.png)
### Future work - Publish RCs to the `candidate` channel
If we wish to publish release candidates to the snap store, we can do that by creating a new snap build config
1. Find the `release-vX.X` branch in the lauchpad.net mirror of the Kubo repo.
- e.g. https://code.launchpad.net/~ipfs/go-ipfs/+git/go-ipfs/+ref/release-v0.7.0
2. Click "Create snap package"
3. Fill out the form using the same values as listed above for the stable channel, but:
- Set `Name` to `ipfs-candidate` _(this just needs to be a unique name to identify this config)_
- For `Risk` select only `Candidate` _(so the snap is published to the `Candidate` channel.)_
You can trigger a build manually to kick things off. Subsequent changes to that branch will be published as a snap automatically when when the mirror next syncs with github (every 6-12hrs)
## Who can edit this?
The `ipfs` snapcraft.io listing can be edited by
- @elopio _TBC, the original submitter, need to check about getting ownership transferred._
- @lidel
- @olizilla
You need a Canonical developer account, then ask an existing owner to add you. Access is managed here https://dashboard.snapcraft.io/snaps/ipfs/collaboration/
The launchpad.net config is managed by [**IPFS Maintainers**](https://launchpad.net/~ipfs) team, and you can request to join that team with your Canonical developer account. The list of maintainers is here: https://launchpad.net/~ipfs/+members
At the time of writing the launchpad maintainers are:
- @lidel
- @olizilla
## References
- Walkthrough of publishing a snap package via snapcraft and launchpad: https://www.youtube.com/watch?v=X_U-pcvBFrU
- For more details on the Kubo snapcraft.yaml see: https://github.com/ipfs-shipyard/ipfs-snap
- publishing to multiple channels via build.snapcraft.io: https://forum.snapcraft.io/t/maintaining-and-publishing-multiple-to-multiple-channels-via-build-snapcraft-io/12455
- How node.js manages snaps: https://github.com/ipfs/go-ipfs/issues/7679#issuecomment-695914986