Bash script that takes multiple path arguments and checks if files can be successfully created there

Question

I would like a bash shell script (for my Debian 12 system) which accepts multiple paths as arguments, and then checks if a file can be successfully created in each one. Then the result should be put into json format.

The command to run should be:

./checkavailable.sh /the/first/path /the/second/path

(where there could be any number of input paths given, but at least one) and I would like the output to be in the following format:

[
  { "is_available": 0, "path": "/the/first/path/" },
  { "is_available": 1, "path": "/the/second/path/" }
]

Currently, I managed to achieve this with the following script:

#!/bin/bash

# Check if first path is available
if touch $1/checkalivefile ; then
    avail_path1=1
    rm $1/checkalivefile
else
    avail_path1=0
fi

# Check if second path is available
if touch $2/checkalivefile ; then
    avail_path2=1
    $2/checkalivefile
else
    avail_path2=0
fi

echo "["
printf "  { \"is_available\": "$avail_path1", \"path\": \"$1\" } "
printf ",\n"
printf "  { \"is_available\": "$avail_path2", \"path\": \"$2\" } "
echo
echo "]"

but it's obviously a bit primitive and is hardcoded to work with x2 arguments only, and doesn't scale to additional arguments.

I could try to add a loop now. However, I came across this script, which seems to do something similar (to get disk usage in this case) but using awk instead of a loop:

#!/bin/bash

echo "["
du -s -B1 "$@" | awk '{if (NR!=1) {printf ",\n"};printf "  { \"dir_size_bytes\": "$1", \"path\": \""$2"\" }";}'
echo
echo "]"

Can someone show how this approach using "awk" could be applied to my case? I am very new to bash scripts, so hope to learn something.

Answer 1

JSON is a poor choice of format as, when UTF-8 encoded (as it's often required to these days, and many tools don't support non-UTF-8 encoded JSON), its strings can't contain arbitrary file paths (which are arbitrary sequences of non-NUL bytes).

But if you're OK with producing non-UTF-8 encoded JSON like many tools on Linux such as lsfd do (but that tools like jq can't process), you could do:

#! /bin/sh -
exec perl -MJSON::PP -Mfiletest=access -e '
  print JSON::PP->new
                ->indent
                ->space_after
                ->indent_length(2)
                ->encode(
                  [
                    map {
                          "path" => $_,
                          "is_available" => !!(-d $_ && -x $_ && -w $_)
                        }, @ARGV
                  ]
                )' -- "$@"

Though you might as well make it a perl script:

#! /usr/bin/perl --
use JSON::PP;
use filetest 'access';
print JSON::PP->new
              ->indent
              ->space_after
              ->indent_length(2)
              ->encode(
                [
                  map {
                        'path' => $_,
                        'is_available' => !!(-d $_ && -x $_ && -w $_)
                      }, @ARGV
                ]
              );

Note that, rather than trying to create files in there, which is potentially destructive (and can at least update the modification time of those directories), it uses heuristics (checks that the paths identify searchable (-x) and writable directories).

The ->indent->space_after->indent_length(2) is just to get a jq-style pretty-formatting. You can remove it to get compact JSON (like with jq -c).

Replace !! with int or 0+ for instance if you do want is_available to be a 0/1 number rather than a false/true boolean.

Answer 2

Your script and the df script test different things. One tests "can I write to this directory" the other could test "is there space on this disk".

Assuming you wanted "can I write" test, your original script is close, but you need to slightly refactor and loop on input.

The big gotcha with a simple loop like this is on removing the final "," so we put that on a line on its own and then delete the last line of the loop. JSON doesn't care where the comma is as long as it's there.

The touch probably also needs stderr throwing away.

This version is totally untested...

#!/bin/bash

echo "["

for p in $@
do
  if touch "$p/checkalivefile" 2>/dev/null ; then
    avail_path=1
    rm "$p/checkalivefile"
  else
    avail_path=0
  fi

  printf "  { \"is_available\": "$avail_path", \"path\": \"$p\" }\n,\n"
done | sed '$d'
echo "]"

Answer 3

Many Bourne-derived shells have primitives for checking this kind of thing, making touch unnecessary under shells which have a test-like utility with -d and -w operators:

$ mkdir dir{1..5} dir\ \"{6..10}\"
$ chmod -w dir2 dir5 'dir "7"' 'dir "9"'; chmod -x dir\ \"8\"
$ ls -ltrd dir*
drwx--x---  2 jim wheel 2 Sep  2 00:01 dir1/
dr-x--x---  2 jim wheel 2 Sep  2 00:01 dir2/
drwx--x---  2 jim wheel 2 Sep  2 00:01 dir3/
drwx--x---  2 jim wheel 2 Sep  2 00:01 dir4/
dr-x--x---  2 jim wheel 2 Sep  2 00:01 dir5/
drwx--x---  2 jim wheel 2 Sep  2 00:01 dir "6"/
dr-x--x---  2 jim wheel 2 Sep  2 00:01 dir "7"/
drw-------  2 jim wheel 2 Sep  2 00:01 dir "8"/
dr-x--x---  2 jim wheel 2 Sep  2 00:01 dir "9"/
drwx--x---  2 jim wheel 2 Sep  2 00:01 dir "10"/

$  ./checkavailable.sh dir*
[
  { "is_available": 1, "path": "dir\ \"10\"" },
  { "is_available": 1, "path": "dir\ \"6\"" },
  { "is_available": 0, "path": "dir\ \"7\"" },
  { "is_available": 0, "path": "dir\ \"8\"" },
  { "is_available": 0, "path": "dir\ \"9\"" },
  { "is_available": 1, "path": "dir1" },
  { "is_available": 0, "path": "dir2" },
  { "is_available": 1, "path": "dir3" },
  { "is_available": 1, "path": "dir4" },
  { "is_available": 0, "path": "dir5" }
]

$ cat checkavailable.sh 
#!/usr/bin/env bash

declare -a avail_array

readarray -t avail_array < <(
    while [[ $# -gt 0 ]]
    do
        # "!" because requested output is 1 for true, 0 for false
        ! ( [[ -d "$1" ]] && [[ -x "$1" ]] && [[ -w "$1" ]] )
        is_avail=$?
        printf '  { "is_available": %d, "path": "%q" },\n' $is_avail "$1"
        shift
    done
)

N=${#avail_array[@]}
[[ $N -gt 0 ]] && {
    # Remove trailing comma from last entry:
    avail_array[$(($N-1))]="${avail_array[$(($N-1))]%,}"
    printf '[\n'
    printf '%s\n' "${avail_array[@]}"
    printf ']\n'
}

Answer 4

Since UNIX paths may very well contain double-quotes and other characters that when interpolated directly would break a JSON file, it would be safer to let a JSON processor handle the task.

Also the script could be heavily simplified.

I would do something like this:

#!/usr/bin/env bash

for p in "${@}"; do
        ! ([ -d "${p}" ] && [ -w "${p}" ] && [ -x "${p}" ])
        jq -n --argjson is_available "${?}" --arg path "${p}" '{ is_available: $is_available, path: $path }'
done | jq -s

If the paths are guaranteed not to contain invalid UTF-8 sequences; otherwise, as Stéphane Chazelas notes, some sort of encoding is required to correctly represent the paths using JSON; see Stéphane Chazelas' answer for a method that deals with paths containing invalid UTF-8 sequences.

For each parameter $p, it will test if the argument is not a writeable and searchable directory, so that $? will contain 0 if the directory is not both writeable and searchable / 1 if the directory is not both writeable and searchable;

Then, it will feed a named argument is_available with a value of $? and a named argument path with a value of $p to jq, which will output a (well-formed) JSON object containing the data;

Finally, it will feed the stream of objects to jq -s for reducing into an array.

% ls -la
totale 4
drwxr-xr-x 1 dev users  92  2 set 06.24  .
drwxr-xr-x 1 dev users 518  2 set 06.24  ..
drwxr-xr-x 1 dev users   0  2 set 05.37 'dir_with'$'\n''newline'
drwxr-xr-x 1 dev users   0  2 set 06.10 'dir_with"double_quote'
-rwx------ 1 dev users 183  2 set 06.24  script.sh
% ./script.sh ~ dir_with$'\n'newline dir_with\"double_quote /root
[
  {
    "is_available": 1,
    "path": "/home/dev"
  },
  {
    "is_available": 1,
    "path": "dir_with\nnewline"
  },
  {
    "is_available": 1,
    "path": "dir_with\"double_quote"
  },
  {
    "is_available": 0,
    "path": "/root"
  }
]

---

Note that is_available should rather be represented as a boolean, otherwise whatever will be parsing the JSON may have to test for numeric equality instead of for truthness:

#!/usr/bin/env bash

for p in "${@}"; do
        ! ([ -d "${p}" ] && [ -w "${p}" ] && [ -x "${p}" ])
        jq -n --argjson is_available "${?}" --arg path "${p}" '{ is_available: ($is_available==1), path: $path }'
done | jq -s

% ./script.sh ~ /root
[
  {
    "is_available": true,
    "path": "/home/user"
  },
  {
    "is_available": false,
    "path": "/root"
  }
]

Answer 5

Using associative array from bash4+.

#!/usr/bin/env bash

declare -A paths ##: declare associative array

for f; do  ##: Loop through all the give arguments
  [[ -z "$f" ]] && continue ##: If the given argument is two single '' quotes it breaks the array.
  if create_file=$(touch "$f"/checkalivefile 2>&1); then ##: command substitution in a variable has a useful exit status
    avail_path1=1
    rm -rf "$create_file"
  else
    avail_path1=0
  fi
  paths["$f"]="$avail_path1"
done

counter=1
total="${#paths[@]}"

##: If no argument is given exit the script
((total)) || {
  printf >&2 'No directory given!\n'
  exit 1
}

printf '[\n'
for i in "${!paths[@]}"; do
  case $counter in
    "$total") ##: Do not add a trailing `,` if it is the last element.
       printf '  { "is_available": %s, "path": "%s" }\n' "${paths[$i]}" "$i";;
    *)
     printf '  { "is_available": %s, "path": "%s" },\n' "${paths[$i]}" "$i";;
  esac
((counter++))
done
printf ']\n'

---

• See help test for checking permissions. Like what the other posted answer suggested. Instead of touch and rm It could be something like:

for f; do
  [[ -z "$f" ]] && continue
  if [[ -d "$f" && -w "$f" && -x "$f" ]]; then
    avail_path1=1
  else
    avail_path1=0
  fi
  paths["$f"]="$avail_path1"
done

• Checkout jq from this forum also for processing/working with json data structure using the shell.

Answer 6

Instead of touch, I would test to see if the path is writeable [[ -w "$p" ]] .. To specifically test for directory and writable, then [[ -d "$p" && -w "$p" ]]. Also I recommend jo to handle creating any json objects. It makes it super easy