In einem aktuellen Projekt steht bald ein signifikanter Server-Wechsel an. Um später genau sagen zu können, was das gebracht hat, wollte ich mehrere Teile der Website (verschiedene URIs) mit dem Apache Tool ab zu verschiedenen Tageszeiten, einmal vor Wechsel des Servers und nach Wechsel des Servers, testen. Da ich nicht viel Zeit verschwenden wollte, hab’ ich ein Shell-Script geschrieben das mir wenigstens die Arbeit abnimmt die verschiedenen URIs abzuchecken:
#!/bin/bash
##############################################################################
# Run ab on a list of URIs
#
# Usage:
# ab_batch.sh
#
# Author: Marcel Eichner // Ephigenia <love@ephigenia.de>
# Date: 2010-06-03
##############################################################################
URL="http://www.horrorblog.org"
SLEEP=30
URIS=(
"/"
"/blog/reca-drei-clips-und-red-band-trailer/"
"/blog/the-crazies-remake-horrorblog-kritik/"
"/blog/the-crazies-interview-clips/"
"/blog/the-devils-playground-erste-bilder/"
"/blog/a-nightmare-on-elm-street-remake-horrorblog-kritik/"
)
date
echo -e "Batch Apache-Benchmarking on n${URL}"
for URI in ${URIS[@]};
do
echo "uri: ${URI}"
ab -c 10 -t 60 "${URL}${URI}" | grep -P "(request|second):"
sleep ${SLEEP}
done
Das liefert dann zum Beispiel folgendes Ergebnis. Die Werte kann man dann in eine Tabelle übertragen und ein Diagram draus machen. Nach dem Server wechseln dann das ganze noch einmal durchführen und schon hat man einen schönen Beweis was der Umzug denn gebracht hat.
Fr 4 Jun 2010 12:15:54 CEST
Batch Apache-Benchmarking on
http://www.horrorblog.org
uri: /
Finished 349 requests
Requests per second: 5.57 [#/sec] (mean)
Time per request: 1794.754 [ms] (mean)
Time per request: 179.475 [ms] (mean, across all concurrent requests)
uri: /blog/reca-drei-clips-und-red-band-trailer/
Finished 588 requests
Requests per second: 9.79 [#/sec] (mean)
Time per request: 1021.170 [ms] (mean)
Time per request: 102.117 [ms] (mean, across all concurrent requests)
uri: /blog/the-crazies-remake-horrorblog-kritik/
Finished 407 requests
Requests per second: 6.78 [#/sec] (mean)
Time per request: 1474.255 [ms] (mean)
Time per request: 147.425 [ms] (mean, across all concurrent requests)
uri: /blog/the-crazies-interview-clips/
Finished 397 requests
Requests per second: 6.60 [#/sec] (mean)
Time per request: 1514.682 [ms] (mean)
Time per request: 151.468 [ms] (mean, across all concurrent requests)
uri: /blog/the-devils-playground-erste-bilder/
Finished 331 requests
Requests per second: 5.50 [#/sec] (mean)
Time per request: 1816.657 [ms] (mean)
Time per request: 181.666 [ms] (mean, across all concurrent requests)
uri: /blog/a-nightmare-on-elm-street-remake-horrorblog-kritik/
Finished 506 requests
Requests per second: 8.43 [#/sec] (mean)
Time per request: 1185.792 [ms] (mean)
Time per request: 118.579 [ms] (mean, across all concurrent requests)
Für Verbesserungsvorschläge bin ich wie immer offen! Kommentiert einfach!
Wie manche von euch wissen betreibe ich seit einiger Zeit ja ein kleines aber mittlerweile echt ganz gut erfolgreiches Blog über Horror- und Fantasyfilme. Bei dem dritten Gewinnspiel haben über 150 Leute mitgemacht und mir eine Email geschickt. Leider etwas viele um per Losverfahren Gewinner auszuwählen. Das folgende Beispiel wird für erfahrene Programmierer nichts neues sein oder total langweilig. Eventuell hilft’s aber dem einen oder anderen weiter ;-)
Einfach mit OSX Mail die Mails extrahieren, die das richtige Lösungswort enthalten, oder die man untersuchen möchte. Dabei erstellt Mail einfach eine Datei mit allen Email-Quelltexten untereinander in einer Textdatei. Diese kann man super mit der Bash maltretieren und die Absenderadresse extrahieren:
grep -Z -P '^From:s(.+)' mail_export.txt | uniq
Wenn man dann noch zwei Gewinner auswählen möchte, braucht man nur doch die Anzahl der Zeilen in der Datei und wählt dann einfach zwei aus. Das ganze Shell-Script sieht dann so aus:
#!/bin/bash
##########################################################
# Extract n radom emails from a file
#
# Usage:
# winner.sh [filename] [count]
#
# Author: Marcel Eichner // Ephigenia <love@ephigenia.de>
# Date: 2009-03-30
##########################################################
TMPFILE=`mktemp -t emails` || exit 1
grep -Z -P '^From:s(.+)' "$1" | uniq > $TMPFILE
# select random line from file
LCOUNT=`wc -l "${TMPFILE}" | awk ' { print $1; }'`
echo "Choosing ${2:-1} winners from ${LCOUNT} emails"
for (( i = 0 ; i < ${2:-1}; i++ ))
do
LINENUMBER=$((($RANDOM % $LCOUNT) + 1))
sed -n ${LINENUMBER}p ${TMPFILE}
done
Das Script kann wenn es ganz doof kommt auch zwei mal die gleichen Absender auswählen. Wenn das passiert kann man das Bash-Script ja gleich noch mal laufen lassen. Danke an Caspar der noch weitere hilfreiche Anregungen gegeben hat!
Aus aktuellem Anlass wollte ich ein Shell-Script schreiben das mir anzeigt, wenn sich eine Datei ändert (ein Log-File) und diese dann kurz ausgibt. Jedes mal wenn sich also die Datei ändert, klingelt es im Terminal (printf 'a') und ich bekomme die letzten Einträge angezeigt:
interval=${2:-1}
filename=$1
filename=${filename:?"missing."}
while true
do
if test `find "$filename" -mmin ${interval}`
then
clear;
printf "`date`n$filenameann";
tail "$filename"
fi
echo "sleeping for next check in $((interval * 60)) seconds ..."
sleep $((interval * 60))
done
Man kann das auch auf die Spitze treiben, aber so macht’s erstmal das was ich wollte. Benutzt wird es dann wie folgt:
./fileChanged.sh folder/testlog.log
Checkt dann jede Minute ob die Datei sich geändert hat. Wer rausbekommt wie man das mit Sekunden machen kann sagt mir Bescheid :)
Wer sich mit Websiten beschäftigt die von mehr als 100 Besuchern am Tag besucht werden und nicht wirklich viel im Terminal macht freut sich eventuell über Apache Bench.
Das ist ein Programm das man auf OSX ganz einfach im Terminal laufen lassen kann um seinen Server mal so richtig schwitzen zu lassen.
Ein üblicher (und auch vergleichbarer) Aufruf ist der folgende:
ab -c 10 -t 60 http://localhost/myProject/
Was 60 Sekunden lang, immer 10 Requests auf die Seite abfeuert und einem danach folgende Ausgabe generiert:
Finished 3102 requests
Server Software: Apache/2.0.59
Server Hostname: localhost
Server Port: 80
Document Path: /myProject/
Document Length: 2005 bytes
Concurrency Level: 10
Time taken for tests: 60.002 seconds
Complete requests: 3102
Failed requests: 303
(Connect: 0, Receive: 0, Length: 303, Exceptions: 0)
Write errors: 0
Total transferred: 7530897 bytes
HTML transferred: 6211149 bytes
Requests per second: 51.70 [#/sec] (mean)
Time per request: 193.431 [ms] (mean)
Time per request: 19.343 [ms] (mean, across all concurrent requests)
Transfer rate: 122.57 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 1 1.2 0 11
Processing: 30 186 663.6 157 20630
Waiting: 0 161 83.6 155 621
Total: 30 187 663.6 157 20631
Percentage of the requests served within a certain time (ms)
50% 157
66% 196
75% 219
80% 235
90% 276
95% 309
98% 354
99% 386
100% 20631 (longest request)
In dieser Ausgabe kann man erkennen das das aktuelle Projekt so ca. 50 Leute gleichzeitig aushalten könnte. Im vergleich mit anderen Projekten kann man dann Rückschlüsse darauf ziehen wie gut man programmiert hat ;-)
Viele benutzen ab auch zum Vergleich von verschiedenen Frameworks die ich euch natürlich nicht vorenthalten möchte: Test1, Test2 und Test3.
ab kann man wie üblich über macports installieren (OSX Developer Tools müssen installiert sein):
sudo port install ab
Ein weiterer Vorteil von mediatemple Servern ist, dass man per rsync und ssh einfache Projektupdates schieben kann.
Ich arbeite an den meisten Projekten, wie auch diesem Blog, lokal auf meinem Rechner und habe bisher immer mit Transmit syncronisiert. Da Transmit aber reichlich beschränkt ist, was die Einstellungsmöglichkeiten betrifft und mein PHP-FTP Sync Programm nicht 100% alle Features abdeckt die rsync abdeckt habe ich mich damit mal beschäftigt.
Sobald man einen ssh Zugang zu seinem Mediatemple server hat kann man mit nur einer Zeile in der Console sein komplettes Projekt updaten - in Windeseile!
rsync -avzcu --cvs-exclude --progress [localDir] -e ssh [host]:[remoteDir] --exclude-from deployIgnore.txt
Die mit eckigen Klammern umklammerten Sachen müsste man dann einfach durch eigene Werte ersetzen.
k, ich hab’s ja versprochen, hier ein kleines shell script für den kleinen mac und auch die großen, um mehrere *.rar Dateien mit einem Passwort zu entpacken:
# copy from marceleichner.de/
password=$1
i=0
for var in "$@"
do
if [ "$i" != 0 ]
then
echo "extracting $var"
command="nice unrar e -p$password $var"
echo $command
$command
fi
i=$((i+1))
done
echo 'OK, finished!'
Das ganze einfach, am liebsten als unroar.sh abspeichern, und aufrufen:
sh unroar.sh passwort erstedatei.rar zweitedateivonwoanders.rar
vielleicht hilft das ja dem einen oder anderen!
Für alle die mal gerne in großen Listen auf ihrem Apple Suchen und gerne wissen wollten wie viel da denn drauf ist (in einem Ordner)
Alle HD-Filme daran erkennen das man die irgendwie im Dateinamen mit "HD" markiert hat:
$ ls | grep HD
Wie viele können das wohl sein?
$ ls | grep HD | wc -l
Das ganze kann man auch einfach abspeichern!
$ ls | grep HD > ~/Desktop/HD_Movies.txt
Speichert euch alles mit HD im Namen auf dem Desktop als Textdatei.
So und um das mal ein wenig praktisch zu machen: Ein Befehl, der euch alle HD Filme aus eurem Home-Movie Ordner auf dem Desktop speichert:
$ ls ~/Movies/ | grep HD > ~/Desktop/HD_Movies.txt
Das ~ bekommt ihr btw. mit Apfel+N (auf der deutschen Klampfe), danach ein Leerzeichen machen!
Das schöne ist - jeder Mac kann das! Ja sogar jeder auf nem *-NIX System basierender Rechner! Ich hab das nicht rausgefunden. Aber das sog. Piping ist so alt und trotzdem noch so toll aktuell und cool - zieht euch hoffentlich die Socken aus. Demnächst noch mehr - "Wie finde ich alle MP3s von einem Künstler" ... bald!
Kommentieren und noch mehr nachfragen ist erwünscht!
Da ich jetzt von KeepassX auf 1Password umgestiegen bin habe ich nicht mehr diese tolle "Passwort generieren"-Funktion und deswegen hab' ich mich mal auf die Suche begeben und hab dieses echt schicke, kurze, einfache Perl script gefunden:
#!/usr/bin/perl
if($ARGV[0] !~ /^d+/) { $count=9; }
else { $count=$ARGV[0]; }
system("head -c $count /dev/random | uuencode -m - | tail -n 2 | head -n 1 ");
Das Speichert man einfach unter einem beliebigen Namen und ruft es im Terminal auf:
$ perl genpass.pl 32
und schon hat man schicke Passwörter :)
So, jetzt mal wieder was für die Shell-Freaks und so ... ist vielleicht nicht für alle interessant, wie schon die vorherigen Beiträge gezeigt haben, aber naja, hey! ich blogge wieder - is das 'n Ding ;-)
Verzeichnisse eines Ordners in einen Array lesen
for i in ./*
do
if (test -d "$i") then
arr[${#dirArr[*]}]=$i;
fi
done
Danach kann man die Ordner fein Zippen - oder sonstwas damit machen wenn man Bock hat:
for dirName in ${dirArr[@]}
do
zip -rq $dirName ./$dirName/*
done
So, wie gestern schon angekündigt, kann ich jetzt endlich code Zeilen posten! Was für ein Spass! So, jetzt hier das aller erste mal richtiger Code. Einfach und nützlich.
Wer auf -NIX Systemen (oder auch OSX) arbeitet kann das hier vielleicht gebrauchten:
# configuration
projectName=$1
projectsDir=projects/
deployDir=download/
# display help message, when -h or --help passed
if (test "$projectName" = "-h" || test "$projectName" = "--help") then
echo "this is the help message for your help - nice huh?"
echo "this script was created for deploying a project"
echo "example usage:"
echo " sh deploy.sh ephReggy -- deploys the ephReggy project"
echo " sh deploy.sh all -- deploys all projects found in the $deployDir"
echo
exit
fi
# no param given, no projectname passed
if (test "$projectName" = '') then
echo "empty project name, please specify a project name"
exit
fi
# deploy all projects? hu?
if (test "$projectName" = "all") then
echo "okay, deploying all projects? Sure? (Y/N) c"
read deployAll
if (test ! "$deployAll" = 'Y') then
echo "okay, no deployment done. see ya!"
exit
fi
projectsToDeploy=( ephReggy ephScrobblrRead ephVat ephWatts )
# deploy only project that was passed
else
projectsToDeploy=( $projectName )
fi
# create deploy directory
if (test ! -d "$deployDir") then
echo "creating deploy Directory $deploy ..."
mkdir "$deployDir"
fi
# start deploying projects
for projectName in ${projectsToDeploy[@]}
do
projectDir=$projectName
# test existence of project folder
projectDir="$projectsDir$projectName"
if (test ! -d "$projectDir") then
echo "project directory for $projectName was not found: $projectDir";
exit
fi
# start deploying
# add exclude if found
if (test -f "deploy_exclude.lst") then
excludeStatement="-x@deploy_exclude.lst"
fi
projectZipFileName="$deployDir$projectName.zip"
echo "deploying $projectName to $projectZipFileName c"
zip -rq $excludeStatement $projectZipFileName $projectDir/*
echo "done!"
done
echo "Everything done, now quiting. See Ya!"
Im groben nimmt dieses Shell-Script einen Ordner den man per Paramter angibt und im $projectsDir liegen muss, zippt diesen und platziert das Zip in $deployDir. Sehr hilfreich wenn man mehrere Projekte, also Ordner zippen möchte und keine Lust hat alles per Hand über den Finder zu machen - Anklicken, zippen, verschieben entfällt.
Man gibt einfach so was in die Console ein:
$ sh deploy.sh all
"deployed" alle Projekte in dem Projekte Ordner die in dem $projectsToDeploy Array angegeben sind. (wie auf dem Screen weiter unten gezeigt)
Einzelne Projekte, oder halt Ordner kann man folgendem Befehl "deployen":
$ sh deploy ephReggy
Wenn man es total funky will kann man auch sog. Escape-Sequenzen benutzen um die Ausgabe des Scripts farbig zu gestalten. Hier ein Screenshot, der zugleich farbige Ausgabe zeigt, als auch die Funktionsweise:
Joar, vielleicht etwas wirr, aber probiert das mal aus, das bringts voll!
Denkbar ist das man das ausbaut, das Script die Dateien auch auf einen Server hochlädt, Teile des Quellcodes löscht, die man nicht drin haben will (offline Code, Testing-Code, Kommentare usw.) und was weiss ich.