7f8a5176ce
I created a server to manage my access and refresh tokens. This server exposes a larger API than it needs to at the moment, but that should change. The goal is to expose a GET at /token to retrieve a valid access token. The server should take care of refreshing tokens before they expire and getting entirely new tokens, should they become so stale that I need to re-authorize my application. A lot of my development of this project has been clumsy. I'm new to Go; I didn't understand OAuth2.0; I'm learning concurrent programming (outside of the context of comfortable Elixir/Erlang). My habits for writing programs in compiled languages feels amateurish. I find myself dropping log.Println's all over the source code when I should be using proper debugging tools like Delve and properly logging with things like httputil.Dump{Request,Response}. The application right now is in a transitional state. There is still plenty of code in main.go that belongs in tokens.go. For instance, the client authorization code belongs in the tokens server. Another question I haven't answered is where is the monzo client that I can use to make function calls like `monzo.Transactions` or `monzo.Accounts`? The benefit of having a tokens server is that it allows me to maintain state of the tokens while I'm developing. This way, I can stop and start main.go without disturbing the state of the access tokens. Of course this isn't the primary benefit, which is to abstract over the OAuth details and expose an API that gives me an access token whenever I request one. The first benefit that I listed could and perhaps should be solved by introducing some simple persistence. I'd like to write the access tokens to disk when I shutdown the tokens server and read them from disk when I start the tokens server. This will come. I could have done this before introducing the tokens server, and it would have saved me a few hours I think. Where has my time gone? Mostly I've been re-authorizing my client unnecessarily. This process is expensive because it opens a web browser, asks me to enter my email address, sends me an email, I then click the link in that email. Overall this takes maybe 1-3 minutes in total. Before my tokens server existed, however, I was doing this about 10-20 times per hour. It's a little disappointing that I didn't rectify this earlier. I'd like to remain vigilant and avoid making similar workflow mistakes as I move ahead. |
||
---|---|---|
advent-of-code | ||
blog | ||
clojure | ||
configs | ||
crack_the_coding_interview | ||
data_structures_and_algorithms | ||
deepmind | ||
deploy | ||
emacs | ||
fish | ||
go | ||
haskell-file | ||
java | ||
lisp | ||
monzo_ynab | ||
rfcToKindle | ||
scripts | ||
third_party/lisp | ||
.envrc | ||
.gitignore | ||
default.nix | ||
elisp-conventions.md | ||
keybindings.md | ||
Makefile | ||
README.md | ||
shell.nix | ||
snippets.md | ||
utils.nix |
briefcase
Welcome to my briefcase: my monorepo.
I'm attempting to amass a collection of packages that span a variety of languages while minimizing the costs of sharing the code. This also includes configuration for things like emacs, tmux, ssh, and other tools.
Installation (Deprecated)
The installation instructions here are deprecated. I'd like to manage packaging and installing with Nix, but that is only partially supported at the moment.
wpgtk and gvcci
$ apti python-pip3
$ gclone deviantfero/wpgtk
$ cd ..
$ gclone FabriceCastel/gvcci
- TODO: Integrate Emacs themes into wpgtk.
- TODO: Integrate Vim themes into wpgtk.
- TODO: add these to the install script
$ ln -s ~/Dropbox/.password-store ~/.password-store
$ ln -s ~/Dropbox/bin ~/bin
$ import_gpg $DOTFILES/configs/shared/gpg/.gnupg/exported
- Clipmenu
Clipmenu is a service to store a history of copied strings.
Install it as:
$ cd ~/programming && g clone cdown/clipmenu
- TODO: Include
~/.config/systemd/user
inconfigs/shared
. - TODO: Obviate installation.
Ensure that it runs on startup:
$ cd ~/programming/clipmenu
$ cp clipmenu clipmenud clipdel ~/bin # You may not need to do this step.
$ vim init/clipmenud.service
# Change the ExecStart line to point to ~/bin/clipmenud
$ cp init/clipmenud.service ~/.config/systemd/user/clipmenud.service
$ systemctl --user start clipmenud
$ systemctl --user enable clipmenud # This step may be optional.
$ reboot
$ systemctl --user status clipmenud # Verify installation worked.
- Install Dropbox
$ cd ~ && wget -O - "https://www.dropbox.com/download?plat=lnx.x86_64" | tar xzf -
$ crontab -e # add the following line...
@reboot ~/.dropbox-dist/dropboxd 2>&1 >/tmp/dropbox.log
$ reboot # 1/3 verify installation
$ pgrep dropbox # 2/3 verify installation
$ dropbox.py status # 3/3 verify installation
- Authorize computer to access GitHub
$ ssh-keygen -t rsa -b 4096 -C 'wpcarro@gmail.com'
$ eval $(ssh-agent -s)
$ ssh-add ~/.ssh/id_rsa
$ xclip -sel clip <~/.ssh/id_rsa.pub
$ browse github.com # paste ssh public key in settings
- Install Vundle, nix-env
$ ln -s ~/Dropbox/Vundle.vim ~/.config/nvim/bundle/Vundle.vim
$ cat ~/Dropbox/install_nix.sh | sh
$ for p in $(cat nix-env.txt); do
> nix-env -i "$p"
> done
- Install dotfiles
- TODO: include steps 2-4 in the
make install
command.
Missing the following dependencies:
stow
neovim
bat
exa
fasd
opam
ghcup
ripgrep
fzf
fd
hub
pass
$ cd ~/Dropbox/dotfiles
$ DOTFILES="$(pwd)" make install
- Install Node dependencies
For now, this deserves its own section since it isn't automated.
$ gclone tj/n # clone repo
$ sudo make install # build from source
$ n stable # install the stable version of node
- TODO: support dependencies like terminal themes
SSHFS
TODO: add explanation about unison
, rsync
, etc.
SSHFS enables seamless file transfers from your local machine to a remote machine.
Usage
Assuming your remote machine is configured in your ~/.ssh/config
(see above),
you can mount your remote machine's home directory on your local machine like
so:
$ mkdir ~/ec2
$ sshfs ec2:/home/ubuntu ~/ec2 -o reconnect,follow_symlinks
Now your remote machine's home directory can be accessed using the ~/ec2
directory. This directory can be treated as if it were an ordinary local
directory. To illustrate how easy it is to use, let's install Vundle
onto our
remote machine.
$ git clone https://github.com/VundleVim/Vundle.vim.git ~/ec2/.vim/bundle/Vundle.vim
Voila! We now have Vundle
installed on our ec2 instance without needing to
manually SSH into that machine.
GnuPG
To install GPG run the following:
$ import_gpg
TODO: create a job that runs this periodically.
$ export_gpg
Reference
- sec: secret key
- pub: public key
- ssb: secret sub-key
- sub: public sub-key
Terminals and Fonts
Any terminal or font I choose should pass the following checks:
$ test_true_color
$ test_16_colors
$ test_text_formatting
$ test_unicode
$ test_emojis
Ligatures
If using a font with ligature (e.g. Hasklig) assert that your terminal also support ligatures.