Brendan A R Sechter’s Development Blog | Freebsd

Installing SonarQube on FreeBSD

2017-02-22T20:09:23+00:00

SonarQube is a static analysis tool that supports many popular languages. It can be integrated with tools like Jenkins and JIRA. This post covers installing it on FreeBSD.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2017-02-22 20:09:23 +0000
$ uname -vm
FreeBSD 11.0-RELEASE-p1 #0 r306420: Thu Sep 29 01:43:23 UTC 2016     root@releng2.nyi.freebsd.org:/usr/obj/usr/src/sys/GENERIC  amd64

Instructions

Install sonarqube.

pkg install sonarqube

Create the database for sonarqube.

SONARQUBE_USER="sonarqube"
SONARQUBE_DATABASE="sonarqube"
SONARQUBE_PASSWORD="secret.password"

createuser "${SONARQUBE_USER}"
psql -c "ALTER USER ${SONARQUBE_USER} WITH PASSWORD '${SONARQUBE_PASSWORD}';"
createdb "${SONARQUBE_DATABASE}"
psql -c "GRANT ALL PRIVILEGES ON DATABASE ${SONARQUBE_DATABASE} TO ${SONARQUBE_USER};"

Configure sonarqube.

/usr/local/sonarqube/conf/sonar.properties partial listing

#--------------------------------------------------------------------------------------------------
# DATABASE
#
# IMPORTANT: the embedded H2 database is used by default. It is recommended for tests but not for
# production use. Supported databases are MySQL, Oracle, PostgreSQL and Microsoft SQLServer.

# User credentials.
# Permissions to create tables, indices and triggers must be granted to JDBC user.
# The schema must be created first.
sonar.jdbc.username=sonarqube
sonar.jdbc.password=secret.password

#----- Embedded Database (default)
# H2 embedded database server listening port, defaults to 9092
#sonar.embeddedDatabase.port=9092
#----- MySQL 5.6 or greater
# Only InnoDB storage engine is supported (not myISAM).
# Only the bundled driver is supported. It can not be changed.
sonar.jdbc.url=jdbc:postgresql://localhost/sonarqube

Enable sonarqube.

/etc/rc.conf partial listing

sonarqube_enable="YES"

Start sonarqube.

service sonarqube start

Alternatively, start the console by calling sonar.sh directly if you want verbose output. This can be useful when troubleshooting.

/usr/local/sonarqube/bin/freebsd/sonar.sh console

It takes a couple of minutes to start, but curl will return html if everything is working. Alternatively, direct your browser to port 9000 of the server running sonarqube.

curl localhost:9000

SonarQube can be configured from the browser.

References:

Straightforward Shell Script Command Line Argument Parsing

2017-01-25T14:27:00+00:00

This post covers a relatively straightforward method of parsing commandline arguments. All commandline arguments take the form of -p=value or –parameter=value. A safe delimeter is used internally so the value can contain an equals sign.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2017-01-25 14:27:00 +0000
$ uname -vm
FreeBSD 12.0-CURRENT #18 4f888bf(drm-next): Wed Jan 18 14:31:26 UTC 2017     root@gauntlet:/usr/obj/usr/src/sys/GENERIC  amd64

Instructions

The basic strategy looks like this, with a safe delimiter.

parse_args() {
  SAFE_DELIMITER="$(printf "\a")"
  while [ "$1" != "" ]
  do
    PARAM=$(echo $1 | cut -f1 -d=)
    VALUE=$(echo $1 | sed "s/=/${SAFE_DELIMITER}/" | cut -f2 "-d${SAFE_DELIMITER}")

    case $PARAM in
      -h | --help)
        usage
        exit
        ;;
      -v | --variable)
        G_VARIABLE="${VALUE}"
        ;;
      *)
        echo "ERROR: Unknown parameter ${PARAM}"
        usage
        exit 1
        ;;
    esac
    shift
  done
}

A complete template example looks something like this.

#!/bin/sh

set_defaults() {
  G_URL="https://www.google.com"
  G_CREDENTIALS="username:password"
}

usage() {
  set_defaults
  cat <<-EOF
./param.sh
Parameters:
  -h | --help:
    Show this help.
  -u | --url)
    URL
    Default: ${G_URL}
  -l=username:password | --login=username:password)
    Username and password login credentials.
    Default: ${G_CREDENTIALS}
EOF
}

parse_args() {
  set_defaults
  SAFE_DELIMITER="$(printf "\a")"
  while [ "$1" != "" ]
  do
    PARAM=$(echo $1 | cut -f1 -d=)
    VALUE=$(echo $1 | sed "s/=/${SAFE_DELIMITER}/" | cut -f2 "-d${SAFE_DELIMITER}")

    case $PARAM in
      -h | --help)
        usage
        exit
        ;;
      -u | --url)
        G_URL="${VALUE}"
        ;;
      -l | --login)
        G_CREDENTIALS="${VALUE}"
        ;;
      *)
        echo "ERROR: Unknown parameter ${PARAM}"
        usage
        exit 1
        ;;
    esac
    shift
  done
}

main() {
  parse_args $@
  echo "URL=${G_URL}"
  echo "CREDENTIALS=$(echo "${G_CREDENTIALS}" | sed 's/:.*/:********/')"
}

main $@

Counting Files of a Particular Type from the Command Line

2017-01-25T09:46:14+00:00

Sometimes it can be useful to know how many files of a particular type are in a directory. This post presents a single line command and a shell function that count the number of files with a given extenstion in the current directory. Directories are searched recursively. A version of the shell function in a stand alone script is also presented.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2017-01-25 09:46:14 +0000
$ uname -vm
FreeBSD 12.0-CURRENT #18 4f888bf(drm-next): Wed Jan 18 14:31:26 UTC 2017     root@gauntlet:/usr/obj/usr/src/sys/GENERIC  amd64

Instructions

The basic command to recursively tally files with a given extension looks like this.

EXTENSION=.sh
ls -lR | grep "${EXTENSION}" | wc -l

The can be used as the basis of a shell script.

countfiles.sh complete listing

#!/bin/sh

countfiles() {
  for extension in $@
  do
    count=$(ls -lR | grep "${extension}" | wc -l)
    printf "${extension}\t${count}\n"
  done
}

countfiles $@

The shell script can be used as follows.

chmod +x countfiles.sh
./countfiles.sh .java .kt .sh

Output will look something like this.

.java	     892
.kt	       2
.sh	     251

Obviously, the countfiles function can be entered in the shell or .profile. In that case it can be used as follows.

.profile partial listing

countfiles() {
  for extension in $@
  do
    count=$(ls -lR | grep "${extension}" | wc -l)
    printf "${extension}\t${count}\n"
  done
}

countfiles.sh .java .kt .sh

Obviously, the output is exactly the same as above.

Shell Script Confirmation Warning Prompt

2017-01-19T12:21:09+00:00

Sometimes scripts need to do something really destructive. It is generally a good idea to display a warning prompt and provide a way to back out before performing these destructive actions. It is also useful to provide a mechanism whereby the interactive prompt can be disabled. This post covers one solution for this problem.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2017-01-19 12:21:09 +0000
$ uname -vm
FreeBSD 12.0-CURRENT #14 f92c24b(drm-next-4.7): Fri Jan  6 19:28:21 UTC 2017     root@gauntlet:/usr/obj/usr/src/sys/GENERIC  amd64

Instructions

The following script pretends to perform a destructive action when the NUKE_ENVIRONMENT environment variable is set to true. By default, a prompt is displayed that allows the user to interactively proceed, skip the destructive action but execute the rest of the script, or abort the script.

If the FORCE environment variable is also set to true, no prompt is displayed. The script assumes the users knows what they are doing and executes the destructive action unconditionally.

warn.sh complete listing

#!/bin/sh

# case insensitive settings
NUKE_ENVIRONMENT=$(echo "${NUKE_ENVIRONMENT}" | tr '[:upper:]' '[:lower:]')
FORCE=$(echo "${FORCE}" | tr '[:upper:]' '[:lower:]')

# prompt if NUKE_ENVIRONMENT == true
# skip prompt if FORCE == true
if [ \( "true" = "${NUKE_ENVIRONMENT}" \) -a \( "true" != "${FORCE}" \) ]
then
  echo "Nuking the environment will do something really destructive."
  echo "This action can not be undone."
  while true
  do
    read -p "Do you really want to nuke the environment? [yes/no/cancel] " result
    case $result in
      [Yy]* ) NUKE_ENVIRONMENT="true"; break;;
      [Nn]* ) NUKE_ENVIRONMENT="false"; break;;
      [Cc]* ) echo "Aborting script."; exit;;
      *) echo "Please answer yes, no or cancel.";;
    esac
  done
fi

# potentially nuke the environment
if [ "true" = "${NUKE_ENVIRONMENT}" ]
then
  echo "* Do something really destructive here. *"
  echo "Nuking environment."
else
  echo "Skip nuking environment."
fi

# do everything else
echo "* Standard procedure here. *"

The script can be tested with the following commands.

chmod +x warn.sh
./warn.sh
NUKE_ENVIRONMENT=true ./warn.sh
NUKE_ENVIRONMENT=true FORCE=true ./warn.sh

This example uses environment variables directly. A production example my use command line parameters instead.

Printing the IP Address for a Device

2017-01-17T11:24:20+00:00

I often work with VMs. Sometimes I want to SSH into a physical server or a laptop. Either way I need to know the IP address of the box to get work done.

This post covers a function that can be used to print the (DHCP) IP for a device on a box you are working on. If you put it in .profile, you can log into a VM or physical box to get the IP address. You can then use that to SSH into the box.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2017-01-17 11:24:20 +0000
$ uname -vm
FreeBSD 12.0-CURRENT #14 f92c24b(drm-next-4.7): Fri Jan  6 19:28:21 UTC 2017     root@gauntlet:/usr/obj/usr/src/sys/GENERIC  amd64

Instructions

Here is an sh function that can be used to print the ip address for a device. I put it in .profile.

.profile partial listing

print_ip_address(){
  ipv4="$(ifconfig "${1}" | grep "inet " | sed -E "s/.*inet.([0-9.]*).*/\1/")"
  ipv6="$(ifconfig "${1}" | grep "inet6 " | sed -E "s/.*inet6.([0-9a-f:]*).*/\1/")"
  printf "${1}\t${ipv4:-(no ipv4)}\t${ipv6:-(no ipv6)}\n"
}

I also have this at the bottom of .profile.

.profile partial listing

hostname
print_ip_address em0
print_ip_address wlan0

When I log in, I see something like this.

my.hostname.com
em0	(no ipv4)	fe80::3e97:eff:fe34:157c
wlan0	192.168.12.34	(no ipv6)

A csh script (for FreeBSD root) that does the same thing looks something like this.

print_ip.csh complete listing

#!/bin/csh

set device = $1
set ipv4 = `ifconfig "${device}" | grep "inet " | sed -E "s/.*inet.([0-9.]*).*/\1/" | sed 's/^$/(no ipv4)/'`
set ipv6 = `ifconfig "${device}" | grep "inet6 " | sed -E "s/.*inet6.([0-9a-f:]*).*/\1/" | sed 's/^$/(no ipv6)/'`
printf "${device}\t${ipv4}\t${ipv6}\n"

Setting Up Lumina with slim in Japanese and Watching YouTube and DVDs on FreeBSD

2016-10-01T23:28:23+00:00

This post covers installing Lumina and xdm on a fresh i386 install. It also covers installing Japanese fonts and a Japanese IME. The final test is watching DVDs and YouTube videos- what a computer needs to do for my wife and kids to consider it useful.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2016-10-01 23:28:23 +0000
$ uname -vm
FreeBSD 11.0-RC3 #0 r305786: Wed Sep 14 04:19:22 UTC 2016     root@releng2.nyi.freebsd.org:/usr/obj/usr/src/sys/GENERIC  i386

Install Lumina Desktop and slim

First, do a minimal install of FreeBSD and login as root.

Make your unprivileged user a member of the wheel group. This will allow you to conveniently shutdown the computer.

pw groupmod wheel -m username

NOTE: Consider increasing FETCH_TIMEOUT and/or FETCH_RETRY in /usr/local/etc/pkg.conf if you are getting timeouts when installing packages.

/usr/local/etc/pkg.conf partial listing

FETCH_RETRY=5
FETCH_TIMEOUT=90

I use vim to edit files, so that gets installed first.

pkg install vim

lumina and slim need to be installed. The localized lumina-i18n pulls in lumina and xorg.

pkg install lumina-i18n slim

Enable slim and dbus in /etc/rc.conf. slim needs dbus to start Lumina. hald is not strictly necessary, but it tends to be enabled when running xorg. Also, if you use a mouse, make sure moused is enabled in /etc/rc.conf.

/etc/rc.conf partial listing

# xorg
slim_enable="YES"
dbus_enable="YES"
hald_enable="YES"
moused_enable="YES"

Consider enabling sshd just in case something goes horribly wrong when configuring xorg.

/etc/rc.conf partial listing

sshd_enable="YES"

Generate xorg.conf.

Xorg -configure
cp ~/xorg.conf.new /etc/X11/xorg.conf

Add the Load "freetype" to the “Module” section of /etc/X11/xorg.conf.

/etc/X11/xorg.conf partial listing

Section "Module"
        Load  "glx"
        Load  "freetype"
EndSection

Add the FontPath "/usr/local/share/fonts/dejavu/" to the “Files” section of /etc/X11/xorg.conf.

/etc/X11/xorg.conf partial listing

Section "Files"
        ModulePath   "/usr/local/lib/xorg/modules"
        FontPath     "/usr/local/share/fonts/misc/"
        FontPath     "/usr/local/share/fonts/TTF/"
        FontPath     "/usr/local/share/fonts/OTF/"
        FontPath     "/usr/local/share/fonts/Type1/"
        FontPath     "/usr/local/share/fonts/100dpi/"
        FontPath     "/usr/local/share/fonts/75dpi/"
        FontPath     "/usr/local/share/fonts/dejavu/"
EndSection

Japanese Fonts and IME

Install the Japanese fonts and IME.

pkg install japanese/font-std japanese/scim-anthy

Create the following .xinitrc for new users.

/usr/share/skel/dot.xinitrc complete listing

#!/bin/sh

# set locale
export LC_ALL=ja_JP.UTF-8
export LANGUAGE=ja_JP.UTF-8
export LANG=ja_JP.UTF-8

# set input method
export XMODIFIERS='@im=SCIM'

# execute scim as a daemon
scim -d

# key board layout
setxkbmap -layout jp

# startx
exec $1

Copy the above .xinitrc to your home directory.

USERNAME=username
cp /usr/share/skel/dot.xinitrc /home/${USERNAME}/.xinitrc

After starting xorg, consider running scim-setup to configure scim for the IME. By default, switch between kanji and romaji input with Ctrl-[SPACE].

YouTube

As root, install chromium or your broswer of choice.

pkg install chromium

As an unprivileged user start chrome and watch a YouTube video.

chrome https://www.youtube.com/watch?v=CynsucGqMtI

DVDs

First, install vlc as root.

pkg install vlc

Also install libdvdcss. The following should work.

pkg install libdvdcss

When I tried, the package was not available, so I had to build the port.

# fetch ports tree
portsnap fetch extract

# install multimedia/libdvdcss port
cd /usr/ports/multimedia/libdvdcss
make config recursive
make install clean

Add the following line to /etc/sysctl.conf.

/etc/sysctl.conf partial listing

vfs.usermount=1

Verify the device name with camcontrol. It is usually /dev/cd0.

camcontrol devlist

Next, modify /etc/sysctl.conf to make the CDROM/DVDROM mountable by unprivileged users. Use the device from the previous step.

/etc/devfs.conf partial listing

## Allow members of the operator to mount the cdrom
own　　　　/dev/cd0    root:operator
perm　　　/dev/cd0     0660

Add your unprivileged user to the operator group.

pw groupmod operator -m username

Reboot.

shutdown -r now

You should be able to mount and unmount the DVDs as your unprivileged user now.

CDROM=/dev/cd0
mkdir -p ~/media/cdrom
mount -t cd9660 "${CDROM}" ~/media/cdrom
umount ~/media/cdrom

As an your unprivileged user, insert a DVD and play it with VLC.

CDROM=/dev/cd0
vlc dvd://

References:

Installing MySQL on FreeBSD

2016-07-14T01:23:55+00:00

Sometimes it can not be avoided. MySQL needs to be installed for one reason or another. This post covers installing MySQL on FreeBSD.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2016-07-14 01:23:55 +0000
$ uname -vm
FreeBSD 11.0-ALPHA6 #0 r302384: Thu Jul  7 22:40:47 JST 2016     root@mirage.sennue.com:/usr/obj/usr/src/sys/MIRAGE_KERNEL  amd64
$ mysqladmin -u root -p version
mysqladmin  Ver 8.42 Distrib 5.7.13, for FreeBSD11.0 on amd64

Server version		5.7.13-log
Protocol version	10
*snipped some output*

Instructions

Install using packages.

pkg install mysql57-server mysql57-client

Alternatively, install using ports.

portmaster databases/mysql57-server databases/mysql57-client

Enable MySQL in rc.conf.

/etc/rc.conf partial listing

mysql_enable="YES"

Start MySQL from the command line. Note that the above rc.conf line will automatically start MySQL when the machine boots. Note that the default location for my.conf is /usr/local/etc/mysql/my.cnf.

service mysql-server start

Note that if /var/db/mysql exists and is not empty, mysql-server will fail to start the first time. Backup or remove this directory if you need to. See this blog post to track down other errors when starting mysql-server for the first time.

# Backup
mv /var/db/mysql /var/db/mysql.old

# Remove
rm -rf /var/db/mysql

Reset the password. Note that the initial password is stored in $HOME/.mysql_secret. For example, if you use mysql -u root -p the initial password is stored in /root/.mysql_secret.

mysql -u root -p -e "ALTER USER 'root'@'localhost' IDENTIFIED BY 'password';"

If upgrading from an earlier version, run mysql_upgrade. Note that the command below upgrades as the root user.

mysql_upgrade -u root -p

Uninstall with pkg.

pkg delete mysql57-server mysql57-client

Uninstall with portmaster.

portmaster -e databases/mysql57-server databases/mysql57-client

References:

Creating a Hidden Service with Phoenix and Elixir on FreeBSD

2016-03-22T06:45:48+00:00

This post is a synthesis of a couple of prior posts.

It covers configuration and deployment of simple Phoenix application as a tor hidden service. Important topics like Phoenix auth, and properly securing a hidden service are not covered.

security/tor needs to be installed.

portmaster security/tor

Phoenix, Elixir and PostgreSQL also need to be installed.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2016-03-22 06:45:48 +0000
$ uname -vm
FreeBSD 11.0-CURRENT #0 r287598: Thu Sep 10 14:45:48 JST 2015     root@:/usr/obj/usr/src/sys/MIRAGE_KERNEL  amd64
$ tor --version
Tor version 0.2.7.6.
$ curl --version
curl 7.47.0 (amd64-portbld-freebsd11.0) libcurl/7.47.0 OpenSSL/1.0.2e zlib/1.2.8
Protocols: dict file ftp ftps gopher http https imap imaps pop3 pop3s rtsp smb smbs smtp smtps telnet tftp 
Features: AsynchDNS IPv6 Largefile GSS-API Kerberos SPNEGO NTLM NTLM_WB SSL libz TLS-SRP UnixSockets 
$ mix hex.info
Hex:    0.11.3
Elixir: 1.2.3
OTP:    18.2.4
* snip *
$ mix phoenix.new -v
Phoenix v1.1.4

Creating a Sample Project

Create a new Phoenix project.

mix phoenix.new phoenix_service --no-brunch
cd phoenix_service
mix ecto.create

The sample project will be a simple memo JSON API service. A real service will almost certainly need some sort of authentication, but that is not covered in this post.

mix phoenix.gen.json Memo memos title:string body:string

Revise the web/router.ex file. The “/api” scope needs to be uncommented and the “/memos” route needs to be added.

web/router.ex

defmodule PhoenixService.Router do
  use PhoenixService.Web, :router

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
  end

  pipeline :api do
    plug :accepts, ["json"]
  end

  scope "/", PhoenixService do
    pipe_through :browser # Use the default browser stack
  
    get "/", PageController, :index
  end

  scope "/api", PhoenixService do
    pipe_through :api

    resources "/memos", MemoController, except: [:new, :edit]
  end
end

Run the migration.

mix ecto.migrate

Configure the app to only serve localhost (127.0.0.1) in config/prod.exs. Also make sure server is set to true and a dynamic port configuration is used.

config/prod.exs partial listing

config :phoenix_service, PhoenixService.Endpoint,
  http: [port: {:system, "PORT"}, ip: {127,0,0,1}], # serve localhost with dynamic port
  url: [host: "example.com", port: 80],
  cache_static_manifest: "priv/static/manifest.json", # added comma
  server: true # this line is new

Optionally, configure the IP address and add a dynamic port configuration with a default value to config/dev.exs. The above dynamic port solution is suitable for releases. The interpreted solution below is suitable for development.

config/dev.exs partial listing

  # http: [port: 4000], # old line 10
  http: [port: System.get_env("PORT") || Application.get_env(:phoenix_service, :port) || 4000, ip: {127,0,0,1}],

Tests should pass

mix test

Start the server.

mix phoenix.server

POST and GET a memo to make sure the server works. A prior post covers a shell script for conveniently interacting with this sample app.

# POST new
curl -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "New Title", "body": "This is the new memo body."}}' http://localhost:4000/api/memos
# GET id 1
curl -H 'Content-Type: application/json' http://localhost:4000/api/memos/1

Generating a Release

Now that the Phoenix app is working, it is time to build a release. Add the elixir release manager (exrm) to mix.exs as a project dependency.

mix.exs partial listing

  defp deps do
    [{:phoenix, "~> 1.1.4"},
     {:postgrex, ">= 0.0.0"},
     {:phoenix_ecto, "~> 2.0"},
     {:phoenix_html, "~> 2.4"},
     {:phoenix_live_reload, "~> 1.0", only: :dev},
     {:gettext, "~> 0.9"},
     {:exrm, "~> 1.0.2"}, # this line is new
     {:cowboy, "~> 1.0"}]
  end

Install exrm and build a release. This will create the rel/ directory.

mix deps.get
mix deps.compile
MIX_ENV=prod mix ecto.create
MIX_ENV=prod mix ecto.migrate
MIX_ENV=prod mix compile
# brunch build --production # if using brunch
MIX_ENV=prod mix phoenix.digest
MIX_ENV=prod mix release

The rc script will use environment variable knobs to configure the app. Note that the RELX_REPLACE_OS_VARS=true environment variable needs to be defined to use environment variables for dynamic configuration.

The vm.args file is primarily used to configure the erlang VM. It can also be used to define application configure parameters. Application configuration parameters defined in this file can be passed into the program as atoms or integers. Note that the location of this file can be configured with the RELEASE_CONFIG_DIR environment variable. Add the following to rel/vm.args.

rel/vm.args

## Name of the node
-name ${NODE_NAME}

## Cookie for distributed erlang
-setcookie ${COOKIE}

## App Settings
-phoenix_service port ${PORT}

Alternatively, sys.config can be used to pass in application configuration parameters. In this file, application configuration parameters defined with environment variables must be strings. Pass the port setting in as above or add the following to rel/sys.config. The app module should work with either solution. Adding both files will not break anything. Note that rel/sys.config is written in Erlang.

rel/sys.config

[
  {phoenix_service, [
    {port, "${PORT}"}
  ]}
].

Rebuild the release with the configuration files.

MIX_ENV=prod mix release

Start the release in the console.

RELX_REPLACE_OS_VARS=true PORT=7777 rel/phoenix_service/bin/phoenix_service console

Make sure the server responds.

curl http://localhost:7777/api/memos

Exit the console with ^C.

Consider configuring the Phoenix app as a service to get it to start automatically when the machine boots.

Serving a Hidden Service

Content needs to be served to a port on localhost. This post will use port 8080.

RELX_REPLACE_OS_VARS=true PORT=8080 rel/phoenix_service/bin/phoenix_service start

Read the tor configuration instructions. Open /usr/local/etc/tor/torrc (see torrc instructions). Add the following lines to the section titled “This section is just for location-hidden services”.

/usr/local/etc/tor/torrc partial listing

HiddenServiceDir /usr/home/tor/hidden_service/
HiddenServicePort 80 127.0.0.1:8080

Enable tor in /etc/rc.conf

/etc/rc.conf partial listing

tor_enable="YES"

Start tor.

service tor start

Get the hostname for your hidden service with the following command. Do not share the private_key, found in the same directory.

cat /usr/home/tor/hidden_service/hostname

Test your hidden service with curl by supplying the tor proxy with the -x option. The -v flag gives verbose output.

# POST new
curl -v -x socks5h://127.0.0.1:9050 -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "New Title", "body": "This is the new memo body."}}' http://$(cat /usr/home/tor/hidden_service/hostname)/api/memos
# GET id 1
curl -v -x socks5h://127.0.0.1:9050 -H 'Content-Type: application/json' http://$(cat /usr/home/tor/hidden_service/hostname)/api/memos/1

You can also test your hidden service with Tor2web. For example, if your hidden service has a hostname of ABCDEFGHIJKLMNOP.onion, go to https://ABCDEFGHIJKLMNOP.onion.to to view it in a web browser.

The author of this post could not get Tor2web curl commands to work with a Phoenix app. Something like the following commands should theoretically work. Note that Tor2web blocks the curl user agent, so the user agent is set to test instead.

# POST new
curl -v -A test -x socks5h://127.0.0.1:9050 -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "New Title", "body": "This is the new memo body."}}' http://$(cat /usr/home/tor/hidden_service/hostname).to/api/memos
# GET id 1
curl -v -A test -x socks5h://127.0.0.1:9050 -H 'Content-Type: application/json' http://$(cat /usr/home/tor/hidden_service/hostname).to/api/memos/1

To disable tor when you no longer need to use it, stop it with the service command.

service tor stop

Then disable it in /etc/rc.conf.

tor_enable="NO"

A Sample Shell Script for Working With Hidden Phoenix JSON APIs

This is a modified version of the script covered in Phoenix, A Shell Script for Working with Phoenix JSON APIs. See that post for a description of the script.

Support for flags has been added. The flags default to using the tor proxy. The default host has been changed to automatically pull in the hidden service hostname.

tor_memo_api.sh

#!/bin/sh

reset() {
  HOST=http://$(cat /usr/home/tor/hidden_service/hostname)
  SCOPE=api
  ROUTE=memos
  METHOD="GET"
  FLAGS="-x socks5h://127.0.0.1:9050"
  HEADERS="Content-Type: application/json"
  ID=""
  TITLE=""
  BODY=""
}

usage() {
  reset
  echo "Usage:  ${0} [options]"
  echo "Options:"
  echo "  -o HOST : set URL host, defaults to \"${HOST}\""
  echo "  -s SCOPE : set URL scope, defaults to \"${SCOPE}\""
  echo "  -r ROUTE : set URL route, defaults to \"${ROUTE}\""
  echo "  -X METHOD : set HTTP method, defaults to \"${METHOD}\""
  echo "  -f FLAGS : set flags passed to curl, defaults to \"${FLAGS}\""
  echo "  -H HEADERS : set HTTP headers, defaults to \"${HEADERS}\""
  echo "  -i ID : set memo id, defaults to \"${ID}\""
  echo "  -t TITLE : set memo title, defaults to \"${TITLE}\""
  echo "  -b BODY : set memo body, defaults to \"${BODY}\""
  echo "  -h : display this help"
  echo "Examples:"
  echo "  ${0} -X GET"
  echo "  ${0} -X GET -i 7"
  echo "  ${0} -X POST -t \"Memo Title\" -b \"Memo body here.\""
  echo "  ${0} -X PATCH -t \"Patched title.\" -i 7"
  echo "  ${0} -X PATCH -b \"Patched body.\" -i 7"
  echo "  ${0} -X PUT -t \"New Title\" -b \"New body.\" -i 7"
  echo "  ${0} -X DELETE -i 7"
  exit ${1}
}

reset
while getopts "o:s:r:X:f:H:i:t:b:h" opt
do
  case "${opt}" in
    o) HOST="${OPTARG}" ;;
    s) SCOPE="${OPTARG}" ;;
    r) ROUTE="${OPTARG}" ;;
    X) METHOD="${OPTARG}" ;;
    f) FLAGS="${OPTARG}" ;;
    H) HEADERS="${OPTARG}" ;;
    i) ID="${OPTARG}" ;;
    t) TITLE="${OPTARG}" ;;
    b) BODY="${OPTARG}" ;;
    h) usage 1 ;;
    \?) usage 2 ;;
  esac
done
shift $(expr ${OPTIND} - 1)

case "${METHOD}" in
  GET)
    curl ${FLAGS} -H "${HEADERS}" -X ${METHOD} "${HOST}/${SCOPE}/${ROUTE}${ID:+"/${ID}"}"
    ;;
  POST)
    PAYLOAD='{"memo": {"title": "'"${TITLE:-(no title)}"'", "body": "'"${BODY:-(no body)}"'"}}'
    curl ${FLAGS} -H "${HEADERS}" -X ${METHOD} -d "${PAYLOAD}" "${HOST}/${SCOPE}/${ROUTE}" 
    ;;
  PUT)
    PAYLOAD='{"memo": {"title": "'"${TITLE:-(no title)}"'", "body": "'"${BODY:-(no body)}"'"}}'
    curl ${FLAGS} -H "${HEADERS}" -X ${METHOD} -d "${PAYLOAD}" "${HOST}/${SCOPE}/${ROUTE}/${ID:?'No ID specified.'}" 
    ;;
  PATCH)
    # if defined replace individual fields with
    # JSON fragments followed by a comma and space
    TITLE=${TITLE:+"\"title\": \"${TITLE}\", "}
    BODY=${BODY:+"\"body\": \"${BODY}\", "}
    # strip trailing comma and space
    PAYLOAD="$(echo "${TITLE}${BODY}" | sed 's/, $//g')"
    # complete JSON payload
    PAYLOAD="{\"memo\": {${PAYLOAD}}}"
    curl ${FLAGS} -H "${HEADERS}" -X ${METHOD} -d "${PAYLOAD}" "${HOST}/${SCOPE}/${ROUTE}/${ID:?'No ID specified.'}" 
    ;;
  DELETE)
    curl ${FLAGS} -H "${HEADERS}" -X ${METHOD} "${HOST}/${SCOPE}/${ROUTE}/${ID:?'No ID specified.'}"
    ;;
  *)
    usage 2
    ;;
esac
echo ""

As written, the above script can only be run as root or the tor user because /usr/home/tor does not have global read permissions. Changing the permissions is a bad idea. Instead, hard code the default host if you want to be able to use the script with unprivileged users.

tor_memo_api.sh partial listing

HOST="http://abcdefghijklmnop.onion"

The script can be used as follows.

chmod +x tor_memo_api.sh
./tor_memo_api.sh -X POST -t "Memo Title" -b "Memo body here."
./tor_memo_api.sh -X GET -i 1
./tor_memo_api.sh -X POST -t "Another Memo" -b "This memo's body."
./tor_memo_api.sh -X PATCH -t "Patched title." -i 2
./tor_memo_api.sh -X PATCH -b "Patched body." -i 1
./tor_memo_api.sh -X PUT -t "New Title" -b "New body." -i 2
./tor_memo_api.sh -X GET
./tor_memo_api.sh -X DELETE -i 1

References:

Phoenix as a Service on FreeBSD

2016-03-21T15:48:51+00:00

In this post a Phoenix app will be installed as a service on FreeBSD. The goals are the same as the Elixir as a Service on FreeBSD post.

The app needs to be able to be rebuilt and the service restarted to reflect changes on a development machine.
The service needs to automatically start when the machine is booted.
The service sould work like any other service.

service phoenix_service start
service phoenix_service stop
service phoenix_service restart
service phoenix_service status

This post assumes Phoenix, Elixir and PostgreSQL are already installed on FreeBSD.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2016-03-21 15:48:51 +0000
$ uname -vm
FreeBSD 11.0-CURRENT #0 r296925: Wed Mar 16 20:53:04 JST 2016     root@mirage.sennue.com:/usr/obj/usr/src/sys/MIRAGE_KERNEL  amd64
$ mix hex.info
Hex:    0.11.3
Elixir: 1.2.3
OTP:    18.2.4
* snip *
$ mix phoenix.new -v
Phoenix v1.1.4

Creating a Sample Project

Create a new Phoenix project.

mix phoenix.new phoenix_service --no-brunch
cd phoenix_service
mix ecto.create

This sample project needs to be simple. Let’s make a JSON memo service.

mix phoenix.gen.json Memo memos title:string body:string

Revise the web/router.ex file. The “/api” scope needs to be uncommented and the “/memos” route needs to be added.

web/router.ex file

defmodule PhoenixService.Router do
  use PhoenixService.Web, :router

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
  end

  pipeline :api do
    plug :accepts, ["json"]
  end

  scope "/", PhoenixService do
    pipe_through :browser # Use the default browser stack
  
    get "/", PageController, :index
  end

  scope "/api", PhoenixService do
    pipe_through :api

    resources "/memos", MemoController, except: [:new, :edit]
  end
end

Run the migration.

mix ecto.migrate

Set server to true in config/prod.exs. Also make sure a dynamic port configuration is used.

config/prod.exs partial listing

config :phoenix_service, PhoenixService.Endpoint,
  http: [port: {:system, "PORT"}], # dynamic port configuration
  url: [host: "example.com", port: 80],
  cache_static_manifest: "priv/static/manifest.json", # added comma
  server: true # this line is new

Optionally, add a dynamic port configuration with a default value to config/dev.exs. The above build time solution is suitable for releases. The interpreted solution below is suitable for development.

config/dev.exs partial listing

  # http: [port: 4000], # old line 10
  http: [port: System.get_env("PORT") || Application.get_env(:phoenix_service, :port) || 4000],

Tests should pass

mix test

Start the server.

mix phoenix.server

POST and GET a memo to make sure the server works. A prior post covers a shell script for conveniently interacting with this sample app.

# POST new
curl -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "New Title", "body": "This is the new memo body."}}' http://localhost:4000/api/memos
# GET id 1
curl -H 'Content-Type: application/json' http://localhost:4000/api/memos/1

Generating a Release

Now that the Phoenix app is working, it is time to build a release. Add the elixir release manager (exrm) to mix.exs as a project dependency.

mix.exs partial listing

  defp deps do
    [{:phoenix, "~> 1.1.4"},
     {:postgrex, ">= 0.0.0"},
     {:phoenix_ecto, "~> 2.0"},
     {:phoenix_html, "~> 2.4"},
     {:phoenix_live_reload, "~> 1.0", only: :dev},
     {:gettext, "~> 0.9"},
     {:exrm, "~> 1.0.2"}, # this line is new
     {:cowboy, "~> 1.0"}]
  end

Install exrm and build a release. This will create the rel/ directory.

mix deps.get
mix deps.compile
MIX_ENV=prod mix ecto.create
MIX_ENV=prod mix ecto.migrate
MIX_ENV=prod mix compile
# brunch build --production # if using brunch
MIX_ENV=prod mix phoenix.digest
MIX_ENV=prod mix release

rel/vm.args

## Name of the node
-name ${NODE_NAME}

## Cookie for distributed erlang
-setcookie ${COOKIE}

## App Settings
-phoenix_service port ${PORT}

rel/sys.config

[
  {phoenix_service, [
    {port, "${PORT}"}
  ]}
].

Rebuild the release with the configuration files.

MIX_ENV=prod mix release

Start the release in the console.

RELX_REPLACE_OS_VARS=true PORT=7777 rel/phoenix_service/bin/phoenix_service console

Make sure the server responds.

curl http://localhost:7777/api/memos

Exit the console with ^C.

Installing the Release as a Service

Now that the release is working, it is time to set it up as a service. Perform the initial install.

su
sh
PROJECT=phoenix_service
INSTALL_DIR=/usr/local/opt
VERSION=$(cat rel/${PROJECT}/releases/start_erl.data | cut -d' ' -f2)
INSTALL_TAR=`pwd`/rel/$PROJECT/releases/$VERSION/$PROJECT.tar.gz
mkdir -p $INSTALL_DIR/$PROJECT
(cd $INSTALL_DIR/$PROJECT; tar -xf $INSTALL_TAR)
pw adduser $PROJECT -d $INSTALL_DIR/$PROJECT -s /usr/sbin/nologin -c "$PROJECT system service user"
chown -R $PROJECT:$PROJECT $INSTALL_DIR/$PROJECT

An rc script defines the the service.

phoenix_service_run() is called from the other functions. It configures and calls the release. HOME is set to the installation directory to force the erlang cookie file to be written there regardless of the phoenix_service_user setting.
phoenix_service_status() echoes a user friendly message if the release can be pinged.
extra_commands is used to add the console and remote_console commands. console is used to start a new service and attach a console to it. remote_console() is used to connect a console to the service if it is already running.
Add shutdown to the keyword list if the service needs to gracefull shutdown when the machine restarts.
The rest is standard rc configuration.

Add following to /usr/local/etc/rc.d/phoenix_service

/usr/local/etc/rc.d/phoenix_service

#!/bin/sh
#
# PROVIDE: phoenix_service
# REQUIRE: networking
# KEYWORD:
 
. /etc/rc.subr
 
name="phoenix_service"
rcvar="${name}_enable"
install_dir="/usr/local/opt/${name}"
version=$(cat ${install_dir}/releases/start_erl.data | cut -d' ' -f2)
command="${install_dir}/bin/${name}"
 
start_cmd="${name}_start"
stop_cmd="${name}_stop"
status_cmd="${name}_status"
console_cmd="${name}_console"
remote_console_cmd="${name}_remote_console"
extra_commands="console remote_console"

load_rc_config $name
: ${phoenix_service_enable:="no"}
: ${phoenix_service_port:="4000"}
: ${phoenix_service_user:=${name}}
: ${phoenix_service_node_name:="${name}@127.0.0.1"}
: ${phoenix_service_cookie:="${name}"}
: ${phoenix_service_config_dir:="${install_dir}/releases/${version}/${name} start"}

phoenix_service_run()
{
  RELX_REPLACE_OS_VARS=true \
  HOME="${install_dir}" \
  RELEASE_CONFIG_DIR="${phoenix_service_config}" \
  NODE_NAME="${phoenix_service_node_name}" \
  COOKIE="${phoenix_service_cookie}" \
  PORT="${phoenix_service_port}" \
  su -m "$phoenix_service_user" -c "$command $1"
}

phoenix_service_start()
{
  phoenix_service_run start
}

phoenix_service_stop()
{
  phoenix_service_run stop
}

phoenix_service_status()
{
  ping_result=`phoenix_service_run ping`
  echo "${ping_result}"
  case "${ping_result}" in
    *pong*)
      echo "${name} is running."
      ;;
  esac
}

phoenix_service_console()
{
  phoenix_service_run console
}

phoenix_service_remote_console()
{
  phoenix_service_run remote_console
}

load_rc_config $name
run_rc_command "$1"

Make /usr/local/etc/rc.d/phoenix_service read only and executable.

chmod 555 /usr/local/etc/rc.d/phoenix_service

Enable and configure the service in /etc/rc.conf.

/etc/rc.conf lines to add

phoenix_service_enable="YES"
phoenix_service_port=8248
phoenix_service_node_name="suzaku"
phoenix_service_cookie="cookie-of-the-southern-flame"

The service can now be started. If the service is enabled, it will automatically start when the machine boots.

service phoenix_service start
# POST new
curl -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "Service Running", "body": "The Phoenix service is running on '"$(hostname)"'."}}' http://localhost:8248/api/memos
# GET id 1
curl -H 'Content-Type: application/json' http://localhost:8248/api/memos/1

Optional: Adding a Release to the Systemwide Path

Adding a release to the systemwide path is not necessary, but it can be convenient. Create a directory for the convenience pass through script.

mkdir -p $INSTALL_DIR/bin

PORT, NODE_NAME and COOKIE need default values because vm.args has no useful default fallbacks. There is no good way to automatically select a port, so 8080 is a hard coded default. Add the following script to /usr/local/opt/bin/phoenix_service.

/usr/local/opt/bin/phoenix_service

#!/bin/sh

SCRIPT=$(realpath $0)
BASENAME=$(basename $SCRIPT)
BASEDIR=$(dirname $SCRIPT)
COMMAND=$(realpath $BASEDIR/../$BASENAME/bin/$BASENAME)

: ${NODE_NAME:=${BASENAME}}
: ${COOKIE:=${BASENAME}}
: ${PORT:="8080"}

NODE_NAME=${NODE_NAME} \
COOKIE=${COOKIE} \
PORT=${PORT} \
RELX_REPLACE_OS_VARS=true \
$COMMAND "$@"

Make the script executable.

chmod +x $INSTALL_DIR/bin/$PROJECT

Add /usr/local/opt/bin to the global path in /etc/profile for sh, and /etc/csh.cshrc for csh. Consider updating the root path in /root/.cshrc.

/usr/local/opt/bin partial listing

PATH=/usr/local/opt/bin:$PATH
export PATH

/etc/csh.cshrc partial listing

set path=(/usr/local/opt/bin $path)

/root/.cshrc partial listing

set path = (/usr/local/opt/bin /sbin /bin /usr/sbin /usr/bin /usr/local/sbin /usr/local/bin $HOME/bin)

Update the path in the current shell if necessary.

# sh bash
source /etc/csh.cshrc
# csh tcsh
. /etc/profile

Fix permissions if you want to be able to run as any user. This may have security implications.

chmod 755 $INSTALL_DIR/$PROJECT/bin/$PROJECT
chmod 755 $INSTALL_DIR/$PROJECT/bin/nodetool
chmod 755 $INSTALL_DIR/$PROJECT/releases/$VERSION/$PROJECT.sh
mkdir -p $INSTALL_DIR/$PROJECT/log
chmod 777 $INSTALL_DIR/$PROJECT/log
chmod 777 $INSTALL_DIR/$PROJECT/log/*.*
mkdir -p $INSTALL_DIR/$PROJECT/tmp/erl_pipes/$PROJECT
chmod 777 $INSTALL_DIR/$PROJECT/tmp/erl_pipes/$PROJECT
mkdir -p $INSTALL_DIR/$PROJECT/running-config/
chmod 777 $INSTALL_DIR/$PROJECT/running-config/
chmod 666 $INSTALL_DIR/$PROJECT/running-config/*.*
chown -R $PROJECT:$PROJECT $INSTALL_DIR/$PROJECT

The release can now be conveniently controlled.

# start service
NODE_NAME=rudra COOKIE=treasure PORT=5678 phoenix_service start
# POST new
curl -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "Service Running", "body": "The Phoenix service is running on '"$(hostname)"'."}}' http://localhost:5678/api/memos
# GET id 1
curl -H 'Content-Type: application/json' http://localhost:5678/api/memos/1
# stop service
NODE_NAME=rudra COOKIE=treasure phoenix_service stop

Setup complete. Switch from root to a normal user.

exit # sh
exit # su

Updating

Casual updates on a development machine can be performed as follows.

# brunch build --production # if using brunch
MIX_ENV=prod mix phoenix.digest # if static assets could have changed
MIX_ENV=prod mix release
su
sh
PROJECT=phoenix_service
INSTALL_DIR=/usr/local/opt
VERSION=$(cat rel/${PROJECT}/releases/start_erl.data | cut -d' ' -f2)
INSTALL_TAR=`pwd`/rel/$PROJECT/releases/$VERSION/$PROJECT.tar.gz
(cd $INSTALL_DIR/$PROJECT; \
tar -xf $INSTALL_TAR)
chown -R $PROJECT:$PROJECT $INSTALL_DIR/$PROJECT
service $PROJECT restart
exit # sh
exit # su

Note that the path permissions will need to be fixed again if you added the release to the systemwide path and want to be able to run it as any user.

Troubleshooting

Make sure to set server to true in config/prod.exs. If the server is mysteriously not working, start the release with console to see error messages.

What Next?

Consider looking into edeliver for deployment. “edeliver is based on deliver and provides a bash script to build and deploy Elixir and Erlang applications and perform hot-code upgrades.”

References:

Installing Phoenix, Elixir and PostgreSQL on FreeBSD

2016-03-19T07:35:02+00:00

This post covers installing Phoenix, Elixir and PostgreSQL on a clean installation of FreeBSD. The post assumes FreeBSD is installed and you have created an unprivileged user. FreeBSD installation instructions can be found here.

Software Versions

$ date -u "+%Y-%m-%d %H:%M:%S +0000"
2016-03-19 07:35:02 +0000
$ uname -vm
FreeBSD 11.0-CURRENT #0 r296925: Wed Mar 16 20:53:04 JST 2016     root@mirage.sennue.com:/usr/obj/usr/src/sys/MIRAGE_KERNEL  amd64
$ psql --version
psql (PostgreSQL) 9.4.6
$ mix hex.info
Hex:    0.11.3
Elixir: 1.2.3
OTP:    18.2.4
* snip *
$ mix phoenix.new -v
Phoenix v1.1.4

Bootstrapping the system

Login as root and install portmaster. If you are using packages instead of ports, you will need to install packages instead of using portmaster.

portsnap fetch extract
(cd /usr/ports/ports-mgmt/portmaster && make config-recursive && make config-recursive && make install clean)
portmaster security/sudo

The following utilities may also be useful. Note that ftp/curl is used at the end of the post.

portmaster ports-mgmt/portupgrade devel/git shells/bash editors/vim ftp/curl ftp/wget

Installing PostgreSQL

Install databases/postgresql94-server as root. If you would rather install a different version, do that instead.

portmaster databases/postgresql94-server

Initialize the database.

service postgresql initdb

If you want to enable remote connections, add the following line to /usr/local/pgsql/data/postgresql.conf.

listen_addresses = '*'

If you want to change the port PostgreSQL listens on, add the following line to /usr/local/pgsql/data/postgresql.conf. Replace 5432 with the port you want to use.

port = 5432                            # (change requires restart)

To use password hash authentication, add the following line to /usr/local/pgsql/data/pg_hba.conf. Replace 192.168.0.0/16 with your own network. Consider changing “trust” to “md5” for local and loopback IP address connections.

host    all             all             192.168.0.0/16          md5

Enable PostgreSQL in /etc/rc.conf.

echo 'postgresql_enable="YES"' >> /etc/rc.conf

Start PostgreSQL.

service postgresql start

Add a PostgreSQL super-user with database and role creation privileges. Replace username with your unprivileged FreeBSD user login.

su pgsql
createuser -sdrP username

You should now be able to start psql as your non-root user.

psql

Installing Elixir and Phoenix

Install Elixir and Phoenix.

sudo portmaster lang/elixir
mix local.hex
mix archive.install https://github.com/phoenixframework/archives/raw/master/phoenix_new.ez

Optionally, install npm and brunch.

sudo portmaster www/node www/npm
sudo npm install -g brunch

Creating a Sample Project

Create a new Phoenix project.

mix phoenix.new phoenix_service --no-brunch
cd phoenix_service
mix ecto.create

Create a simple JSON memo service.

mix phoenix.gen.json Memo memos title:string body:string

Revise the web/router.ex file. The “/api” scope needs to be uncommented and the “/memos” route needs to be added.

web/router.ex file

defmodule PhoenixService.Router do
  use PhoenixService.Web, :router

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
  end

  pipeline :api do
    plug :accepts, ["json"]
  end

  scope "/", PhoenixService do
    pipe_through :browser # Use the default browser stack
  
    get "/", PageController, :index
  end

  scope "/api", PhoenixService do
    pipe_through :api

    resources "/memos", MemoController, except: [:new, :edit]
  end
end

Run the migration.

mix ecto.migrate

Tests should pass.

mix test

Running the Sample Project

Start the server.

mix phoenix.server

The following curl commands can be used to interact with the running JSON API. My previous post covers a shell script for interacting with this sample app.

# POST new
curl -H 'Content-Type: application/json' -X POST -d '{"memo": {"title": "New Title", "body": "This is the new memo body."}}' http://localhost:4000/api/memos
# PATCH id 1
curl -H 'Content-Type: application/json' -X PATCH -d '{"memo": {"title": "Patched Title"}}' http://localhost:4000/api/memos/1
curl -H 'Content-Type: application/json' -X PATCH -d '{"memo": {"body": "Patched memo body."}}' http://localhost:4000/api/memos/1
# PUT id 1
curl -H 'Content-Type: application/json' -X PUT -d '{"memo": {"title": "Updated Title", "body": "Updated memo body."}}' http://localhost:4000/api/memos/1
# GET all
curl -H 'Content-Type: application/json' http://localhost:4000/api/memos
# GET id 1
curl -H 'Content-Type: application/json' http://localhost:4000/api/memos/1
# DELETE id 1
curl -H 'Content-Type: application/json' -X DELETE http://localhost:4000/api/memos/1