git.iko.soy/obelisk
on decrease-android-validity help sign in
obelisk/README.md
308 lines 14 kB history raw
1# Obelisk
3Obelisk provides an easy way to develop and deploy your [Reflex](https://github.com/reflex-frp/reflex) project as web apps and as mobile apps.
5- [Installing Obelisk](#installing-obelisk)
6- [Developing an Obelisk project](#developing-an-obelisk-project)
7 - [Hoogle](#hoogle)
8 - [Adding Packages](#adding-packages)
9 - [Adding Package Overrides](#adding-package-overrides)
10- [Deploying](#deploying)
11 - [Locally](#locally)
12 - [EC2](#ec2)
13 - [From macOS](#from-macos)
14 - [Deploying an updated version](#deploying-an-updated-version)
15- [Mobile](#mobile)
16 - [iOS](#ios)
17 - [Android](#android)
19## Installing Obelisk
201. [Install Nix](https://nixos.org/nix/).
21 If you already have Nix installed, make sure you have version 2.0 or higher. To check your current version, run `nix-env --version`.
221. Set up nix caches
23 1. If you are running NixOS, add this to `/etc/nixos/configuration.nix`:
24 ```
25 nix.binaryCaches = [ "https://cache.nixos.org/" "https://nixcache.reflex-frp.org" ];
26 nix.binaryCachePublicKeys = [ "ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=" ];
27 ```
28 and rebuild your NixOS configuration (e.g. `sudo nixos-rebuild switch`).
29 1. If you are using another operating system or linux distribution, ensure that these lines are present in your Nix configuration file (`/etc/nix/nix.conf` on most systems; [see full list](https://nixos.org/nix/manual/#sec-conf-file)):
30 ```
31 substituters = https://cache.nixos.org https://nixcache.reflex-frp.org
32 trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=
33 ```
34 * other Linux: enable sandboxing (see these [issue172](https://github.com/obsidiansystems/obelisk/issues/172#issuecomment-411507818) or [issue6](https://github.com/obsidiansystems/obelisk/issues/6) if you run into build problems)
35 ```
36 sandbox = true
37 ```
38 * MacOS: disable sandboxing (there are still some impure dependencies for now)
39 ```
40 sandbox = false
41 ```
42 then restart the nix daemon
43 ```
44 sudo launchctl stop org.nixos.nix-daemon
45 sudo launchctl start org.nixos.nix-daemon
46 ```
471. Install obelisk: `nix-env -f https://github.com/obsidiansystems/obelisk/archive/master.tar.gz -iA command`
49### Contributing to Obelisk
51When developing on obelisk itself you may launch `ghcid` for the corresponding project as follows. For example to launch ghcid for `lib/backend` project:
53```
54nix-shell -A obeliskEnvs.obelisk-backend --run "cd lib/backend && ghcid -c 'cabal new-repl'"
55```
57Or to launch ghcid for `lib/command` project:
59```
60nix-shell -A obeliskEnvs.obelisk-command --run "cd lib/command && ghcid -c 'cabal new-repl'"
61```
63### Accessing private repositories
65To allow the Nix builder to access private git repositories, you must be set up
66to access them via SSH. Follow these steps depending on the platform you need
67access to:
69- [GitHub](https://help.github.com/articles/connecting-to-github-with-ssh/)
70- [GitLab](https://docs.gitlab.com/ee/gitlab-basics/create-your-ssh-keys.html)
72## Developing an Obelisk project
74To create a new Obelisk project, go to an empty directory and run:
76```
77ob init
78```
80Obelisk leverages ghcid to provide a live-reloading server that handles both frontend and backend. To run your Obelisk app and monitor the source for changes:
82```
83ob run
84```
86Now go to http://localhost:8000 (or the address/port specified in `config/common/route`) to access your app.
88Every time you change the Haskell source files in frontend, common or backend, `ob run` will automatically recompile the modified files and reload the server. Furthermore, it will display on screen compilation errors and warnings if any.
90### Hoogle
92To enter a nix-shell from which you can run the hoogle command-line client or a hoogle server for your project:
94`nix-shell -A shells.ghc --arg withHoogle true`
96### Adding packages
98In order to add package dependencies, declare them under the build-depends field in the appropriate cabal files (backend, common, and frontend each have their own). The corresponding Nix packages will automatically be selected when building.
100### Adding package overrides
102To add a version override to any Haskell package, or to add a Haskell package that doesn't exist in the nixpkgs used by Obelisk, use the `overrides` attribute in your project's `default.nix`. For example, to use a specific version of the `aeson` package, your `default.nix` will look like:
104```nix
105# ...
106project ./. ({ pkgs, ... }: {
107# ...
108 overrides = self: super: let
109 aeson = pkgs.fetchFromGitHub {
110 owner = "obsidiansystems";
111 repo = "aeson-gadt-th";
112 rev = "ed573c2cccf54d72aa6279026752a3fecf9c1383";
113 sha256 = "08q6rnz7w9pn76jkrafig6f50yd0f77z48rk2z5iyyl2jbhcbhx3";
114 };
115 in
116 {
117 aeson = self.callCabal2nix "aeson" aeson {};
118 };
119# ...
120```
122For further information see [the Haskell section](https://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure) of nixpkgs Contributors Guide.
124## Deploying
126### Locally
128Build everything:
130```
131nix-build -A exe -o result-exe
132```
134Run the server:
136```
137cd result-exe
138./backend
139```
141### EC2
143In this section we will demonstrate how to deploy your Obelisk app to an Amazon EC2 instance.
145First create a new EC2 instance:
1471. Launch a NixOS 18.09 EC2 instance (we recommend [this AMI](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#LaunchInstanceWizard:ami=ami-009c9c3f1af480ff3))
1481. In the instance configuration wizard ensure that your instance has at least 1GB RAM and 10GB disk space.
1491. When prompted save your AWS private key (`~/myaws.pem`) somewhere safe. We'll need it later during deployment.
1501. Go to "Security Groups", select your instance's security group and under "Inbound" tab add a new rule for HTTP port 80 and 443.
152At this stage your instance should be booting and become accessible shortly. Note down the hostname of your EC2 instance.
154Now go to your Obelisk project directory (`~/code/myapp`), and initialize a deployment config (`~/code/myapp-deploy`):
155Your project directory must be "thunkable", i.e. something on which `ob thunk pack` can be called. Usually it will be a git repository whose current revision has been pushed upstream.
157```
158cd ~/code/myapp
159SERVER=ec2-35-183-22-197.ca-central-1.compute.amazonaws.com
160ROUTE=https://myapp.com # Publicly accessible route to your app
161EMAIL=myname@myapp.com
162ob deploy init \
163 --ssh-key ~/myaws.pem \
164 --hostname $SERVER \
165 --route $ROUTE \
166 --admin-email $EMAIL \
167 ~/code/myapp-deploy
168```
170NOTE: HTTPS is enabled by default; to disable https, pass `--disable-https` to the `ob deploy init` command above.
172Then go to that created deployment configuration directory, and initiate the deployment:
174```
175cd ~/code/myapp-deploy
176ob deploy push
177```
179`ob deploy push` will locally build your app and then transfer it, along with all the Nix package dependencies, via ssh to the EC2 instance. The backend will live in `/var/lib/backend`.
181At this point you are done. Your app will be accessible at `${ROUTE}`. The currently deployed version - the git commit hash of the source repo - can be found at `${ROUTE}/version`.
183### From macOS
185Deploying from macOS requires some extra setup:
187- [Install nix-darwin](https://github.com/LnL7/nix-darwin)
188- [Install docker](https://docs.docker.com/)
190Running `ob deploy push` will give you additional setup instructions.
192### Deploying an updated version
194If you'd like to deploy an updated version (with new commits) of your Obelisk app: simply go to the configuration directory, update the source thunk and push:
196```
197cd ~/code/myapp-deploy
198ob deploy update
199ob deploy push
200```
202## Mobile
203Until Obelisk offers a `ob deploy` equivalent for mobile apps, you are recommended to do it manually as follows.
205### iOS
207#### First time setup
208Development on iOS requires a computer running macOS and an iOS developer account.
209Your account must also belong to an Apple Developer Team, if you want to access developer portal links (otherwise they'll redirect to your account page).
211##### iPhone
2121. Connect the iPhone on which you'd like to run builds - this will open up iTunes.
2131. Click accept to authorize on both the computer and the iPhone.
215##### Xcode
216Install Xcode 8.2 (contains iOS SDK 10.2) and open it so that it runs its post install tool setup.
218These versions will work out of the box but iOS SDKs prior to 11.3 should also work. You can choose another installed version in `default.nix`
220More recent Xcodes should also work, as long as one of the SDKs mentioned above has been used.
221To add another SDK to your current Xcode, [download](https://developer.apple.com/download/more/) the corresponding Xcode, extract it and copy its SDK folder next to the installed one, e.g.
222```
223open -W Xcode_9.2.xip
224sudo cp -R Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.2.sdk
225```
228You can verify that you have correct versions by running
229```
230xcodebuild -showsdks
231```
233##### Certificates
234To deploy and/or package apps, you'll need to inform Apple of your development devices and permissions by
235adding credentials to the correct provisioning profile via the Apple Developer portal.
2371. Open up XCode and go to Preferences - Accounts. Select the organization
238Member role, click Manage Certificates, and add an iOS Development
239certificate.
2401. Go to [developer portal - devices](https://developer.apple.com/account/ios/device/) and add your device.
241To find your device's UDID, select it in iTunes and click the serial number.
2421. Go to [developer portal - development profiles](https://developer.apple.com/account/ios/profile/limited).
243Create a development profile and add your certificate and device.
244Click "Generate" and then download and open the profile.
246#### Building
2471. In your project's `default.nix` set values for `ios.bundleIdentifier` and `ios.bundleName`.
248Ensure that `bundleIdentifier` matches the App ID of the development profile, or that you are using a wildcard profile.
2491. Run `nix-build -A ios.frontend -o result-ios` to build the app. Find it at `result-ios/frontend.app`
251#### Deploying
2521. Connect the registered iPhone.
2531. Find your Apple Team ID in the [developer portal](https://developer.apple.com/account/#/membership).
2541. Run the deploy command with your Team ID:
255```
256result-ios/bin/deploy [TEAM_ID]
257# or in debug mode via lldb:
258result-ios/bin/deploy [TEAM_ID] -d
259```
261#### Packaging
2621. Go to [developer portal - distribution profiles](https://developer.apple.com/account/ios/profile/production).
263Create and download a distribution profile.
2641. Run the package script with your TEAM ID and your distribution profile to create a `.ipa`:
265```
266result-ios/bin/package [TEAM_ID] /path/to/output/.ipa /path/to/profile/file
267```
269#### Debugging
270It's also possible to inspect iOS WkWebView apps once they are installed in the iPhone:
2711. On the desktop, go to Safari > Preferences > Advanced and enable Develop menu.
2721. On the iPhone go to Settings > Safari > Advanced and enable Web Inspector.
2731. Open the app on the iPhone while it is connected to the desktop.
2741. In the desktop's Safari Develop menu, you should see your iPhone. Select the screen under the name of the app.
276### Android
278NOTE: Currently Android builds are only supported on Linux.
2801. In your project's `default.nix` set a suitable value for `android.applicationId` and `android.displayName`.
2811. In your project's `default.nix` pass `config.android_sdk.accept_license = true;` in the arguments to the import of of `.obelisk/impl` to indicate your acceptance of the [Android Software Development Kit License Agreement](https://developer.android.com/studio/terms), which is required to build Android apps.
2821. Run `nix-build -A android.frontend -o result-android` to build the Android app.
2831. A debug version of the app should be generated at `result-android/android-app-debug.apk`
285Now deploy the built apk file to your Android device:
2871. Enable *USB debugging* in your Android device ([instructions here](https://developer.android.com/studio/debug/dev-options))
2881. Connect the device using USB (be sure to confirm any security prompts on the device)
2891. Run the deploy script: `result-android/bin/deploy`
291Alternatively, you can deploy from an obelisk deployment directory (a directory generated post `ob deploy init ...` command) using the `ob deploy test android` command.
292This command will accomplish the following:
2941. Create a key store and apk signing key (`android_keystore.jks`)
2951. Build a Signed Android apk for your application
2961. Deploy the Signed apk to your connected Android device
298In the event that you change your key or keystore password, you will have to update your credentials within the JSON object found in `android_keytool_config.json`
300Additional documentation on java key stores can be found [here] (https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html)
302This should copy over and install the application on your device (if you see a "*signatures do not match*" error, simply uninstall the previous app from the device before retrying the deploy). The name of the installed application will be what you have specified for `android.displayName` in the `default.nix`.
304#### Releasing to Play Store
306##### Build a release version
308After having configured signing for your app, you may proceed to build a release version of the app. This is no different to how you build the non-release version, so consult the section [Android](#android) further above for exact instructions on building and deploying to your device.