It's kind of unbelievable that Amazon is forcing their customers into a vendor lock and not allowing them an easy or straightforward way to download ALL of their photos in bulk.

The explanation is simple. They don't want you go to another service and lose the revenue. It would certainly appear that their bottom line is more important to them than the customers rights.

Provided is a Javascript snippet that can be used to download all your photos without any size or count limitations. You can just plop this in your web console and let it run.

How do I open the chrome web console?

However, since this is running serially, it will take some time. there are timeouts in the script and waiters for elements to be visible before downloading the image to help make the process more reliable and prevent photos from being skipped.

Bonus

This script will allow you to delete the photos from Amazon Photos after they have been downloaded. Just set the varible to true at the bottom of the script before running.

// Set to true to delete files after downloading
const deleteFiles = true;

Let's go!

• Open amazon photos in chrome
• Select the first photo so you can see it in a "slide show"
• Open the web console
• Paste the entire code snippet
• Press Enter
• Wait
• Profit

function waitForElement(selector, timeout = 100) {
  return new Promise((resolve, reject) => {
    const startTime = Date.now();

    const checkElement = () => {
      const element = document.querySelector(selector);
      if (element) {
        resolve(element);
      } else if (Date.now() - startTime > timeout) {
        reject(new Error(`Element ${selector} not found within ${timeout}ms`));
      } else {
        setTimeout(checkElement, 100);
      }
    };

    checkElement();
  });
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run(deleteFiles=false) {
  let downloadCount = 0;

  try {
    // Click the Information button at the beginning
    const spans = document.querySelectorAll('#main-content > section > header > ul > li > button > span.label');
    const infoButton = Array.from(spans).find(span => span.textContent.trim() === 'Information');
    if (infoButton) {
      infoButton.closest('button').click();
      console.log('Clicked Information button');
      await sleep(500);
    }

    while (true) {
      await ensureAsideVisible();
      await clickMainContentButton();
      await waitForElement('button.download[title="Download"]');
      await clickDownloadButton(++downloadCount);
      await sleep(1200); // Wait for download to start

      if (deleteFiles) {
        await clickDeleteButton();
        await confirmDelete();
        await sleep(500);
      }

      const hasNext = await clickNextButton();
      if (!hasNext) {
        break;
      }
      await waitForElement('#main-content > section > header > div > button');
    }

    console.log(`Finished downloading ${downloadCount} files`);
  } catch (error) {
    console.error(`Script stopped: ${error.message}`);
    console.log(`Total files downloaded before stopping: ${downloadCount}`);
  }
}

async function ensureAsideVisible() {
  const aside = document.querySelector('#main-content > section > aside');
  if (!aside || window.getComputedStyle(aside).display === 'none' || !aside.offsetParent) {
    const button = document.querySelector('#main-content > section > header > div > button');
    if (button) {
      button.click();
      await sleep(300);
      console.log('Opened aside panel');
    }
  }
}

function clickMainContentButton() {
  const button = document.querySelector('#main-content > section > header > div > button');
  if (button) {
    button.click();
  }
}

function clickDownloadButton(count) {
  const downloadButton = document.querySelector('button.download[title="Download"]');
  if (!downloadButton) {
    throw new Error('Download button not found');
  }
  const fileInfoDiv = document.querySelector('.detail-item.file-info');
  const imageName = fileInfoDiv ? fileInfoDiv.querySelector('span.label').innerText : 'unknown';
  downloadButton.click();
  console.log(`Downloading file ${count} - ${imageName}`);
}

function clickDeleteButton() {
  const deleteButton = document.querySelector('button.trash');
  if (!deleteButton) {
    throw new Error('Delete button (button.trash) not found');
  }
  deleteButton.click();
  console.log('Opened delete modal');
}

async function confirmDelete() {
  // Wait for the delete dialog to appear
  await waitForElement('aside.TrashConfirm', 5000);
  // Wait for the delete confirmation button to be visible
  await waitForElement('button[aria-label="Delete"]', 5000);
  const confirmButton = document.querySelector('button[aria-label="Delete"]');
  if (!confirmButton) {
    throw new Error('Delete confirmation button not found');
  }
  confirmButton.click();
  console.log('Confirmed delete');
  // Wait for the dialog to close and action to complete
  await sleep(500);
}

async function clickNextButton() {
  try {
    await waitForElement('.image-and-controls .next', 3000);
    const nextButton = document.querySelector('.image-and-controls .next');
    if (nextButton) {
      nextButton.click();
      return true;
    }
  } catch (error) {
    console.log('No next button found - reached end of album');
  }
  return false;
}

// Set to true to delete files after downloading
const deleteFiles = true;

// Start the script
run(deleteFiles);

Do you really need to see a billion lines of diff in a `package-lock.json` file? I know I rarely benefit from seeing the diff. Wouldn't it be great if those were just collapsed when you run git diff in the terminal? Lets make it happen.

Create a .gitattributes file

touch ~/.gitattributes

Add Content to the file

Add the following lines the file to collapse package-lock.json files from diffs.

# Exclude package-lock from git diff
**/package-lock.json -diff

Configure Git to use the new configuration

Tell Git to use the new .gitattributes file

git config --global core.attributesFile "~/.gitattributes"

Its a typical situation where you may want to disable your PiHole ad blocking momentarily to open a link. To increase the wife appreciation factor, this needs to be a task that can be accomplished as easily as possible. Don't get me wrong, the PiHole UI is great and this task can be accomplished there pretty easily, but wouldn't it be great to trigger this action from my Apple Watch or iPhone?

The Solution:

Build an Apple shortcut that has options to disable ad blocking for 10 seconds, 30 seconds and 5 minutes that can be ran on an Apple Watch, iPad, iPhone, etc.

Assumptions:

This solution is intended to be used with PiHole >= 6. IT IS NOT compatible with PiHole 5.

• You have an app password which is used as your API KEY

Tbe app password can be created a the following route: /admin/settings/api

The Shortcut

Global Variables:

We need to set some variables for our shortcut to use

Select Disable Time:

Allow the user to select how long to disable ad blocking

Authenticate:

Authenticate and get a session ID (sid) to be used with our API requests

Store Authentication Session ID:

By clicking the Set variable we need to specify the key that contains our session ID. in this case we set the Get Value for Key to session.id

Disable Ad Blocking:

Make the POST request to the API to disable ad blocking

Delete Authentication Session:

We need to clean up after ourselves each time because by default PiHole is set up to allow 10 sessions. You could increase this number but it seems more responsible to delete our session ID when we are done.

This solution requires a values file with the following schema. Notice how each component is in components. The best part of this is that if there is no secrets property in the component, it will skip the secrets template.

If no value is provided by setting it via the command line and it has a value already set, it will use the current value in the secret.

All secrets will be initialized with the value of initial unless they are specifically provided on install or upgrade like so.

helm upgrade juggle ./chart_directory -n juggle \
  --set components.second.secrets.SUPER_SECRET="string"

## values.yaml ##

components:
  first:
    name: first component

  second:
    name: second component

    secrets:
      SUPER_SECRET: null 
      ANOTHER_SECRET: null

## secrets.yaml ##

{{- range $system, $settings := .Values.components -}}
{{ if $settings.secrets }}
{{ include "system.secrets.component"  (dict "component" $settings "values" $.Values "release" $.Release) }}
{{- end }}
{{- end }}

## _secrets.tpl ##

{{/*
Secret initializer and data maintainer
This helper will initialize the secret data with "initial" value if the secret is not found in the secret object.
IF the secret is found in the secret object, it will use the set value from the secret object thereby maintaining the secret data.
*/}}
{{- define "helper.secrets" -}}
  {{- $secretObj := (lookup "v1" "Secret" .release.Namespace .component.name) | default dict }}
  {{- range $key, $value := .component.secrets }}
  {{- if empty $value -}}
  {{- $secretData := (get $secretObj "data") | default dict }}
  {{- $secret := (get $secretData $key) | default ("initial" | b64enc) }}
  {{ $key }}: {{ $secret | quote }}
  {{- else }}
  {{ $key }}: {{ $value | b64enc | quote }}
  {{- end -}}
  {{- end }}
{{- end -}}

{{- define "system.secrets.component" }}

---
apiVersion: v1
kind: Secret
metadata:
  name: {{ .component.name }}
  labels:
{{ include "helper.metaLabels" . | indent 4 }}
type: Opaque
data:
{{ include "helper.secrets" . | indent 2 }}
{{- end }}

Troubleshooting

In order to really test this during a ` Dry Run` you need to make sure you tweak your option so helm has access to the server data at run time.

--dry-run=server

If you manage multiple k8s clusters you have no doubt tinkered with different ways to store and use the config files.

Below is my preferred method of wrangling them and how I switch between them effectively.

In my ~/.kube directory I have individual configs for each cluster and a config file with null values. This config file with null values is used as a placeholder and gets updated when thecurrent-context changes. This is preferable to having the current context updated in a seemingly random config file.

~/.kube/config

apiVersion: v1
clusters: null
contexts: null
current-context: Trowbridge-k0s
kind: Config
preferences: {}
users: null

Your individual cluster configs will reside in the ~/.kube directory as well and will have a filename prefix of config

~/.kube/config-example

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: somesupersecretstring
    server: https://example.com:16443
  name: Example
contexts:
- context:
    cluster: Example
    user: Example
  name: Example
kind: Config
preferences: {}
users:
- name: Example
  user:
    token: somesupersecretstring

Notice the example config does not have a current-context line

For this to work you will need to make a slight modification to your terminal profile. .bash_profile / .bashrc / etc.

# load all the config files in the .kube directory
export KUBECONFIG=$(find ~/.kube -name 'config*' | sort | tr '\n' ':')

This line is iterating over the ~/.kube directory and grabbing files that begin with config and sorting them so that the config proper file is loaded first.

With that, kubectl has access to all your configs and they are nicely separated and easy to work with.

Helper Script

Add the following either as a bash function in your profile or as a shell script that is linked to an alias to make context switching a breeze.

ktx.sh

#!/usr/bin/env bash

red=$(tput setaf 1)
gold=$(tput setaf 3)
blue=$(tput setaf 4)
magenta=$(tput setaf 5)
cyan=$(tput setaf 6)
default=$(tput sgr0)

# ensure kubectl is installed
if ! hash kubectl 2>/dev/null
then
  echo "${red}You need kubectl installed${default}"
  exit 0
fi

CONTEXTS=( $(kubectl config get-contexts | awk 'NR!=1''{print $2}') )

PS3="${cyan}Select a kubectl context (q to quit): $gold"
select context in "${CONTEXTS[@]}"; do
  case "$context" in
    "") break ;;  # This is a fake; any invalid entry makes $context=="", not just "q".
    *) break ;;
  esac
done


if [ ! -z "$context" ]
then
  kubectl config use-context $context > /dev/null
  echo "${blue}Kubectl Context switched to [${magenta}$context${default}]"
fi

Apparently, Apple is being a big baby and not installing a modern version of bash on macOs any longer.

macOs is currently shipping with bash version 3. This is fine in most cases but what if you want to use some of the modern conveniences that come with bash >= 4? (like associative arrays).

we can do that by installing the latest version (version 5 at the time of this writing) using homebrew.

brew install bash
brew link bash

The Catch!

we dont want to use the old version 3 binary that is still living on the machine so we can no longer use #!/bin/bash at the top of our bash scripts.

The Solution

We have to get in the habit of using the users specified version of bash

#!/usr/bin/env bash

Additionally, I have been including a check for bash >= 4 in my scripts that use associative arrays like so:

# Ensure bash version is greater than or equal to 4, so we can use associtative arrays
if [ "${BASH_VERSINFO:-0}" -le 4 ]
then  
	echo "You need bash >= 4"
    exit 0
fi

People always ask me "what were your camera settings for that photo", so I wrote some bash functions to burn the relevant data to the bottom of the image.

The following bash functions assume a few things:

• you are on a Mac or Linux system
• You know how to modify your .bash_profile (macOs) or .bashrc (Linux). We arent going to get into that here. For more info see https://linuxhint.com/simple-guide-to-create-open-edit-bash-profile/
• You have exiftool installed
• brew install exiftool (macOs)
• apt install exiftool (Linux)

Once you have met the requirements, you just need to put the following functions in your appropriate profile.

function exifshort(){

  if hash exiftool 2>/dev/null; then
    echo ""
  else
    if [ "$(uname)" == "Darwin" ]; then
      brew install exiftool
    elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
      sudo apt install exiftool
    fi
  fi

  FILE=$1
  if [ -z "$FILE" ];then
    echo "${red}You must specify a file path${default}"
    exit 1
  else
    MODEL=`exiftool -Model $FILE | awk -F ': ' '{print $2}'`
    ISO=`exiftool -ISO $FILE | awk -F ': ' '{print $2}'`
    LENS=`exiftool -LensModel $FILE | awk -F ': ' '{print $2}'`
    EXPOSURE=`exiftool -ExposureTime $FILE | awk -F ': ' '{print $2}'`
    DATE=`exiftool -CreateDate $FILE | awk -F ': ' '{print $2}'`
    APERTURE=`exiftool -ApertureValue $FILE | awk -F ': ' '{print $2}'`
    FOCAL_LENGTH=`exiftool -FocalLength $FILE | awk -F ': ' '{print $2}'`

    echo "$MODEL + $LENS @ $FOCAL_LENGTH, ISO $ISO, $EXPOSURE seconds, f/$APERTURE, $DATE"
  fi
}

function burnexif(){
  IN=$1
  PAD=100
  FONT_SIZE=32

  PATH_IN=$(readlink -f $IN)
  EXTENSION=${PATH_IN##*.}
  PATH_OUT=${PATH_IN%.*}-processed.${EXTENSION}

  echo -e "\nProcessing:\n  $PATH_IN"
  echo -e "Output File:\n  $PATH_OUT"

  ((LEFT=(0 + $PAD)))
  ((RIGHT=$(identify -format '%w' $PATH_IN) - $PAD - 240))
  ((BOTTOM=$(identify -format '%h' $PATH_IN) - $PAD))

  STRING="$(exifshort $PATH_IN)"
  echo -e "\nBurning exif data to image"
  convert -pointsize $FONT_SIZE -fill yellow -draw "text 10,$BOTTOM '$STRING'" $PATH_IN $PATH_OUT
  echo -e "\nBurning watermark to image"
  convert -pointsize $FONT_SIZE -fill yellow -draw "text $RIGHT,$BOTTOM 'karnsonline.com'" $PATH_OUT $PATH_OUT
}

Running the scripts

To show the short version of a photos metadata you can run the following command:

$ exifshort path/to/image/file.jpg

To burn the short version of the photos metadata to the image, run the following command:

burnexif path/to/image/file.jpg

The result will be a new image sitting right next to your source image with the addition of -processed to the file name. This script WILL NOT modify the original image source.

Lets face it, sometimes we need to move massive amounts of data between servers. wouldn't it be great if it wasn't so darn slow? In some cases rsync would do the job just fine, but it gets slowed down when it has to do checksum checks before and after a file transfer. Sure you could turn off the checksum checks but you would still be limited by rsync.

Enter netcat tar pipe

we can use a combination of netcat, tar, and a pipe to blast data from one server to the other.

While copying files from an old NAS to a new NAS I was seeing the following transfer speeds.

How to Run it

Receiver

On the receiving machine start a listener in the directory where files will be received.

cd /path/to/destination/directory
ncat -l -p 7000 | tar -xpf -

Sender

On the sending machine start a transfer to the listening receiver.

cd /path/to/source/directory
tar -cf - * | ncat <hostname_of_receiver> 7000

Synology

Synology NAS's do not have netcat installed by default and you will need to install the DiagnosisTool to get access to the binary. Run the following command on your synology machine to install netcat.

sudo synogear install