eeva/gRPC-haskell
1
0
Fork 0
mirror of https://github.com/unclechu/gRPC-haskell.git synced 2024-11-26 13:09:43 +01:00
Code Issues Projects Releases Wiki Activity

Remove support for stack (#116)

Browse source 
Fixes #113
This commit is contained in:
Gabriel Gonzalez 2021-01-13 15:56:23 -08:00 committed by GitHub
parent 01e138e98d
commit 641f0bab04
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 6 additions and 98 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

102
README.md
View file

@ -17,108 +17,16 @@ There is a tutorial [here](examples/tutorial/TUTORIAL.md)
Building and testing
--------------------
If you want to use `stack` on MacOS, you will need to have GRPC installed
already -- see the [Installing GRPC for `stack`](#stackgrpc) section below. Any
example build and test recipes below which use `stack` assume you have already
performed the steps described in that section.
Without `stack`, `nix-build release.nix -A grpc-haskell` will build and test the
whole thing and put the completed package into the nix store. `nix-shell` can be
used to give you a development environment where you can use the `cabal` and
`stack` toolchains for development and testing:
`nix-build release.nix -A grpc-haskell` will build and test the whole thing and
put the completed package into the nix store. `nix-shell` can be used to give
you a development environment where you can use `cabal` for development and
testing:
```bash
$ nix-shell release.nix -A grpc-haskell.env
$ nix-shell
[nix-shell]$ cabal configure --enable-tests && cabal build && cabal test
```
```bash
$ nix-shell release.nix -A grpc-haskell.env
[nix-shell]$ stack build --fast && stack test --fast
```
Note that, for `stack`, the `nix-shell` environment is only needed to run the
tests, because it uses some custom python tooling (for grpc interop
testing). You should still be able to `stack build` without using the
`nix-shell` environment at all.
NB: You can also instruct `stack` to run the tests inside the `nix-shell`
environment directly, via `stack --nix test --fast`. However, this will
frequently rebuild the custom ghc that is used in `release.nix`, so is not
recommended during develop-debug cycles (use the `cabal` path for that, or
iterate within a `nix-shell`).
Finally, since `stack` does not use `nix` for any Haskell package dependencies,
be sure to update repository references for dependent packages such as
`protobuf-wire` in both `nix/<pkg>.nix` AND in `stack.yaml`.
<a name="stackgrpc"></a>Installing GRPC for `stack` (MacOS)
-----------------------------------------------------------
If you want to use `stack` in a relatively natural and painless manner, you will
need a working installation of the GRPC C core libraries.
On MacOS, because of
issues [related](https://github.com/commercialhaskell/stack/issues/1161) to
System Integrity Protection, dependencies on the nix-built `grpc` don't seem to
work properly in the stack toolflow when `DYLD_LIBRARY_PATH` refers to the
`nix`-built `grpc` library in the nix store, so the library needs to be
installed somewhere that the loader can pick it up without `DYLD_LIBRARY_PATH`
set (e.g., in `/usr/local/lib`).
There are basically two methods to accomplish this:
1. Run `bin/install-macos-nix-grpc.sh`.
This script will build the same version of `grpc` used in `release.nix`, which
is what is used in the end-to-end system and in our CI testing flows. It then
pretends to be an impoverished version of `brew` and installs symlinks from
the nix store into `/usr/local/include/grpc` and
`/usr/local/lib/libgrpc.dylib`. It should be run manually whenever the `grpc`
dependency is updated. Note that it is intentionally destructive to any
existing `brew` installs of `grpc`.
Is it an ugly hack? Yes, but it's better than having either a rootless system
to circumvent SIP or building atop a version of `grpc` which may differ from
CI and production environments (which may be the case with `brew`-installed
grpc).
After running this script, you should be able to use `stack` normally, in
combination with a `nix-shell` environment for running the tests:
```bash
$ bin/install-macos-nix-grpc.sh
$ stack build --fast
$ stack --nix test --fast
```
1. Use `brew`
If you don't want to hack the global pathing yourself using the above script,
you can rely on homebrew to do this for you instead. However, you will need to
specify the version of the `grpc` release that you want to use.
```bash
$ brew tap grpc/grpc
$ brew edit grpc
$ brew install grpc
```
Make sure you select a release version that is reasonably close to our grpc
dependency, e.g.:
```
url "https://github.com/grpc/grpc/archive/release-0_15_0.tar.gz"
sha256 "d02235dff278869e94cb0dcb31cfea935693c6f87bd73f43d44147185e6becdd"
```
or
```
url "https://github.com/grpc/grpc/archive/v1.0.1.tar.gz"
sha256 "efad782944da13d362aab9b81f001b7b8b1458794751de818e9848c47acd4b32"
```
Using the Library
-----------------

2
release.nix
View file

@ -16,7 +16,7 @@
# If you want to build and test this repository using `nix`, you can run the
# following command:
#
# $ nix-build -A grpc-haskell release.nix
# $ nix-build --attr grpc-haskell release.nix
#
# ... but this is not recommended for normal development because this will
# rebuild the repository from scratch every time, which is extremely slow. Only