zgrep tar.gz file with file location results & match [duplicate] - bash
Am trying to grep pattern from dozen files .tar.gz but its very slow
am using
tar -ztf file.tar.gz | while read FILENAME
do
if tar -zxf file.tar.gz "$FILENAME" -O | grep "string" > /dev/null
then
echo "$FILENAME contains string"
fi
done
If you have zgrep you can use
zgrep -a string file.tar.gz
You can use the --to-command option to pipe files to an arbitrary script. Using this you can process the archive in a single pass (and without a temporary file). See also this question, and the manual.
Armed with the above information, you could try something like:
$ tar xf file.tar.gz --to-command "awk '/bar/ { print ENVIRON[\"TAR_FILENAME\"]; exit }'"
bfe2/.bferc
bfe2/CHANGELOG
bfe2/README.bferc
I know this question is 4 years old, but I have a couple different options:
Option 1: Using tar --to-command grep
The following line will look in example.tgz for PATTERN. This is similar to #Jester's example, but I couldn't get his pattern matching to work.
tar xzf example.tgz --to-command 'grep --label="$TAR_FILENAME" -H PATTERN ; true'
Option 2: Using tar -tzf
The second option is using tar -tzf to list the files, then go through them with grep. You can create a function to use it over and over:
targrep () {
for i in $(tar -tzf "$1"); do
results=$(tar -Oxzf "$1" "$i" | grep --label="$i" -H "$2")
echo "$results"
done
}
Usage:
targrep example.tar.gz "pattern"
Both the below options work well.
$ zgrep -ai 'CDF_FEED' FeedService.log.1.05-31-2019-150003.tar.gz | more
2019-05-30 19:20:14.568 ERROR 281 --- [http-nio-8007-exec-360] DrupalFeedService : CDF_FEED_SERVICE::CLASSIFICATION_ERROR:408: Classification failed even after maximum retries for url : abcd.html
$ zcat FeedService.log.1.05-31-2019-150003.tar.gz | grep -ai 'CDF_FEED'
2019-05-30 19:20:14.568 ERROR 281 --- [http-nio-8007-exec-360] DrupalFeedService : CDF_FEED_SERVICE::CLASSIFICATION_ERROR:408: Classification failed even after maximum retries for url : abcd.html
If this is really slow, I suspect you're dealing with a large archive file. It's going to uncompress it once to extract the file list, and then uncompress it N times--where N is the number of files in the archive--for the grep. In addition to all the uncompressing, it's going to have to scan a fair bit into the archive each time to extract each file. One of tar's biggest drawbacks is that there is no table of contents at the beginning. There's no efficient way to get information about all the files in the archive and only read that portion of the file. It essentially has to read all of the file up to the thing you're extracting every time; it can't just jump to a filename's location right away.
The easiest thing you can do to speed this up would be to uncompress the file first (gunzip file.tar.gz) and then work on the .tar file. That might help enough by itself. It's still going to loop through the entire archive N times, though.
If you really want this to be efficient, your only option is to completely extract everything in the archive before processing it. Since your problem is speed, I suspect this is a giant file that you don't want to extract first, but if you can, this will speed things up a lot:
tar zxf file.tar.gz
for f in hopefullySomeSubdir/*; do
grep -l "string" $f
done
Note that grep -l prints the name of any matching file, quits after the first match, and is silent if there's no match. That alone will speed up the grepping portion of your command, so even if you don't have the space to extract the entire archive, grep -l will help. If the files are huge, it will help a lot.
For starters, you could start more than one process:
tar -ztf file.tar.gz | while read FILENAME
do
(if tar -zxf file.tar.gz "$FILENAME" -O | grep -l "string"
then
echo "$FILENAME contains string"
fi) &
done
The ( ... ) & creates a new detached (read: the parent shell does not wait for the child)
process.
After that, you should optimize the extracting of your archive. The read is no problem,
as the OS should have cached the file access already. However, tar needs to unpack
the archive every time the loop runs, which can be slow. Unpacking the archive once
and iterating over the result may help here:
local tempPath=`tempfile`
mkdir $tempPath && tar -zxf file.tar.gz -C $tempPath &&
find $tempPath -type f | while read FILENAME
do
(if grep -l "string" "$FILENAME"
then
echo "$FILENAME contains string"
fi) &
done && rm -r $tempPath
find is used here, to get a list of files in the target directory of tar, which we're iterating over, for each file searching for a string.
Edit: Use grep -l to speed up things, as Jim pointed out. From man grep:
-l, --files-with-matches
Suppress normal output; instead print the name of each input file from which output would
normally have been printed. The scanning will stop on the first match. (-l is specified
by POSIX.)
Am trying to grep pattern from dozen files .tar.gz but its very slow
tar -ztf file.tar.gz | while read FILENAME
do
if tar -zxf file.tar.gz "$FILENAME" -O | grep "string" > /dev/null
then
echo "$FILENAME contains string"
fi
done
That's actually very easy with ugrep option -z:
-z, --decompress
Decompress files to search, when compressed. Archives (.cpio,
.pax, .tar, and .zip) and compressed archives (e.g. .taz, .tgz,
.tpz, .tbz, .tbz2, .tb2, .tz2, .tlz, and .txz) are searched and
matching pathnames of files in archives are output in braces. If
-g, -O, -M, or -t is specified, searches files within archives
whose name matches globs, matches file name extensions, matches
file signature magic bytes, or matches file types, respectively.
Supported compression formats: gzip (.gz), compress (.Z), zip,
bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz, .tbz2, .tb2, .tz2),
lzma and xz (requires suffix .lzma, .tlz, .xz, .txz).
Which requires just one command to search file.tar.gz as follows:
ugrep -z "string" file.tar.gz
This greps each of the archived files to display matches. Archived filenames are shown in braces to distinguish them from ordinary filenames. For example:
$ ugrep -z "Hello" archive.tgz
{Hello.bat}:echo "Hello World!"
Binary file archive.tgz{Hello.class} matches
{Hello.java}:public class Hello // prints a Hello World! greeting
{Hello.java}: { System.out.println("Hello World!");
{Hello.pdf}:(Hello)
{Hello.sh}:echo "Hello World!"
{Hello.txt}:Hello
If you just want the file names, use option -l (--files-with-matches) and customize the filename output with option --format="%z%~" to get rid of the braces:
$ ugrep -z Hello -l --format="%z%~" archive.tgz
Hello.bat
Hello.class
Hello.java
Hello.pdf
Hello.sh
Hello.txt
All of the code above was really helpful, but none of it quite answered my own need: grep all *.tar.gz files in the current directory to find a pattern that is specified as an argument in a reusable script to output:
The name of both the archive file and the extracted file
The line number where the pattern was found
The contents of the matching line
It's what I was really hoping that zgrep could do for me and it just can't.
Here's my solution:
pattern=$1
for f in *.tar.gz; do
echo "$f:"
tar -xzf "$f" --to-command 'grep --label="`basename $TAR_FILENAME`" -Hin '"$pattern ; true";
done
You can also replace the tar line with the following if you'd like to test that all variables are expanding properly with a basic echo statement:
tar -xzf "$f" --to-command 'echo "f:`basename $TAR_FILENAME` s:'"$pattern\""
Let me explain what's going on. Hopefully, the for loop and the echo of the archive filename in question is obvious.
tar -xzf: x extract, z filter through gzip, f based on the following archive file...
"$f": The archive file provided by the for loop (such as what you'd get by doing an ls) in double-quotes to allow the variable to expand and ensure that the script is not broken by any file names with spaces, etc.
--to-command: Pass the output of the tar command to another command rather than actually extracting files to the filesystem. Everything after this specifies what the command is (grep) and what arguments we're passing to that command.
Let's break that part down by itself, since it's the "secret sauce" here.
'grep --label="`basename $TAR_FILENAME`" -Hin '"$pattern ; true"
First, we use a single-quote to start this chunk so that the executed sub-command (basename $TAR_FILENAME) is not immediately expanded/resolved. More on that in a moment.
grep: The command to be run on the (not actually) extracted files
--label=: The label to prepend the results, the value of which is enclosed in double-quotes because we do want to have the grep command resolve the $TAR_FILENAME environment variable passed in by the tar command.
basename $TAR_FILENAME: Runs as a command (surrounded by backticks) and removes directory path and outputs only the name of the file
-Hin: H Display filename (provided by the label), i Case insensitive search, n Display line number of match
Then we "end" the first part of the command string with a single quote and start up the next part with a double quote so that the $pattern, passed in as the first argument, can be resolved.
Realizing which quotes I needed to use where was the part that tripped me up the longest. Hopefully, this all makes sense to you and helps someone else out. Also, I hope I can find this in a year when I need it again (and I've forgotten about the script I made for it already!)
And it's been a bit a couple of weeks since I wrote the above and it's still super useful... but it wasn't quite good enough as files have piled up and searching for things has gotten more messy. I needed a way to limit what I looked at by the date of the file (only looking at more recent files). So here's that code. Hopefully it's fairly self-explanatory.
if [ -z "$1" ]; then
echo "Look within all tar.gz files for a string pattern, optionally only in recent files"
echo "Usage: targrep <string to search for> [start date]"
fi
pattern=$1
startdatein=$2
startdate=$(date -d "$startdatein" +%s)
for f in *.tar.gz; do
filedate=$(date -r "$f" +%s)
if [[ -z "$startdatein" ]] || [[ $filedate -ge $startdate ]]; then
echo "$f:"
tar -xzf "$f" --to-command 'grep --label="`basename $TAR_FILENAME`" -Hin '"$pattern ; true"
fi
done
And I can't stop tweaking this thing. I added an argument to filter by the name of the output files in the tar file. Wildcards work, too.
Usage:
targrep.sh [-d <start date>] [-f <filename to include>] <string to search for>
Example:
targrep.sh -d "1/1/2019" -f "*vehicle_models.csv" ford
while getopts "d:f:" opt; do
case $opt in
d) startdatein=$OPTARG;;
f) targetfile=$OPTARG;;
esac
done
shift "$((OPTIND-1))" # Discard options and bring forward remaining arguments
pattern=$1
echo "Searching for: $pattern"
if [[ -n $targetfile ]]; then
echo "in filenames: $targetfile"
fi
startdate=$(date -d "$startdatein" +%s)
for f in *.tar.gz; do
filedate=$(date -r "$f" +%s)
if [[ -z "$startdatein" ]] || [[ $filedate -ge $startdate ]]; then
echo "$f:"
if [[ -z "$targetfile" ]]; then
tar -xzf "$f" --to-command 'grep --label="`basename $TAR_FILENAME`" -Hin '"$pattern ; true"
else
tar -xzf "$f" --no-anchored "$targetfile" --to-command 'grep --label="`basename $TAR_FILENAME`" -Hin '"$pattern ; true"
fi
fi
done
zgrep works fine for me, only if all files inside is plain text.
it looks nothing works if the tgz file contains gzip files.
You can mount the TAR archive with ratarmount and then simply search for the pattern in the mounted view:
pip install --user ratarmount
ratarmount large-archive.tar mountpoint
grep -r '<pattern>' mountpoint/
This is much faster than iterating over each file and piping it to grep separately, especially for compressed TARs. Here are benchmark results in seconds for a 55 MiB uncompressed and 42 MiB compressed TAR archive containing 40 files:
Compression
Ratarmount
Bash Loop over tar -O
none
0.31 +- 0.01
0.55 +- 0.02
gzip
1.1 +- 0.1
13.5 +- 0.1
bzip2
1.2 +- 0.1
97.8 +- 0.2
Of course, these results are highly dependent on the archive size and how many files the archive contains. These test examples are pretty small because I didn't want to wait too long. But, they already exemplify the problem well enough. The more files there are, the longer it takes for tar -O to jump to the correct file. And for compressed archives, it will be quadratically slower the larger the archive size is because everything before the requested file has to be decompressed and each file is requested separately. Both of these problems are solved by ratarmount.
This is the code for benchmarking:
function checkFilesWithRatarmount()
{
local pattern=$1
local archive=$2
ratarmount "$archive" "$archive.mountpoint"
'grep' -r -l "$pattern" "$archive.mountpoint/"
}
function checkEachFileViaStdOut()
{
local pattern=$1
local archive=$2
tar --list --file "$archive" | while read -r file; do
if tar -x --file "$archive" -O -- "$file" | grep -q "$pattern"; then
echo "Found pattern in: $file"
fi
done
}
function createSampleTar()
{
for i in $( seq 40 ); do
head -c $(( 1024 * 1024 )) /dev/urandom | base64 > $i.dat
done
tar -czf "$1" [0-9]*.dat
}
createSampleTar myarchive.tar.gz
time checkEachFileViaStdOut ABCD myarchive.tar.gz
time checkFilesWithRatarmount ABCD myarchive.tar.gz
sleep 0.5s
fusermount -u myarchive.tar.gz.mountpoint
In my case the tarballs have a lot of tiny files and I want to know what archived file inside the tarball matches. zgrep is fast (less than one second) but doesn't provide the info I want, and tar --to-command grep is much, much slower (many minutes)1.
So I went the other direction and had zgrep tell me the byte offsets of the matches in the tarball and put that together with the list of offsets in the tarball of all archived files to find the matching archived files.
#!/bin/bash
set -e
set -o pipefail
function tar_offsets() {
# Get the byte offsets of all the files in a given tarball
# based on https://stackoverflow.com/a/49865044/60422
[ $# -eq 1 ]
tar -tvf "$1" -R | awk '
BEGIN{
getline;
f=$8;
s=$5;
}
{
offset = int($2) * 512 - and((s+511), compl(512)+1)
print offset,s,f;
f=$8;
s=$5;
}'
}
function tar_byte_offsets_to_files() {
[ $# -eq 1 ]
# Convert the search results of a tarball with byte offsets
# to search results with archived file name and offset, using
# the provided tar_offsets output (single pass, suitable for
# process substitution)
offsets_file="$1"
prev_offset=0
prev_offset_filename=""
IFS=' ' read -r last_offset last_len last_offset_filename < "$offsets_file"
while IFS=':' read -r search_result_offset match_text
do
while [ $last_offset -lt $search_result_offset ]; do
prev_offset=$last_offset
prev_offset_filename="$last_offset_filename"
IFS=' ' read -r last_offset last_len last_offset_filename < "$offsets_file"
# offsets increasing safeguard
[ $prev_offset -le $last_offset ]
done
# now last offset is the first file strictly after search result offset so prev offset is
# the one at or before it, and must be the one it is in
result_file_offset=$(( $search_result_offset - $prev_offset ))
echo "$prev_offset_filename:$result_file_offset:$match_text"
done
}
# Putting it together e.g.
zgrep -a --byte-offset "your search here" some.tgz | tar_byte_offsets_to_files <(tar_offsets some.tgz)
1 I'm running this in Git for Windows' minimal MSYS2 fork unixy environment, so it's possible that the launch overhead of grep is much much higher than on any kind of real Unix machine and would make `tar --to-command grep` good enough there; benchmark solutions for your own needs and platform situation before selecting.
Related
How do you check the size of a tar archive before saving it without doing the compression twice?
I'm trying to make a bash script that will compress directory, and will check if there is space on the disk for the directory that needs to be compressed. The problem that I'm running into is that I can't find that out without first compressing the file and passing it to wc, and then if the condition passes, compress the file again, making the PC do the compression twice for no reason. Current code: EMPTY_SPACE=$(df -k . | awk 'NR==2 {print $4}') ARCHIVE_SIZE=$(( $(tar czf - "$1" | wc -c )/1000 )) if [ $EMPTY_SPACE -lt $ARCHIVE_SIZE ]; then echo "Not enough disk space to save the archive" exit 6 fi tar czf ${1%/}".tar.gz" $1 What I would like to do is have some kind of conditional tee or the sort that would only fire if the [ $EMPTY_SPACE -lt $ARCHIVE_SIZE ] passes and would save the output of tar czf - "$1" to the disk. One other idea for solving it was to save it temporarily in a variable, but saving a potentially multi GB file in a bash variable seems like just asking for trouble. I've looked at the conditional pipeline post on the Unix StackExchange, but that only covers a conditional pipeline, and I can't (that I know of) use the same output of the tar czf - "$1" in 2 consecutive pipeline parts.
How to find latest modified files and delete them with SHELL code
I need some help with a shell code. Now I have this code: find $dirname -type f -exec md5sum '{}' ';' | sort | uniq --all-repeated=separate -w 33 | cut -c 35- This code finds duplicated files (with same content) in a given directory. What I need to do is to update it - find out latest (by date) modified file (from duplicated files list), print that file name and also give opportunity to delete that file in terminal.
Doing this in pure bash is a tad awkward, it would be a lot easier to write this in perl or python. Also, if you were looking to do this with a bash one-liner, it might be feasible, but I really don't know how. Anyhoo, if you really want a pure bash solution below is an attempt at doing what you describe. Please note that: I am not actually calling rm, just echoing it - don't want to destroy your files There's a "read -u 1" in there that I'm not entirely happy with. Here's the code: #!/bin/bash buffer='' function process { if test -n "$buffer" then nbFiles=$(printf "%s" "$buffer" | wc -l) echo "=================================================================================" echo "The following $nbFiles files are byte identical and sorted from oldest to newest:" ls -lt -c -r $buffer lastFile=$(ls -lt -c -r $buffer | tail -1) echo while true do read -u 1 -p "Do you wish to delete the last file $lastFile (y/n/q)? " answer case $answer in [Yy]* ) echo rm $lastFile; break;; [Nn]* ) echo skipping; break;; [Qq]* ) exit;; * ) echo "please answer yes, no or quit";; esac done echo fi } find . -type f -exec md5sum '{}' ';' | sort | uniq --all-repeated=separate -w 33 | cut -c 35- | while read -r line do if test -z "$line" then process buffer='' else buffer=$(printf "%s\n%s" "$buffer" "$line") fi done process echo "done"
Here's a "naive" solution implemented in bash (except for two external commands: md5sum, of course, and stat used only for user's comfort, it's not part of the algorithm). The thing implements a 100% Bash quicksort (that I'm kind of proud of): #!/bin/bash # Finds similar (based on md5sum) files (recursively) in given # directory. If several files with same md5sum are found, sort # them by modified (most recent first) and prompt user for deletion # of the oldest die() { printf >&2 '%s\n' "$#" exit 1 } quicksort_files_by_mod_date() { if ((!$#)); then qs_ret=() return fi # the return array is qs_ret local first=$1 shift local newers=() local olders=() qs_ret=() for i in "$#"; do if [[ $i -nt $first ]]; then newers+=( "$i" ) else olders+=( "$i" ) fi done quicksort_files_by_mod_date "${newers[#]}" newers=( "${qs_ret[#]}" ) quicksort_files_by_mod_date "${olders[#]}" olders=( "${qs_ret[#]}" ) qs_ret=( "${newers[#]}" "$first" "${olders[#]}" ) } [[ -n $1 ]] || die "Must give an argument" [[ -d $1 ]] || die "Argument must be a directory" dirname=$1 shopt -s nullglob shopt -s globstar declare -A files declare -A hashes for file in "$dirname"/**; do [[ -f $file ]] || continue read md5sum _ < <(md5sum -- "$file") files[$file]=$md5sum ((hashes[$md5sum]+=1)) done has_found=0 for hash in "${!hashes[#]}"; do ((hashes[$hash]>1)) || continue files_with_same_md5sum=() for file in "${!files[#]}"; do [[ ${files[$file]} = $hash ]] || continue files_with_same_md5sum+=( "$file" ) done has_found=1 echo "Found ${hashes[$hash]} files with md5sum=$hash, sorted by modified (most recent first):" # sort them by modified date (using quicksort :p) quicksort_files_by_mod_date "${files_with_same_md5sum[#]}" for file in "${qs_ret[#]}"; do printf " %s %s\n" "$(stat --printf '%y' -- "$file")" "$file" done read -p "Do you want to remove the oldest? [yn] " answer if [[ ${answer,,} = y ]]; then echo rm -fv -- "${qs_ret[#]:1}" fi done if((!has_found)); then echo "Didn't find any similar files in directory \`$dirname'. Yay." fi I guess the script is self-explanatory (you can read it like a story). It uses the best practices I know of, and is 100% safe regarding any silly characters in file names (e.g., spaces, newlines, file names starting with hyphens, file names ending with a newline, etc.). It uses bash's globs, so it might be a bit slow if you have a bloated directory tree. There are a few error checkings, but many are missing, so don't use as-is in production! (it's a trivial but rather tedious taks to add these). The algorithm is as follows: scan each file in the given directory tree; for each file, will compute its md5sum and store in associative arrays: files with keys the file names and values the md5sums. hashes with keys the hashes and values the number of files the md5sum of which is the key. After this is done, we'll scan through all the found md5sum, select only the ones that correspond to more than one file, then select all files with this md5sum, then quicksort them by modified date, and prompt the user. A sweet effect when no dups are found: the script nicely informs the user about it. I would not say it's the most efficient way of doing things (might be better in, e.g., Perl), but it's really a lot of fun, surprisingly easy to read and follow, and you can potentially learn a lot by studying it! It uses a few bashisms and features that only are in bash version ≥ 4 Hope this helps! Remark. If on your system date has the -r switch, you can replace the stat command by: date -r "$file" Remark. I left the echo in front of rm. Remove it if you're happy with how the script behaves. Then you'll have a script that uses 3 external commands :).
Deleting files by date in a shell script?
I have a directory with lots of files. I want to keep only the 6 newest. I guess I can look at their creation date and run rm on all those that are too old, but is the a better way for doing this? Maybe some linux command I could use? Thanks! :)
rm -v $(ls -t mysvc-*.log | tail -n +7) ls -t, list sorted by time tail -n +7, +7 here means length-7, so all but first 7 lines $() makes a list of strings from the enclosed command output rm to remove the files, of course Beware files with space in their names, $() splits on any white-space!
Here's my take on it, as a script. It does handle spaces in file names even if it is a bit of a hack. #!/bin/bash eval set -- $(ls -t1 | sed -e 's/.*/"&"/') if [[ $# -gt 6 ]] ; then shift 6 while [[ $# -gt 0 ]] ; do echo "remove this file: $1" # rm "$1" shift done fi The second option to ls up there is a "one" for one file name per line. Doesn't actually seem to matter, though, since that appears to be the default when ls isn't feeding a tty.
grep spacing error
Hi guys i've a problem with grep . I don't know if there is another search code in shell script. I'm trying to backup a folder AhmetsFiles which is stored in my Flash Disk , but at the same time I've to group them by their extensions and save them into [extensionName] Folder. AhmetsFiles An example : /media/FlashDisk/AhmetsFiles/lecture.pdf must be stored in /home/$(whoami)/Desktop/backups/pdf Problem is i cant copy a file which name contains spaces.(lecture 2.pptx) After this introduction here my code. filename="/media/FlashDisk/extensions" count=0 exec 3<&0 exec 0< $filename mkdir "/home/$(whoami)/Desktop/backups" while read extension do cd "/home/$(whoami)/Desktop/backups" rm -rf "$extension" mkdir "$extension" cd "/media/FlashDisk/AhmetsFiles" files=( `ls | grep -i "$extension"` ) fCount=( `ls | grep -c -i "$extension"` ) for (( i=0 ; $i<$fCount ; i++ )) do cp -f "/media/FlashDisk/AhmetsFiles/${files[$i]}" "/home/$(whoami)/Desktop/backups/$extension" done let count++ done exec 0<&3 exit 0
Your looping is way more complicated than it needs to be, no need for either ls or grep or the files and fCount variables: for file in *.$extension do cp -f "/media/FlashDisk/AhmetsFiles/$file" "$HOME/Desktop/backups/$extension" done This works correctly with spaces. I'm assuming that you actually wanted to interpret $extension as a file extension, not some random string in the middle of the filename like your original code does.
Why don't you grep -i "$extension" | while IFS=: read x ; do cp .. done instead? Also, I believe you may prefer something like grep -i ".$extension$" instead (anchor it to the end of line). On the other hand, the most optimal way is probably cp -f /media/FlashDisk/AhmetsFiles/*.$extension "$HOME/Desktop/backups/$extension/"
How can I check the size of a file using Bash?
I've got a script that checks for 0-size, but I thought there must be an easier way to check for file sizes instead. I.e. file.txt is normally 100 kB; how can I make a script check if it is less than 90 kB (including 0), and make it Wget a new copy because the file is corrupt in this case? What I'm currently using... if [ -n file.txt ] then echo "everything is good" else mail -s "file.txt size is zero, please fix. " myemail#gmail.com < /dev/null # Grab wget as a fallback wget -c https://www.server.org/file.txt -P /root/tmp --output-document=/root/tmp/file.txt mv -f /root/tmp/file.txt /var/www/file.txt fi
[ -n file.txt ] doesn't check its size. It checks that the string file.txt is non-zero length, so it will always succeed. If you want to say "size is non-zero", you need [ -s file.txt ]. To get a file's size, you can use wc -c to get the size (file length) in bytes: file=file.txt minimumsize=90000 actualsize=$(wc -c <"$file") if [ $actualsize -ge $minimumsize ]; then echo size is over $minimumsize bytes else echo size is under $minimumsize bytes fi In this case, it sounds like that's what you want. But FYI, if you want to know how much disk space the file is using, you could use du -k to get the size (disk space used) in kilobytes: file=file.txt minimumsize=90 actualsize=$(du -k "$file" | cut -f 1) if [ $actualsize -ge $minimumsize ]; then echo size is over $minimumsize kilobytes else echo size is under $minimumsize kilobytes fi If you need more control over the output format, you can also look at stat. On Linux, you'd start with something like stat -c '%s' file.txt, and on BSD and Mac OS X, something like stat -f '%z' file.txt.
stat can also check the file size. Some methods are definitely better: using -s to find out whether the file is empty or not is easier than anything else if that's all you want. And if you want to find files of a size, then find is certainly the way to go. I also like du a lot to get file size in kb, but, for bytes, I'd use stat: size=$(stat -f%z $filename) # BSD stat size=$(stat -c%s $filename) # GNU stat?
An alternative solution with AWK and double parenthesis: FILENAME=file.txt SIZE=$(du -sb $FILENAME | awk '{ print $1 }') if ((SIZE<90000)) ; then echo "less"; else echo "not less"; fi
If your find handles this syntax, you can use it: find -maxdepth 1 -name "file.txt" -size -90k This will output file.txt to stdout if and only if the size of file.txt is less than 90k. To execute a script script if file.txt has a size less than 90k: find -maxdepth 1 -name "file.txt" -size -90k -exec script \;
If you are looking for just the size of a file: cat $file | wc -c Sample output: 203233
This works in both Linux and macOS: function filesize { local file=$1 size=`stat -c%s $file 2>/dev/null` # Linux if [ $? -eq 0 ] then echo $size return 0 fi eval $(stat -s $file) # macOS if [ $? -eq 0 ] then echo $st_size return 0 fi return -1 }
Use: python -c 'import os; print (os.path.getsize("... filename ..."))' It is portable, for all flavours of Python, and it avoids variation in stat dialects.
For getting the file size in both Linux and Mac OS X (and presumably other BSD systems), there are not many options, and most of the ones suggested here will only work on one system. Given f=/path/to/your/file, what does work in both Linux and Mac's Bash: size=$( perl -e 'print -s shift' "$f" ) or size=$( wc -c "$f" | awk '{print $1}' ) The other answers work fine in Linux, but not in Mac: du doesn't have a -b option in Mac, and the BLOCKSIZE=1 trick doesn't work ("minimum blocksize is 512", which leads to a wrong result) cut -d' ' -f1 doesn't work because on Mac, the number may be right-aligned, padded with spaces in front. So if you need something flexible, it's either perl's -s operator , or wc -c piped to awk '{print $1}' (awk will ignore the leading white space). And of course, regarding the rest of your original question, use the -lt (or -gt) operator: if [ $size -lt $your_wanted_size ]; then, etc.
Based on gniourf_gniourf’s answer, find "file.txt" -size -90k will write file.txt to stdout if and only if the size of file.txt is less than 90K, and find "file.txt" -size -90k -exec command \; will execute the command command if file.txt has a size less than 90K. I have tested this on Linux. From find(1), … Command-line arguments following (the -H, -L and -P options) are taken to be names of files or directories to be examined, up to the first argument that begins with ‘-’, … (emphasis added).
ls -l $file | awk '{print $6}' assuming that ls command reports filesize at column #6
I would use du's --threshold for this. Not sure if this option is available in all versions of du but it is implemented in GNU's version. Quoting from du(1)'s manual: -t, --threshold=SIZE exclude entries smaller than SIZE if positive, or entries greater than SIZE if negative Here's my solution, using du --threshold= for OP's use case: THRESHOLD=90k if [[ -z "$(du --threshold=${THRESHOLD} file.txt)" ]]; then mail -s "file.txt size is below ${THRESHOLD}, please fix. " myemail#gmail.com < /dev/null mv -f /root/tmp/file.txt /var/www/file.txt fi The advantage of that, is that du can accept an argument to that option in a known format - either human as in 10K, 10MiB or what ever you feel comfortable with - you don't need to manually convert between formats / units since du handles that. For reference, here's the explanation on this SIZE argument from the man page: The SIZE argument is an integer and optional unit (example: 10K is 10*1024). Units are K,M,G,T,P,E,Z,Y (powers of 1024) or KB,MB,... (powers of 1000). Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
Okay, if you're on a Mac, do this: stat -f %z "/Users/Example/config.log" That's it!