├── README
├── apache_top5log.py
├── bash-web-server.sh
├── block_daemon
    ├── README
    ├── block_daemon.pl
    ├── block_daemon_wrapper.sh
    └── block_ip_daemon.sh
├── carp
    ├── check_carp.sh
    └── check_carp_wrapper.sh
├── check_areca.sh
├── check_disk_dmesg.pl
├── check_disks.pl
├── check_domain.pl
├── check_http.py
├── check_md.sh
├── check_md5sums_script.sh
├── check_raid_etegro.sh
├── check_snmp_disk.sh
├── chroot_ssh_freebsd.sh
├── cpu_util_linux_bsd.py
├── create_lxc.sh
├── disk_iostat.pl
├── geoupdate.sh
├── host_checker.py
├── ipfw_rules.sh
├── iptables_rules.sh
├── jail_make
    ├── Makefile
    ├── README
    ├── fstab.in
    └── rc.config.in
├── java_prof.sh
├── kickstart
    ├── ks.cfg
    ├── ks.cfg_default
    └── make_ks.sh
├── kill_ppid.py
├── logrotate.sh
├── mailx_wrapper.py
├── merger.sh
├── mongo_reclaim.sh
├── mongodb_backup.sh
├── mp3.sh
├── mysql_pgsql_backup
    ├── mysqlbackup.sh
    ├── mysqldumpslow
    ├── mysqlhotbackup.sh
    ├── mysqlhotcopy
    ├── pgsqlbackup.sh
    └── slowlogstats
├── mysql_replica_watcher.py
├── mysqlbackup_snapshot.sh
├── pgsqlbackup.sh
├── prich_nginxconf.sh
├── send_xmpp_message.py
├── squid
    ├── allowed_urls
    ├── denied_urls
    ├── extended_access_group
    └── squid.conf
├── svnconfbackup.conf
├── svnconfbackup.sh
├── svncreat.sh
├── tail_with_thread.sh
├── template_bash_script.sh
├── template_python_script.py
├── top_ip_address.sh
├── usbmodem_watchdog.sh
├── users_whitelist.sh
├── webdiff.sh
├── whatsapp_install.sh
└── win_installed_pkg_list.ps


/README:
--------------------------------------------------------------------------------
1 | some useful admin scripts
2 | 


--------------------------------------------------------------------------------
/apache_top5log.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | 
  3 | # top5log 25 < apache.log
  4 | # where the argument 25 represents how many days ago the day of interest is (the default is 1, i.e., yesterday), and apache.log is the name of the log file, which the script reads via stdin. The output looks like this:
  5 | 
  6 | # Jul 03, 2013 pages
  7 | #     907  /all-this/2013/06/feedle-dee-dee/
  8 | #     813  /all-this/
  9 | #     749  /all-this/2013/07/last-i-hope-thoughts-on-rss/
 10 | #      74  /all-this/2007/03/improved-currency-conversion-card/
 11 | #      74  /all-this/2009/08/camry-smart-key-battery-replacement/
 12 | #    7134  total
 13 | 
 14 | 
 15 | import re
 16 | import sys
 17 | from datetime import datetime, date, timedelta
 18 | from collections import Counter
 19 | 
 20 | # Define the day of interest in the Apache common log format.
 21 | try:
 22 |   daysAgo = int(sys.argv[1])
 23 | except:
 24 |   daysAgo = 1
 25 | theDay = date.today() - timedelta(daysAgo)
 26 | apacheDay = theDay.strftime('[%d/%b/%Y:')
 27 | 
 28 | # Regex for the Apache common log format.
 29 | parts = [
 30 |     r'(?P<host>\S+)',                   # host %h
 31 |     r'\S+',                             # indent %l (unused)
 32 |     r'(?P<user>\S+)',                   # user %u
 33 |     r'\[(?P<time>.+)\]',                # time %t
 34 |     r'"(?P<request>.*)"',               # request "%r"
 35 |     r'(?P<status>[0-9]+)',              # status %>s
 36 |     r'(?P<size>\S+)',                   # size %b (careful, can be '-')
 37 |     r'"(?P<referrer>.*)"',              # referrer "%{Referer}i"
 38 |     r'"(?P<agent>.*)"',                 # user agent "%{User-agent}i"
 39 | ]
 40 | pattern = re.compile(r'\s+'.join(parts)+r'\s*\Z')
 41 | 
 42 | # Regex for a feed request.
 43 | feed = re.compile(r'/all-this/(\d\d\d\d/\d\d/[^/]+/)?feed/(atom/)?')
 44 | 
 45 | # Change Apache log items into Python types.
 46 | def pythonized(d):
 47 |   # Clean up the request.
 48 |   d["request"] = d["request"].split()[1]
 49 | 
 50 |   # Some dashes become None.
 51 |   for k in ("user", "referrer", "agent"):
 52 |     if d[k] == "-":
 53 |       d[k] = None
 54 | 
 55 |   # The size dash becomes 0.
 56 |   if d["size"] == "-":
 57 |     d["size"] = 0
 58 |   else:
 59 |     d["size"] = int(d["size"])
 60 | 
 61 |   # Convert the timestamp into a datetime object. Accept the server's time zone.
 62 |   time, zone = d["time"].split()
 63 |   d["time"] = datetime.strptime(time, "%d/%b/%Y:%H:%M:%S")
 64 | 
 65 |   return d
 66 | 
 67 | # Is this hit a page?
 68 | def ispage(hit):
 69 |   # Failures and redirects.
 70 |   hit["status"] = int(hit["status"])
 71 |   if hit["status"] < 200 or hit["status"] >= 300:
 72 |     return False
 73 | 
 74 |   # Feed requests.
 75 |   if feed.search(hit["request"]):
 76 |     return False
 77 | 
 78 |   # Requests that aren't GET.
 79 |   if hit["request"][0:3] != "GET":
 80 |     return False
 81 | 
 82 |   # Images, sounds, etc.
 83 |   if hit["request"].split()[1][-1] != '/':
 84 |     return False
 85 | 
 86 |   # Must be a page.
 87 |   return True
 88 | 
 89 | # Regexes for internal and Google search referrers.
 90 | internal = re.compile(r'https?://(www\.)?leancrew\.com.*')
 91 | google = re.compile(r'https?://(www\.)?google\..*')
 92 | 
 93 | # Is the referrer interesting? Internal and Google referrers are not.
 94 | def goodref(hit):
 95 |   if hit['referrer']:
 96 |     return not (google.search(hit['referrer']) or
 97 |                 internal.search(hit['referrer']))
 98 |   else:
 99 |     return False
100 | 
101 | # Initialize.
102 | pages = []
103 | 
104 | # Parse all the lines associated with the day of interest.
105 | for line in sys.stdin:
106 |   if apacheDay in line:
107 |     m = pattern.match(line)
108 |     hit = m.groupdict()
109 |     if ispage(hit):
110 |       pages.append(pythonized(hit))
111 |     else:
112 |       continue
113 | 
114 | # Show the top five pages and the total.
115 | print '%s pages' % theDay.strftime("%b %d, %Y")
116 | pageViews = Counter(x['request'] for x in pages)
117 | top5 = pageViews.most_common(5)
118 | for p in top5:
119 |   print "  %5d  %s" % p[::-1]
120 | print "  %5d  total" % len(pages)
121 | 
122 | # Show the top five referrers.
123 | print '''
124 | %s referrers''' % theDay.strftime("%b %d, %Y")
125 | referrers = Counter(x['referrer'] for x in pages if goodref(x) )
126 | top5 = referrers.most_common(5)
127 | for r in top5:
128 |   print "  %5d  %s" % r[::-1]
129 | 


--------------------------------------------------------------------------------
/bash-web-server.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash 
  2 | 
  3 | # usage: ncat -l 8080 -e ./httpd.sh
  4 | 
  5 | ### global variables that contain the configuration options ###
  6 | basedir="$PWD/webroot"
  7 | logfile="/tmp/httpd.log"
  8 | timeout="10"
  9 | ###############################################################
 10 | 
 11 | log() {
 12 | 	# use tail -f /tmp/httpd.log
 13 | 	echo $@ >> "$logfile"
 14 | }
 15 | 
 16 | process_alive() {
 17 | 	ps -o pid= --pid $1 &> /dev/null
 18 | }
 19 | 
 20 | kill_tree() {
 21 | 	for child in $(ps -o pid= --ppid $1); do
 22 | 		kill_tree $child
 23 | 	done
 24 | 	kill -9 $1
 25 | }
 26 | 
 27 | fork_with_timeout() {
 28 |     log "running $@"
 29 |     iters=0
 30 |     $@ 2>> $logfile &
 31 |     pid=$!
 32 |     log "forked CGI: $pid, waiting"
 33 |     while process_alive $pid; do 
 34 | 	    if [ $iters -ge $((5*timeout)) ]; then
 35 | 		    log "Killing $pid"
 36 | 		    kill_tree $pid
 37 | 		    break
 38 | 	    fi
 39 | 	    sleep 0.2
 40 | 	    iters=$((iters+1))
 41 |     done
 42 |     log "Killer process on $pid exiting"
 43 |     wait $pid # && echo $?
 44 | }
 45 | 
 46 | upperx() {
 47 |     echo "$*" | tr 'a-z' 'A-Z' | tr -d '\r'
 48 | }
 49 | 
 50 | serve() {
 51 |     if [ ! -e "$(echo "${basedir}""${url}" | sed 's#%20#\ #g')" ]; then response "404 Not found" "$basedir$url"
 52 |     else
 53 |         if [ ! -r "$(echo "${basedir}""${url}" |   sed 's#%20#\ #g')" ]; then response "403 Forbidden" "$basedir$url"
 54 |             else
 55 |             response "200 OK" "${basedir}""${url}"
 56 |         fi
 57 |     fi
 58 | }
 59 | 
 60 | get_mime() {
 61 | 	file="$1"
 62 | 	mime=$(file --mime-type "$file" | sed 's#.*:\ ##')
 63 | 	if [ $mime = "application/x-directory" -o $mime = "application/x-empty" ]; then mime="text/html"; fi
 64 | 	echo $mime
 65 | }
 66 | 
 67 | add_header() {
 68 |     echo "$1" | egrep -i "^$2:" &>/dev/null || echo -en "$2: $3\r\n"
 69 | }
 70 | 
 71 | list_dir() {
 72 |                     echo "<table><tr><th>"
 73 |                     IFS=$(echo -en "\n\b")
 74 |                     for file in $(ls -1a "$path" | grep -v "^\.$"); do
 75 |                         [ -d "$path/$file" ] && file="$file/"
 76 |                         echo "<tr><td valign="top"><a href=\""$file"\">"$file"</a></td>"
 77 |                     done
 78 |                     unset IFS
 79 |                     echo "</th></tr></table>"
 80 | }
 81 | 
 82 | response() {
 83 | 	code="$1"
 84 |         path="$(echo $2 | sed -e 's#\ #%20#g')"
 85 |         [[ "$code" != "200 OK" ]] && echo "$(upperx $http_version) $code";
 86 | 	
 87 | 	case "$code" in
 88 | 		200*)
 89 | 	        mime=$(get_mime "$path")
 90 | 		if [ -d "$path" ]; then 
 91 |                     echo "$(upperx $http_version) $code";
 92 |                     tmpfile=$(mktemp)
 93 |                     echo $(list_dir "$path") > "$tmpfile"
 94 | 		    echo -en "Content-Type: $mime; charset=utf-8\r\n"
 95 | 		    echo -en "Connection: close\r\n"
 96 | 		    echo -en "Content-Length: $(wc -c < "$tmpfile")\r\n\r\n"
 97 | 		    cat "$tmpfile" && rm -f "$tmpfile"
 98 | 	       elif [ -x "$path" ] && [[ "$path" =~ \.cgi$ ]]; then
 99 |                             tmpfile=$(mktemp)
100 |                             cgiret=$(mktemp)
101 | 			    echo "$(fork_with_timeout "$path" ; echo "$?" > "$cgiret")" > "$tmpfile"
102 |                             if [ "$(cat $cgiret)" != "0" ]; then
103 |                                 code="500 Internal Server Error"
104 |                                 rm -f $cgiret
105 |                                 echo "$(upperx $http_version) $code";
106 |                                 print_500
107 |                             else
108 |                                 rm -f $cgiret
109 |                                 echo "$(upperx $http_version) $code";
110 | 			        if cat "$tmpfile" | tr -d '\r' | egrep '^$' &>/dev/null; then
111 | 			                log "Headers found."
112 | 				        headers="$(cat "$tmpfile" | sed -rn '1,/^\r*$/p')"
113 | 				        sed -ri '1,/^\r*$/d' "$tmpfile"
114 | 			        else
115 | 			                log "No headers found."
116 | 			        fi
117 | 
118 | 			        add_header "$headers" "Content-Type"   "text/plain; charset=UTF-8"
119 | 			        add_header "$headers" "Content-Length" "$(wc -c < "$tmpfile")"
120 | 			        add_header "$headers" "Connection" "close"
121 | 
122 | 			        echo "$headers"
123 | 			        cat $tmpfile && rm -f "$tmpfile"
124 |                             fi
125 | 		else
126 |                         echo "$(upperx $http_version) $code";
127 | 			echo -en "Content-Length: $(wc -c < "$path")\r\n";
128 | 			echo -en "Connection: close\r\n"
129 | 			echo -en "Content-Type: $mime\r\n\r\n";
130 | 			cat "$path" # FIXME: directory traversal?
131 | 		fi
132 | 		;;
133 | 
134 | 		403*)
135 |                     print_403
136 | 		;;
137 |             	404*)
138 |                     print_404
139 | 		;;
140 |                 501*)
141 |                     print_501
142 |                 ;;  
143 | 	        *)
144 |                     print_500
145 |                 ;;
146 | 	esac
147 | }
148 | 
149 | print_403() {
150 | ### 403 forbidden ###
151 | cat << 403
152 | Content-Type:text/html; charset=utf-8
153 | Connection: close
154 | 
155 | <html><head>
156 | <title>403 Forbidden</title>
157 | </head><body>
158 | <h1>Forbidden</h1>
159 | <p>You don't have permission to access $url
160 | on this server.</p>
161 | </body></html>
162 | 403
163 | }
164 | 
165 | print_404() {
166 | ### 404 not found ###
167 | cat << 404
168 | Content-Type:text/html; charset=utf-8
169 | Connection: close
170 | 
171 | <html><head>
172 | <title>404 Not Found</title>
173 | </head><body>
174 | <h1>Not Found</h1>
175 | <p>The requested URL $url was not found on this server.</p>
176 | </body></html>
177 | 404
178 | }
179 | 
180 | print_500() {
181 | # 500 Server Error
182 | cat << 500
183 | Content-Type:text/html; charset=utf-8
184 | Connection: close
185 | 
186 | <html><head>
187 | <title>500 Server error</title>
188 | </head><body>
189 | <h1>Server error</h1>
190 | <p>Method not implemented or other misconfiguration occured.</p>
191 | </body></html>
192 | 500
193 | }
194 | 
195 | print_501() {
196 | # 501 Not Implemented
197 | cat << 501
198 | Content-Type:text/html; charset=utf-8
199 | <html><head>
200 | <title>501 Not implemented</title>
201 | </head><body>
202 | <h1>Not Implemented</h1>
203 | <p>Method not implemented or other misconfiguration occured.</p>
204 | </body></html>
205 | 501
206 | }
207 | 
208 | url_escape() {
209 |  encoded=$(
210 |    echo "$1" | hexdump -v -e '1/1 "%02x\t"' -e '1/1 "%_c\n"' |
211 |    LANG=C awk '
212 |      $1 == "20"                     { printf("%s",   "+");  next } 
213 |      $1 ~  /0[adAD]/                {                       next } 
214 |      $2 ~  /^[_a-zA-Z0-9.*()\/-]$/  { printf("%s",   $2);   next }
215 |                                     { printf("%%%s", $1)         }
216 |    ')
217 |   echo "$encoded"
218 | }
219 | 
220 | read method rest # url + http version
221 | http_version=$(echo "$rest" | awk '{print $NF}')
222 | rawurl=$(echo "$rest" | sed "s# $http_version\$##")
223 | url=$(url_escape "$rawurl")
224 | 
225 | host="?"
226 | while read header; do
227 | 	header="$(echo "$header" | tr -d '\r')"
228 | 	[ "$header" = "" ] && break
229 | 
230 | 	[[ "$header" =~ ^[hH][oO][sS][tT] ]] && host="${header#*:}"
231 | done
232 | 
233 | case "$(upperx $http_version)" in
234 |   HTTP/1.0)
235 |   ;;
236 | 
237 |   HTTP/1.1)
238 | 	log "Host: $host"
239 |   ;;
240 | 
241 |   *)
242 |     response 501 "Not Implemented" ""
243 |     exit 1
244 |   ;;
245 | esac
246 | 
247 | case "$(upperx $method)" in
248 |   GET)
249 |     serve
250 |   ;;
251 | 
252 |   POST) 
253 |     response 501 "Not Implemented" ""
254 |   ;;
255 | 
256 |   *)
257 |    response 500 "Server error" ""
258 |   ;;
259 | esac
260 | 


--------------------------------------------------------------------------------
/block_daemon/README:
--------------------------------------------------------------------------------
1 | just for fun
2 | old stuff
3 | play with perl and nginx
4 | daemon add deny ip to nginx blocklist
5 | 


--------------------------------------------------------------------------------
/block_daemon/block_daemon.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/local/bin/perl -w
 2 | 
 3 | use IO::Socket;
 4 | use Net::hostent;
 5 | use Sys::Syslog;
 6 | use File::Pid;
 7 | 
 8 | $pidFile  = "/tmp/block_daemon.pid";
 9 | $denyconf = "/usr/local/etc/nginx/blocked.conf";
10 | 
11 | $pid = fork();
12 | if($pid) {
13 |     exit(0);
14 | }
15 | 
16 | $pidfile = File::Pid->new( { file => $pidFile, } );
17 | $pidfile->write or die "Can't write PID file, /dev/null: $!";
18 | 
19 | $server = new IO::Socket::INET ( LocalPort => '7070', Proto => 'tcp', Listen => 1, Reuse => 1,  );
20 | die "Could not create socket: $!\n" unless $server;
21 |  while ($client = $server->accept()) {
22 |    $client->autoflush(1);
23 |    print $client "200 Welcome to $0\n";
24 |    $hostinfo = gethostbyaddr($client->peeraddr);
25 |    while ( <$client>) {
26 |      next unless /\S/;       # blank line
27 |      if    (/quit|exit/i)    { last;                                     }
28 |      elsif (/date|time/i)    { printf $client "200 %s\n", scalar localtime;  }
29 |      elsif (/commit MEDVED/i) {
30 |     system("nginx -t -q && killall -1 nginx"); 
31 |     syslog("security|notice", "COMMIT from %s\n", $hostinfo->name || $client->peerhost);
32 |      }
33 |      elsif (/commit/i){ printf $client "421 try again\n",  }
34 |      elsif (/clear/i) {
35 |         open FILE, ">", $denyconf or die $!;
36 |         printf FILE "";
37 |         close FILE;
38 |     syslog("security|notice", "CLEAR from %s\n", $hostinfo->name || $client->peerhost);
39 |      }
40 |      elsif (m/^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?) PREVED$/) {
41 |     open FILE, ">>", $denyconf or die $!;
42 |     chomp;
43 |     s/PREVED//g;
44 |     printf FILE "deny %s;\n", $_;
45 |     close FILE;
46 |     syslog("security|notice", "%s from %s\n", $_, $hostinfo->name || $client->peerhost);
47 |      }
48 |      else {
49 |        print $client "301 Commands: {clear|commit|quit}\n";
50 |      }
51 |    } continue {
52 |       print $client "220 Ready\n";
53 |    }
54 |    close $client;
55 |  }  
56 | 
57 | 


--------------------------------------------------------------------------------
/block_daemon/block_daemon_wrapper.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #Small wrapper for block_daemon.pl
 3 | if [ -f /tmp/block_daemon.pid ] ; then
 4 |    # the pid file already exists, so what to do?
 5 |    if [ "$(ps -aux|grep `cat /tmp/block_daemon.pid` |grep -v grep | wc -l)" -eq 1 ]; then
 6 |      # process is still running
 7 |      exit 0
 8 |    else
 9 |      # process not running, but pid file not deleted?
10 |      rm /tmp/block_daemon.pid
11 |      perl /root/bin/block_daemon.pl
12 |    fi
13 | fi
14 | 
15 | 


--------------------------------------------------------------------------------
/block_daemon/block_ip_daemon.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
 3 | 
 4 | #Collect ip to block and send them to perl daemon on server.
 5 | for ip in `tail -20000 /logs/apache/access_log | grep 'spam' | awk '{print $1}' | sort | uniq -c | sort -g | awk '$1>25{print $2}' | grep -v ^$`;do
 6 |         #echo $ip PREVED
 7 |         echo $ip PREVED|nc server 7070
 8 | done
 9 | 
10 | #Send -HUP to nginx on server
11 | echo "commit MEDVED"|nc server 7070


--------------------------------------------------------------------------------
/carp/check_carp.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | usage() {
 4 | 	echo "$0 iface_num (int)"
 5 | 	exit 1
 6 | }
 7 | 
 8 | ret() {
 9 | 	R=${1}
10 | 	if [ "x${R}" = "xOK" ]; then
11 | 		RET="0";
12 | 	else
13 | 		RET="2";
14 | 	fi
15 | 	echo "${R}: carp${2}: ADVSKEW: ${3}; STATUS: ${4}"
16 | 	exit ${RET}
17 | }
18 | 
19 | IFACE=${1}
20 | if echo ${IFACE} | grep -E '^[0-9]+$' > /dev/null; then :; else usage; fi
21 | 
22 | STATUS="`ifconfig carp${IFACE} 2>/dev/null | grep "carp:" | awk '{print $2;}'`"
23 | ADVSKEW="`ifconfig carp${IFACE} 2>/dev/null | grep "carp:" | awk '{print $8;}'`"
24 | 
25 | if [ "x${ADVSKEW}" = "x1" ]; then
26 | 	if [ "x${STATUS}" = "xMASTER" ]; then
27 | 		ret OK ${IFACE} ${ADVSKEW} ${STATUS}
28 | 	else
29 | 		ret ERR ${IFACE} ${ADVSKEW} ${STATUS}
30 | 	fi
31 | else
32 | 	if [ "x${ADVSKEW}" != "x" ]; then
33 | 		if [ "x${STATUS}" = "xBACKUP" ]; then
34 | 			ret OK ${IFACE} ${ADVSKEW} ${STATUS}
35 | 		else
36 | 			ret ERR ${IFACE} ${ADVSKEW} ${STATUS}
37 | 		fi
38 | 	fi
39 | fi
40 | echo "ERR: can't determinate IFACE: carp${IFACE}, STATUS: ${STATUS} or ADVSKEW: ${ADVSKEW}"
41 | 


--------------------------------------------------------------------------------
/carp/check_carp_wrapper.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | for i in `jot - 0 5`; do
4 | 	STATUS=`/root/bin/check_carp.sh ${i}`
5 | 	if echo ${STATUS} | grep OK > /dev/null; then :; else echo -n "${STATUS}"; F=1; fi
6 | done
7 | 
8 | if [ "x${F}" != 1 ]; then echo -n " "; fi
9 | 


--------------------------------------------------------------------------------
/check_areca.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
 4 | 
 5 | export RAIDFLAG="/var/tmp/raidflag.$1"
 6 | MAILTO='root@example.ru'
 7 | CMD="/root/bin/cli32 ctrl=$1 vsf info"
 8 | 
 9 | #alias mail=echo
10 | 
11 | $CMD | perl -x $0
12 | 
13 | if ([ "$?" -gt "0" ];) then
14 | 	if (perl -e 'exit (-f $ENV{RAIDFLAG} and -M $ENV{RAIDFLAG} < 1/24)';) then
15 | 		$CMD | mail -E -s "`hostname` RAID channel $1 alert" $MAILTO;
16 | 		touch $RAIDFLAG;
17 | 	fi
18 | else
19 | 	[ -e $RAIDFLAG ] && $CMD | mail -E -s "`hostname` RAID channel $1 recovery" $MAILTO;
20 | 	rm -f $RAIDFLAG 2>/dev/null
21 | fi
22 | 
23 | exit
24 | 
25 | #!/usr/bin/perl
26 | 
27 | # raidutil output parser
28 | # exit nonzero if any of the arrays id not optimal
29 | 
30 | $ret = 0;
31 | 
32 | while (<STDIN>) {
33 | 	$ret++ if (/Raid\d\s+[0-9\.]+GB\s+[0-9\/]+\s+(\S+)\s+$/ and $1 ne 'Normal');
34 | }
35 | 
36 | exit $ret;
37 | 


--------------------------------------------------------------------------------
/check_disk_dmesg.pl:
--------------------------------------------------------------------------------
 1 | my $DMESG_CMD  = 'dmesg | tail -50 | grep "I/O error"';
 2 | 
 3 | my @DMESG_OUT = qx($DMESG_CMD);
 4 | foreach (@DMESG_OUT) {
 5 |     if ((/I\/O error/)) {
 6 |     $errors{'DMESG'}++;
 7 |     $errors_text .= "Dmesg disk IO errors. ";
 8 |     last;
 9 |     }
10 | }
11 | my $text = join('', @GMIRROR_OUT, "\n\n\n",
12 |                     @MD_OUT, "\n\n\n",
13 |                     @MEGACLI_OUT, "\n\n\n",
14 |                     @MEGARC_OUT);


--------------------------------------------------------------------------------
/check_disks.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env perl
  2 | #/usr/local/etc/snmpd/snmpd.conf 
  3 | #exec raidmon /root/bin/check_disks.pl
  4 | 
  5 | #nagios config
  6 | #define service {
  7 | #        use                     hdd-service
  8 | #        host_name               youserver.example.com
  9 | #        service_description     raid
 10 | #        check_command           check_log_snmp!raidmon
 11 | #}
 12 | 
 13 | 
 14 | 
 15 | # TODO: add inode checks
 16 | 
 17 | use strict;
 18 | use POSIX qw(uname);
 19 | use Sys::Hostname;
 20 | use File::Glob ':glob';
 21 | 
 22 | my $mailto = 'root@example.com';
 23 | my $hostname = hostname();
 24 | my $now = time();
 25 | my $cache_file = '/tmp/check_disks_cache';
 26 | my $flag_file = '/tmp/check_disks_flag';
 27 | 
 28 | my (%errors, %warnings);
 29 | my ($nagios_crit_msg, $nagios_warn_msg);
 30 | 
 31 | my (%states, $current_dev, $errors_text, $warnings_text);
 32 | 
 33 | my $uname = (POSIX::uname())[0];
 34 | 
 35 | # Commands of checkers.
 36 | my $GMIRROR_CMD = '/sbin/gmirror list';
 37 | my $MD_CMD = "/sbin/mdadm -D `/bin/cat /proc/mdstat | /bin/awk '/^md/ {print \"/dev/\" \$1}'`";
 38 | my $MEGACLI_CMD = '/root/bin/MegaCli -CfgDsply -a0';
 39 | my $MEGARC_CMD  = '/root/bin/megarc  -dispCfg  -a0';
 40 | 
 41 | # Trying to read results from cache.
 42 | if ($ARGV[0] ne '-f') { 
 43 |     if ($now - (stat($cache_file))[9] < 300) {
 44 |         open(FH, "< $cache_file")
 45 |              or die "Can't open cache file $cache_file: $!";
 46 |         while (<FH>) { print $_; }
 47 |         close(FH);
 48 |         exit;
 49 |     }
 50 | }
 51 | 
 52 | # Analizing states.
 53 | my (@GMIRROR_OUT, @MD_OUT);
 54 | 
 55 | if ($uname eq 'FreeBSD' && -d '/dev/mirror') {
 56 |     @GMIRROR_OUT = qx($GMIRROR_CMD);
 57 |     foreach (@GMIRROR_OUT) {
 58 |         if (/State:\s+(\S+)/ and $1 ne 'ACTIVE' and $1 ne 'COMPLETE' || /^Components: 1/) {
 59 |             $errors{'GMIRROR'}++; last;
 60 |             $errors_text .= "One or more gmirrors were degraded or have only one component. ";
 61 |         }
 62 |     }
 63 | } elsif ($uname eq 'Linux' && `cat /proc/mdstat | /bin/egrep '^md.* : '`) {
 64 |     @MD_OUT = qx($MD_CMD);
 65 |     foreach (@MD_OUT) {
 66 |         if (/UUID :/) {
 67 |             if ($states{'State'} =~ /clean, degraded$/) {
 68 |                 $errors{'MD'}++;
 69 |                 $errors_text .= "$current_dev $states{'Raid Level'} degraded. ";
 70 |             } elsif ($states{'State'} =~ /clean, degraded, recovering/
 71 |                   || $states{'State'} =~ /clean, resyncing/) {
 72 |                 $warnings{'MD'}++;
 73 |                 $warnings_text .= "Rbld: $current_dev $states{'Raid Level'} $states{'Rebuild Status'}. ";
 74 |             } elsif ($states{'State'} ne 'clean' && $states{'State'} ne 'active') {
 75 |                 $warnings{'MD'}++;
 76 |                 $warnings_text .= "Unknown error state: $current_dev $states{'Raid Level'} $states{'State'}. ";
 77 |             }
 78 |         }
 79 |         if (/(.*) : (.*)$/) {
 80 |             my ($state, $value) = ($1, $2);
 81 |             $state =~ s/^\s*(.*)\s*$/$1/;
 82 |             $states{$state} = $value;
 83 |         }
 84 |         if (/^\/dev\/(.*):$/) {
 85 |             $current_dev = $1;
 86 |             %states = undef;
 87 |         }
 88 |     }
 89 | }
 90 | 
 91 | my @MEGACLI_OUT = qx($MEGACLI_CMD);
 92 | foreach (@MEGACLI_OUT) {
 93 |     if ((/^State:\s?(\w+)\s*$/ and $1 ne 'Optimal')) {
 94 |         $errors{'MEGACLI'}++; last;
 95 |     }
 96 | }
 97 | 
 98 | my @MEGARC_OUT = qx($MEGARC_CMD);
 99 | foreach (@MEGARC_OUT) {
100 |     if (/^\s+\d+\s+\d+\s+0x\S+\s+0x\S+\s+(\w+)\s*$/ and $1 ne 'ONLINE') {
101 |         $errors{'MEGARC'}++; last;
102 |     }
103 | }
104 | 
105 | my $text = join('', @GMIRROR_OUT, "\n\n\n",
106 |                     @MD_OUT, "\n\n\n",
107 |                     @MEGACLI_OUT, "\n\n\n",
108 |                     @MEGARC_OUT);
109 | my $warnings_list = join(', ', keys(%warnings));
110 | my $errors_list = join(', ', keys(%errors));
111 | 
112 | if ($ARGV[0] eq '-v') { print $text; }
113 | 
114 | if ($warnings_list) {
115 |     $nagios_warn_msg .= "There are warnings shown by $warnings_list. $warnings_text";
116 | }
117 | 
118 | if ($errors_list) {
119 |     $nagios_crit_msg .= "There are errors shown by $errors_list. $errors_text";
120 |     if ($ARGV[0] eq '-c') {
121 |         open(FH, "| mail -s '${hostname} RAID ${errors_list} alert' $mailto")
122 |              or die "Can't open pipe to mail: $!";
123 |         print(FH $text);
124 |         close(FH);
125 |     }
126 |     open(FH, '>', $flag_file) or die "Can't create flag file: $!";
127 |     close(FH);
128 | } elsif (-f $flag_file) {
129 |     open(FH, "| mail -s '${hostname} RAID recovery' $mailto")
130 |          or die "Can't open pipe to mail: $!";
131 |     print(FH $text);
132 |     close(FH);
133 |     unlink($flag_file);
134 | }
135 | 
136 | # Nagios handler and cron mini patch
137 | my @DF_OUT = qx'df | egrep \'^/dev/\' | awk \'{print $6 " " $5 " " $4}\' | tr -d "%" | egrep -v "(Mounted|/proc|/dev|/sys|/ports)"';
138 | foreach (@DF_OUT) {
139 |     my ($part, $percent, $free) = split(/\s/);
140 |     my ($part_ext, $add_warn_msg, $add_crit_msg);
141 |     my $free_text = sprintf('%.2f GB', $free / 1024 / 1024);
142 | 
143 |     if ($percent > 90 && $percent < 96) { $add_warn_msg++; }
144 |     elsif ($percent >= 96) { $add_crit_msg++; }
145 | 
146 |     if ($part =~ m{^/www} && $percent > 85
147 |             && (glob("$part/ff*.example1.ru") || glob("$part/file*.example2.ru"))) {
148 |         ($add_warn_msg, $add_crit_msg) = undef;
149 |         if (glob("$part/ff*.example1.ru")) {
150 |             $part_ext = '/{ff*.example1.ru}';
151 |             if ($free < 20 * 1024 * 1024) {
152 |                 $add_crit_msg++;
153 |             } elsif ($free < 40 * 1024 * 1024) {
154 |                 $add_warn_msg++;
155 |             }
156 |         } elsif (glob("$part/file*.example2.ru")) {
157 |             $part_ext = '/{file*.example2.ru}';
158 |             if ($free < 1 * 1024 * 1024) {
159 |                 $add_crit_msg++;
160 |             } elsif ($free < 8 * 1024 * 1024) {
161 |                 $add_warn_msg++;
162 |             }
163 |         }
164 |     }
165 | 
166 |     if ($add_warn_msg) {
167 |         $nagios_warn_msg .= "[${part}${part_ext}, used: ${percent}%, free: ${free_text}] ";
168 |     }
169 |     if ($add_crit_msg) {
170 |         $nagios_crit_msg .= "[${part}${part_ext}, used: ${percent}%, free: ${free_text}] ";
171 |     }
172 | }
173 | 
174 | my $msg;
175 | if ($nagios_crit_msg) {
176 |     $msg = "CRITICAL: ${nagios_crit_msg}";
177 | }
178 | if ($nagios_warn_msg) {
179 |     $msg .= "WARNING: ${nagios_warn_msg}";
180 | }
181 | if (!$msg && $ARGV[0] ne '-c') { # Suppress output of normal result for run from cron.
182 |     $msg = 'OK';
183 | }
184 | 
185 | print $msg;
186 | 
187 | open(FH, "> $cache_file")
188 |      or die "Can't open cache file $cache_file: $!";
189 | print(FH $msg);
190 | close(FH);
191 | 


--------------------------------------------------------------------------------
/check_domain.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | 
  3 | #add to cron
  4 | #/root/bin/checkdomain/checkdomain.pl < /root/bin/checkdomain/domains.txt 2>&1
  5 | 
  6 | # added cache whois 
  7 | use Net::Domain::ExpireDate;
  8 | use Time::Piece;
  9 | use Net::Whois::Raw qw( whois );
 10 | 
 11 | my $mailto = 'root@examle.com';
 12 | my $debug = 1;
 13 | my $now = localtime;
 14 | my $mail = 'mail -Es "Domain Expiration Status" '.$mailto;
 15 | #my $mail = 'cat';
 16 | my $warntime = 3*30*24*60*60; # 3 months
 17 | #my $warntime = 3*30*24*60;
 18 | 
 19 | $Net::Whois::Raw::CHECK_EXCEED = 0;
 20 | $Net::Whois::Raw::TIMEOUT = 60;
 21 | $Net::Whois::Raw::USE_CNAMES = 1;
 22 | 
 23 | while (<STDIN>) {
 24 | 	chomp;
 25 | 
 26 | 	if ( $_ !~ /^([-a-z0-9]+\.)+[a-z]{2,6}$/i ) { # domain name?
 27 | 		print "$_: not a domain name\n" if $debug;
 28 | 		next;
 29 | 	}
 30 | 	
 31 | 	$domainname = $_;
 32 | 
 33 | 	my $try = 1;
 34 | 	while ( $try <= 3 ) { # try 3 times with sleeps
 35 | 		eval {
 36 |  			$exp = expire_date( $_ );
 37 | 		};
 38 | 		last unless ( $@ or not defined ($exp));
 39 | 		print "$_: try $try\n" if $debug;
 40 | 		$try++;
 41 | 		sleep 15;
 42 | 	}
 43 | 
 44 | 	if ( $@ ) {
 45 |                 print("$domainname: whois error\n");
 46 |                 push @unwhoised, $domainname;
 47 | 		next;
 48 | 	}
 49 | 
 50 | 	sleep 1;
 51 | 
 52 | 	if ( defined ($exp)) {
 53 | 		printf("%s %d-%02d-%02d ",$domainname,$exp->year,$exp->mon,$exp->mday) if $debug;
 54 | 		if ( $exp < $now ) {
 55 | 			push @expired, $domainname;
 56 | 			@expired{$domainname}=$exp;
 57 | 			print "expired\n" if $debug;
 58 | 			next;
 59 | 		} 
 60 |                 if ( $exp - $warntime < $now ) {
 61 |                         push @expiring, $domainname;
 62 | 			@expiring{$domainname} = $exp;
 63 |                         print "expiring\n" if $debug;
 64 | 			next;
 65 |                 }
 66 | 		
 67 | 		($domaininfo = whois($domainname) ) =~ s/^Last\ updated.*$//m;
 68 | 		open (F,"> "."cache/$domainname");
 69 | 		print F $domaininfo;
 70 | 		close (F);
 71 | 		
 72 | 		print "ok\n" if $debug;
 73 | 	} else {
 74 | 		print("$_: whois error\n");
 75 | 		push @unwhoised, $domainname;
 76 | 	}
 77 | }
 78 | 
 79 | open(MAIL, "| $mail");
 80 | 
 81 | if ( defined(@expiring) ){
 82 | 	printf(MAIL "Expiring:\n");
 83 | 	foreach $domain (sort { @expiring{$a} <=> @expiring{$b} } @expiring) {
 84 | 		printf(MAIL "%s %d-%02d-%02d\n",$domain,@expiring{$domain}->year,
 85 | 			@expiring{$domain}->mon,@expiring{$domain}->mday);
 86 | 	}
 87 | 	printf(MAIL "\n");
 88 | }
 89 | 
 90 | if ( defined(@expired) ){
 91 | 	printf(MAIL "Expired:\n");
 92 | 	foreach $domain (sort { @expired{$a} <=> @expired{$b} } @expired) {
 93 | 		printf(MAIL "%s %d-%02d-%02d\n",$domain,@expired{$domain}->year,
 94 |                         @expired{$domain}->mon,@expired{$domain}->mday);
 95 | 	}
 96 | 	printf(MAIL "\n");
 97 | }
 98 | 
 99 | if ( defined(@unwhoised)) {
100 | 	printf(MAIL "Whois error:\n%s", join("\n",@unwhoised));
101 | 	print(MAIL "\n\n");
102 | }
103 | 
104 | close (MAIL);
105 | 
106 | 


--------------------------------------------------------------------------------
/check_http.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | import os
 3 | import urllib2
 4 | import pwd
 5 | import smtplib
 6 | import socket
 7 | import requests
 8 | 
 9 | hostname = socket.gethostname()
10 | url = "http://localhost/http_check"
11 | stop_file = '/tmp/check_stop'
12 | user = 'www'
13 | timeout = 300
14 | 
15 | mail_from = "adm@" + hostname
16 | mail_to = "root@example.ru"
17 | 
18 | def mail(server_url=None, sender='', to='', subject='', text=''):
19 |     if not to:
20 |         return
21 |     headers = "From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n" % (sender, to, subject)
22 |     message = headers + text
23 |     mail_server = smtplib.SMTP(server_url)
24 |     mail_server.sendmail(sender, to, message)
25 |     mail_server.quit()
26 | 
27 | def pkill(user):
28 |     pids = []
29 |     user_pids = []
30 |     uid = pwd.getpwnam(user).pw_uid
31 |     for i in os.listdir('/proc'):
32 |         if i.isdigit():
33 |             pids.append(i)
34 |     for i in pids:
35 |         puid = os.stat(os.path.join('/proc', i)).st_uid
36 |         if puid == uid:
37 |             user_pids.append(i)
38 |     for i in user_pids:
39 |         if os.path.exists(os.path.join('/proc',i)):
40 |             try:
41 |                 os.kill(int(i), 15)
42 |             except OSError as e:
43 |                 print e
44 |                 #exit(0)
45 | 
46 | def check_http(url):
47 |     try:
48 |         response = requests.get(url, timeout=timeout)
49 |         response.close()
50 |     except (ConnectionError, HTTPError, Timeout ) as e:
51 |             #mail('localhost', mail_from, mail_to, 'HttpCheck at ' + hostname, "kill all")
52 |             pkill(user)
53 | 
54 | def main():
55 |     if os.path.isfile(stop_file):
56 |         sys.exit(0)
57 |     else:
58 |         check_http(url)
59 | 
60 | if __name__ == '__main__':
61 |     main()
62 | 


--------------------------------------------------------------------------------
/check_md.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
 3 | 
 4 | export RAIDFLAG="/var/tmp/raidflag"
 5 | MAILTO='root@example.ru'
 6 | CMD="/sbin/mdadm -D /dev/md0 /dev/md1 /dev/md2 /dev/md3 /dev/md4 /dev/md5 /dev/md6"
 7 | 
 8 | #alias mail=echo
 9 | 
10 | $CMD | grep degraded > /dev/null 2>&1
11 | 
12 | if ([ "$?" -ne "1" ];) then
13 | 	if (perl -e 'exit (-f $ENV{RAIDFLAG} and -M $ENV{RAIDFLAG} < 1/24)';) then
14 | 		$CMD | mail -s "`hostname` RAID alert" $MAILTO;
15 | 		touch $RAIDFLAG;
16 | 	fi
17 | else
18 | 	[ -e $RAIDFLAG ] && $CMD | mail -s "`hostname` RAID recovery" $MAILTO;
19 | 	rm -f $RAIDFLAG 2>/dev/null
20 | fi
21 | 
22 | exit
23 | 


--------------------------------------------------------------------------------
/check_md5sums_script.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | OS=`uname`
 4 | if [ x$OS = xLinux ]; then
 5 |         export MD5=/usr/bin/md5sum
 6 |         DIRS="/bin /boot /lib /root /sbin /usr/bin /usr/games /usr/include /usr/kerberos /usr/lib /usr/libexec /usr/local/bin /usr/local/include /usr/local/lib /usr/local/sbin /usr/sbin"
 7 |         #DIRS="/bin"
 8 |         find $DIRS -type f | sort | awk '{print "$MD5 " $1 " | tr \"\n\" \" \"; ls -la " $1}' | sh | awk '{print $3 "\t" $2 "\t" $1}'
 9 | else
10 |         export MD5=/sbin/md5
11 |         DIRS="/bin /boot /lib /libexec /root /sbin /usr/bin /usr/games /usr/include /usr/lib* /usr/local/bin /usr/local/include /usr/local/lib /usr/local/libexec /usr/sbin /usr/local/sbin"
12 |         #DIRS="/bin"
13 |         find $DIRS -type f | sort | awk '{print "$MD5 " $1 " | tr \"\n\" \" \"; ls -la " $1}' | sh | awk '{print $5 "\t" $NF "\t" $4}'
14 | fi


--------------------------------------------------------------------------------
/check_raid_etegro.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
 3 | 
 4 | export RAIDFLAG="/var/tmp/raidflag"
 5 | MAILTO="root@example.ru"
 6 | 
 7 | #alias mail=echo
 8 | 
 9 | NONOPT=`sysctl -n dev.mpt.1.nonoptimal_volumes`
10 | # test if the oid exists at all
11 | [ $? = 0 ] || exit 1
12 | 
13 | REPORTCMD="echo dmesg output follows; echo; dmesg | grep mpt | tail -n 20"
14 | 
15 | if ([ "$NONOPT" -gt "0" ];) then
16 |         if (perl -e 'exit (-f $ENV{RAIDFLAG} and -M $ENV{RAIDFLAG} < 1/24)';) then
17 |                 eval $REPORTCMD | mail -s "`hostname` RAID alert" $MAILTO;
18 |                 touch $RAIDFLAG;
19 |         fi
20 | else
21 |         [ -e $RAIDFLAG ] && eval $REPORTCMD | mail -s "`hostname` RAID recovery" $MAILTO;
22 |         rm -f $RAIDFLAG 2>/dev/null
23 | fi
24 | 
25 | exit
26 | 
27 | #!perl
28 | 
29 | # raidutil output parser
30 | # exit nonzero if any of the arrays id not optimal
31 | 
32 | $ret = 0;
33 | 
34 | while (<STDIN>) {
35 |         $ret++ if (/State:\s+(\S+)/ and $1 ne 'up');
36 | }
37 | 
38 | exit $ret;
39 | 


--------------------------------------------------------------------------------
/check_snmp_disk.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/local/bin/bash
 2 | 
 3 | # This script takes:
 4 | # <host> <community> <mountpoint> <megs>
 5 | 
 6 | snmpwalk=/usr/local/bin/snmpwalk
 7 | snmpget=/usr/local/bin/snmpget
 8 | 
 9 | calc_free()
10 | # takes <size> <used> <allocation>
11 | {
12 | if result=`echo "($1*$3*.92/1024-$2*$3/1024)/1024" | bc`
13 | then
14 | echo "$result"
15 | else
16 | echo "DISK UNKNOWN: Cant calculate free space."
17 | exit 3
18 | fi
19 | }
20 | 
21 | fetch_details()
22 | #takes <host> <community> <index>
23 | {
24 | if result=`$snmpget -v2c -c $2 -OqvU $1 hrStorageSize.$3 hrStorageUsed.$3 hrStorageAllocationUnits.$3 | while read oid ; do printf "$oid " ; done`
25 | then
26 | echo "$result"
27 | else
28 | echo "DISK UNKNOWN: Cant fetch details."
29 | exit 3
30 | fi
31 | }
32 | 
33 | if result=`$snmpwalk -v2c -c $2 -Oqs $1 hrStorageDescr | grep "$3$"`
34 | then
35 | index=`echo $result | sed 's/hrStorageDescr\.//' | sed 's/ .*//'`
36 | 
37 | details=`fetch_details $1 $2 $index`
38 | 
39 | free=`calc_free $details`
40 | 
41 | if [ "$free" -gt "$4" ]
42 | then
43 | echo "DISK OK: mount $3 free $free MB."
44 | exit 0
45 | else
46 | echo "DISK CRITICAL: mount $3 free $free MB."
47 | exit 2
48 | fi
49 | else
50 | echo "DISK UNKNOWN: $3 dosent exist or snmp isent responding."
51 | exit 3
52 | fi


--------------------------------------------------------------------------------
/chroot_ssh_freebsd.sh:
--------------------------------------------------------------------------------
  1 | #BASH. Создание chroot окружения для SSH chroot в FreeBSD. 
  2 | #!/usr/local/bin/bash
  3 | 
  4 | # Проверка задано ли имя пользователя
  5 | if [ "$1" = "" ] ; then
  6 |   echo "    Usage: $0 [ username ]"
  7 |   exit
  8 | fi
  9 | 
 10 | 
 11 | USER=$1
 12 | GID=`cat /etc/master.passwd | grep "^$USER:" | cut -d ":" -f 4`
 13 | HOMEDIR=/home/$USER
 14 | 
 15 | # Задаем список бинарных файлов, 
 16 | # которые хотим предоставить пользователю
 17 | BINARIES="
 18 | /bin/cat \
 19 | /bin/chmod \
 20 | /bin/cp \
 21 | /bin/csh \
 22 | /bin/date \
 23 | /bin/echo \
 24 | /bin/expr \
 25 | /bin/ln \
 26 | /bin/ls \
 27 | /bin/mkdir \
 28 | /bin/mv \
 29 | /bin/ps \
 30 | /bin/pwd \
 31 | /bin/rm \
 32 | /bin/rmdir \
 33 | /bin/sh \
 34 | /usr/bin/awk \
 35 | /usr/bin/bzip2 \
 36 | /usr/bin/diff \
 37 | /usr/bin/du \
 38 | /usr/bin/ee \
 39 | /usr/bin/fetch \
 40 | /usr/bin/find \
 41 | /usr/bin/grep \
 42 | /usr/bin/gunzip \
 43 | /usr/bin/gzip \
 44 | /usr/bin/less \
 45 | /usr/bin/sed \
 46 | /usr/bin/sort \
 47 | /usr/bin/tail \
 48 | /usr/bin/tar \
 49 | /usr/bin/touch \
 50 | /usr/bin/vi \
 51 | /usr/local/bin/bash \
 52 | /usr/local/bin/mc \
 53 | /usr/local/bin/mcedit \
 54 | /usr/local/bin/mcmfmt \
 55 | /usr/local/bin/unrar \
 56 | /usr/local/bin/unzip \
 57 | /usr/local/bin/wget"
 58 | 
 59 | # Создаем структуру каталогов внутри chroot окружения
 60 | mkdir $HOMEDIR/bin
 61 | mkdir $HOMEDIR/etc
 62 | mkdir $HOMEDIR/home
 63 | mkdir $HOMEDIR/home/$USER
 64 | mkdir $HOMEDIR/lib
 65 | mkdir $HOMEDIR/libexec
 66 | mkdir $HOMEDIR/tmp
 67 | mkdir $HOMEDIR/usr
 68 | mkdir $HOMEDIR/usr/bin
 69 | mkdir $HOMEDIR/usr/local
 70 | mkdir $HOMEDIR/usr/local/bin
 71 | mkdir $HOMEDIR/usr/local/etc
 72 | mkdir $HOMEDIR/usr/local/share
 73 | 
 74 | # Копируем бинарники внутрь chroot окружения
 75 | for item in $BINARIES;
 76 | do
 77 |   cp $item $HOMEDIR$item
 78 | done
 79 | 
 80 | # Определяем какие библиотеки необходимо скопировать
 81 | for item in $BINARIES;
 82 | do
 83 |   ldd $item |awk '{print $3}'|grep "."  >> /tmp/chroot_liblist
 84 | done
 85 | 
 86 | # Копируем библиотеки
 87 | for item in `cat /tmp/chroot_liblist|sort|uniq`;
 88 | do
 89 |   cp $item $HOMEDIR/lib/
 90 | done
 91 | 
 92 | # Копируем оставшиеся необходимые файлы и библиотеки
 93 | cp /etc/termcap $HOMEDIR/etc/termcap
 94 | cp /etc/resolv.conf $HOMEDIR/etc/resolv.conf
 95 | cp /etc/nsswitch.conf $HOMEDIR/etc/nsswitch.conf
 96 | cp -R /usr/local/share/mc $HOMEDIR/usr/local/share/mc
 97 | cp /libexec/ld-elf.so.1 $HOMEDIR/libexec/ld-elf.so.1
 98 | cp /libexec/ld-elf32.so.1 $HOMEDIR/libexec/ld-elf32.so.1
 99 | 
100 | # Генерируем /etc/motd для chroot окружения
101 | echo 'Welcome to chroot environment' > $HOMEDIR/etc/motd
102 | 
103 | # Генерируем /etc/profile для chroot окружения
104 | echo 'export TERMCAP=/etc/termcap' > $HOMEDIR/etc/profile
105 | echo 'export PS1="[ w ]$ "' >> $HOMEDIR/etc/profile
106 | 
107 | # Генерируем /etc/group для chroot окружения
108 | cat /etc/group | grep $GID > $HOMEDIR/etc/group
109 | 
110 | # Переносим запись о пользователе
111 | cat /etc/master.passwd|grep "^$USER:" > $HOMEDIR/etc/master.passwd
112 | pwd_mkdb -d $HOMEDIR/etc $HOMEDIR/etc/master.passwd
113 | 
114 | # Выставляем права
115 | chown root:wheel  $HOMEDIR
116 | chmod 755 $HOMEDIR
117 | chown -R $USER:$GID $HOMEDIR/bin
118 | chown -R $USER:$GID $HOMEDIR/etc
119 | chown -R $USER:$GID $HOMEDIR/home
120 | chown -R $USER:$GID $HOMEDIR/lib
121 | chown -R $USER:$GID $HOMEDIR/libexec
122 | chown -R $USER:$GID $HOMEDIR/tmp
123 | chown -R $USER:$GID $HOMEDIR/usr
124 | chmod 777 $HOMEDIR/tmp
125 | 
126 | # Подчищаем за собой
127 | rm /tmp/chroot_liblist


--------------------------------------------------------------------------------
/cpu_util_linux_bsd.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #
 3 | #       Simple script to monitor CPU utilization on FreeBSD or Linux.
 4 | #
 5 | 
 6 | from platform import system
 7 | from time import sleep
 8 | 
 9 | from os import strerror
10 | from sys import stderr, exit
11 | 
12 | debug = False
13 | interval = 1    # pause interval in seconds
14 | os = system()
15 | 
16 | def countCpu(cptime_0, cptime_1):
17 |     cp_diff = [cptime_1[i] - cptime_0[i] for i in range(len(cptime_0))]
18 |     cp_total = sum(cp_diff)
19 |     cp_cpu = cp_total - cp_diff[-1]
20 |     res = int(round((100.0 * cp_cpu) / cp_total))
21 |     return res
22 | 
23 | if os == "FreeBSD":
24 | 
25 |     from ctypes import *
26 |     libc = CDLL("libc.so")
27 |     errno = c_int.in_dll(libc, "errno")
28 | 
29 |     def check_fail (fail):
30 |         if fail:
31 |             exit (1)
32 |         else:
33 |             return None
34 | 
35 |     def sysctlnametomib (name, fail = True):
36 |         mibsize = len(name.split('.'))
37 |         size = c_uint(mibsize)
38 |         mib = (c_int * mibsize)()
39 |         if libc.sysctlnametomib(name, byref(mib), byref(size)) != 0:
40 |             print >> stderr, 'sysctlnametomib("%s"):' % name, strerror(errno.value)
41 |             return check_fail(fail)
42 |         if debug:
43 |             print >> stderr, 'sysctlnametomib("%s") -->' % name, str(list(mib))
44 |         return mib
45 | 
46 |     def sysctl_ulongarray (mib, count = None, fail = True):
47 |         return sysctl_numericarray(c_ulong, mib, count, fail)
48 | 
49 |     def sysctl_numericarray (type, mib, count = None, fail = True):
50 |         if count is None:
51 |             size = c_uint(0)
52 |             if libc.sysctl(byref(mib), len(mib), None, byref(size), None, 0) != 0:
53 |                 print >> stderr, 'sysctl(%s):' % str(list(mib)), strerror(errno.value)
54 |                 return check_fail(fail)
55 |             if debug:
56 |                 print >> stderr, 'sysctl(%s) --> size' % str(list(mib)), size.value
57 |             count = size.value / sizeof(type)
58 |         else:
59 |             size = c_uint(count * sizeof(type))
60 |         value = (type * count)()
61 |         if libc.sysctl(byref(mib), len(mib), byref(value), byref(size), None, 0) != 0:
62 |             print >> stderr, 'sysctl(%s):' % str(list(mib)), strerror(errno.value)
63 |             return check_fail(fail)
64 |         if debug:
65 |             print >> stderr, 'sysctl(%s) -->' % str(list(mib)), repr(list(value))
66 |         return list(value)
67 | 
68 |     def getTimeList():
69 |         return sysctl_ulongarray(kern_cptime, 5)
70 | 
71 |     kern_cptime = sysctlnametomib("kern.cp_time")
72 | 
73 | if os == "Linux":
74 |     def getTimeList():
75 |         statFile = file("/proc/stat", "r")
76 |         timeList = statFile.readline().split(" ")[2:6]
77 |         statFile.close()
78 |         for i in range(len(timeList))  :
79 |             timeList[i] = int(timeList[i])
80 |         return timeList
81 | 
82 | while True:
83 |     cptime_0 = getTimeList()
84 |     sleep (interval)
85 |     cptime_1 = getTimeList()
86 | 
87 |     print countCpu(cptime_0, cptime_1)
88 | 


--------------------------------------------------------------------------------
/create_lxc.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | if [[ $# -ne 2 ]]; then
 4 | 	echo "Use: $0 <VMNAME> <IP>"
 5 | 	exit 1
 6 | fi
 7 | 
 8 | #2 задаем константы
 9 | HDD_SIZE="10G"
10 | VM_NAME=$1
11 | IP=$2
12 | VG="vg00"
13 | TEMPLATE_PATH="/lxc/template.tar.gz"
14 | TEMPLATE="template.tar.gz"
15 | 
16 | if [[ -e "/var/lib/lxc/$VM_NAME" ]]; then
17 | 	echo "VM alredy exist"
18 | 	exit 1
19 | fi
20 | 
21 | lvcreate -n "$VM_NAME" -L "$HDD_SIZE" "$VG"
22 | if [[ $? -ne 0 ]]; then
23 | 	echo "LVM volume for $VM_NAME not created"
24 | 	exit 1
25 | fi
26 | 
27 | mkfs.ext4 /dev/"$VG"/"$VM_NAME"
28 | if [[ $? -ne 0 ]]; then
29 |         echo "FS on $VM_NAME not created"
30 |         exit 1
31 | fi
32 | 
33 | mkdir /lxc/"$VM_NAME"
34 | if [[ $? -ne 0 ]]; then
35 |         echo "Dir /lxc/$VM_NAME not created"
36 |         exit 1
37 | fi
38 | 
39 | mount /dev/"$VG"/"$VM_NAME" /lxc/"$VM_NAME" -w
40 | if [[ $? -ne 0 ]]; then
41 |         echo "fail to mount /lxc/$VM_NAME"
42 |         exit 1
43 | fi
44 | 
45 | cp "$TEMPLATE_PATH" /lxc/"$VM_NAME"
46 | if [[ $? -ne 0 ]]; then
47 |         echo "Default template not created in /lxc/$VM_NAME"
48 |         exit 1
49 | fi
50 | 
51 | tar zxf /lxc/$VM_NAME/$TEMPLATE -C /lxc/$VM_NAME/
52 | if [[ $? -ne 0 ]]; then
53 |         echo "Cant unpack template in lxc/$VM_NAME"
54 |         exit 1
55 | fi
56 | 
57 | rm /lxc/"$VM_NAME"/"$TEMPLATE"
58 | if [[ $? -ne 0 ]]; then
59 |         echo "Cant delete templete"
60 |         exit 1
61 | fi
62 | 
63 | mkdir /var/lib/lxc/"$VM_NAME"/
64 | if [[ $? -ne 0 ]]; then
65 |         echo "Cant create dir for configs"
66 |         exit 1
67 | fi
68 | 
69 | mv /lxc/$VM_NAME/configclean /var/lib/lxc/"$VM_NAME"/config
70 | if [[ $? -ne 0 ]]; then
71 |         echo "Cant config default config"
72 |         exit 1
73 | fi
74 | 
75 | 
76 | sed -i.bak "s/hostnametmp/$VM_NAME/g" /var/lib/lxc/"$VM_NAME"/config
77 | 
78 | sed -i.bak "s/127.0.0.1/$IP/g" /lxc/$VM_NAME/rootfs/etc/network/interfaces
79 | 
80 | chattr +i /lxc/$VM_NAME/rootfs/etc/resolv.conf
81 | 
82 | rm /lxc/$VM_NAME/rootfs/etc/rc0.d/S60umountroot
83 | 
84 | echo "Ok now run sudo lxc-start -n $VM_NAME -d" 
85 | 
86 | exit 0
87 | 
88 | 


--------------------------------------------------------------------------------
/disk_iostat.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | 
 3 | use strict;
 4 | use Data::Dumper;
 5 | 
 6 | my $tmp_file = '/tmp/diskload.txt';
 7 | my %dev;
 8 | 
 9 | if ($ARGV[0] eq 'snmp') {
10 |     my @lines;
11 |     if (time() - (stat($tmp_file))[9] < 300) {
12 |         open(FH, "<$tmp_file") or die('Cannot open file');
13 |         @lines = <FH>;
14 |         close(FH);
15 |     }
16 |     my ($max_u_dev, $dev_max_u);
17 |     foreach (@lines) {
18 |         my ($d, $r, $w, $u) = split();
19 |         $dev{$d}{'avg_r'} = $r;
20 |         $dev{$d}{'avg_w'} = $w;
21 |         $dev{$d}{'avg_u'} = $u;
22 |         if ($u > $dev_max_u) {
23 |             $dev_max_u = $u;
24 |             $max_u_dev = $d;
25 |         }
26 |     }
27 |     #print Dumper(\%dev);
28 |     my $t = $ARGV[1];
29 |     my $d = $ARGV[2] || $max_u_dev;
30 |     if ($t eq 'read') { print $dev{$d}{'avg_r'}; }
31 |     if ($t eq 'write') { print $dev{$d}{'avg_w'}; }
32 |     if ($t eq 'util') { print $dev{$d}{'avg_u'}; }
33 | } else {
34 |     my $count = 0;
35 | 
36 |     open(IN, 'iostat -x 15 2 | grep -A 1000 "Device:" | grep -v "%" | grep -Ev "^ " | grep -v "^$" | awk \'{print $1, $4, $5, $12}\' |') or die('Cannot open pipe.');
37 | 
38 |     while (<IN>) {
39 |         my @line = split();
40 |         # This 'if' skippes first abnormal result.
41 |         if (!defined($dev{$line[0]})) {
42 |             $dev{$line[0]} = {};
43 |             next();
44 |         }
45 |         $dev{$line[0]}{'avg_r'} += $line[1];
46 |         $dev{$line[0]}{'avg_w'} += $line[2];
47 |         $dev{$line[0]}{'avg_u'} += $line[3];
48 |         $count++;
49 |     }
50 | 
51 |     close(IN);
52 | 
53 |     #print Dumper(\%dev);
54 | 
55 |     open(FH, ">$tmp_file") or die('Cannot open file');
56 |     foreach my $d (keys(%dev)) {
57 |         $dev{$d}{'avg_r'} /= $count;
58 |         $dev{$d}{'avg_w'} /= $count;
59 |         $dev{$d}{'avg_u'} /= $count;
60 |         print(FH $d." ".int($dev{$d}{'avg_r'})." ".int($dev{$d}{'avg_w'})." ".int($dev{$d}{'avg_u'})."\n");
61 |     }
62 |     close(FH);
63 | }
64 | 


--------------------------------------------------------------------------------
/geoupdate.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
 3 | DATE=`date "+%Y%m%d"`
 4 | URL="http://geolite.maxmind.com/download/geoip/database/GeoIPCountryCSV.zip"
 5 | DBNEW="maxmind.zip"
 6 | DBOLD="maxmind_last.zip"
 7 | GEODB="geo.conf"
 8 | DBDIR="./GEODB/"
 9 | 
10 | dummy() {
11 | 	echo "Do nothing :)"
12 | }
13 | 
14 | test_db() {
15 | 	wget -q -O ${DBNEW} ${URL}
16 |     DBNEWSZ=$(stat -c%s "${DBNEW}")
17 |     DBOLDSZ=$(stat -c%s "${DBOLD}")
18 | 	if [ ${DBNEWSZ} = ${DBOLDSZ} ]; then
19 |     echo "DB IS UP-TO-DATE,NO NEED TO UPDATE"
20 | 	else 
21 |     make_new_db
22 | 	fi
23 | }
24 | 
25 | make_new_db() {
26 | 	#wget -q -O ${DBNEW} ${URL}
27 | 	unzip -o -qq ${DBNEW}
28 |     ./geo2nginx.pl < GeoIPCountryWhois.csv > geo.conf
29 | 
30 | 	grep -e "AZ\|AM\|BY\|GE\|KZ\|KG\|MD\|RU\|TJ\|UZ\|\TM\|EE\|LT\|LV" ${GEODB} |tr [A-Z] [a-z] > ${DBDIR}geo.ru
31 | 	grep UA ${GEODB} | tr [A-Z] [a-z] > ${DBDIR}geo.ua
32 | 	grep CN ${GEODB} | sed s/CN/1/g > ${DBDIR}denyexpress
33 | 
34 | 	cp ${GEODB} ${DBDIR}geo_full.conf
35 | 
36 | 	grep RU ${GEODB} | sed s/RU/0/g > ${DBDIR}russian.geo
37 | 	grep UA ${GEODB} | sed s/UA/2/g > ${DBDIR}ukraina-newline.geo
38 | 
39 | 	cp ${GEODB} ${DBDIR}geo.conf
40 | 
41 | 	grep CN ${GEODB} > ${DBDIR}china.geo
42 | 	grep ES ${GEODB} | sed s/ES/2/g > ${DBDIR}spain.geo
43 | 
44 | 	grep UA ${GEODB} > ${DBDIR}geo_ua.conf
45 | 
46 |     cp ${DBNEW} ${DBOLD}
47 | }
48 | 
49 | build_geo() {
50 | 	echo "Checkouting revision $REV"
51 | }
52 | 
53 | build_nginx() {
54 | 	echo "Checkouting revision $REV"
55 | }
56 | 
57 | restart() {
58 | 	echo "Checkouting revision $REV"
59 | }
60 | 
61 | undo() {
62 | 	echo "Checkouting revision $REV"
63 | }
64 | 
65 | case $1 in
66 | 	geoup)
67 | 	make_new_db
68 | 	#test_db
69 | 		;;
70 | 	install_geo)
71 |         backup
72 |         build_libs
73 | 		restart
74 | 		;;
75 | 	dummy)
76 | 		dummy
77 | 		;;
78 | 	*)
79 | 		echo "Use $0 (geoup|install_geo|)"
80 | 	;;
81 | esac
82 | 


--------------------------------------------------------------------------------
/host_checker.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | alphabet = (u"alpha", u"beta", u"gamma", u"delta", u"epsilon", u"zeta", u"eta", u"theta", u"iota", u"kappa", u"mu", u"nu", u"xi", u"omicron", u"pi", u"rho", u"sigma", u"tau", u"upsilon", u"phi", u"chi", u"psi", u"omega" )
 5 | 
 6 | 
 7 | import stat, sys, os, string, commands, re
 8 | print u"Free hostnames :"
 9 | try:
10 | 	for L in alphabet :	
11 | 		commandString = "host " + L
12 | 		commandOutput = commands.getoutput(commandString)
13 | 		pattern = '192.168.56.1'
14 | 		found = re.findall( pattern, commandOutput )		
15 | 		if len(found) != 0 :
16 | 			print L	
17 | 
18 | except:
19 | 	print u"ERROR"
20 | 


--------------------------------------------------------------------------------
/ipfw_rules.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | ipfw=`which ipfw`" -q"
 4 | extif='em0'
 5 | 
 6 | if [ "$1" = "echo" ]; then
 7 |     ipfw=`which echo`
 8 | else
 9 |     ipfw=`which ipfw`" -q"
10 | fi
11 | 
12 | rule_num=1000
13 | 
14 | pass ()
15 | {
16 |     rule_num=$(($rule_num+10))
17 |     $ipfw add $rule_num allow $*
18 | }
19 | 
20 | count ()
21 | {
22 |     rule_num=$(($rule_num+10))
23 |     $ipfw add $rule_num count $*
24 | }
25 | 
26 | deny ()
27 | {
28 |     rule_num=$(($rule_num+10))
29 |     $ipfw add $rule_num deny $*
30 | }
31 | 
32 | any ()
33 | {
34 |     pass all from $* to any
35 |     pass all from any to $*
36 | }
37 | 
38 | $ipfw -f flush
39 | 
40 | # loopback iface
41 | pass ip from any to any via lo0
42 | deny ip from any to 127.0.0.0/8
43 | deny ip from 127.0.0.0/8 to any
44 | 
45 | # deny
46 | deny ip from me to any in recv ${extif}
47 | 
48 | # deny special ip
49 | deny ip from { 10.0.0.0/8 or 172.16.0.0/12 or 192.168.0.0/16 or 169.254.0.0/16 or 224.0.0.0/4 or 240.0.0.0/4 } to any
50 | 
51 | # icmp
52 | deny icmp from any to any frag
53 | pass icmp from any to any icmptype 0,3,8,11
54 | 
55 | #fast tcp established
56 | pass tcp from any to any established
57 | 
58 | # local ssh
59 | pass tcp from any to me 22 setup
60 | 
61 | # www
62 | pass tcp from any to me 80,443 setup
63 | 
64 | # connections from me
65 | pass tcp from me to any setup keep-state
66 | pass udp from me to any keep-state
67 | 
68 | rule_num=64990
69 | deny ip from any to any
70 | 


--------------------------------------------------------------------------------
/iptables_rules.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | IPT=/sbin/iptables
 3 | $IPT --flush
 4 | $IPT -t nat --flush
 5 | 
 6 | # loopback iface
 7 | $IPT -A INPUT -i lo -j ACCEPT
 8 | $IPT -A INPUT -d 127.0.0.0/8 -j DROP
 9 | $IPT -A INPUT -s 127.0.0.0/8 -j DROP
10 | 
11 | # deny special ipz
12 | $IPT -A INPUT -s 10.0.0.0/8 -j DROP
13 | $IPT -A INPUT -s 172.16.0.0/12 -j DROP
14 | $IPT -A INPUT -s 192.168.0.0/16 -j DROP
15 | $IPT -A INPUT -s 169.254.0.0/16 -j DROP
16 | $IPT -A INPUT -s 224.0.0.0/4 -j DROP
17 | $IPT -A INPUT -s 240.0.0.0/4 -j DROP
18 | 
19 | # icmp
20 | $IPT -A INPUT -p icmp --icmp-type fragmentation-needed -j DROP
21 | $IPT -A INPUT -p icmp --icmp-type 0 -j ACCEPT
22 | $IPT -A INPUT -p icmp --icmp-type 3 -j ACCEPT
23 | $IPT -A INPUT -p icmp --icmp-type 8 -j ACCEPT
24 | $IPT -A INPUT -p icmp --icmp-type 11 -j ACCEPT
25 | 
26 | $IPT -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
27 | 
28 | # local ssh
29 | $IPT -A INPUT -p tcp --dport 22 -j ACCEPT
30 | 
31 | # www
32 | $IPT -A INPUT -p tcp --dport 80 -j ACCEPT
33 | $IPT -A INPUT -p tcp --dport 443 -j ACCEPT
34 | 
35 | $IPT -A INPUT -j DROP
36 | 
37 | $IPT -A OUTPUT -j ACCEPT
38 | 
39 | $IPT -A FORWARD -j DROP
40 | 


--------------------------------------------------------------------------------
/jail_make/Makefile:
--------------------------------------------------------------------------------
 1 | #
 2 | # example:
 3 | #JAILS=		jail1:jail1.example.ru:10.10.10.6 \
 4 | #		jail2:jail2.dev.example.ru:10.10.10.4
 5 | 
 6 | JAILS=		jail1:jail1.example.ru:10.10.10.6
 7 | 
 8 | RO=		bin lib libexec sbin usr dev
 9 | RW=		root usr/local usr/build etc usr/home tmp var www
10 | 
11 | NFSMOUNTS=	/usr/src /usr/obj
12 | CONFIGS=	fstab rc.config
13 | INSTALLDIR=	/www/jail-struct
14 | JAILDIR=	/www/jail
15 | RCCONF=		/etc/rc.conf
16 | ECHO_MSG?=	echo
17 | MKDIR_PROG?=	mkdir -p
18 | 
19 | all:	clean conf
20 | 
21 | conf:
22 | 	@${ECHO_MSG} "=> Generating ${@}"
23 | 	@for JAIL in ${JAILS}; do \
24 | 		NAME=`echo $${JAIL} | cut -f1 -d:`; \
25 | 		HOSTNAME=`echo $${JAIL} | cut -f2 -d:`; \
26 | 		IP=`echo $${JAIL} | cut -f3 -d:`; \
27 | 		${ECHO_MSG} "==> $${HOSTNAME}" ; \
28 | 		for CONFIG in ${CONFIGS}; do \
29 | 		sed -e "s|%HOSTNAME%|$${HOSTNAME}|g" \
30 | 			-e "s|%NAME%|$${NAME}|g" -e "s|%IP%|$${IP}|g" $${CONFIG}.in > $${HOSTNAME}.$${CONFIG} ;\
31 | 		done ; \
32 | 	done
33 | 
34 | install: conf
35 | 	@for JAIL in ${JAILS}; do \
36 | 		NAME=`echo $${JAIL} | cut -f1 -d:` ; \
37 | 		HOSTNAME=`echo $${JAIL} | cut -f2 -d:` ; \
38 | 		if [ -f ${INSTALLDIR}/$${HOSTNAME}.fstab ]; then : ; \
39 | 		else  \
40 | 			${ECHO_MSG} "==> Installing fstab for $${HOSTNAME}" ; \
41 | 			cp $${HOSTNAME}.fstab /www/jail-struct/ ; \
42 | 		fi ; \
43 | 		if cat ${RCCONF} | grep -e "jail_$${NAME}_hostname=\"$${HOSTNAME}\"" > /dev/null ; then : ; \
44 | 		else \
45 | 			${ECHO_MSG} "==> Installing rc script for ${NAME}" ; \
46 | 			cat $${HOSTNAME}.rc.config >> /etc/rc.conf ; \
47 | 		fi ; \
48 | 		if cat ${RCCONF} | grep jail_list | grep -e " $${NAME}" -e "$${NAME} " > /dev/null ; then : ; \
49 | 		else \
50 | 			sed -i '' -e "s|jail_list=\"|jail_list=\"$${NAME} |g" ${RCCONF} ; \
51 | 			${ECHO_MSG} "==> Adding in jail_list $${NAME}" ; \
52 | 		fi ; \
53 | 	done
54 | 
55 | create: conf
56 | 	@${ECHO_MSG} "=> Creating jails"
57 | 	@for NFSMOUNT in ${NFSMOUNTS}; do \
58 | 		if mount | grep -e "$${NFSMOUNT}" > /dev/null ; then : ; \
59 | 		else \
60 | 			${ECHO_MSG} "==> Mounting $${NFSMOUNT} .." ; \
61 | 			mount $${NFSMOUNT} ; \
62 | 		fi ; \
63 | 	done
64 | 	@for JAIL in ${JAILS}; do \
65 | 		HOSTNAME=`echo $${JAIL} | cut -f2 -d:` ; \
66 | 		if [ -d ${JAILDIR}/$${HOSTNAME} -o -d ${INSTALLDIR}/$${HOSTNAME} ]; then \
67 | 			${ECHO_MSG} "==> $${HOSTNAME} already created! Skiping.." ; \
68 | 		else \
69 | 			${ECHO_MSG} "==> Making $${HOSTNAME}" ; \
70 | 			for DIR in ${RO} ${RW}; do \
71 | 				${ECHO_MSG} "===> Creating $${DIR}" ; \
72 | 				${MKDIR_PROG} ${INSTALLDIR}/$${HOSTNAME}/$${DIR} ${JAILDIR}/$${HOSTNAME}/$${DIR}; \
73 | 			done ; \
74 | 			cd /usr/src && make -s -i distrib-dirs DESTDIR=${INSTALLDIR}/$${HOSTNAME}; \
75 | 			cd /usr/src && make -s -i distribution DESTDIR=${INSTALLDIR}/$${HOSTNAME}; \
76 | 		fi ; \
77 | 	done
78 | 
79 | init:
80 | 	@${ECHO_MSG} "=> Starting init.."
81 | 	@if cat ${RCCONF} | grep jail_enable  > /dev/null ; then : ; \
82 | 	else \
83 | 		${ECHO_MSG} "jail_enable=\"YES\"" >> ${RCCONF} ; \
84 | 		${ECHO_MSG} "jail_sysvipc_allow=\"YES\"" >> ${RCCONF} ; \
85 | 		${ECHO_MSG} "jail_list=\"\"" >> ${RCCONF} ; \
86 | 	fi
87 | 	
88 | clean:
89 | 	@${ECHO_MSG} "=> Cleaning.."
90 | 	@rm -f *~ *.fstab *.rc.config
91 | 
92 | help:
93 | 	@${ECHO_MSG} "Usage: init create conf install"
94 | 


--------------------------------------------------------------------------------
/jail_make/README:
--------------------------------------------------------------------------------
 1 | Create FreeBSD jails
 2 | 
 3 | 1.Make jail FS
 4 | 2.Generate jail config and add it to rc.conf
 5 | 3.Generate fstab and add it to /www/jail-struct
 6 | 
 7 | For help run:
 8 | 
 9 | >make help
10 | Usage: init create conf install
11 | 
12 | init - jail struct init
13 | create - create new jail
14 | conf - generate new jail config rc && fstab 
15 | install - install new jail config
16 | 
17 | 
18 | To start new jail run:
19 | 
20 | >/etc/rc.d/jail start
21 | 


--------------------------------------------------------------------------------
/jail_make/fstab.in:
--------------------------------------------------------------------------------
 1 | /bin					/www/jail/%HOSTNAME%/bin	nullfs	ro	0	0
 2 | /lib					/www/jail/%HOSTNAME%/lib	nullfs	ro	0	0
 3 | /libexec				/www/jail/%HOSTNAME%/libexec	nullfs	ro	0	0
 4 | /sbin					/www/jail/%HOSTNAME%/sbin	nullfs	ro	0	0
 5 | /usr					/www/jail/%HOSTNAME%/usr	nullfs	ro	0	0
 6 | /www/jail-struct/%HOSTNAME%/root	/www/jail/%HOSTNAME%/root	nullfs	rw	0	0
 7 | /www/jail-struct/%HOSTNAME%/usr/local	/www/jail/%HOSTNAME%/usr/local	nullfs	rw	0	0
 8 | /www/jail-struct/%HOSTNAME%/usr/build	/www/jail/%HOSTNAME%/usr/build	nullfs	rw	0	0
 9 | /www/jail-struct/%HOSTNAME%/etc		/www/jail/%HOSTNAME%/etc	nullfs	rw	0	0
10 | /www/jail-struct/%HOSTNAME%/usr/home	/www/jail/%HOSTNAME%/usr/home	nullfs	rw	0	0
11 | /www/jail-struct/%HOSTNAME%/tmp		/www/jail/%HOSTNAME%/tmp	nullfs	rw	0	0
12 | /www/jail-struct/%HOSTNAME%/var		/www/jail/%HOSTNAME%/var	nullfs	rw	0	0
13 | /www/jail-struct/%HOSTNAME%/www		/www/jail/%HOSTNAME%/www	nullfs	rw	0	0
14 | /usr/ports				/www/jail/%HOSTNAME%/usr/ports	nullfs	ro	0	0
15 | 


--------------------------------------------------------------------------------
/jail_make/rc.config.in:
--------------------------------------------------------------------------------
 1 | jail_%NAME%_rootdir="/www/jail/%HOSTNAME%"
 2 | jail_%NAME%_hostname="%HOSTNAME%"
 3 | jail_%NAME%_ip="%IP%"
 4 | jail_%NAME%_exec_start="/bin/sh /etc/rc"
 5 | jail_%NAME%_exec_stop="/bin/sh /etc/rc.shutdown"
 6 | jail_%NAME%_devfs_enable="YES"
 7 | jail_%NAME%_fdescfs_enable="YES"
 8 | jail_%NAME%_procfs_enable="YES"
 9 | jail_%NAME%_mount_enable="YES"
10 | jail_%NAME%_fstab="/www/jail-struct/%HOSTNAME%.fstab"
11 | jail_%NAME%_devfs_ruleset="devfsrules_jail"
12 | 
13 | 


--------------------------------------------------------------------------------
/java_prof.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # The idea of the script is based on the method from poor man’s profiler adapted for HotSpot thread dumps. The script does the following things:
 3 | 
 4 | # - Takes $P_CNT thread dumps of the Java process ID passed as $1 (10 by default)
 5 | # - If a native thread ID has been supplied as $2, then searches for the thread stack of this thread in the thread dump
 6 | # - Concatenates each thread stack trace into a comma-separated string
 7 | # - Aggregates strings and sorts them by the number of occurrences
 8 | # - Prettifies the output: removes tabs, commas, and adds new lines back to the thread stack
 9 | 
10 | # ./prof.sh 7599 7601
11 | 
12 | # For monitoring JVM I’d also recommend a jvmtop tool (https://github.com/patric-r/jvmtop).
13 | 
14 | # Installl (needs Java to be installed and accessible):
15 | # curl -sL “https://github.com/patric-r/jvmtop/releases/download/0.8.0/jvmtop-0.8.0.tar.gz” | gunzip | tar -x -C /bin/ && mv /bin/jvmtop.sh /bin/jvmtop && chmod +x /bin/jvmtop
16 | 
17 | # Execute:
18 | # jvmtop
19 | 
20 | P_PID=$1
21 | P_NID=$2
22 | 
23 | if [ "$P_SLEEP" == "" ]; then
24 |   P_SLEEP=0.5
25 | fi
26 | 
27 | if [ "$P_CNT" == "" ]; then
28 |   P_CNT=10
29 | fi
30 | 
31 | echo Sampling PID=$P_PID every $P_SLEEP seconds for $P_CNT samples
32 | 
33 | if [ "$P_NID" == "" ]; then
34 |   CMD="awk '//'"
35 | else
36 |   CMD="awk '/ nid='"$(printf '%#x' $P_NID)"' /,/^$/'"
37 | fi
38 | 
39 | for i in `seq $P_CNT`
40 | do
41 |   jstack $P_PID | eval $CMD
42 |   sleep $P_SLEEP;
43 | done |
44 |   awk ' BEGIN { x = 0; s = "" }
45 |     /nid=/ { x = 1; }
46 |     // {if (x == 1) {s = s ", "gensub(/<\w*>/, "<address>", "g") } }
47 |     /^$/ { if ( x == 1) { print s; x = 0; s = ""; } }' |
48 |   sort | uniq -c | sort -n -r | head -10 |
49 |   sed -e 's/$/\n/g' -e 's/\t/\n\t/g' -e 's/,//g'


--------------------------------------------------------------------------------
/kickstart/ks.cfg:
--------------------------------------------------------------------------------
  1 | #platform=x86, AMD64, or Intel EM64T
  2 | #version=DEVEL
  3 | # Firewall configuration
  4 | firewall --disabled
  5 | # Install OS instead of upgrade
  6 | install
  7 | # Use network installation
  8 | url --url="http://ks.example.ru/"
  9 | # Root password
 10 | rootpw --iscrypted $1$5Ytbfas1119/$XxFXz1XIbPjHqgxTyMuGk1
 11 | # Network information
 12 | network  --bootproto=static --device=eth0 --gateway=192.168.56.1 --ip=192.168.56.101 --nameserver=8.8.8.8 --netmask=255.255.255.0 --onboot=on --hostname default.example.ru --noipv6
 13 | # System authorization information
 14 | auth  --useshadow  --passalgo=sha512
 15 | # Use text mode install
 16 | text
 17 | firstboot --disable
 18 | # System keyboard
 19 | keyboard us
 20 | # System language
 21 | lang en_US
 22 | # SELinux configuration
 23 | selinux --disabled
 24 | # Installation logging level
 25 | logging --level=info
 26 | # Reboot after installation
 27 | reboot
 28 | # System timezone
 29 | timezone  Europe/Moscow
 30 | # System bootloader configuration
 31 | bootloader --location=mbr
 32 | # Partition clearing information
 33 | clearpart --all --initlabel
 34 | # Disk partitioning information
 35 | part / --fstype="ext4" --size=1024
 36 | part swap --fstype="swap" --size=2048
 37 | part /usr --fstype="ext4" --size=5120
 38 | part /var --fstype="ext4" --size=3072
 39 | part /tmp --fstype="ext4" --size=3072
 40 | part /logs --fstype="ext4" --size=13000
 41 | #part /www --fstype="ext4" --grow --size=1
 42 | 
 43 | # Disk partitioning information for soft RAID1
 44 | #part raid.01 --size=1024 --ondisk=sda
 45 | #part raid.02 --size=2048 --ondisk=sda
 46 | #part raid.03 --size=5120 --ondisk=sda
 47 | #part raid.04 --size=3072 --ondisk=sda
 48 | #part raid.05 --size=3072 --ondisk=sda
 49 | #part raid.06 --size=13000 --ondisk=sda
 50 | #part raid.07 --size=1 --grow --ondisk=sda
 51 | 
 52 | #part raid.08 --size=1024 --ondisk=sdb
 53 | #part raid.09 --size=2048 --ondisk=sdb
 54 | #part raid.10 --size=5120 --ondisk=sdb
 55 | #part raid.11 --size=3072 --ondisk=sdb
 56 | #part raid.12 --size=3072 --ondisk=sdb
 57 | #part raid.13 --size=13000 --ondisk=sdb
 58 | #part raid.14 --size=1 --grow --ondisk=sdb
 59 | 
 60 | #raid /        --level=RAID1 --device=md0 --fstype=ext4 raid.01 raid.08
 61 | #raid /logs    --level=RAID1 --device=md1 --fstype=ext4 raid.06 raid.13
 62 | #raid /usr     --level=RAID1 --device=md2 --fstype=ext4 raid.03 raid.10
 63 | #raid /var     --level=RAID1 --device=md3 --fstype=ext4 raid.04 raid.11
 64 | #raid /tmp     --level=RAID1 --device=md4 --fstype=ext4 raid.05 raid.12
 65 | #raid swap     --level=RAID1 --device=md5 --fstype=swap raid.02 raid.09
 66 | ##raid /www    --level=RAID1 --device=md6 --fstype=ext4 raid.07 raid.14
 67 | 
 68 | # Repo
 69 | repo --name="CentOS"  --baseurl=http://ks.example.ru/ --cost=100
 70 | 
 71 | #Packages
 72 | %packages
 73 | #@base
 74 | @core
 75 | @server-policy
 76 | OpenIPMI-tools
 77 | logwatch
 78 | postfix
 79 | gcc
 80 | telnet
 81 | gcc-c++
 82 | make
 83 | rpm-build
 84 | cvs
 85 | ntp
 86 | net-snmp
 87 | sysstat
 88 | screen
 89 | strace
 90 | mc
 91 | vim-common
 92 | iptraf
 93 | mtr
 94 | autoconf
 95 | subversion
 96 | flex
 97 | zlib-devel
 98 | openssl-devel
 99 | libxml2-devel
100 | libjpeg-devel
101 | libpng-devel
102 | curl-devel
103 | db4-devel
104 | freetype-devel
105 | pcre-devel
106 | libxslt-devel
107 | mysql-devel
108 | libtool-ltdl-devel
109 | libtool-ltdl
110 | bzip2-devel
111 | expat-devel
112 | ncurses-devel
113 | pam_passwdqc
114 | pam_pkcs11
115 | pam_krb5
116 | wget
117 | sudo
118 | bind-utils
119 | csh
120 | caching-nameserver
121 | openssh-clients
122 | bacula-client
123 | procmail
124 | vim-enhanced
125 | %end
126 | 
127 | %pre
128 | 
129 | %end
130 | 
131 | %post
132 | (
133 | set -x
134 | echo
135 | echo "################################"
136 | echo "# Running Post Configuration   #"
137 | echo "################################"
138 | 
139 | #Update system
140 | hostname default.example.ru
141 | rm -rf /var/cache/yum/timedhosts.txt
142 | yum update -y
143 | 
144 | #Tune FS
145 | df -k | grep -v Filesystem | awk '{if($2>10000000) print "tune2fs -i 0 -c 0 " $1}' | /bin/sh
146 | 
147 | #Turn OFF useless daemons
148 | chkconfig autofs off 2> /dev/null
149 | chkconfig bluetooth off 2> /dev/null
150 | chkconfig cpuspeed off 2> /dev/null
151 | chkconfig cups off 2> /dev/null
152 | chkconfig gpm off 2> /dev/null
153 | chkconfig hidd off 2> /dev/null
154 | chkconfig isdn off 2> /dev/null
155 | chkconfig kudzu off 2> /dev/null
156 | chkconfig mcstrans off 2> /dev/null
157 | chkconfig netfs off 2> /dev/null
158 | chkconfig nfslock off 2> /dev/null
159 | chkconfig pcscd off 2> /dev/null
160 | chkconfig portmap off 2> /dev/null
161 | chkconfig restorecond off 2> /dev/null
162 | chkconfig rpcgssd off 2> /dev/null
163 | chkconfig rpcidmapd off 2> /dev/null
164 | chkconfig sendmail off 2> /dev/null
165 | chkconfig xfs off 2> /dev/null
166 | chkconfig hplip off 2> /dev/null
167 | chkconfig smartd off 2> /dev/null
168 | chkconfig ip6tables off 2> /dev/null
169 | chkconfig haldaemon off 2> /dev/null
170 | chkconfig avahi-daemon off 2> /dev/null
171 | chkconfig avahi-dnsconfd off 2> /dev/null
172 | chkconfig auditd off 2> /dev/null
173 | chkconfig dsm_om_connsvc off 2> /dev/null
174 | chkconfig dsm_om_shrsvc off 2> /dev/null
175 | chkconfig dsm_sa_ipmi off 2> /dev/null
176 | chkconfig ip6tables off 2> /dev/null
177 | 
178 | #Config Named
179 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/named.conf -O /etc/named.conf
180 | echo 'OPTIONS="-4"' >> /etc/sysconfig/named
181 | chkconfig named on
182 | 
183 | #Config Posfix
184 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/main.cf -O /etc/postfix/main.cf
185 | newaliases;
186 | chkconfig postfix on
187 | 
188 | sed -i -r '/(www)|(backup)|(spool)|(logs)/s/([^a-zA-Z0-9,]+)(defaults)([^a-zA-Z0-9,]+)/\1defaults,bsdgroups,noatime\3/g' /etc/fstab
189 | sed -i 's/ENABLED=yes/ENABLED=no/' /etc/sysconfig/raid-check
190 | sed -i 's/PRELINKING=yes/PRELINKING=no/' /etc/sysconfig/prelink; prelink -ua
191 | sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/sysconfig/selinux; echo 0 > /selinux/enforce
192 | sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/selinux/config; echo 0 > /selinux/enforce
193 | 
194 | for i in /etc/sysconfig/network-scripts/ifcfg-eth?; do sed -i '/^HWADDR\=/d' $i; done
195 | sed -i 's/Defaults    requiretty/#Defaults    requiretty/g' /etc/sudoers
196 | cd /; mv home /usr/; ln -sf /usr/home /home
197 | 
198 | ln -sf /usr/share/zoneinfo/Europe/Moscow /etc/localtime
199 | localedef -f CP1251 -i ru_RU /usr/lib/locale/ru_RU.CP1251
200 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/i18n -O /etc/sysconfig/i18n
201 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/csh.cshrc -O /etc/csh.cshrc
202 | touch /etc/cron.allow
203 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/crontab -O /etc/crontab
204 | 
205 | #PAM.d
206 | cd /etc/pam.d; unlink system-auth; cp system-auth-ac system-auth;
207 | sed -i 's/pam_cracklib\.so try_first_pass retry=3 type=/pam_passwdqc\.so enforce=everyone passphrase=0 min=disabled\,disabled\,disabled\,8\,8 random=0/g' system-auth
208 | 
209 | wget -nv --no-check-certificate -O /etc/init.d/boot-notify https://mnt.example.ru/pub/boot-notify
210 | chmod 755 /etc/init.d/boot-notify && chkconfig boot-notify on
211 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/ntp.conf -O /etc/ntp.conf
212 | awk '/^server/ {print $2}' /etc/ntp.conf > /etc/ntp/step-tickers; chkconfig ntpd on
213 | 
214 | mkdir /www/db; mkdir /www/backup; mkdir /usr/build
215 | mkdir /root/bin; chmod 700 /root/bin; cd /root/bin
216 | wget -nv --no-check-certificate https://mnt.example.ru/pub/conf-reglament/All/check_disks.pl; chmod +x check_disks.pl
217 | wget -nv --no-check-certificate https://mnt.example.ru/pub/cvsbackup/linux_cvs.sh && sh ./linux_cvs.sh
218 | wget -nv --no-check-certificate -O /etc/snmp/snmpd.conf https://mnt.example.ru/pub/conf-reglament/Linux/snmpd.conf && chkconfig snmpd on
219 | sed -i s/syslogd/rsyslogd/g /etc/snmp/snmpd.conf
220 | 
221 | mkdir -p /www/tmp; chmod 1777 /www/tmp;
222 | 
223 | wget --no-check-certificate -O /root/bin/MegaCli https://mnt.example.ru/pub/MegaCli; chmod +x /root/bin/MegaCli
224 | 
225 | #Create MNT
226 | wget --no-check-certificate -O /root/bin/create_mnt.sh https://mnt.example.ru/pub/mnt/create_mnt.sh && /bin/sh /root/bin/create_mnt.sh
227 | 
228 | wget --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/sysctl.conf -O /etc/sysctl.conf
229 | 
230 | sed -i 's/net\.ipv4\.ip_conntrack_max/net\.nf_conntrack_max/'  /etc/sysctl.conf
231 | sed -i 's/\"/ /g'  /etc/sysctl.conf
232 | 
233 | wget --no-check-certificate https://mnt.example.ru/pub/conf-reglament/Linux/logwatch.conf -O /etc/logwatch/conf/logwatch.conf
234 | 
235 | #Firewall
236 | wget --no-check-certificate -O /root/bin/fw.sh https://mnt.example.ru/pub/conf-reglament/Linux/fw.sh
237 | wget --no-check-certificate -O /root/bin/fw-sship https://mnt.example.ru/pub/conf-reglament/All/fw-sship
238 | #sh /root/bin/fw.sh && service iptables save
239 | 
240 | sed -i 's/rhgb//g ; s/quiet//g' /boot/grub/grub.conf
241 | 
242 | sed -i "/deadline/d" /etc/rc.local
243 | for i in a b c d e f g h ; do
244 |    if [ -w /sys/block/sd${i}/queue/scheduler ]; then
245 |      echo sd${i} ;
246 |      echo deadline > /sys/block/sd${i}/queue/scheduler ;
247 |      ( echo "echo deadline > /sys/block/sd${i}/queue/scheduler" >> /etc/rc.local );
248 |      fi;
249 |    done
250 | 
251 | if [ -w /etc/rsyslog.conf ]; then
252 |    sed -r -i 's/(\/var\/log\/messages)/\-\1/ ; s/(\/var\/log\/maillog)/\-\1/ ; s/\-\-/\-/g' /etc/rsyslog.conf
253 |    fi
254 | if [ -w /etc/syslog.conf ]; then
255 |    sed -r -i 's/(\/var\/log\/messages)/\-\1/ ; s/(\/var\/log\/maillog)/\-\1/ ; s/\-\-/\-/g' /etc/syslog.conf
256 |    fi
257 | 
258 | #sed -i '/alias\ net\-pf\-10/d ; /alias\ ipv6/d ; /options\ ipv6\ disable=1/d' /etc/modprobe.d/modprobe.conf
259 | echo "alias net-pf-10 off" >> /etc/modprobe.d/modprobe.conf
260 | echo "alias ipv6 off" >> /etc/modprobe.d/modprobe.conf
261 | echo "options ipv6 disable=1" >> /etc/modprobe.d/modprobe.conf
262 | sed  -i '/NETWORKING_IPV6=/d' /etc/sysconfig/network
263 | echo 'NETWORKING_IPV6=no' >> /etc/sysconfig/network
264 | 
265 | rm -f /root/bin/lr.sh
266 | wget --no-check-certificate -O /root/bin/lr.sh https://mnt.example.ru/pub/conf-reglament/All/lr.sh
267 | chmod a+x /root/bin/lr.sh
268 | sed -i '/#log\ rotate/d ; /\/root\/bin\/lr\.sh/d' /etc/crontab
269 | echo '#log rotate' >> /etc/crontab
270 | echo 'MAILTO=root@example.ru' >> /etc/crontab
271 | echo '0       2       *       *       *       root    /root/bin/lr.sh' >> /etc/crontab
272 | 
273 | wget --no-check-certificate https://mnt.example.ru/pub/conf-reglament/All/resolv.conf -O /etc/resolv.conf.tmp
274 | mv -f /etc/resolv.conf.tmp /etc/resolv.conf; rm -f /etc/resolv.conf.tmp
275 | 
276 | groupadd -g80 www ; useradd -u 80 -g 80 -s /sbin/nologin -d /nonexistent www
277 | 
278 | #add some repository
279 | rpm -iv http://mirror.yandex.ru/epel/6/x86_64/epel-release-6-5.noarch.rpm
280 | 
281 | #ladvd - Link Layer Discovery Protocol tool
282 | #mkdir /var/run/ladvd
283 | #useradd -s /sbin/nologin -d /var/run/ladvd ladvd
284 | 
285 | 
286 | #POST-POST INSTALL!
287 | cat >  /etc/rc.d/rc.local <<-EOF
288 | /bin/sh /root/bin/fw.sh
289 | /sbin/service iptables save
290 | /sbin/modprobe ipmi_devintf; /sbin/modprobe ipmi_si; /sbin/modprobe ipmi_msghandler
291 | ipmitool sel clear
292 | ipmitool chassis policy always-on
293 | 
294 | /root/bin/MegaCli -ldsetprop adra -Lall -aALL -NoLog
295 | /root/bin/MegaCli -ldsetprop wb -Lall -aALL -NoLog
296 | /root/bin/MegaCli -ldsetprop cached -Lall -aALL -NoLog
297 | /root/bin/MegaCli -ldsetprop -endskcache -Lall -aALL -NoLog
298 | /root/bin/MegaCli -ldsetprop CachedBadBBU -Lall -aALL -NoLog
299 | /root/bin/MegaCli -AdpCcSched -SetDelay 1440 -aALL -NoLog
300 | 
301 | touch /var/lock/subsys/local
302 | echo "" > /etc/rc.d/rc.local
303 | echo "touch /var/lock/subsys/local" >> /etc/rc.d/rc.local
304 | EOF
305 | 
306 | ) > /root/post_install.log 2>&1
307 | #) > /root/post.log
308 | %end
309 | 


--------------------------------------------------------------------------------
/kickstart/ks.cfg_default:
--------------------------------------------------------------------------------
 1 | #platform=x86, AMD64, or Intel EM64T
 2 | #version=DEVEL
 3 | # Firewall configuration
 4 | firewall --disabled
 5 | # Install OS instead of upgrade
 6 | install
 7 | # Use network installation
 8 | url --url="http://ks.example.ru/"
 9 | # Root password
10 | rootpw --iscrypted $1$5Ytbf19/$XxFXz1XIbPjHqgxTazGk1123
11 | # Network information
12 | network  --bootproto=static --device=eth0 --gateway=192.168.56.1 --ip=192.168.56.101 --nameserver=8.8.8.8 --netmask=255.255.255.0 --onboot=on
13 | # System authorization information
14 | auth  --useshadow  --passalgo=sha512
15 | # Use text mode install
16 | text
17 | firstboot --disable
18 | # System keyboard
19 | keyboard us
20 | # System language
21 | lang en_US
22 | # SELinux configuration
23 | selinux --disabled
24 | # Installation logging level
25 | logging --level=info
26 | # Reboot after installation
27 | reboot
28 | # System timezone
29 | timezone  Europe/Moscow
30 | # System bootloader configuration
31 | bootloader --location=mbr
32 | # Partition clearing information
33 | clearpart --all --initlabel 
34 | # Disk partitioning information
35 | part / --fstype="ext4" --size=1024
36 | part swap --fstype="swap" --size=2048
37 | part /usr --fstype="ext4" --size=5120
38 | part /var --fstype="ext4" --size=3072
39 | part /tmp --fstype="ext4" --size=3072
40 | part /logs --fstype="ext4" --size=12288
41 | part /www --fstype="ext4" --grow --size=1
42 | 
43 | %packages
44 | @base
45 | 
46 | %end
47 | 


--------------------------------------------------------------------------------
/kickstart/make_ks.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | clear
 3 | while true; do
 4 | echo "Enter Network Configuration"
 5 | echo "---------------------------"
 6 | echo " "
 7 | 
 8 | echo -en "Enter the Hostname? : "
 9 | read host
10 | 
11 | echo -en "Enter the IP Address? : "
12 | read ip
13 | 
14 | echo -en "Enter the Netmask? : "
15 | read netmask
16 | 
17 | echo -en "Enter the Gateway? : "
18 | read gateway
19 | 
20 | echo -e ""
21 | echo -e "Please Review Your Entries "
22 | echo -e "--------------------------"
23 | echo -e "Hostname : $host"
24 | echo -e "IP Address : $ip"
25 | echo -e "Netmask : $netmask"
26 | echo -e "Gateway : $gateway"
27 | echo -e " "
28 | echo -en "Does Everything Look Correct? (y/n) "
29 | read yn
30 | case $yn in
31 | y* | Y* ) line="network --bootproto=static --device=eth0 --gateway=$gateway --ip=$ip --nameserver=8.8.8.8 --netmask=$netmask --onboot=on --hostname $host --noipv6"
32 | 
33 | ks="/www/ks.example.ru/htdocs/ks.cfg"
34 | 
35 | sed -e "/^network/s/^network.*/$line/" $ks | sed -e "s/default.example.ru/$host/" > ${ks}.tmp && mv ${ks}.tmp $host.cfg;
36 | echo -e " ";
37 | echo "To Install Your System Use This Command: linux ks=http://ks.example.ru:/$host.cfg ip=$ip gateway=$gateway dns=8.8.8.8"; 
38 | echo "--------------------------";
39 | break;;
40 | [nN]* ) echo -e "Renter Your Information" ; continue;;
41 | q* ) exit ;;
42 | * ) echo "Enter yes or no" ;;
43 | esac
44 | done
45 | 


--------------------------------------------------------------------------------
/kill_ppid.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | import os
 4 | import signal
 5 | import subprocess
 6 | import time
 7 | import re
 8 | 
 9 | # Change this to your process name
10 | processname = '/usr/local/apache2/bin/httpd'
11 | user = 'www'
12 | 
13 | pids = {}
14 | 
15 | out, err = subprocess.Popen(['ps', 'xwww', '-U', user, '-O', 'ppid'], stdout=subprocess.PIPE).communicate()
16 | 
17 | for line in out.splitlines():
18 |         col = line.split()
19 |         pid = col[0]
20 |         ppid = col[1]
21 |         process = col[5:]
22 | 
23 |         if re.search(processname, line):
24 |                 pids[ppid] = pid
25 | 
26 | for ppid in pids:
27 |         for pid in pids.values():
28 |                 if ppid == pid:
29 |                         kill_pid = int(pids[ppid])
30 |                         try:
31 |                                 time.sleep(0.5)
32 |                                 os.kill(kill_pid, 0)
33 |                                 print "kill -9", kill_pid
34 |                                 os.kill(kill_pid, signal.SIGKILL)
35 |                         except:
36 |                                 pass
37 | 


--------------------------------------------------------------------------------
/logrotate.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
 4 | 
 5 | log_dirs='/logs/'
 6 | pid_dirs='/logs /var/run'
 7 | httpds='"*http*" "apache*" "nginx"'
 8 | 
 9 | for log_dir in $log_dirs; do
10 |     find $log_dir -type f -name '*_log.*.gz' -mtime 5 | xargs rm -f
11 | done
12 | 
13 | if uname | grep -qi linux; then
14 |     # Linux
15 |     yesterday () {
16 | 	date -d "12 hours ago" +%Y%m%d
17 |     }
18 |     before_yesterday () {
19 | 	date -d "36 hours ago" +%Y%m%d
20 |     }
21 | elif uname | grep -qi freebsd; then
22 |     # FreeBSD
23 |     if uname -r | grep -q ^4; then
24 | 	# 4* FreeBSD
25 | 	yesterday () {
26 | 	    date -j -v -12H +%Y%m%d
27 | 	}
28 | 	before_yesterday () {
29 | 	    date -j -v -36H +%Y%m%d
30 | 	}
31 |     else
32 | 	# other, use old 'date'
33 | 	yesterday () {
34 | 	    sec=`date +%s`
35 | 	    date -r `expr $sec - 43200` +%Y%m%d
36 | 	}
37 | 	before_yesterday () {
38 | 	    sec=`date +%s`
39 | 	    date -r `expr $sec - 129600` +%Y%m%d
40 | 	}
41 |     fi
42 | else
43 |     # Other
44 |     echo "Don't know this operating system: `uname`" 2>&1
45 |     exit 1
46 | fi
47 | 
48 | walk_with () {
49 |     cmd=$1
50 |     for log_dir in $log_dirs; do
51 | 	for d in $log_dir $log_dir/*; do
52 | 	    if [ -d $d ]; then
53 | 		for log in $d/*_log; do
54 | 		    [ -f $log ] && eval "$cmd"
55 | 		done
56 | 	    fi
57 | 	done
58 |     done
59 | }
60 | 
61 | date=`yesterday`
62 | 
63 | walk_with '[ -f $log -a -s $log ] && mv -f $log $log.$date'
64 | 
65 | for pid_dir in $pid_dirs; do
66 |     for httpd in $httpds; do
67 | 	httpd=`echo $httpd | sed 's/^"\(.*\)"$/\1/'`
68 | 	for pid_file in $pid_dir/$httpd.pid; do
69 | 	    if [ -f $pid_file ]; then
70 | 		if ! echo $pid_file | grep -q thttp; then
71 | 		    # rotate log apache
72 | 		    kill -USR1 `cat $pid_file`
73 | 		else
74 | 		    # rotate log thttpd
75 | 		    thttpd_script=/usr/local/etc/rc.d/thttpd.sh
76 | 		    if [ -x $thttpd_script ]; then
77 | 			sh -c "$thttpd_script restart | grep -v thttpd"
78 | 		    else
79 | 			echo "please move start of thttpd from /etc/rc.local to /usr/local/etc/rc.d/thttpd.sh" 2>&1
80 | 		    fi
81 | 		fi
82 | 	    fi
83 | 	done
84 |     done
85 | done
86 | sleep 15
87 | 
88 | # gzip files of a day before yesterday
89 | 
90 | date=`yesterday`
91 | 
92 | walk_with '[ -f $log.$date ] && gzip $log.$date'
93 | 
94 | 


--------------------------------------------------------------------------------
/mailx_wrapper.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | # coding: utf8
 3 | 
 4 | """
 5 | A simple wrapper for the `mailx` command.
 6 | Purpose
 7 | -------
 8 | Send an email notification to yourself from a Python script.
 9 | """
10 | 
11 | import os
12 | 
13 | DEBUG = True
14 | # DEBUG = False
15 | 
16 | 
17 | class NoSubjectError(Exception):
18 |     pass
19 | 
20 | 
21 | class NoRecipientError(Exception):
22 |     pass
23 | 
24 | 
25 | def send_email(to='', subject='', body=''):
26 |     if not subject:
27 |         raise NoSubjectError
28 |     if not to:
29 |         raise NoRecipientError
30 |     #
31 |     if not body:
32 |         cmd = """mailx -s "{s}" < /dev/null "{to}" 2>/dev/null""".format(
33 |             s=subject, to=to
34 |         )
35 |     else:
36 |         cmd = """echo "{b}" | mailx -s "{s}" "{to}" 2>/dev/null""".format(
37 |             b=body, s=subject, to=to
38 |         )
39 |     if DEBUG:
40 |         print("#", cmd)
41 |     #
42 |     os.system(cmd)
43 | 
44 | 
45 | def main():
46 |     send_email(to="to@email.com",
47 |                subject="subject")
48 |     #
49 |     send_email(to="to@email.com",
50 |                subject="subject",
51 |                body='this is the body of the email')
52 | 
53 | #############################################################################
54 | 
55 | if __name__ == "__main__":
56 |     main()


--------------------------------------------------------------------------------
/merger.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # ./merger.sh firstfile secondfile
 3 | # 1line,2line
 4 | 
 5 | length=$(wc -l $1 | awk '{print $1}')
 6 | count=1
 7 | while [ "$count" -le "$length" ] ; do
 8 |       a=$(head -$count $1 | tail -1)
 9 |       b=$(head -$count $2 | tail -1)
10 |       echo "$a,$b"
11 |       count=$(expr $count + 1)
12 | done
13 | # I press Control+D here to stop sending characters to the pipe.


--------------------------------------------------------------------------------
/mongo_reclaim.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | # Force MongoDB to only use as much storage as it needs
  4 | # instead of taking up more and more space without reclaiming it
  5 | 
  6 | # Make sure of the following:
  7 | #
  8 | # 1. The mongod user has its shell set to /bin/bash on both machines
  9 | # 2. The mongod user has SSH keys set up such that it can SSH from 
 10 | #    the primary to the secondary without prompt
 11 | # 3. The mongod user has the following permissions in /etc/sudoers:
 12 | #    mongod ALL=NOPASSWD: /sbin/service mongod status, /sbin/service mongod stop, /sbin/service mongod start
 13 | #    (modify accordingly if not using Red Hat/CentOS)
 14 | # 4. Make sure the requiretty option is off in /etc/sudoers
 15 | 
 16 | # Only run as mongod user
 17 | if [ "$(whoami)" != "mongod" ] ; then echo "Not mongod user" ; exit 1 ; fi
 18 | 
 19 | # Determine environment - change these as needed
 20 | case "$(hostname)" in
 21 |   primary.production.mydomain.com ) primary=primary.production.mydomain.com ; secondary=secondary.production.mydomain.com ;;
 22 |   primary.staging.mydomain.com ) primary=primary.staging.mydomain.com ; secondary=secondary.staging.mydomain.com ;;
 23 |   primary.development.mydomain.com ) primary=primary.development.mydomain.com ; secondary=secondary.development.mydomain.com ;;
 24 |   * ) echo "Unknown environment" ; exit 1 ;;
 25 | esac
 26 | 
 27 | # Check sudo and SSH
 28 | if ! sudo -n /sbin/service mongod status > /dev/null ; then
 29 |   echo "Problem with sudo on $primary" ; exit 1
 30 | elif ! ssh -q $secondary "sudo -n /sbin/service mongod status > /dev/null" ; then
 31 |   echo "Problem with SSH and/or sudo on $secondary" ; exit 1
 32 | fi
 33 | 
 34 | # Take backup on primary
 35 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Taking backup /tmp/dump on $primary..."
 36 | cd /tmp ; rm -rf dump ; mongodump > /dev/null
 37 | if [ "$?" != "0" ] ; then echo " Problem taking backup on $primary" ; exit 1 ; fi
 38 | echo " done"
 39 | 
 40 | # Clear data on secondary
 41 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Clearing data on $secondary..."
 42 | ssh -q $secondary "sudo -n /sbin/service mongod stop > /dev/null"
 43 | if [ "$?" != "0" ] ; then echo " Problem stopping mongod on $secondary" ; exit 1 ; fi
 44 | ssh -q $secondary "rm -rf /var/lib/mongo/*"
 45 | ssh -q $secondary "sudo -n /sbin/service mongod start > /dev/null"
 46 | if [ "$?" != "0" ] ; then echo " Problem starting mongod on $secondary" ; exit 1 ; fi
 47 | echo " done"
 48 | 
 49 | # Wait for secondary to come back up
 50 | issecondary=$(ssh -q $secondary "echo 'db.isMaster()' | mongo" | grep secondary | awk -F '[ ,]' '{print $3}')
 51 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Waiting for $secondary to come up..."
 52 | until [ "$issecondary" == "true" ] ; do
 53 |   sleep 5
 54 |   echo -n "."
 55 |   issecondary=$(ssh -q $secondary "echo 'db.isMaster()' | mongo" | grep secondary | awk -F '[ ,]' '{print $3}')
 56 | done
 57 | echo " done"
 58 | 
 59 | # Demote primary so secondary is master
 60 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Demoting $primary..."
 61 | echo 'rs.stepDown()' | mongo --quiet > /dev/null
 62 | if [ "$?" != "0" ] ; then echo " Problem demoting $primary" ; exit 1 ; fi
 63 | echo " done"
 64 | 
 65 | # Wait for secondary to take over as master
 66 | issecondary=$(echo 'db.isMaster()' | mongo | grep secondary | awk -F '[ ,]' '{print $3}')
 67 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Waiting for $secondary to become master..."
 68 | until [ "$issecondary" == "true" ] ; do
 69 |   sleep 5
 70 |   echo -n "."
 71 |   issecondary=$(echo 'db.isMaster()' | mongo | grep secondary | awk -F '[ ,]' '{print $3}')
 72 | done
 73 | echo " done"
 74 | 
 75 | # Clear data on primary
 76 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Clearing data on $primary..."
 77 | sudo -n /sbin/service mongod stop > /dev/null
 78 | if [ "$?" != "0" ] ; then echo " Problem stopping mongod on $primary" ; exit 1 ; fi
 79 | rm -rf /var/lib/mongo/*
 80 | sudo -n /sbin/service mongod start > /dev/null
 81 | if [ "$?" != "0" ] ; then echo " Problem starting mongod on $primary" ; exit 1 ; fi
 82 | echo " done"
 83 | 
 84 | # Wait for primary to come up
 85 | issecondary=$(echo 'db.isMaster()' | mongo | grep secondary | awk -F '[ ,]' '{print $3}')
 86 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Waiting for $primary to come up..."
 87 | until [ "$issecondary" == "true" ] ; do
 88 |   sleep 5
 89 |   echo -n "."
 90 |   issecondary=$(echo 'db.isMaster()' | mongo | grep secondary | awk -F '[ ,]' '{print $3}')
 91 | done
 92 | echo " done"
 93 | 
 94 | # Demote secondary so primary is master
 95 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Demoting $secondary..."
 96 | ssh -q $secondary "echo 'rs.stepDown()' | mongo --quiet > /dev/null"
 97 | if [ "$?" != "0" ] ; then echo " Problem demoting $secondary" ; exit 1 ; fi
 98 | echo " done"
 99 | 
100 | # Wait for primary to take over as master
101 | isprimary=$(echo 'db.isMaster()' | mongo | grep ismaster | awk -F '[ ,]' '{print $3}')
102 | echo -n "$(date +'%Y-%m-%d %H-%M-%S') Waiting for $primary to become master..."
103 | until [ "$isprimary" == "true" ] ; do
104 |   sleep 5
105 |   echo -n "."
106 |   isprimary=$(echo 'db.isMaster()' | mongo | grep ismaster | awk -F '[ ,]' '{print $3}')
107 | done
108 | echo " done"
109 | 


--------------------------------------------------------------------------------
/mongodb_backup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -u
 3 | 
 4 | BDIR='/mongo_backup/'
 5 | EPERIOD=7
 6 | DBASE='db1'
 7 | LOG='/mongo_backup/backup.log'
 8 | #USER=''
 9 | #PASSWORD=''
10 | 
11 | if [ "xfalse" == "x$(mongo --quiet admin --eval 'rs.isMaster().ismaster')" ]; then
12 |     find $BDIR -maxdepth 1 -mindepth 1 -type d -name "2*" -mtime +$EPERIOD -exec rm -rf {} \;
13 |     for i in $DBASE; do
14 |         echo -n "$(date +%d-%m-%y' '%T) " >> $LOG
15 |         /usr/bin/mongodump -h $(hostname -f) -d $i --out "${BDIR}$(date +%Y%m%d)" >> $LOG 2>&1
16 |         [ $? -gt 0 ] && echo "Error backup mongodb database $i" | mail -s "$(hostname) mongodb backup error" root@example.ru
17 |     done
18 | else
19 |     echo "$(date +%d-%m-%y' '%T) isMaster = true, skip backup" >> $LOG
20 | fi
21 | 


--------------------------------------------------------------------------------
/mp3.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | FILE=`zenity --file-selection --directory --title="Выберите путь к крякозябрам"`
 4 | case $? in
 5 | 0)
 6 | echo "Выбран \"$FILE\".";;
 7 | 1)
 8 | echo "Файл не выбран.";;
 9 | -1)
10 | echo "Файл не выбран.";;
11 | esac 
12 | cd "$FILE" || exit; 
13 | (find -iname '*.mp3' -print0 | xargs -0 mid3iconv -e KOI8-R --remove-v1; find -iname '*.mp3' -print0 | xargs -0 mid3iconv -e CP1251 --remove-v1)|zenity --progress --pulsate --auto-close --text "идет процесс" --title "Меняем кодировку"
14 | zenity --info --text="теперь у Вас православный UTF"
15 | 


--------------------------------------------------------------------------------
/mysql_pgsql_backup/mysqlbackup.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | ###################################
  3 | REPLICATION="YES"
  4 | ONSLAVE="YES"
  5 | KEEPDAYS=7
  6 | BASEDIR=/www/backup
  7 | TMPDIR=/www/tmp/backup
  8 | DEBUG="0"
  9 | ###################################
 10 | 
 11 | OS=`uname`
 12 | SOCKET=/tmp
 13 | 
 14 | if [ $OS = "Linux" ]; then SOCKET=/var/lib/mysql; fi 
 15 | if [ -z "${1}" ]; then SOCKET=${SOCKET}/mysql.sock; else SOCKET=${SOCKET}/$1; fi
 16 | 
 17 | REPL_TABLE="log_pos_"
 18 | MYSQL="mysql -S ${SOCKET}"
 19 | MYSQLHOTCOPY="/root/bin/mysqlhotcopy -S ${SOCKET}"
 20 | MYSQLDUMP="mysqldump -S ${SOCKET}"
 21 | BASES=`${MYSQL} -Be 'show databases' | egrep -v '^(Database|information_schema)$'`
 22 | #BASES="mysql"
 23 | DATE=`date +%Y%m%d`
 24 | OWNER='mysql:mysql'
 25 | 
 26 | XARGS="xargs"
 27 | if [ $OS = "Linux" ]; then XARGS="xargs -r"; fi
 28 | find ${BASEDIR} -type f -name '*.gz' -mtime +${KEEPDAYS} | ${XARGS} -r rm
 29 | 
 30 | rm -rf ${TMPDIR}
 31 | mkdir -p -m 700 ${TMPDIR}
 32 | 
 33 | for i in ${BASES}; do
 34 |   TABLESCOUNT=`${MYSQL} -Be 'show tables\g' ${i} | wc -l`
 35 |   if [ $DEBUG = "1" ]; then echo "Tables COUNT: ${TABLESCOUNT}"; fi
 36 |   if [ $TABLESCOUNT -eq 0 ]; then
 37 | 	   if [ $DEBUG = "1" ]; then echo "SKIP: ${i}"; fi
 38 | 	  continue
 39 |   fi
 40 |   ${MYSQL} -Be 'show table status' $i | cut -f 2 | grep InnoDB >/dev/null && \
 41 |     INNODBBASES="${INNODBBASES} $i" || \
 42 |     MYISAMBASES="${MYISAMBASES} $i"
 43 | done
 44 | 
 45 | for base in ${BASES}; do
 46 |   if [ ! -d ${BASEDIR}/${base} ]; then
 47 |     mkdir -p -m 750 ${BASEDIR}/${base}
 48 |   fi
 49 | done
 50 | 
 51 | if [ $DEBUG = "1" ]; then echo "Backup MyISAM bases: ${MYISAMBASES}"; fi
 52 | if [ $DEBUG = "1" ]; then echo "Backup InnoDB bases: ${INNODBBASES}"; fi
 53 | cd ${TMPDIR}
 54 | chown -R ${OWNER} .
 55 | 
 56 | mysql_check_repltable() {
 57 | 	REPLTABLE_COUNT=`${MYSQL} -e 'show tables\g' mysql | grep ${REPL_TABLE}${base} | wc -l`
 58 | 	if [ $REPLTABLE_COUNT -eq 0 ]; then 
 59 | 	{
 60 | 	    if [ $DEBUG = "1" ]; then
 61 | 		echo "Creating ${REPL_TABLE}${base} for base: ${base}";
 62 | 	    fi
 63 | 		${MYSQL} -e "create table ${REPL_TABLE}${base} (host varchar(60) NOT null,time_stamp timestamp(14) NOT NULL, log_file  varchar(32) default NULL,log_pos int(11)     default NULL,master_host varchar(60) NULL,master_log_file varchar(32) NULL,master_log_pos int NULL,PRIMARY KEY (host))" mysql;
 64 | 	} else {
 65 | 	    if [ $DEBUG = "1" ]; then
 66 | 		echo "Repl table ${REPL_TABLE}${base} for base: ${base} already exist";
 67 | 	    fi
 68 | 	}
 69 | 	fi
 70 | }
 71 | 
 72 | if [ -z $REPLICATION ]; then {
 73 |      if [ $DEBUG = "1" ]; then
 74 | 	echo "Doing backup WITHOUT replication"
 75 |      fi
 76 | 
 77 | 	for base in ${MYISAMBASES}; do
 78 | 		${MYSQLHOTCOPY} -q --addtodest --noindices ${base} ${TMPDIR}
 79 | 
 80 | 	if [ -d ${TMPDIR}/${base} ]; then
 81 | 		nice -n 20 tar -czf ${BASEDIR}/${base}/${base}.${DATE}.tar.gz ./${base}
 82 | 		rm -rf ${TMPDIR}/${base}
 83 | 	fi
 84 | 	done
 85 | }
 86 | else
 87 | {
 88 |      if [ $DEBUG = "1" ]; then
 89 |         echo "Doing backup WITH replication"
 90 |      fi
 91 | 	if [ -z $ONSLAVE ]; then {
 92 | 	   if [ $DEBUG = "1" ]; then
 93 | 		echo "Doing backup WITH replication on MASTER"
 94 | 	   fi
 95 | 	        for base in ${MYISAMBASES}; do
 96 | 			mysql_check_repltable;
 97 | 	                ${MYSQLHOTCOPY} -q --addtodest --noindices  --record_log_pos=mysql.${REPL_TABLE}${base} ${base} ${TMPDIR}
 98 | 		        if [ -d ${TMPDIR}/${base} ]; then
 99 | 				nice -n 20 tar -czf ${BASEDIR}/${base}/${base}.${DATE}.tar.gz ./${base}
100 | 				rm -rf ${TMPDIR}/${base}
101 | 			fi
102 | 		done
103 |         } 
104 | 	else
105 | 	{
106 | 	  if [ $DEBUG = "1" ]; then
107 |                 echo "Doing backup WITH replication on SLAVE"
108 | 	  fi
109 |                 for base in ${MYISAMBASES}; do
110 | 			mysql_check_repltable;
111 |                         ${MYSQLHOTCOPY} -q --addtodest --noindices --on_slave --record_log_pos=mysql.${REPL_TABLE}${base} ${base} ${TMPDIR}
112 |                         if [ -d ${TMPDIR}/${base} ]; then
113 |                         	nice -n 20 tar -czf ${BASEDIR}/${base}/${base}.${DATE}.tar.gz ./${base}
114 |                         	rm -rf ${TMPDIR}/${base}
115 | 			fi
116 |                 done
117 | 	
118 | 	}
119 | 	fi
120 | }
121 | fi
122 | 	
123 | rm -rf ${TMPDIR}
124 | 
125 | # InnoDB databases backup
126 | if [ -z $REPLICATION ]; then {
127 | 	for base in ${INNODBBASES}; do
128 | 		if ( ${MYSQLDUMP} --opt --single-transaction $base | gzip -9 -c >${BASEDIR}/${base}/${base}.${DATE}.sql.gz ) 2>&1 | grep .; then
129 |     		echo "Error backuping db: $base"
130 |   		fi
131 | 	done
132 | }
133 | else
134 | {
135 |         if [ -z $ONSLAVE ]; then {
136 | 	   if [ $DEBUG = "1" ]; then
137 |                 echo "Doing backup WITH replication on MASTER"
138 | 	   fi
139 |         	for base in ${INNODBBASES}; do
140 |         		if ( ${MYSQLDUMP} --master-data=2 --opt --single-transaction $base | gzip -9 -c >${BASEDIR}/${base}/${base}.${DATE}.sql.gz ) 2>&1 | grep .; then
141 |                		echo "Error backuping db: $base"
142 |                 	fi
143 | 		done
144 | 	}
145 | 	else
146 | 	{
147 | 	   if [ $DEBUG = "1" ]; then
148 | 		echo "Can't do backup on SLAVE InnoDB bases"
149 | 	   fi
150 | 	}
151 | 	fi
152 | }
153 | fi
154 | 


--------------------------------------------------------------------------------
/mysql_pgsql_backup/mysqldumpslow:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | # mysqldumpslow - parse and summarize the MySQL slow query log
  3 | 
  4 | # Original version by Tim Bunce, sometime in 2000.
  5 | # Further changes by Tim Bunce, 8th March 2001.
  6 | # Handling of strings with \ and double '' by Monty 11 Aug 2001.
  7 | 
  8 | use strict;
  9 | use Getopt::Long;
 10 | 
 11 | # t=time, l=lock time, r=rows
 12 | # at, al, and ar are the corresponding averages
 13 | 
 14 | my %opt = (
 15 |     s => 'at',
 16 |     h => '*',
 17 | );
 18 | 
 19 | GetOptions(\%opt,
 20 |     'verbose|v+',# verbose
 21 |     'help+',	# write usage info
 22 |     'debug|d+',	# debug
 23 |     's=s',	# what to sort by (t, at, l, al, r, ar etc)
 24 |     'r!',	# reverse the sort order (largest last instead of first)
 25 |     't=i',	# just show the top n queries
 26 |     'a!',	# don't abstract all numbers to N and strings to 'S'
 27 |     'n=i',	# abstract numbers with at least n digits within names
 28 |     'g=s',	# grep: only consider stmts that include this string
 29 |     'h=s',	# hostname of db server for *-slow.log filename (can be wildcard)
 30 |     'i=s',	# name of server instance (if using mysql.server startup script)
 31 |     'l!',	# don't subtract lock time from total time
 32 | ) or usage("bad option");
 33 | 
 34 | $opt{'help'} and usage();
 35 | 
 36 | unless (@ARGV) {
 37 |     my $defaults   = `my_print_defaults mysqld`;
 38 |     my $basedir = ($defaults =~ m/--basedir=(.*)/)[0]
 39 | 	or die "Can't determine basedir from 'my_print_defaults mysqld' output: $defaults";
 40 |     warn "basedir=$basedir\n" if $opt{v};
 41 | 
 42 |     my $datadir = ($defaults =~ m/--datadir=(.*)/)[0];
 43 |     if (!$datadir or $opt{i}) {
 44 | 	# determine the datadir from the instances section of /etc/my.cnf, if any
 45 | 	my $instances  = `my_print_defaults instances`;
 46 | 	die "Can't determine datadir from 'my_print_defaults mysqld' output: $defaults"
 47 | 	    unless $instances;
 48 | 	my @instances = ($instances =~ m/^--(\w+)-/mg);
 49 | 	die "No -i 'instance_name' specified to select among known instances: @instances.\n"
 50 | 	    unless $opt{i};
 51 | 	die "Instance '$opt{i}' is unknown (known instances: @instances)\n"
 52 | 	    unless grep { $_ eq $opt{i} } @instances;
 53 | 	$datadir = ($instances =~ m/--$opt{i}-datadir=(.*)/)[0]
 54 | 	    or die "Can't determine --$opt{i}-datadir from 'my_print_defaults instances' output: $instances";
 55 | 	warn "datadir=$datadir\n" if $opt{v};
 56 |     }
 57 | 
 58 |     @ARGV = <$datadir/$opt{h}-slow.log>;
 59 |     die "Can't find '$datadir/$opt{h}-slow.log'\n" unless @ARGV;
 60 | }
 61 | 
 62 | warn "\nReading mysql slow query log from @ARGV\n";
 63 | 
 64 | my @pending;
 65 | my %stmt;
 66 | $/ = ";\n#";		# read entire statements using paragraph mode
 67 | while ( defined($_ = shift @pending) or defined($_ = <>) ) {
 68 |     warn "[[$_]]\n" if $opt{d};	# show raw paragraph being read
 69 | 
 70 |     my @chunks = split /^\/.*Version.*started with[\000-\377]*?Time.*Id.*Command.*Argument.*\n/m;
 71 |     if (@chunks > 1) {
 72 | 	unshift @pending, map { length($_) ? $_ : () } @chunks;
 73 | 	warn "<<".join(">>\n<<",@chunks).">>" if $opt{d};
 74 | 	next;
 75 |     }
 76 | 
 77 |     s/^#? Time: \d{6}\s+\d+:\d+:\d+.*\n//;
 78 |     my ($user,$host) = s/^#? User\@Host:\s+(\S+)\s+\@\s+(\S+).*\n// ? ($1,$2) : ('','');
 79 | 
 80 |     s/^# Query_time: (\d+)  Lock_time: (\d+)  Rows_sent: (\d+)  Rows_examined: (\d+).*\n//;
 81 |     my ($t, $l, $r, $e) = ($1, $2, $3, $4);
 82 |     $t -= $l unless $opt{l};
 83 | 
 84 |     # remove fluff that mysqld writes to log when it (re)starts:
 85 |     s!^/.*Version.*started with:.*\n!!mg;
 86 |     s!^Tcp port: \d+  Unix socket: \S+\n!!mg;
 87 |     s!^Time.*Id.*Command.*Argument.*\n!!mg;
 88 | 
 89 |     s/^use \w+;\n//;	# not consistently added
 90 |     s/^SET timestamp=\d+;\n//;
 91 | 
 92 |     s/^[ 	]*\n//mg;	# delete blank lines
 93 |     s/^[ 	]*/  /mg;	# normalize leading whitespace
 94 |     s/\s*;\s*(#\s*)?$//;	# remove trailing semicolon(+newline-hash)
 95 | 
 96 |     next if $opt{g} and !m/$opt{g}/io;
 97 | 
 98 |     unless ($opt{a}) {
 99 | 	s/\b\d+\b/N/g;
100 | 	s/\b0x[0-9A-Fa-f]+\b/N/g;
101 |         s/''/'S'/g;
102 |         s/""/"S"/g;
103 |         s/(\\')//g;
104 |         s/(\\")//g;
105 |         s/'[^']+'/'S'/g;
106 |         s/"[^"]+"/"S"/g;
107 | 	# -n=8: turn log_20001231 into log_NNNNNNNN
108 | 	s/([a-z_]+)(\d{$opt{n},})/$1.('N' x length($2))/ieg if $opt{n};
109 | 	# abbreviate massive "in (...)" statements and similar
110 | 	s!(([NS],){100,})!sprintf("$2,{repeated %d times}",length($1)/2)!eg;
111 |     }
112 | 
113 |     my $s = $stmt{$_} ||= { users=>{}, hosts=>{} };
114 |     $s->{c} += 1;
115 |     $s->{t} += $t;
116 |     $s->{l} += $l;
117 |     $s->{r} += $r;
118 |     $s->{e} += $e;
119 |     $s->{users}->{$user}++ if $user;
120 |     $s->{hosts}->{$host}++ if $host;
121 | 
122 |     warn "{{$_}}\n\n" if $opt{d};	# show processed statement string
123 | }
124 | 
125 | foreach (keys %stmt) {
126 |     my $v = $stmt{$_} || die;
127 |     my ($c, $t, $l, $r, $e) = @{ $v }{qw(c t l r e)};
128 |     $v->{at} = $t / $c;
129 |     $v->{al} = $l / $c;
130 |     $v->{ar} = $r / $c;
131 |     $v->{ae} = $e / $c;
132 | }
133 | 
134 | my @sorted = sort { $stmt{$b}->{$opt{s}} <=> $stmt{$a}->{$opt{s}} } keys %stmt;
135 | @sorted = @sorted[0 .. $opt{t}-1] if $opt{t};
136 | @sorted = reverse @sorted         if $opt{r};
137 | 
138 | foreach (@sorted) {
139 |     my $v = $stmt{$_} || die;
140 |     my ($c, $t,$at, $l,$al, $r,$ar, $e,$ae) = @{ $v }{qw(c t at l al r ar e ae)};
141 |     my @users = keys %{$v->{users}};
142 |     my $user  = (@users==1) ? $users[0] : sprintf "%dusers",scalar @users;
143 |     my @hosts = keys %{$v->{hosts}};
144 |     my $host  = (@hosts==1) ? $hosts[0] : sprintf "%dhosts",scalar @hosts;
145 |     printf "Count: %d  Time=%.2fs (%ds)  Lock=%.2fs (%ds)  Rows=%.1f (%d)  Examined=%.1f (%d), $user\@$host\n%s\n\n",
146 | 	    $c, $at,$t, $al,$l, $ar,$r, $ae,$e, $_;
147 | }
148 | 
149 | sub usage {
150 |     my $str= shift;
151 |     my $text= <<HERE;
152 | Usage: mysqldumpslow [ OPTS... ] [ LOGS... ]
153 | 
154 | Parse and summarize the MySQL slow query log. Options are
155 | 
156 |   --verbose    verbose
157 |   --debug      debug
158 |   --help       write this text to standard output
159 | 
160 |   -v           verbose
161 |   -d           debug
162 |   -s ORDER     what to sort by (t, at, l, al, r, ar, e, ae etc), 'at' is default
163 |   -r           reverse the sort order (largest last instead of first)
164 |   -t NUM       just show the top n queries
165 |   -a           don't abstract all numbers to N and strings to 'S'
166 |   -n NUM       abstract numbers with at least n digits within names
167 |   -g PATTERN   grep: only consider stmts that include this string
168 |   -h HOSTNAME  hostname of db server for *-slow.log filename (can be wildcard),
169 |                default is '*', i.e. match all
170 |   -i NAME      name of server instance (if using mysql.server startup script)
171 |   -l           don't subtract lock time from total time
172 | 
173 | HERE
174 |     if ($str) {
175 |       print STDERR "ERROR: $str\n\n";
176 |       print STDERR $text;
177 |       exit 1;
178 |     } else {
179 |       print $text;
180 |       exit 0;
181 |     }
182 | }
183 | 


--------------------------------------------------------------------------------
/mysql_pgsql_backup/mysqlhotbackup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | MYSQLHOTCOPY=/root/bin/mysqlhotcopy
 4 | BASEDIR=/www/backup
 5 | TMPDIR=/www/tmp/backup
 6 | KEEPDAYS=7
 7 | BASES=`mysql -Be 'show databases' | egrep -v '^(Database|test|information_schema)$'`
 8 | #BASES="mysql"
 9 | DATE=`date +%Y%m%d`
10 | OWNER='mysql:mysql'
11 | REPLTABLE=mysql.log_pos
12 | ON_SLAVE=YES
13 | 
14 | find ${BASEDIR} -type f -name '*.gz' -mtime +${KEEPDAYS} | xargs rm
15 | 
16 | rm -rf ${TMPDIR}
17 | mkdir -p -m 700 ${TMPDIR}
18 | 
19 | if [ -z ${REPLTABLE} ]; then
20 | 	${MYSQLHOTCOPY} -q --addtodest --noindices ${BASES} ${TMPDIR}
21 | else 
22 | 	if [ ${ON_SLAVE} = "YES" ]; then
23 | 		${MYSQLHOTCOPY} -q --addtodest --noindices \
24 | 			--on_slave --record_log_pos=${REPLTABLE} ${BASES} ${TMPDIR}
25 | 	else
26 |                 ${MYSQLHOTCOPY} -q --addtodest --noindices \
27 |                         --record_log_pos=${REPLTABLE} ${BASES} ${TMPDIR}
28 | 	fi
29 | fi
30 | 
31 | cd ${TMPDIR}
32 | chown -R ${OWNER} .
33 | 
34 | for base in ${BASES}; do
35 |   if [ ! -d ${BASEDIR}/${base} ]; then
36 |     mkdir -p -m 750 ${BASEDIR}/${base}
37 |   fi
38 | 
39 |   if [ -d ${TMPDIR}/${base} ]; then
40 |     nice -n 20 tar -czf ${BASEDIR}/${base}/${base}.${DATE}.tar.gz ./${base}
41 |     rm -rf ${TMPDIR}/${base}
42 |   fi
43 | done
44 | 
45 | rm -rf ${TMPDIR}
46 | 
47 | #               CREATE TABLE log_pos (
48 | #                 host            varchar(60) NOT null,
49 | #                 time_stamp      timestamp(14) NOT NULL,
50 | #                 log_file        varchar(32) default NULL,
51 | #                 log_pos         int(11)     default NULL,
52 | #                 master_host     varchar(60) NULL,
53 | #                 master_log_file varchar(32) NULL,
54 | #                 master_log_pos  int NULL,
55 | #
56 | #                 PRIMARY KEY  (host)
57 | #               );
58 | 


--------------------------------------------------------------------------------
/mysql_pgsql_backup/mysqlhotcopy:
--------------------------------------------------------------------------------
   1 | #!/usr/bin/perl -w
   2 | 
   3 | use strict;
   4 | use Getopt::Long;
   5 | use Data::Dumper;
   6 | use File::Basename;
   7 | use File::Path;
   8 | use DBI;
   9 | use Sys::Hostname;
  10 | use File::Copy;
  11 | use File::Temp qw(tempfile);
  12 | 
  13 | =head1 NAME
  14 | 
  15 | mysqlhotcopy - fast on-line hot-backup utility for local MySQL databases and tables
  16 | 
  17 | =head1 SYNOPSIS
  18 | 
  19 |   mysqlhotcopy db_name
  20 | 
  21 |   mysqlhotcopy --suffix=_copy db_name_1 ... db_name_n
  22 | 
  23 |   mysqlhotcopy db_name_1 ... db_name_n /path/to/new_directory
  24 | 
  25 |   mysqlhotcopy db_name./regex/
  26 | 
  27 |   mysqlhotcopy db_name./^\(foo\|bar\)/
  28 | 
  29 |   mysqlhotcopy db_name./~regex/
  30 | 
  31 |   mysqlhotcopy db_name_1./regex_1/ db_name_1./regex_2/ ... db_name_n./regex_n/ /path/to/new_directory
  32 | 
  33 |   mysqlhotcopy --method='scp -Bq -i /usr/home/foo/.ssh/identity' --user=root --password=secretpassword \
  34 |          db_1./^nice_table/ user@some.system.dom:~/path/to/new_directory
  35 | 
  36 | WARNING: THIS PROGRAM IS STILL IN BETA. Comments/patches welcome.
  37 | 
  38 | =cut
  39 | 
  40 | # Documentation continued at end of file
  41 | 
  42 | my $VERSION = "1.22";
  43 | 
  44 | my $opt_tmpdir = $ENV{TMPDIR} || "/tmp";
  45 | 
  46 | my $OPTIONS = <<"_OPTIONS";
  47 | 
  48 | $0 Ver $VERSION
  49 | 
  50 | Usage: $0 db_name[./table_regex/] [new_db_name | directory]
  51 | 
  52 |   -?, --help           display this helpscreen and exit
  53 |   -u, --user=#         user for database login if not current user
  54 |   -p, --password=#     password to use when connecting to server (if not set
  55 |                        in my.cnf, which is recommended)
  56 |   -h, --host=#         Hostname for local server when connecting over TCP/IP
  57 |   -P, --port=#         port to use when connecting to local server with TCP/IP
  58 |   -S, --socket=#       socket to use when connecting to local server
  59 | 
  60 |   --allowold           don\'t abort if target dir already exists (rename it _old)
  61 |   --addtodest          don\'t rename target dir if it exists, just add files to it
  62 |   --keepold            don\'t delete previous (now renamed) target when done
  63 |   --noindices          don\'t include full index files in copy
  64 |   --method=#           method for copy (only "cp" currently supported)
  65 | 
  66 |   -q, --quiet          be silent except for errors
  67 |   --debug              enable debug
  68 |   -n, --dryrun         report actions without doing them
  69 | 
  70 |   --regexp=#           copy all databases with names matching regexp
  71 |   --suffix=#           suffix for names of copied databases
  72 |   --checkpoint=#       insert checkpoint entry into specified db.table
  73 |   --flushlog           flush logs once all tables are locked 
  74 |   --resetmaster        reset the binlog once all tables are locked
  75 |   --resetslave         reset the master.info once all tables are locked
  76 |   --tmpdir=#	       temporary directory (instead of $opt_tmpdir)
  77 |   --record_log_pos=#   record slave and master status in specified db.table
  78 |   --on_slave           tells record_log_pos that this is a slave box
  79 |   --chroot=#           base directory of chroot jail in which mysqld operates
  80 | 
  81 |   Try \'perldoc $0\' for more complete documentation
  82 | _OPTIONS
  83 | 
  84 | sub usage {
  85 |     die @_, $OPTIONS;
  86 | }
  87 | 
  88 | # Do not initialize user or password options; that way, any user/password
  89 | # options specified in option files will be used.  If no values are specified
  90 | # all, the defaults will be used (login name, no password).
  91 | 
  92 | my %opt = (
  93 |     noindices	=> 0,
  94 |     allowold	=> 0,	# for safety
  95 |     keepold	=> 0,
  96 |     method	=> "cp",
  97 |     flushlog    => 0,
  98 | );
  99 | Getopt::Long::Configure(qw(no_ignore_case)); # disambuguate -p and -P
 100 | GetOptions( \%opt,
 101 |     "help",
 102 |     "host|h=s",
 103 |     "user|u=s",
 104 |     "password|p=s",
 105 |     "port|P=s",
 106 |     "socket|S=s",
 107 |     "allowold!",
 108 |     "keepold!",
 109 |     "addtodest!",
 110 |     "noindices!",
 111 |     "method=s",
 112 |     "debug",
 113 |     "quiet|q",
 114 |     "mv!",
 115 |     "regexp=s",
 116 |     "suffix=s",
 117 |     "checkpoint=s",
 118 |     "record_log_pos=s",
 119 |     "on_slave",
 120 |     "flushlog",
 121 |     "resetmaster",
 122 |     "resetslave",
 123 |     "tmpdir|t=s",
 124 |     "dryrun|n",
 125 |     "chroot=s",
 126 | ) or usage("Invalid option");
 127 | 
 128 | # @db_desc
 129 | # ==========
 130 | # a list of hash-refs containing:
 131 | #
 132 | #   'src'     - name of the db to copy
 133 | #   't_regex' - regex describing tables in src
 134 | #   'target'  - destination directory of the copy
 135 | #   'tables'  - array-ref to list of tables in the db
 136 | #   'files'   - array-ref to list of files to be copied
 137 | #               (RAID files look like 'nn/name.MYD')
 138 | #   'index'   - array-ref to list of indexes to be copied
 139 | #
 140 | 
 141 | my @db_desc = ();
 142 | my $tgt_name = undef;
 143 | 
 144 | usage("") if ($opt{help});
 145 | 
 146 | if ( $opt{regexp} || $opt{suffix} || @ARGV > 2 ) {
 147 |     $tgt_name   = pop @ARGV unless ( exists $opt{suffix} );
 148 |     @db_desc = map { s{^([^\.]+)\./(.+)/$}{$1}; { 'src' => $_, 't_regex' => ( $2 ? $2 : '.*' ) } } @ARGV;
 149 | }
 150 | else {
 151 |     usage("Database name to hotcopy not specified") unless ( @ARGV );
 152 | 
 153 |     $ARGV[0] =~ s{^([^\.]+)\./(.+)/$}{$1};
 154 |     @db_desc = ( { 'src' => $ARGV[0], 't_regex' => ( $2 ? $2 : '.*' ) } );
 155 | 
 156 |     if ( @ARGV == 2 ) {
 157 | 	$tgt_name   = $ARGV[1];
 158 |     }
 159 |     else {
 160 | 	$opt{suffix} = "_copy";
 161 |     }
 162 | }
 163 | 
 164 | my %mysqld_vars;
 165 | my $start_time = time;
 166 | $opt_tmpdir= $opt{tmpdir} if $opt{tmpdir};
 167 | $0 = $1 if $0 =~ m:/([^/]+)$:;
 168 | $opt{quiet} = 0 if $opt{debug};
 169 | $opt{allowold} = 1 if $opt{keepold};
 170 | 
 171 | # --- connect to the database ---
 172 | my $dsn;
 173 | $dsn  = ";host=" . (defined($opt{host}) ? $opt{host} : "localhost");
 174 | $dsn .= ";port=$opt{port}" if $opt{port};
 175 | $dsn .= ";mysql_socket=$opt{socket}" if $opt{socket};
 176 | 
 177 | # use mysql_read_default_group=mysqlhotcopy so that [client] and
 178 | # [mysqlhotcopy] groups will be read from standard options files.
 179 | 
 180 | my $dbh = DBI->connect("dbi:mysql:$dsn;mysql_read_default_group=mysqlhotcopy",
 181 |                         $opt{user}, $opt{password},
 182 | {
 183 |     RaiseError => 1,
 184 |     PrintError => 0,
 185 |     AutoCommit => 1,
 186 | });
 187 | 
 188 | # --- check that checkpoint table exists if specified ---
 189 | if ( $opt{checkpoint} ) {
 190 |     $opt{checkpoint} = quote_names( $opt{checkpoint} );
 191 |     eval { $dbh->do( qq{ select time_stamp, src, dest, msg 
 192 | 			 from $opt{checkpoint} where 1 != 1} );
 193 |        };
 194 | 
 195 |     die "Error accessing Checkpoint table ($opt{checkpoint}): $@"
 196 |       if ( $@ );
 197 | }
 198 | 
 199 | # --- check that log_pos table exists if specified ---
 200 | if ( $opt{record_log_pos} ) {
 201 |     $opt{record_log_pos} = quote_names( $opt{record_log_pos} );
 202 | 
 203 |     eval { $dbh->do( qq{ select host, time_stamp, log_file, log_pos, master_host, master_log_file, master_log_pos
 204 | 			 from $opt{record_log_pos} where 1 != 1} );
 205 |        };
 206 | 
 207 |     die "Error accessing log_pos table ($opt{record_log_pos}): $@"
 208 |       if ( $@ );
 209 | }
 210 | 
 211 | # --- get variables from database ---
 212 | my $sth_vars = $dbh->prepare("show variables like 'datadir'");
 213 | $sth_vars->execute;
 214 | while ( my ($var,$value) = $sth_vars->fetchrow_array ) {
 215 |     $mysqld_vars{ $var } = $value;
 216 | }
 217 | my $datadir = $mysqld_vars{'datadir'}
 218 |     || die "datadir not in mysqld variables";
 219 |     $datadir= $opt{chroot}.$datadir if ($opt{chroot});
 220 | $datadir =~ s:/$::;
 221 | 
 222 | 
 223 | # --- get target path ---
 224 | my ($tgt_dirname, $to_other_database);
 225 | $to_other_database=0;
 226 | if (defined($tgt_name) && $tgt_name =~ m:^\w+$: && @db_desc <= 1)
 227 | {
 228 |     $tgt_dirname = "$datadir/$tgt_name";
 229 |     $to_other_database=1;
 230 | }
 231 | elsif (defined($tgt_name) && ($tgt_name =~ m:/: || $tgt_name eq '.')) {
 232 |     $tgt_dirname = $tgt_name;
 233 | }
 234 | elsif ( $opt{suffix} ) {
 235 |     print "Using copy suffix '$opt{suffix}'\n" unless $opt{quiet};
 236 | }
 237 | elsif ( ($^O =~ m/^(NetWare)$/) && defined($tgt_name) && ($tgt_name =~ m:\\: || $tgt_name eq '.'))  
 238 | {
 239 | 	$tgt_dirname = $tgt_name;
 240 | }
 241 | else
 242 | {
 243 |   $tgt_name="" if (!defined($tgt_name));
 244 |   die "Target '$tgt_name' doesn't look like a database name or directory path.\n";
 245 | }
 246 | 
 247 | # --- resolve database names from regexp ---
 248 | if ( defined $opt{regexp} ) {
 249 |     my $t_regex = '.*';
 250 |     if ( $opt{regexp} =~ s{^/(.+)/\./(.+)/$}{$1} ) {
 251 |         $t_regex = $2;
 252 |     }
 253 | 
 254 |     my $sth_dbs = $dbh->prepare("show databases");
 255 |     $sth_dbs->execute;
 256 |     while ( my ($db_name) = $sth_dbs->fetchrow_array ) {
 257 | 	push @db_desc, { 'src' => $db_name, 't_regex' => $t_regex } if ( $db_name =~ m/$opt{regexp}/o );
 258 |     }
 259 | }
 260 | 
 261 | # --- get list of tables to hotcopy ---
 262 | 
 263 | my $hc_locks = "";
 264 | my $hc_tables = "";
 265 | my $num_tables = 0;
 266 | my $num_files = 0;
 267 | 
 268 | foreach my $rdb ( @db_desc ) {
 269 |     my $db = $rdb->{src};
 270 |     my @dbh_tables = get_list_of_tables( $db );
 271 | 
 272 |     ## generate regex for tables/files
 273 |     my $t_regex;
 274 |     my $negated;
 275 |     if ($rdb->{t_regex}) {
 276 |         $t_regex = $rdb->{t_regex};        ## assign temporary regex
 277 |         $negated = $t_regex =~ s/^~//;     ## note and remove negation operator
 278 | 
 279 |         $t_regex = qr/$t_regex/;           ## make regex string from
 280 |                                            ## user regex
 281 | 
 282 |         ## filter (out) tables specified in t_regex
 283 |         print "Filtering tables with '$t_regex'\n" if $opt{debug};
 284 |         @dbh_tables = ( $negated 
 285 |                         ? grep { $_ !~ $t_regex } @dbh_tables
 286 |                         : grep { $_ =~ $t_regex } @dbh_tables );
 287 |     }
 288 | 
 289 |     ## get list of files to copy
 290 |     my $db_dir = "$datadir/$db";
 291 |     opendir(DBDIR, $db_dir ) 
 292 |       or die "Cannot open dir '$db_dir': $!";
 293 | 
 294 |     my %db_files;
 295 |     my @raid_dir = ();
 296 | 
 297 |     while ( defined( my $name = readdir DBDIR ) ) {
 298 | 	if ( $name =~ /^\d\d$/ && -d "$db_dir/$name" ) {
 299 | 	    push @raid_dir, $name;
 300 | 	}
 301 | 	else {
 302 | 	    $db_files{$name} = $1 if ( $name =~ /(.+)\.\w+$/ );
 303 |         }
 304 |     }
 305 |     closedir( DBDIR );
 306 | 
 307 |     scan_raid_dir( \%db_files, $db_dir, @raid_dir );
 308 | 
 309 |     unless( keys %db_files ) {
 310 | 	warn "'$db' is an empty database\n";
 311 |     }
 312 | 
 313 |     ## filter (out) files specified in t_regex
 314 |     my @db_files;
 315 |     if ($rdb->{t_regex}) {
 316 |         @db_files = ($negated
 317 |                      ? grep { $db_files{$_} !~ $t_regex } keys %db_files
 318 |                      : grep { $db_files{$_} =~ $t_regex } keys %db_files );
 319 |     }
 320 |     else {
 321 |         @db_files = keys %db_files;
 322 |     }
 323 | 
 324 |     @db_files = sort @db_files;
 325 | 
 326 |     my @index_files=();
 327 | 
 328 |     ## remove indices unless we're told to keep them
 329 |     if ($opt{noindices}) {
 330 |         @index_files= grep { /\.(ISM|MYI)$/ } @db_files;
 331 | 	@db_files = grep { not /\.(ISM|MYI)$/ } @db_files;
 332 |     }
 333 | 
 334 |     $rdb->{files}  = [ @db_files ];
 335 |     $rdb->{index}  = [ @index_files ];
 336 |     my @hc_tables = map { quote_names("$db.$_") } @dbh_tables;
 337 |     $rdb->{tables} = [ @hc_tables ];
 338 | 
 339 |     $rdb->{raid_dirs} = [ get_raid_dirs( $rdb->{files} ) ];
 340 | 
 341 |     $hc_locks .= ", "  if ( length $hc_locks && @hc_tables );
 342 |     $hc_locks .= join ", ", map { "$_ READ" } @hc_tables;
 343 |     $hc_tables .= ", "  if ( length $hc_tables && @hc_tables );
 344 |     $hc_tables .= join ", ", @hc_tables;
 345 | 
 346 |     $num_tables += scalar @hc_tables;
 347 |     $num_files  += scalar @{$rdb->{files}};
 348 | }
 349 | 
 350 | # --- resolve targets for copies ---
 351 | 
 352 | if (defined($tgt_name) && length $tgt_name ) {
 353 |     # explicit destination directory specified
 354 | 
 355 |     # GNU `cp -r` error message
 356 |     die "copying multiple databases, but last argument ($tgt_dirname) is not a directory\n"
 357 |       if ( @db_desc > 1 && !(-e $tgt_dirname && -d $tgt_dirname ) );
 358 | 
 359 |     if ($to_other_database)
 360 |     {
 361 |       foreach my $rdb ( @db_desc ) {
 362 | 	$rdb->{target} = "$tgt_dirname";
 363 |       }
 364 |     }
 365 |     elsif ($opt{method} =~ /^scp\b/) 
 366 |     {   # we have to trust scp to hit the target
 367 | 	foreach my $rdb ( @db_desc ) {
 368 | 	    $rdb->{target} = "$tgt_dirname/$rdb->{src}";
 369 | 	}
 370 |     }
 371 |     else
 372 |     {
 373 |       die "Last argument ($tgt_dirname) is not a directory\n"
 374 | 	if (!(-e $tgt_dirname && -d $tgt_dirname ) );
 375 |       foreach my $rdb ( @db_desc ) {
 376 | 	$rdb->{target} = "$tgt_dirname/$rdb->{src}";
 377 |       }
 378 |     }
 379 |   }
 380 | else {
 381 |   die "Error: expected \$opt{suffix} to exist" unless ( exists $opt{suffix} );
 382 | 
 383 |   foreach my $rdb ( @db_desc ) {
 384 |     $rdb->{target} = "$datadir/$rdb->{src}$opt{suffix}";
 385 |   }
 386 | }
 387 | 
 388 | print Dumper( \@db_desc ) if ( $opt{debug} );
 389 | 
 390 | # --- bail out if all specified databases are empty ---
 391 | 
 392 | die "No tables to hot-copy" unless ( length $hc_locks );
 393 | 
 394 | # --- create target directories if we are using 'cp' ---
 395 | 
 396 | my @existing = ();
 397 | 
 398 | if ($opt{method} =~ /^cp\b/)
 399 | {
 400 |   foreach my $rdb ( @db_desc ) {
 401 |     push @existing, $rdb->{target} if ( -d  $rdb->{target} );
 402 |   }
 403 | 
 404 |   if ( @existing && !($opt{allowold} || $opt{addtodest}) )
 405 |   {
 406 |     $dbh->disconnect();
 407 |     die "Can't hotcopy to '", join( "','", @existing ), "' because directory\nalready exist and the --allowold or --addtodest options were not given.\n"
 408 |   }
 409 | }
 410 | 
 411 | retire_directory( @existing ) if @existing && !$opt{addtodest};
 412 | 
 413 | foreach my $rdb ( @db_desc ) {
 414 |     foreach my $td ( '', @{$rdb->{raid_dirs}} ) {
 415 | 
 416 | 	my $tgt_dirpath = "$rdb->{target}/$td";
 417 | 	# Remove trailing slashes (needed for Mac OS X)
 418 |     	substr($tgt_dirpath, 1) =~ s|/+$||;
 419 | 	if ( $opt{dryrun} ) {
 420 | 	    print "mkdir $tgt_dirpath, 0750\n";
 421 | 	}
 422 | 	elsif ($opt{method} =~ /^scp\b/) {
 423 | 	    ## assume it's there?
 424 | 	    ## ...
 425 | 	}
 426 | 	else {
 427 | 	    mkdir($tgt_dirpath, 0750) or die "Can't create '$tgt_dirpath': $!\n"
 428 | 		unless -d $tgt_dirpath;
 429 | 	     if ($^O !~ m/^(NetWare)$/)  
 430 |     	    {
 431 | 	    my @f_info= stat "$datadir/$rdb->{src}";
 432 | 	    chown $f_info[4], $f_info[5], $tgt_dirpath;
 433 |     	    }
 434 | 	}
 435 |     }
 436 | }
 437 | 
 438 | ##############################
 439 | # --- PERFORM THE HOT-COPY ---
 440 | #
 441 | # Note that we try to keep the time between the LOCK and the UNLOCK
 442 | # as short as possible, and only start when we know that we should
 443 | # be able to complete without error.
 444 | 
 445 | # read lock all the tables we'll be copying
 446 | # in order to get a consistent snapshot of the database
 447 | 
 448 | if ( $opt{checkpoint} || $opt{record_log_pos} ) {
 449 |   # convert existing READ lock on checkpoint and/or log_pos table into WRITE lock
 450 |   foreach my $table ( grep { defined } ( $opt{checkpoint}, $opt{record_log_pos} ) ) {
 451 |     $hc_locks .= ", $table WRITE" 
 452 | 	unless ( $hc_locks =~ s/$table\s+READ/$table WRITE/ );
 453 |   }
 454 | }
 455 | 
 456 | my $hc_started = time;	# count from time lock is granted
 457 | 
 458 | if ( $opt{dryrun} ) {
 459 |     print "LOCK TABLES $hc_locks\n";
 460 |     print "FLUSH TABLES /*!32323 $hc_tables */\n";
 461 |     print "FLUSH LOGS\n" if ( $opt{flushlog} );
 462 |     print "RESET MASTER\n" if ( $opt{resetmaster} );
 463 |     print "RESET SLAVE\n" if ( $opt{resetslave} );
 464 | }
 465 | else {
 466 |     my $start = time;
 467 |     $dbh->do("LOCK TABLES $hc_locks");
 468 |     printf "Locked $num_tables tables in %d seconds.\n", time-$start unless $opt{quiet};
 469 |     $hc_started = time;	# count from time lock is granted
 470 | 
 471 |     # flush tables to make on-disk copy uptodate
 472 |     $start = time;
 473 |     $dbh->do("FLUSH TABLES /*!32323 $hc_tables */");
 474 |     printf "Flushed tables ($hc_tables) in %d seconds.\n", time-$start unless $opt{quiet};
 475 |     $dbh->do( "FLUSH LOGS" ) if ( $opt{flushlog} );
 476 |     $dbh->do( "RESET MASTER" ) if ( $opt{resetmaster} );
 477 |     $dbh->do( "RESET SLAVE" ) if ( $opt{resetslave} );
 478 | 
 479 |     if ( $opt{record_log_pos} ) {
 480 | 		record_log_pos( $dbh, $opt{record_log_pos}, $opt{on_slave} );
 481 | 		$dbh->do("FLUSH TABLES /*!32323 $hc_tables */");
 482 |     }
 483 | }
 484 | 
 485 | my @failed = ();
 486 | 
 487 | foreach my $rdb ( @db_desc )
 488 | {
 489 |   my @files = map { "$datadir/$rdb->{src}/$_" } @{$rdb->{files}};
 490 |   next unless @files;
 491 |   
 492 |   eval { copy_files($opt{method}, \@files, $rdb->{target}, $rdb->{raid_dirs} ); };
 493 |   push @failed, "$rdb->{src} -> $rdb->{target} failed: $@"
 494 |     if ( $@ );
 495 |   
 496 |   @files = @{$rdb->{index}};
 497 |   if ($rdb->{index})
 498 |   {
 499 |     copy_index($opt{method}, \@files,
 500 | 	       "$datadir/$rdb->{src}", $rdb->{target} );
 501 |   }
 502 |   
 503 |   if ( $opt{checkpoint} ) {
 504 |     my $msg = ( $@ ) ? "Failed: $@" : "Succeeded";
 505 |     
 506 |     eval {
 507 |       $dbh->do( qq{ insert into $opt{checkpoint} (src, dest, msg) 
 508 | 		      VALUES ( '$rdb->{src}', '$rdb->{target}', '$msg' )
 509 | 		    } ); 
 510 |     };
 511 |     
 512 |     if ( $@ ) {
 513 |       warn "Failed to update checkpoint table: $@\n";
 514 |     }
 515 |   }
 516 | }
 517 | 
 518 | if ( $opt{dryrun} ) {
 519 |     print "UNLOCK TABLES\n";
 520 |     if ( @existing && !$opt{keepold} ) {
 521 | 	my @oldies = map { $_ . '_old' } @existing;
 522 | 	print "rm -rf @oldies\n" 
 523 |     }
 524 |     $dbh->disconnect();
 525 |     exit(0);
 526 | }
 527 | else {
 528 |     $dbh->do("UNLOCK TABLES");
 529 | }
 530 | 
 531 | my $hc_dur = time - $hc_started;
 532 | printf "Unlocked tables.\n" unless $opt{quiet};
 533 | 
 534 | #
 535 | # --- HOT-COPY COMPLETE ---
 536 | ###########################
 537 | 
 538 | $dbh->disconnect;
 539 | 
 540 | if ( @failed ) {
 541 |     # hotcopy failed - cleanup
 542 |     # delete any @targets 
 543 |     # rename _old copy back to original
 544 | 
 545 |     my @targets = ();
 546 |     foreach my $rdb ( @db_desc ) {
 547 |         push @targets, $rdb->{target} if ( -d  $rdb->{target} );
 548 |     }
 549 |     print "Deleting @targets \n" if $opt{debug};
 550 | 
 551 |     print "Deleting @targets \n" if $opt{debug};
 552 |     rmtree([@targets]);
 553 |     if (@existing) {
 554 | 	print "Restoring @existing from back-up\n" if $opt{debug};
 555 |         foreach my $dir ( @existing ) {
 556 | 	    rename("${dir}_old", $dir )
 557 | 	      or warn "Can't rename ${dir}_old to $dir: $!\n";
 558 | 	}
 559 |     }
 560 | 
 561 |     die join( "\n", @failed );
 562 | }
 563 | else {
 564 |     # hotcopy worked
 565 |     # delete _old unless $opt{keepold}
 566 | 
 567 |     if ( @existing && !$opt{keepold} ) {
 568 | 	my @oldies = map { $_ . '_old' } @existing;
 569 | 	print "Deleting previous copy in @oldies\n" if $opt{debug};
 570 | 	rmtree([@oldies]);
 571 |     }
 572 | 
 573 |     printf "$0 copied %d tables (%d files) in %d second%s (%d seconds overall).\n",
 574 | 	    $num_tables, $num_files,
 575 | 	    $hc_dur, ($hc_dur==1)?"":"s", time - $start_time
 576 | 	unless $opt{quiet};
 577 | }
 578 | 
 579 | exit 0;
 580 | 
 581 | 
 582 | # ---
 583 | 
 584 | sub copy_files {
 585 |     my ($method, $files, $target, $raid_dirs) = @_;
 586 |     my @cmd;
 587 |     print "Copying ".@$files." files...\n" unless $opt{quiet};
 588 | 
 589 |     if ($^O =~ m/^(NetWare)$/)  # on NetWare call PERL copy (slower)
 590 |     {
 591 |       foreach my $file ( @$files )
 592 |       {
 593 |         copy($file, $target."/".basename($file));
 594 |       }
 595 |     }
 596 |     elsif ($method =~ /^s?cp\b/)  # cp or scp with optional flags
 597 |     {
 598 | 	my $cp = $method;
 599 | 	# add option to preserve mod time etc of copied files
 600 | 	# not critical, but nice to have
 601 | 	$cp.= " -p" if $^O =~ m/^(solaris|linux|freebsd|darwin)$/;
 602 | 
 603 | 	# add recursive option for scp
 604 | 	$cp.= " -r" if $^O =~ /m^(solaris|linux|freebsd|darwin)$/ && $method =~ /^scp\b/;
 605 | 
 606 | 	my @non_raid = map { "'$_'" } grep { ! m:/\d{2}/[^/]+$: } @$files;
 607 | 
 608 | 	# add files to copy and the destination directory
 609 | 	safe_system( $cp, @non_raid, "'$target'" ) if (@non_raid);
 610 | 	
 611 | 	foreach my $rd ( @$raid_dirs ) {
 612 | 	    my @raid = map { "'$_'" } grep { m:$rd/: } @$files;
 613 | 	    safe_system( $cp, @raid, "'$target'/$rd" ) if ( @raid );
 614 | 	}
 615 |     }
 616 |     else
 617 |     {
 618 | 	die "Can't use unsupported method '$method'\n";
 619 |     }
 620 | }
 621 | 
 622 | #
 623 | # Copy only the header of the index file
 624 | #
 625 | 
 626 | sub copy_index
 627 | {
 628 |   my ($method, $files, $source, $target) = @_;
 629 |   
 630 |   print "Copying indices for ".@$files." files...\n" unless $opt{quiet};  
 631 |   foreach my $file (@$files)
 632 |   {
 633 |     my $from="$source/$file";
 634 |     my $to="$target/$file";
 635 |     my $buff;
 636 |     open(INPUT, "<$from") || die "Can't open file $from: $!\n";
 637 |     binmode(INPUT, ":raw");
 638 |     my $length=read INPUT, $buff, 2048;
 639 |     die "Can't read index header from $from\n" if ($length < 1024);
 640 |     close INPUT;
 641 |     
 642 |     if ( $opt{dryrun} )
 643 |     {
 644 |       print "$opt{method}-header $from $to\n";
 645 |     }
 646 |     elsif ($opt{method} eq 'cp')
 647 |     {
 648 |       open(OUTPUT,">$to")   || die "Can\'t create file $to: $!\n";
 649 |       if (syswrite(OUTPUT,$buff) != length($buff))
 650 |       {
 651 | 	die "Error when writing data to $to: $!\n";
 652 |       }
 653 |       close OUTPUT	   || die "Error on close of $to: $!\n";
 654 |     }
 655 |     elsif ($opt{method} =~ /^scp\b/)
 656 |     {
 657 |       my ($fh, $tmp)= tempfile('mysqlhotcopy-XXXXXX', DIR => $opt_tmpdir) or
 658 | 	die "Can\'t create/open file in $opt_tmpdir\n";
 659 |       if (syswrite($fh,$buff) != length($buff))
 660 |       {
 661 | 	die "Error when writing data to $tmp: $!\n";
 662 |       }
 663 |       close $fh || die "Error on close of $tmp: $!\n";
 664 |       safe_system("$opt{method} $tmp $to");
 665 |       unlink $tmp;
 666 |     }
 667 |     else
 668 |     {
 669 |       die "Can't use unsupported method '$opt{method}'\n";
 670 |     }
 671 |   }
 672 | }
 673 | 
 674 | 
 675 | sub safe_system {
 676 |   my @sources= @_;
 677 |   my $method= shift @sources;
 678 |   my $target= pop @sources;
 679 |   ## @sources = list of source file names
 680 | 
 681 |   ## We have to deal with very long command lines, otherwise they may generate 
 682 |   ## "Argument list too long".
 683 |   ## With 10000 tables the command line can be around 1MB, much more than 128kB
 684 |   ## which is the common limit on Linux (can be read from
 685 |   ## /usr/src/linux/include/linux/binfmts.h
 686 |   ## see http://www.linuxjournal.com/article.php?sid=6060).
 687 |  
 688 |   my $chunk_limit= 100 * 1024; # 100 kB
 689 |   my @chunk= (); 
 690 |   my $chunk_length= 0;
 691 |   foreach (@sources) {
 692 |       push @chunk, $_;
 693 |       $chunk_length+= length($_);
 694 |       if ($chunk_length > $chunk_limit) {
 695 |           safe_simple_system($method, @chunk, $target);
 696 |           @chunk=();
 697 |           $chunk_length= 0;
 698 |       }
 699 |   }
 700 |   if ($chunk_length > 0) { # do not forget last small chunk
 701 |       safe_simple_system($method, @chunk, $target); 
 702 |   }
 703 | }
 704 | 
 705 | sub safe_simple_system {
 706 |     my @cmd= @_;
 707 | 
 708 |     if ( $opt{dryrun} ) {
 709 |         print "@cmd\n";
 710 |     }
 711 |     else {
 712 |         ## for some reason system fails but backticks works ok for scp...
 713 |         print "Executing '@cmd'\n" if $opt{debug};
 714 |         my $cp_status = system "@cmd > /dev/null";
 715 |         if ($cp_status != 0) {
 716 |             warn "Executing command failed ($cp_status). Trying backtick execution...\n";
 717 |             ## try something else
 718 |             `@cmd` || die "Error: @cmd failed ($?) while copying files.\n";
 719 |         }
 720 |     }
 721 | }
 722 | 
 723 | sub retire_directory {
 724 |     my ( @dir ) = @_;
 725 | 
 726 |     foreach my $dir ( @dir ) {
 727 | 	my $tgt_oldpath = $dir . '_old';
 728 | 	if ( $opt{dryrun} ) {
 729 | 	    print "rmtree $tgt_oldpath\n" if ( -d $tgt_oldpath );
 730 | 	    print "rename $dir, $tgt_oldpath\n";
 731 | 	    next;
 732 | 	}
 733 | 
 734 | 	if ( -d $tgt_oldpath ) {
 735 | 	    print "Deleting previous 'old' hotcopy directory ('$tgt_oldpath')\n" unless $opt{quiet};
 736 | 	    rmtree([$tgt_oldpath],0,1);
 737 | 	}
 738 | 	rename($dir, $tgt_oldpath)
 739 | 	  or die "Can't rename $dir=>$tgt_oldpath: $!\n";
 740 | 	print "Existing hotcopy directory renamed to '$tgt_oldpath'\n" unless $opt{quiet};
 741 |     }
 742 | }
 743 | 
 744 | sub record_log_pos {
 745 |     my ( $dbh, $table_name, $on_slave ) = @_;
 746 | 
 747 |     eval {
 748 | 	my ($file, $position, $master_host, $log_file, $log_pos);
 749 | 	if (defined $on_slave) {
 750 | 		## try to get from slave status
 751 | 		my $io_running;
 752 | 
 753 | 		my $row_hash = get_row_hash( $dbh, "show slave status" );
 754 | 		($file, $position, $master_host, $log_file, $log_pos, $io_running)
 755 | 			= @{$row_hash}{ qw / Master_Log_File Exec_Master_Log_Pos Master_Host Master_Log_File Exec_Master_Log_Pos Slave_IO_Running / };
 756 | 
 757 | #		($master_host, undef, undef, undef, $file, $position, undef, undef, $log_file, $io_running, undef, undef, undef, undef, undef, undef, $log_pos, undef) = get_row( $dbh, "show slave status" );
 758 | 
 759 | 		if ($io_running ne 'Yes') {
 760 | 			die "IO thread is not running, so can't get reliable master info";
 761 | 		}
 762 | 	} else {
 763 | 	        ($file,$position) = get_row( $dbh, "show master status" );
 764 | 	        die "master status is undefined" if !defined $file || !defined $position;
 765 | 	
 766 | 	        my $row_hash = get_row_hash( $dbh, "show slave status" );
 767 | 	        if ( $dbh->{mysql_serverinfo} =~ /^3\.23/ ) {
 768 | 	            ($master_host, $log_file, $log_pos )
 769 | 	              = @{$row_hash}{ qw / Master_Host Log_File Pos / };
 770 | 	        } else {
 771 | 	            ($master_host, $log_file, $log_pos )
 772 | 	              = @{$row_hash}{ qw / Master_Host Master_Log_File Read_Master_Log_Pos / };
 773 |         	}
 774 | 	}
 775 | 
 776 | 	my $hostname = hostname();
 777 | 	
 778 | 	$dbh->do( qq{ replace into $table_name 
 779 | 			  set host=?, log_file=?, log_pos=?, 
 780 |                           master_host=?, master_log_file=?, master_log_pos=? }, 
 781 | 		  undef, 
 782 | 		  $hostname, $file, $position, 
 783 | 		  $master_host, $log_file, $log_pos  );
 784 | 	
 785 |     };
 786 |     
 787 |     if ( $@ ) {
 788 | 	warn "Failed to store master position: $@\n";
 789 |     }
 790 | }
 791 | 
 792 | sub get_row {
 793 |   my ( $dbh, $sql ) = @_;
 794 | 
 795 |   my $sth = $dbh->prepare($sql);
 796 |   $sth->execute;
 797 |   return $sth->fetchrow_array();
 798 | }
 799 | 
 800 | sub get_row_hash {
 801 |   my ( $dbh, $sql ) = @_;
 802 | 
 803 |   my $sth = $dbh->prepare($sql);
 804 |   $sth->execute;
 805 |   return $sth->fetchrow_hashref();
 806 | }
 807 | 
 808 | sub scan_raid_dir {
 809 |     my ( $r_db_files, $data_dir, @raid_dir ) = @_;
 810 | 
 811 |     local(*RAID_DIR);
 812 |     
 813 |     foreach my $rd ( @raid_dir ) {
 814 | 
 815 | 	opendir(RAID_DIR, "$data_dir/$rd" ) 
 816 | 	    or die "Cannot open dir '$data_dir/$rd': $!";
 817 | 
 818 | 	while ( defined( my $name = readdir RAID_DIR ) ) {
 819 | 	    $r_db_files->{"$rd/$name"} = $1 if ( $name =~ /(.+)\.\w+$/ );
 820 | 	}
 821 | 	closedir( RAID_DIR );
 822 |     }
 823 | }
 824 | 
 825 | sub get_raid_dirs {
 826 |     my ( $r_files ) = @_;
 827 | 
 828 |     my %dirs = ();
 829 |     foreach my $f ( @$r_files ) {
 830 | 	if ( $f =~ m:^(\d\d)/: ) {
 831 | 	    $dirs{$1} = 1;
 832 | 	}
 833 |     }
 834 |     return sort keys %dirs;
 835 | }
 836 | 
 837 | sub get_list_of_tables {
 838 |     my ( $db ) = @_;
 839 | 
 840 |     # "use database" cannot cope with database names containing spaces
 841 |     # so create a new connection 
 842 | 
 843 |     my $dbh = DBI->connect("dbi:mysql:${db}${dsn};mysql_read_default_group=mysqlhotcopy",
 844 | 			    $opt{user}, $opt{password},
 845 |     {
 846 | 	RaiseError => 1,
 847 | 	PrintError => 0,
 848 | 	AutoCommit => 1,
 849 |     });
 850 | 
 851 |     my @dbh_tables = eval { $dbh->tables() };
 852 | 
 853 |     ## Remove quotes around table names
 854 |     my $quote = $dbh->get_info(29); # SQL_IDENTIFIER_QUOTE_CHAR
 855 |     if ($quote) {
 856 |       foreach (@dbh_tables) {
 857 | #        s/^$quote(.*)$quote$/$1/;
 858 |         s/^$quote($db$quote\.$quote)?(.*)$quote$/$2/;
 859 |         s/$quote$quote/$quote/g;
 860 |       }
 861 |     }
 862 | 
 863 |     $dbh->disconnect();
 864 |     return @dbh_tables;
 865 | }
 866 | 
 867 | sub quote_names {
 868 |   my ( $name ) = @_;
 869 |   # given a db.table name, add quotes
 870 | 
 871 |   my ($db, $table, @cruft) = split( /\./, $name );
 872 |   die "Invalid db.table name '$name'" if (@cruft || !defined $db || !defined $table );
 873 | 
 874 |   # Earlier versions of DBD return table name non-quoted,
 875 |   # such as DBD-2.1012 and the newer ones, such as DBD-2.9002
 876 |   # returns it quoted. Let's have a support for both.
 877 |   $table=~ s/\`//g;
 878 |   return "`$db`.`$table`";
 879 | }
 880 | 
 881 | __END__
 882 | 
 883 | =head1 DESCRIPTION
 884 | 
 885 | mysqlhotcopy is designed to make stable copies of live MySQL databases.
 886 | 
 887 | Here "live" means that the database server is running and the database
 888 | may be in active use. And "stable" means that the copy will not have
 889 | any corruptions that could occur if the table files were simply copied
 890 | without first being locked and flushed from within the server.
 891 | 
 892 | =head1 OPTIONS
 893 | 
 894 | =over 4
 895 | 
 896 | =item --checkpoint checkpoint-table
 897 | 
 898 | As each database is copied, an entry is written to the specified
 899 | checkpoint-table.  This has the happy side-effect of updating the
 900 | MySQL update-log (if it is switched on) giving a good indication of
 901 | where roll-forward should begin for backup+rollforward schemes.
 902 | 
 903 | The name of the checkpoint table should be supplied in database.table format.
 904 | The checkpoint-table must contain at least the following fields:
 905 | 
 906 | =over 4
 907 | 
 908 |   time_stamp timestamp not null
 909 |   src varchar(32)
 910 |   dest varchar(60)
 911 |   msg varchar(255)
 912 | 
 913 | =back
 914 | 
 915 | =item --record_log_pos log-pos-table
 916 | 
 917 | Just before the database files are copied, update the record in the
 918 | log-pos-table from the values returned from "show master status" and
 919 | "show slave status". The master status values are stored in the
 920 | log_file and log_pos columns, and establish the position in the binary
 921 | logs that any slaves of this host should adopt if initialised from
 922 | this dump.  The slave status values are stored in master_host,
 923 | master_log_file, and master_log_pos, and these are useful if the host
 924 | performing the dump is a slave and other sibling slaves are to be
 925 | initialised from this dump.
 926 | 
 927 | The name of the log-pos table should be supplied in database.table format.
 928 | A sample log-pos table definition:
 929 | 
 930 | =item --on_slave
 931 | 
 932 | This changes behavior of --record_log_pos to only check slave status.
 933 | This allows us to get an indication of the actual position in the master
 934 | log file we are at on this slave at the time of the hot copy so that you
 935 | can use this data to build another replicant from this running slave.
 936 | 
 937 | =over 4
 938 | 
 939 | CREATE TABLE log_pos (
 940 |   host            varchar(60) NOT null,
 941 |   time_stamp      timestamp(14) NOT NULL,
 942 |   log_file        varchar(32) default NULL,
 943 |   log_pos         int(11)     default NULL,
 944 |   master_host     varchar(60) NULL,
 945 |   master_log_file varchar(32) NULL,
 946 |   master_log_pos  int NULL,
 947 | 
 948 |   PRIMARY KEY  (host) 
 949 | );
 950 | 
 951 | =back
 952 | 
 953 | 
 954 | =item --suffix suffix
 955 | 
 956 | Each database is copied back into the originating datadir under
 957 | a new name. The new name is the original name with the suffix
 958 | appended. 
 959 | 
 960 | If only a single db_name is supplied and the --suffix flag is not
 961 | supplied, then "--suffix=_copy" is assumed.
 962 | 
 963 | =item --allowold
 964 | 
 965 | Move any existing version of the destination to a backup directory for
 966 | the duration of the copy. If the copy successfully completes, the backup 
 967 | directory is deleted - unless the --keepold flag is set.  If the copy fails,
 968 | the backup directory is restored.
 969 | 
 970 | The backup directory name is the original name with "_old" appended.
 971 | Any existing versions of the backup directory are deleted.
 972 | 
 973 | =item --keepold
 974 | 
 975 | Behaves as for the --allowold, with the additional feature 
 976 | of keeping the backup directory after the copy successfully completes.
 977 | 
 978 | =item --addtodest
 979 | 
 980 | Don't rename target directory if it already exists, just add the
 981 | copied files into it.
 982 | 
 983 | This is most useful when backing up a database with many large
 984 | tables and you don't want to have all the tables locked for the
 985 | whole duration.
 986 | 
 987 | In this situation, I<if> you are happy for groups of tables to be
 988 | backed up separately (and thus possibly not be logically consistant
 989 | with one another) then you can run mysqlhotcopy several times on
 990 | the same database each with different db_name./table_regex/.
 991 | All but the first should use the --addtodest option so the tables
 992 | all end up in the same directory.
 993 | 
 994 | =item --flushlog
 995 | 
 996 | Rotate the log files by executing "FLUSH LOGS" after all tables are
 997 | locked, and before they are copied.
 998 | 
 999 | =item --resetmaster
1000 | 
1001 | Reset the bin-log by executing "RESET MASTER" after all tables are
1002 | locked, and before they are copied. Useful if you are recovering a
1003 | slave in a replication setup.
1004 | 
1005 | =item --resetslave
1006 | 
1007 | Reset the master.info by executing "RESET SLAVE" after all tables are
1008 | locked, and before they are copied. Useful if you are recovering a
1009 | server in a mutual replication setup.
1010 | 
1011 | =item --regexp pattern
1012 | 
1013 | Copy all databases with names matching the pattern
1014 | 
1015 | =item --regexp /pattern1/./pattern2/
1016 | 
1017 | Copy all tables with names matching pattern2 from all databases with
1018 | names matching pattern1. For example, to select all tables which
1019 | names begin with 'bar' from all databases which names end with 'foo':
1020 | 
1021 |    mysqlhotcopy --indices --method=cp --regexp /foo$/./^bar/
1022 | 
1023 | =item db_name./pattern/
1024 | 
1025 | Copy only tables matching pattern. Shell metacharacters ( (, ), |, !,
1026 | etc.) have to be escaped (e.g. \). For example, to select all tables
1027 | in database db1 whose names begin with 'foo' or 'bar':
1028 | 
1029 |     mysqlhotcopy --indices --method=cp db1./^\(foo\|bar\)/
1030 | 
1031 | =item db_name./~pattern/
1032 | 
1033 | Copy only tables not matching pattern. For example, to copy tables
1034 | that do not begin with foo nor bar:
1035 | 
1036 |     mysqlhotcopy --indices --method=cp db1./~^\(foo\|bar\)/
1037 | 
1038 | =item -?, --help
1039 | 
1040 | Display helpscreen and exit
1041 | 
1042 | =item -u, --user=#         
1043 | 
1044 | user for database login if not current user
1045 | 
1046 | =item -p, --password=#     
1047 | 
1048 | password to use when connecting to the server. Note that you are strongly
1049 | encouraged *not* to use this option as every user would be able to see the
1050 | password in the process list. Instead use the '[mysqlhotcopy]' section in
1051 | one of the config files, normally /etc/my.cnf or your personal ~/.my.cnf.
1052 | (See the chapter 'my.cnf Option Files' in the manual)
1053 | 
1054 | =item -h, -h, --host=#
1055 | 
1056 | Hostname for local server when connecting over TCP/IP.  By specifying this
1057 | different from 'localhost' will trigger mysqlhotcopy to use TCP/IP connection.
1058 | 
1059 | =item -P, --port=#         
1060 | 
1061 | port to use when connecting to MySQL server with TCP/IP.  This is only used
1062 | when using the --host option.
1063 | 
1064 | =item -S, --socket=#         
1065 | 
1066 | UNIX domain socket to use when connecting to local server
1067 | 
1068 | =item  --noindices          
1069 | 
1070 | Don\'t include index files in copy. Only up to the first 2048 bytes
1071 | are copied;  You can restore the indexes with isamchk -r or myisamchk -r
1072 | on the backup.
1073 | 
1074 | =item  --method=#           
1075 | 
1076 | method for copy (only "cp" currently supported). Alpha support for
1077 | "scp" was added in November 2000. Your experience with the scp method
1078 | will vary with your ability to understand how scp works. 'man scp'
1079 | and 'man ssh' are your friends.
1080 | 
1081 | The destination directory _must exist_ on the target machine using the
1082 | scp method. --keepold and --allowold are meaningless with scp.
1083 | Liberal use of the --debug option will help you figure out what\'s
1084 | really going on when you do an scp.
1085 | 
1086 | Note that using scp will lock your tables for a _long_ time unless
1087 | your network connection is _fast_. If this is unacceptable to you,
1088 | use the 'cp' method to copy the tables to some temporary area and then
1089 | scp or rsync the files at your leisure.
1090 | 
1091 | =item -q, --quiet              
1092 | 
1093 | be silent except for errors
1094 | 
1095 | =item  --debug
1096 | 
1097 | Debug messages are displayed 
1098 | 
1099 | =item -n, --dryrun
1100 | 
1101 | Display commands without actually doing them
1102 | 
1103 | =back
1104 | 
1105 | =head1 WARRANTY
1106 | 
1107 | This software is free and comes without warranty of any kind. You
1108 | should never trust backup software without studying the code yourself.
1109 | Study the code inside this script and only rely on it if I<you> believe
1110 | that it does the right thing for you.
1111 | 
1112 | Patches adding bug fixes, documentation and new features are welcome.
1113 | Please send these to internals@lists.mysql.com.
1114 | 
1115 | =head1 TO DO
1116 | 
1117 | Extend the individual table copy to allow multiple subsets of tables
1118 | to be specified on the command line:
1119 | 
1120 |   mysqlhotcopy db newdb  t1 t2 /^foo_/ : t3 /^bar_/ : +
1121 | 
1122 | where ":" delimits the subsets, the /^foo_/ indicates all tables
1123 | with names begining with "foo_" and the "+" indicates all tables
1124 | not copied by the previous subsets.
1125 | 
1126 | newdb is either another not existing database or a full path to a directory
1127 | where we can create a directory 'db'
1128 | 
1129 | Add option to lock each table in turn for people who don\'t need
1130 | cross-table integrity.
1131 | 
1132 | Add option to FLUSH STATUS just before UNLOCK TABLES.
1133 | 
1134 | Add support for other copy methods (eg tar to single file?).
1135 | 
1136 | Add support for forthcoming MySQL ``RAID'' table subdirectory layouts.
1137 | 
1138 | =head1 AUTHOR
1139 | 
1140 | Tim Bunce
1141 | 
1142 | Martin Waite - added checkpoint, flushlog, regexp and dryrun options
1143 |                Fixed cleanup of targets when hotcopy fails. 
1144 | 	       Added --record_log_pos.
1145 |                RAID tables are now copied (don't know if this works over scp).
1146 | 
1147 | Ralph Corderoy - added synonyms for commands
1148 | 
1149 | Scott Wiersdorf - added table regex and scp support
1150 | 
1151 | Monty - working --noindex (copy only first 2048 bytes of index file)
1152 |         Fixes for --method=scp
1153 | 
1154 | Ask Bjoern Hansen - Cleanup code to fix a few bugs and enable -w again.
1155 | 
1156 | Emil S. Hansen - Added resetslave and resetmaster.
1157 | 
1158 | Jeremy D. Zawodny - Removed depricated DBI calls.  Fixed bug which
1159 | resulted in nothing being copied when a regexp was specified but no
1160 | database name(s).
1161 | 
1162 | Martin Waite - Fix to handle database name that contains space.
1163 | 
1164 | Paul DuBois - Remove end '/' from directory names
1165 | 


--------------------------------------------------------------------------------
/mysql_pgsql_backup/pgsqlbackup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | HOST=master.server
 3 | BASEDIR=/www/backup
 4 | BASES=`psql -U root -h ${HOST} -d postgres --tuples-only -c '\l' | awk -F\| '{ print $1 }' | grep -E -v '(template0|template1)'` 
 5 | 
 6 | for base in $BASES; do
 7 |         #make directory if not existant
 8 |         if [ ! -d $BASEDIR/$base ]; then
 9 |                 mkdir $BASEDIR/$base
10 |         fi
11 |         if ( nice -n 19 pg_dump -C -F c -h ${HOST} -U root $base \
12 |                 > $BASEDIR/$base/$base.`date +%w`.custom.sql ) 2>&1 | grep -E '^.+'; then
13 |                 printf "(relevant db: $base)\n\n"
14 |         fi
15 | #printf "${base}\n"
16 | done
17 | pg_dumpall  -U root -h ${HOST} -g |  gzip -9 -c > $BASEDIR/system.`date +%w`.gz
18 | 
19 | 


--------------------------------------------------------------------------------
/mysql_pgsql_backup/slowlogstats:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | if uname | grep -qi linux; then
 4 |     # Linux
 5 |     yesterday () {
 6 |         date -d "12 hours ago" +%Y%m%d
 7 |     }
 8 | elif uname | grep -qi freebsd; then
 9 |     # FreeBSD
10 |     if uname -r | grep -q ^4; then
11 |         # 4* FreeBSD
12 |         yesterday () {
13 |             date -j -v -12H +%Y%m%d
14 |         }
15 |     else
16 |         # other, use old 'date'
17 |         yesterday () {
18 |             sec=`date +%s`
19 |             date -r `expr $sec - 43200` +%Y%m%d
20 |         }
21 |     fi
22 | else
23 |     # Other
24 |     echo "Don't know this operating system: `uname`" 2>&1
25 |     exit 1
26 | fi
27 | 
28 | for slowlog in `ls /logs/mysql/mysql*slow.log`; do
29 | NumberMysql=`echo $slowlog | grep -o '[0-9]'`
30 | if [ -z $NumberMysql ]; then
31 |         PORT=3306
32 | else
33 |         PORT=`expr 3305 + $NumberMysql`
34 | fi
35 | 
36 | (
37 | echo '
38 | ===========================================
39 | === Slow queries sorted by average time ===
40 | ===========================================
41 | '
42 | /root/bin/mysqldumpslow -s at $slowlog 2>/dev/null
43 | echo '
44 | =========================================
45 | === Slow queries sorted by total time ===
46 | =========================================
47 | '
48 | /root/bin/mysqldumpslow -s t $slowlog 2>/dev/null
49 | ) | mail -s "slow log stats on host `hostname` port $PORT at `yesterday`" slowlog@example.ru
50 | done
51 | 


--------------------------------------------------------------------------------
/mysql_replica_watcher.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- coding: utf8 -*-
 3 | import os,sys,platform,subprocess,smtplib,MySQLdb
 4 | from socket import gethostname
 5 | 
 6 | system = platform.system()
 7 | email_subject = "Replication problem on slave %s"
 8 | email_to = "root@example.ru"
 9 | email_from = " "
10 |  
11 | def mysql_cmd(cmd):
12 |     cnx = MySQLdb.connect(user='root', host='localhost', connect_timeout=10)
13 |     cur = cnx.cursor()
14 |     cur.execute(cmd)
15 |     columns = tuple( [d[0].decode('utf8') for d in cur.description] )
16 |     row = cur.fetchone()
17 |     if row is None:
18 |         raise StandardError("MySQL Server not configured as Slave")
19 |     result = dict(zip(columns, row))
20 |     cur.close()
21 |     cnx.close()
22 |     return result
23 |  
24 | try:
25 |     slave_status = mysql_cmd("show slave status")
26 | except StandardError, msg:
27 |     print >> sys.stderr, "There was an error:", msg
28 |     sys.exit(1)
29 |      
30 | if (slave_status['Slave_IO_Running'] == 'Yes' and slave_status['Slave_SQL_Running'] == 'Yes' and slave_status['Seconds_Behind_Master'] == 0 and slave_status['Last_Errno'] == 0):
31 |     if system == "Linux":
32 |         p = subprocess.Popen(["/sbin/iptables -F"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
33 |     elif system == "FreeBSD":
34 |         p = subprocess.Popen(["ipfw delete 06666"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
35 |         p = subprocess.Popen(["ipfw delete 06667"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
36 |     sys.exit(0)
37 | else:
38 |     if system == "Linux":
39 |         p = subprocess.Popen(["/sbin/iptables -A INPUT -p tcp --dport 80 -j REJECT --reject-with tcp-reset"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
40 |         p = subprocess.Popen(["/sbin/iptables -A INPUT -p tcp --dport 8000 -j REJECT --reject-with tcp-reset"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
41 |     elif system == "FreeBSD":
42 |         p = subprocess.Popen(["/sbin/ipfw add 06666 reject tcp from any to me 80"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
43 |         p = subprocess.Popen(["/sbin/ipfw add 06667 reject tcp from any to me 8000"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
44 | 
45 |     email_body = [
46 |         "From: %s" % email_from,
47 |         "To: %s" % email_to,
48 |         "Subject: %s" % (email_subject %  gethostname()),
49 |         "",
50 |         '\n'.join([ k + ' : ' + str(v) for k,v in slave_status.iteritems()]),
51 |         "\r\n",
52 |         ]
53 | 
54 |     server = smtplib.SMTP('localhost')
55 |     server.sendmail(email_from, email_to, '\r\n'.join(email_body))
56 |     server.quit()
57 | 


--------------------------------------------------------------------------------
/mysqlbackup_snapshot.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | DBDIR="db"
 4 | SNAPFILE="/www/.snap/1"
 5 | MNTDIR="/mnt"
 6 | BACKUPDIR="/www/backup"
 7 | DATE=`date +%Y%m%d`
 8 | DEBUG="1"
 9 | KEEPDAYS=23
10 | 
11 | find -L $BACKUPDIR -type f -name 'db_*.tar.gz' -mtime +$KEEPDAYS | xargs rm -f
12 | 
13 | D() {
14 | 	[ $DEBUG -eq 1 ] && echo $1
15 | }
16 | [ -f $SNAPFILE ] && echo "Snapfile $SNAPFILE exists, exiting..." && exit 255
17 | [ -b /dev/md0 ] && echo "Memory device /dev/md0 exist, exiting..." && exit 255
18 | 
19 | D "Stopping MySQL:"
20 | #/usr/local/etc/rc.d/mysql-server stop > /dev/null 2>&1
21 | /usr/local/etc/rc.d/mysql-server stop > /dev/null 2>&1
22 | D "Creating snapshot:"
23 | mksnap_ffs $SNAPFILE
24 | D "Creating memory device /dev/md0 and mounting it into $MNTDIR:"
25 | mdconfig -a -t vnode -o readonly -f $SNAPFILE
26 | mount -o ro /dev/md0 /mnt/
27 | D "Starting MySQL:"
28 | /usr/local/etc/rc.d/mysql-server start > /dev/null 2>&1
29 | D "Creating tar.gz archive $BACKUPDIR/db_$DATE.tar.gz:"
30 | tar czf $BACKUPDIR/db_$DATE.tar.gz $MNTDIR/$DBDIR
31 | D "Unmoniting, removing device and snapshot:"
32 | 
33 | sync
34 | umount -f $MNTDIR
35 | sync
36 | mdconfig -d -u /dev/md0
37 | sync
38 | rm -f $SNAPFILE
39 | sync
40 | 
41 | D "OK"
42 | exit 0
43 | 


--------------------------------------------------------------------------------
/pgsqlbackup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | HOST=example.ru
 4 | BASEDIR=/www/backup
 5 | BASES=`psql -U root -h ${HOST} -d postgres --tuples-only -c '\l' | awk -F\| '{ print $1 }' | grep -E -v '(template0|template1)'` 
 6 | 
 7 | for base in $BASES; do
 8 |         #make directory if not existant
 9 |         if [ ! -d $BASEDIR/$base ]; then
10 |                 mkdir $BASEDIR/$base
11 |         fi
12 |         if ( nice -n 19 pg_dump -C -F c -h ${HOST} -U root $base \
13 |                 > $BASEDIR/$base/$base.`date +%w`.custom.sql ) 2>&1 | grep -E '^.+'; then
14 |                 printf "(relevant db: $base)\n\n"
15 |         fi
16 | #printf "${base}\n"
17 | done
18 | pg_dumpall  -U root -h ${HOST} -g |  gzip -9 -c > $BASEDIR/system.`date +%w`.gz
19 | 
20 | 


--------------------------------------------------------------------------------
/prich_nginxconf.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | BACKUP=`mktemp /tmp/nginx.conf.backup.XXXXXX`
 4 | [ -f /usr/local/nginx/conf/nginx.conf ] && CONFIG=/usr/local/nginx/conf/nginx.conf && NGINX=/usr/local/nginx/sbin/nginx
 5 | [ -f /usr/local/etc/nginx/nginx.conf ] && CONFIG=/usr/local/etc/nginx/nginx.conf && NGINX=/usr/local/sbin/nginx
 6 | 
 7 | TAB=0
 8 | cp $CONFIG $BACKUP && echo "Saved as $BACKUP"
 9 | cat $BACKUP | while read line; do
10 |         i=0
11 |         echo "$line" | egrep -v "^#" | grep -q '{' && TAB=`expr $TAB + 1` && i=1
12 |         echo "$line" | egrep -v "^#" | grep -q '}' && TAB=`expr $TAB - 1`
13 |         while [ $i -lt $TAB ]; do
14 |                 printf "\t"
15 |                 i=`expr $i + 1`
16 |         done
17 |         echo "$line"
18 | done > $CONFIG
19 | 
20 | $NGINX -t && echo "Config ok"


--------------------------------------------------------------------------------
/send_xmpp_message.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #-*- coding: utf-8 -*-
 3 | 
 4 | import xmpp,sys
 5 | 
 6 | xmpp_jid = 'me@me.ru'
 7 | xmpp_pwd = 'P@ssw0rd'
 8 | 
 9 | to = sys.argv[1]
10 | msg = sys.argv[2]
11 | 
12 | jid = xmpp.protocol.JID(xmpp_jid)
13 | client = xmpp.Client(jid.getDomain(),debug=[])
14 | client.connect()
15 | client.auth(jid.getNode(),str(xmpp_pwd),resource='xmpppy')
16 | client.send(xmpp.protocol.Message(to,msg))
17 | client.disconnect()
18 | 
19 | #2use ./send_xmpp_message.py me@me.ru "hi"
20 | #apt-get install python-xmpp
21 | #apt-get install python-dnspython
22 | 


--------------------------------------------------------------------------------
/squid/allowed_urls:
--------------------------------------------------------------------------------
1 | yandex.ru


--------------------------------------------------------------------------------
/squid/denied_urls:
--------------------------------------------------------------------------------
1 | geektimes.ru
2 | habrahabr.ru
3 | toster.ru
4 | windowsupdate.microsoft.com


--------------------------------------------------------------------------------
/squid/extended_access_group:
--------------------------------------------------------------------------------
1 | 192.168.1.5
2 | 192.168.1.87


--------------------------------------------------------------------------------
/squid/squid.conf:
--------------------------------------------------------------------------------
 1 | acl localnet src 192.168.0.0/16 # RFC1918 possible internal network
 2 | 
 3 | acl SSL_ports port 443
 4 | acl Safe_ports port 80          # http
 5 | acl Safe_ports port 21          # ftp
 6 | acl Safe_ports port 443         # https
 7 | acl Safe_ports port 70          # gopher
 8 | acl Safe_ports port 210         # wais
 9 | acl Safe_ports port 1025-65535  # unregistered ports
10 | acl Safe_ports port 280         # http-mgmt
11 | acl Safe_ports port 488         # gss-http
12 | acl Safe_ports port 591         # filemaker
13 | acl Safe_ports port 777         # multiling http
14 | acl Safe_ports port 901         # SWAT
15 | 
16 | acl CONNECT method CONNECT
17 | 
18 | #Добавление в acl трёх списков: запрещенные, разрешенные и группа расширенного доступа
19 | acl denied_urls url_regex "/etc/squid/denied_urls"
20 | acl allowed_urls url_regex "/etc/squid/allowed_urls"
21 | acl extended_access_group src "/etc/squid/extended_access_group"
22 | 
23 | http_access deny !Safe_ports
24 | 
25 | http_access deny CONNECT !SSL_ports
26 | http_access allow localhost manager
27 | http_access deny manager
28 | 
29 | #Ключевая строчка из-за которой долго ломали голову, так как без нее запрос сертификатов к сайтам
30 | # на https не осуществляется.
31 | #Разрешаем осуществлять коннект к ресурсу, если https
32 | http_access allow localnet CONNECT
33 | #Запрещаем всем доступ на запрещенные сайты
34 | http_access deny denied_urls
35 | #Этим правилом разрешаем всем кто не в группе расширенного доступа ходить только на
36 | #разрешенные сайты
37 | http_access deny !extended_access_group !allowed_urls
38 | 
39 | http_access allow localnet
40 | http_access allow localhost
41 | http_access deny all
42 | 
43 | #Обязательно один из портов должен быть в таком виде и являться заглушкой
44 | http_port 3130
45 | http_port 3128 intercept
46 | https_port 3129 intercept ssl-bump options=ALL:NO_SSLv3:NO_SSLv2 connection-auth=off cert=/etc/squid/squidCA.pem
47 | 
48 | always_direct allow all
49 | sslproxy_cert_error allow all
50 | sslproxy_flags DONT_VERIFY_PEER
51 | 
52 | #Правила доступа для ssl
53 | acl allowed_urls_ssl ssl::server_name_regex "/etc/squid/allowed_urls"
54 | acl denied_urls_ssl ssl::server_name_regex "/etc/squid/denied_urls"
55 | acl step1 at_step SslBump1
56 | ssl_bump peek step1
57 | ssl_bump terminate denied_ssl
58 | ssl_bump splice extended_access_group
59 | ssl_bump terminate !allowed_urls_ssl
60 | ssl_bump splice all
61 | sslcrtd_program /usr/lib/squid/ssl_crtd -s /var/lib/ssl_db -M 4MB
62 | 
63 | #cache_dir ufs /var/cache/squid 100 16 256
64 | 
65 | coredump_dir /var/cache/squid
66 | 
67 | refresh_pattern ^ftp:           1440    20%     10080
68 | refresh_pattern ^gopher:        1440    0%      1440
69 | refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
70 | refresh_pattern .               0       20%     4320


--------------------------------------------------------------------------------
/svnconfbackup.conf:
--------------------------------------------------------------------------------
 1 | TMPDIR="/var/tmp"
 2 | REPDIR="conf"
 3 | DESTDIR=$REPDIR.`date +%s`
 4 | LIST="/etc /usr/local/etc /var/named"
 5 | EXCLUDE_LIST="-not -path /etc/'*'shadow'*' \
 6 | -and -not -path /var/named/internal/slave/'*' \
 7 | -and -not -name '*'.pem \
 8 | -and -not -name '*'.key \
 9 | -and -not -name '*'.crt \
10 | -and -not -path /etc/ssh_host_rsa_key \
11 | -and -not -path /etc/ssh_host_dsa_key"
12 | FILES="/home/pgsql/data/*.conf"
13 | SVN=`which svn`
14 | SVNADMIN=`which svnadmin`
15 | SVNROOT="/usr/local/svnconfbackuproot"
16 | 


--------------------------------------------------------------------------------
/svnconfbackup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | . /usr/local/etc/svnconfbackup.conf
 3 | 
 4 | #Repo path in URL format
 5 | SVNROOTsvn="file://$SVNROOT"
 6 | 
 7 | which pax > /dev/null
 8 | 
 9 | if [ $? -ne 0 ] ; then 
10 |   echo "Error: pax not found, aborting!"
11 |   exit 1
12 | fi
13 | 
14 | case "$1" in
15 | init)
16 | 	 cd $TMPDIR
17 | 	 #Temporary directory creation
18 | 	 mkdir $DESTDIR
19 | 	 chmod 700 $DESTDIR
20 | 	 #Initial repository layout setup
21 | 	 mkdir $DESTDIR/branch
22 | 	 mkdir $DESTDIR/tag
23 | 	 mkdir $DESTDIR/trunk
24 | 	 cd $DESTDIR
25 | 	 #Check SVN root existence
26 | 	 if [ ! -d $SVNROOT ]; then
27 | 	   $SVNADMIN create $SVNROOT
28 | 	 fi
29 | 	 #Import repository tree
30 | 	 $SVN import $SVNROOTsvn/$REPDIR -q -m "Initial repository layout"
31 | 	 #Cleanup
32 | 	 cd ../
33 | 	 rm -rf $DESTDIR
34 | 	;;
35 | update)
36 | 	 cd $TMPDIR
37 | 	 #Temporary directory creation
38 | 	 mkdir $DESTDIR
39 | 	 chmod 700 $DESTDIR
40 | 	 #svn working dir setup
41 | 	 $SVN checkout -q $SVNROOTsvn/$REPDIR/trunk $DESTDIR
42 | 	 cd $DESTDIR
43 | 	 #Build file list
44 | 	 list=`eval find $LIST $EXCLUDE_LIST -and -type f|sort`
45 | 	 #Copy files
46 | 	 for p in ${list} $FILES ; do
47 | 	  pax -rw $p . > /dev/null 2>&1
48 | 	 done;
49 | 	 #Build recently added files list
50 | 	 list=`eval $SVN status|grep ^?|awk '{print $2}'`
51 | 	 #Add these files to version control
52 | 	 for p in ${list} ; do
53 | 	  $SVN add -q $p
54 | 	 done;
55 | 	 #Build all files list except .svn dirs
56 | 	 list=`eval find . -name .svn -prune -or -print`
57 | 	 #Remove non-existent files from version control
58 | 	 for p in ${list} ; do
59 | 	  if [ ! -e /$p ]; then
60 | 	   $SVN delete -q $p --force
61 | 	  fi
62 | 	 done;
63 | 	 #Commit changes
64 | 	 $SVN diff
65 | 	 $SVN commit -q -m "svnbackup automatic update"
66 | 	 #Cleanup
67 | 	 cd ../
68 | 	 rm -rf $DESTDIR
69 | esac
70 | 


--------------------------------------------------------------------------------
/svncreat.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #
 3 | # create svn repo $1 for group $2
 4 | 
 5 | SVNADMIN=/usr/bin/svnadmin
 6 | SVN=/usr/bin/svn
 7 | 
 8 | TMP_DIR=/tmp/svncreate/
 9 | 
10 | usage () {
11 |         echo "Usage: svncreate.sh PATH GROUP"
12 | }
13 | 
14 | if [ -z "$1" -o -z "$2" ]; then
15 |         usage; exit 0;
16 | fi
17 | 
18 | if [ -e "$1" ]; then
19 |         echo "ERROR: $1 exists";
20 |         usage; exit 0;
21 | fi
22 | 
23 | if ! egrep -qi "^$2:" /etc/group; then
24 |         echo "ERROR: group $2 does not exist"
25 |         usage; exit 0;
26 | fi
27 | 
28 | $SVNADMIN create $1 --fs-type=fsfs
29 | 
30 | if [ ! -d "$1" ]; then
31 |         echo "ERROR: could not create repository $1";
32 |         usage; exit 0;
33 | fi
34 | 
35 | chown -R :"$2" "$1"
36 | chmod -R g+w "$1"
37 | chmod -R o-rwx "$1"
38 | 
39 | #
40 | mkdir -p ${TMP_DIR}.$$/branches ${TMP_DIR}.$$/tags ${TMP_DIR}.$$/trunk && \
41 | ${SVN} import -m "creating branches, tags, trunk.." ${TMP_DIR}.$$/ file://$1
42 | rm -r ${TMP_DIR}.$$
43 | #
44 | 
45 | 


--------------------------------------------------------------------------------
/tail_with_thread.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | LOG_PATTERN=$1
 3 | BASE_DIR=$(dirname $LOG_PATTERN* | head -1)
 4 | 
 5 | run_thread (){
 6 |     echo Running thread
 7 |     tail -F $LOG_PATTERN* &
 8 |     THREAD_PID=$!
 9 | }
10 | 
11 | # When someone decides to stop the script - killall children
12 | cleanup () {
13 |     pgrep -P $$ | xargs -i kill {}
14 |     exit
15 | }
16 | 
17 | trap cleanup SIGHUP SIGINT SIGTERM
18 | 
19 | if [ $# -ne 1 ]; then
20 |     echo "usage: $0 <directory/pattern without * in the end>"
21 |     exit 1
22 | fi
23 | 
24 | # Wait for the directory to be created
25 | if [ ! -d $BASE_DIR ] ; then
26 |     echo DIR $BASE_DIR does not exist, waiting for it...
27 |     while [ ! -d $BASE_DIR ] ; do
28 |         sleep 2
29 |     done
30 |     echo DIR $BASE_DIR is now online
31 | fi
32 | 
33 | # count current number of files
34 | OLD_NUM_OF_FILES=$(ls -l $LOG_PATTERN* 2>/dev/null | wc -l)
35 | 
36 | # Start Tailing
37 | run_thread
38 | 
39 | while [ 1 ]; do
40 |     # If files are added - retail
41 |     NUM_FILES=$(ls -l $LOG_PATTERN* 2>/dev/null | wc -l)
42 |     if [ $NUM_FILES -ne $OLD_NUM_OF_FILES ]; then
43 |         OLD_NUM_OF_FILES=$NUM_FILES
44 |         kill $THREAD_PID
45 |         run_thread
46 |     fi
47 |     sleep 1
48 | done


--------------------------------------------------------------------------------
/template_bash_script.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | ##########################################################################
  4 | # Program: <APPLICATION DESCRIPTION HERE>
  5 | ##########################################################################
  6 | VERSION="0.0.1"; # <release>.<major change>.<minor change>
  7 | PROGNAME="<APPLICATION NAME>";
  8 | AUTHOR="You, you lucky so and so";
  9 |  
 10 | ##########################################################################
 11 | ## Pipeline:
 12 | ## TODO:
 13 | ##########################################################################
 14 | 
 15 | ##########################################################################
 16 | # XXX: Coloured variables
 17 | ##########################################################################
 18 | red=`echo -e "\033[31m"`
 19 | lcyan=`echo -e "\033[36m"`
 20 | yellow=`echo -e "\033[33m"`
 21 | green=`echo -e "\033[32m"`
 22 | blue=`echo -e "\033[34m"`
 23 | purple=`echo -e "\033[35m"`
 24 | normal=`echo -e "\033[m"`
 25 |  
 26 | ##########################################################################
 27 | # XXX: Configuration
 28 | ##########################################################################
 29 |  
 30 | declare -A EXIT_CODES
 31 |  
 32 | EXIT_CODES['unknown']=-1
 33 | EXIT_CODES['ok']=0
 34 | EXIT_CODES['generic']=1
 35 | EXIT_CODES['limit']=3
 36 | EXIT_CODES['missing']=5
 37 | EXIT_CODES['failure']=10
 38 |  
 39 | DEBUG=0
 40 | param=""
 41 |  
 42 | ##########################################################################
 43 | # XXX: Help Functions
 44 | ##########################################################################
 45 | show_usage() {
 46 |         echo -e """ABCDEFG\n
 47 |         Usage: $0 <target>
 48 |         \t-h\t\tshows this help menu
 49 |         \t-v\t\tshows the version number and other misc info
 50 |         \t-D\t\tdisplays more verbose output for debugging purposes"""
 51 |         
 52 |         exit 1
 53 |         exit ${EXIT_CODES['ok']};
 54 | }
 55 |  
 56 | show_version() {
 57 |         echo "$PROGNAME version: $VERSION ($AUTHOR)";
 58 |         exit ${EXIT_CODES['ok']};
 59 | }
 60 |  
 61 | debug() {
 62 |         # Only print when in DEBUG mode
 63 |         if [[ $DEBUG == 1 ]]; then
 64 |                 echo $1;
 65 |         fi
 66 | }
 67 |  
 68 | err() {
 69 |         echo "$@" 1>&2;
 70 |         exit ${EXIT_CODES['generic']};
 71 | }
 72 |  
 73 | ##########################################################################
 74 | # XXX: Initialisation and menu
 75 | ##########################################################################
 76 | if [ $# == 0 ] ; then
 77 |         show_usage;
 78 | fi
 79 |  
 80 | while getopts :vhx opt
 81 | do
 82 |   case $opt in
 83 |   v) show_version;;
 84 |   h) show_usage;;
 85 |   *)  echo "Unknown Option: -$OPTARG" >&2; exit 1;;
 86 |   esac
 87 | done
 88 | 
 89 |  
 90 |  
 91 | # Make sure we have all the parameters we need (if you need to force any parameters)
 92 | #if [[ -z "$param" ]]; then
 93 | #        err "This is a required parameter";
 94 | #fi
 95 |  
 96 | ##########################################################################
 97 | # XXX: Kick off
 98 | ##########################################################################
 99 | header() {
100 |         clear
101 |         echo -e """
102 | ----------------------------------
103 |  $PROGNAME v$VERSION $AUTHOR
104 | ----------------------------------\n"""
105 | }
106 | 
107 | main() {
108 | 
109 | #start coding here
110 |   echo "start coding here"
111 |   
112 | }
113 | 
114 | header
115 | main "$@"
116 | 
117 | debug $param;
118 | 


--------------------------------------------------------------------------------
/template_python_script.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | import optparse
 3 | import re
 4 | import socket
 5 | import sys
 6 | from signal import signal, SIGPIPE, SIG_DFL
 7 | signal(SIGPIPE,SIG_DFL)
 8 | 
 9 | #########################################################################
10 | # Program: <APPLICATION DESCRIPTION HERE>
11 | #########################################################################
12 | #########################################################################
13 | # Copyright: <COPYRIGHT NOTICE HERE>
14 | #########################################################################
15 | __version__ =   "0.0.1" # <release>.<major change>.<minor change>
16 | __prog__ =      "<APPLICATION NAME>"
17 | __author__ =    "<YOUR NAME>"
18 | 
19 | #########################################################################
20 | ## Pipeline:
21 | ## TODO: 
22 | #########################################################################
23 | 
24 | #########################################################################
25 | # XXX: Configuration
26 | #########################################################################
27 | 
28 | EXIT_CODES = {
29 | 	"ok"	  : 0,
30 | 	"generic" : 1,
31 | 	"invalid" : 3,
32 | 	"missing" : 5,
33 | 	"limit"   : 7,
34 | }
35 | 
36 | #########################################################################
37 | # XXX: Kick off
38 | #########################################################################
39 | 
40 | def run():
41 | 	# <START CODING HERE>
42 | 	pass
43 | 
44 | #########################################################################
45 | # XXX: Helpers
46 | #########################################################################
47 | 
48 | def debug(msg, override=False):
49 | 	if options.debug or override:
50 | 		print msg
51 | 
52 | def warn(msg):
53 | 	debug("[WARNING]: %s" % msg)
54 | 	sys.stderr.write("[WARNING]: %s\n" % msg)
55 | 
56 | def err(msg, level="generic"):
57 | 	if level.lower() not in EXIT_CODES:
58 | 		level = "generic"
59 | 	
60 | 	sys.stderr.write("[ERROR]: %s\n" % msg)
61 | 	sys.exit(EXIT_CODES[level])
62 | 
63 | #########################################################################
64 | # XXX: Initialisation
65 | #########################################################################
66 | 
67 | if __name__ == "__main__":
68 | 	parser = optparse.OptionParser(
69 |                 usage="Usage: %prog [OPTIONS]",
70 |                 version="%s: v%s (%s)" % (__prog__, __version__, __author__),
71 |                 description="<DESCRIPTION OF THE APPLICATION HERE>",
72 |                 epilog="Example: <EXAMPLE HERE>",
73 |         )
74 | 
75 |         parser.add_option("-c", "--conf", default="config.conf", action="store", dest="config",
76 |                 help="Specify which config to use (default: config.conf)")
77 | 
78 |         parser.add_option('-o', '--output', default="STDOUT", dest="output",
79 |                 help='Specify the output file (default: STDOUT)')
80 | 
81 |         parser.add_option('-d', '--debug', action='store_true', dest="debug",
82 |                 help='Display verbose processing details (default: False)')
83 |         
84 | 	parser.add_option('-v', action='version',
85 |                 help="Shows the current version number and exits")
86 | 
87 |         (options, args) = parser.parse_args()
88 | 
89 | 	try:
90 | 		run()
91 | 	except KeyboardInterrupt:
92 | 		print "\n\nCancelled."
93 | 		sys.exit(0)
94 | 


--------------------------------------------------------------------------------
/top_ip_address.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Shell Script To List All Top Hitting IP Address to your webserver.
 3 | # This may be useful to catch spammers and scrappers.
 4 | # -------------------------------------------------------------------------
 5 | 
 6 | # where to store final report?
 7 | DEST=/tmp/ips
 8 |  
 9 | # domain name
10 | DOM=$1
11 |  
12 | # log file location
13 | LOGFILE=/logs/$DOM/access_log
14 |  
15 | # die if no domain name given
16 | [ $# -eq 0 ] && exit 1
17 |  
18 | # make dir
19 | [ ! -d $DEST ] && mkdir -p $DEST
20 |  
21 | # ok, go though log file and create report
22 | if [ -f $LOGFILE ]
23 | then
24 | 	echo "Processing log for $DOM..."
25 | 	awk '{ print $1}' $LOGFILE | sort  | uniq -c  | sort -nr > $DEST/$DOM.txt
26 | 	echo "Report written to $DEST/$DOM.txt"
27 | fi
28 | 
29 | #|awk '{ print $1}' | sort  | uniq -c  | sort -nr


--------------------------------------------------------------------------------
/usbmodem_watchdog.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | # yum install usb_modeswitch usb_modeswitch-data
  4 | # */5 * * * * /usr/local/bin/usbmodem_watchdog -m Huawei -s ya.ru -i wwp6s0u2i1 -n 3 -d 1-1 > /dev/null 2>&1
  5 | 
  6 | 
  7 | export PATH="$PATH:/usr/sbin"
  8 | SN="$(basename "$0")"
  9 | 
 10 | function print_help() {
 11 |     printf "\n"
 12 |     printf "Использование: %s options...\n" "$SN"
 13 |     printf "Параметры:\n"
 14 |     printf "  -s         Проверяемый ресурс.\n"
 15 |     printf "  -i         Имя сетевого интерфейса.\n"
 16 |     printf "  -d         Шина и порт модема lsusb -t.\n"
 17 |     printf "  -n         Число ошибочных пингов.\n"
 18 |     printf "  -m         Маркер модема, из команды lsusb.\n"
 19 |     printf "  -h         Справка.\n"
 20 |     printf "\n"
 21 | }
 22 | 
 23 | # Если скрипт запущен без аргументов, открываем справку.
 24 | if [[ $# = 0 ]]; then
 25 |     print_help && exit 1
 26 | fi
 27 | while getopts ":s:i:d:n:m:h" opt ;
 28 | do
 29 |     case $opt in
 30 |         s) SITE=$OPTARG;
 31 |             ;;
 32 |         i) IF=$OPTARG;
 33 |             ;;
 34 |         d) DEV=$OPTARG;
 35 |             ;;
 36 |         n) EP=$OPTARG;
 37 |             ;;
 38 |         m) MM=$OPTARG;
 39 |             ;;
 40 |         h) print_help
 41 |             exit 1
 42 |             ;;
 43 |         *) printf "Неправильный параметр\n";
 44 |            printf "Для вызова справки запустите %s -h\n" "$SN";
 45 |             exit 1
 46 |             ;;
 47 |         esac
 48 | done
 49 | 
 50 | if [[ "$SITE" == "" ]] || [[ "$IF" == "" ]] || [[ "$DEV" == "" ]] || [[ "$EP" == "" ]] || [[ "$MM" == "" ]] ;  then
 51 |  printf "\n"
 52 |  printf "Одна или несколько опций не указаны.\n"
 53 |  printf "Для справки наберите: %s -h\n" "$SN"
 54 |  printf "\n"
 55 |  exit 1
 56 | fi
 57 | 
 58 | M="$(lsusb | grep -w "$MM")"  #строка модема из lsusb
 59 | 
 60 | 
 61 | if [[ "$M" != "" ]]; then   #если модем выбран, можно проверять пинги
 62 | 
 63 |   if grep -w -q "$IF" /proc/net/dev; then #проверяем наличие сетевого интерфейса
 64 |    printf "\n"
 65 |    printf "Проверка доступности %s через интерфейс %s\n" "$SITE" "$IF"
 66 |    printf "\n"
 67 |     if [[ "$EP" -ge 6 ]]; then
 68 |      printf "Число ошибочных пингов должно быть меньше или равно 5\n"
 69 |      exit 1
 70 |     else
 71 |      printf "Делаем пинги...\n"
 72 |      flag="0"
 73 |      for i in {1..5}; do #делаем 5 пингов до сервера
 74 |      timeout -k 2 -s TERM 16 ping -w 14 -s 8 -c 1 -I "$IF" "$SITE" || flag=$((flag+1)) && printf "пинг:%s/5 (ошибок:%s)\n" "$i" "$flag" #пинг не прошел - инкрементируем счетчик
 75 |       if (("$flag" >= "$EP")); then
 76 |        break
 77 |       else
 78 |        read -r -t 1 > /dev/null
 79 |       fi
 80 |      done
 81 |      printf "потерь пакетов: %s из %s\n" "$flag" "$i"
 82 |      printf "\n"
 83 | 
 84 |      if (("$flag" >= "$EP")); then #если потерь пакетов больше 2х
 85 |       M="$(lsusb | grep "$MM")"   #на всякий случай снова глянем - вдруг модем выдернули
 86 |       printf "Будет сброшен модем:\n"
 87 |       printf "%s\n" "$M" | cut -c 34-
 88 |       if ! [[ -d /sys/bus/usb/drivers/usb/"$DEV" ]]; then
 89 |        printf "Неверно указаны Bus и Port модема.\n"
 90 |        exit 1
 91 |       else
 92 |       ifdown "$IF" #деактивируем интерфейс
 93 |       printf "%s" "$DEV" > "/sys/bus/usb/drivers/usb/unbind" && printf "%s" "$DEV" > "/sys/bus/usb/drivers/usb/bind" #перезегрузка модема
 94 | #      read -r -t 1 > /dev/null
 95 |       ifup "$IF" #активируем интерфейс
 96 |       fi
 97 |      fi
 98 |     fi
 99 |   else
100 |    printf "\n"
101 |    printf "Интерфейс %s не существует\n" "$IF"
102 |    printf "\n"
103 |    exit 1
104 |   fi
105 | else
106 |   printf "Модем %s не найден.\n" "$MM"
107 | fi


--------------------------------------------------------------------------------
/users_whitelist.sh:
--------------------------------------------------------------------------------
  1 | #!bash
  2 | 
  3 | TMPDIR=$1
  4 | 
  5 | if [ -x /usr/bin/wget ]; then
  6 | 	wget -q --timeout=30 --no-check-certificate -O users-whitelist.txt https://mnt.example.ru/pub/${TMPDIR}/users-whitelist.txt
  7 | else
  8 | 	fetch -q -T 30 https://mnt.relax.ru/pub/${TMPDIR}/users-whitelist.txt
  9 | fi
 10 | 
 11 | 
 12 | RE_FILTER='^([-a-z0-9_\.]+:(\*:|\!:|\!\!:|\!\$1\$|\*LOCKED\*)|#)'
 13 | 
 14 | if [[ "`uname`" == 'Linux' ]]; then
 15 | 	PASSWD=/etc/shadow
 16 | else
 17 | 	PASSWD=/etc/master.passwd
 18 | fi
 19 | 
 20 | # Checking passwords
 21 | cat ./users-whitelist.txt | cut -d ':' -f 1 > ./users-whitelist-logins.txt
 22 | sudo cat ${PASSWD} | grep -v -f ./users-whitelist-logins.txt | egrep -i -v "${RE_FILTER}"
 23 | rm -f ./users-whitelist-logins.txt
 24 | 
 25 | # 1. More than one login.
 26 | # 2. GID of 0.
 27 | # 3. authorized_keys
 28 | 
 29 | # Checking other data
 30 | cat <<'EOP' | perl
 31 | 	use strict;
 32 | 	use Data::Dumper;
 33 | 
 34 | 	my (%white, %passwd, %shadow);
 35 | 
 36 | 	open(FH, '< users-whitelist.txt') or die('Cannot open ./users-whitelist.txt.');
 37 | 	while (<FH>) { chomp(); @{$white{substr($_, 0, index($_, ':'))}} = split(':'); }
 38 | 	close(FH);
 39 | 
 40 | 	my $passwd_re = qr/^([-a-z0-9_\.]+:(\*:|\!:|x:|\!\!:|\!\$1\$|\*LOCKED\*)|#)/;
 41 | 
 42 | 	# Reading passwords
 43 | 	my ($pwfile);
 44 | 	if (-r '/etc/master.passwd') { $pwfile = '/etc/master.passwd'; }
 45 | 	elsif (-r '/etc/shadow') { $pwfile = '/etc/shadow'; }
 46 | 	if (-r $pwfile) {
 47 | 		open(FH, '<', $pwfile) or die('Cannot open ${pwfile}.');
 48 | 		while (<FH>) {
 49 | 			chomp();
 50 | 			if ($_ =~ /^#/) { next(); }
 51 | 			@{$shadow{substr($_, 0, index($_, ':'))}} = split(':');
 52 | 		}
 53 | 		close(FH);
 54 | 	}
 55 | 
 56 | 	open(FH, '< /etc/passwd') or die('Cannot open /etc/passwd.');
 57 | 	while (<FH>) {
 58 | 		chomp();
 59 | 		my $line = $_;
 60 | 		if ($line =~ /^#/) { next(); }
 61 | 		my ($login, $passwd, $uid, $gid, $comment, $home, $shell) = split(':', $line);
 62 | 		if ($shadow{$login} =~ $passwd_re && ! -f "~$login/.ssh/authorized_keys") {
 63 | 			print "Shadow line:\n$shadow{$login}\n";
 64 | 			# TODO: check if user home exists and have authorized_keys
 65 | 			next();
 66 | 		}
 67 | 
 68 | 		# TODO: delete this
 69 | 		if ($uid < 500) { next(); }
 70 | 
 71 | 		$passwd{$login} = $line;
 72 | 
 73 | 		if ($login eq 'nobody') { next(); }
 74 | 
 75 | 		my $wgid = $white{$login}[1];
 76 | 		my $wcomment = $white{$login}[2];
 77 | 
 78 | 		if ($wcomment && $comment ne $wcomment) {
 79 | 			print "Real name of ${login} is ${comment}; must be ${wcomment}:"
 80 | 				. "\n" . $line . "\n";
 81 | 		}
 82 | 		if ($wgid != 0 && $home !~ m@^/home/@
 83 | 			&& $login !~ /ftp/i && $comment !~ /ftp/i
 84 | 		) {
 85 | 			print "Home of user ${login} not in /home/:"
 86 | 				. "\n" . $line . "\n";
 87 | 		}
 88 | 		if ($shell =~ /nologin/ && $login !~ /ftp$/i && $comment !~ /ftp/i
 89 | 			&& $login != 'nfsnobody'
 90 | 			&& $login != 'wwwpartner' # Must be converted to FTP login
 91 | 		) {
 92 | 			print "Shell of not blocked user ${login} is nologin:"
 93 | 				. "\n" . $line . "\n";
 94 | 		}
 95 | 
 96 | 		if ($shell !~ /nologin/ && ($login =~ /ftp/i || $comment =~ /ftp/i)
 97 | 			&& $login ne 'kards.ru' 
 98 | 		) {
 99 | 			print "Shell of FTP user ${login} is not nologin:"
100 | 				. "\n" . $line . "\n";
101 | 		}
102 | 
103 | 		# nologin && auth
104 | 	}
105 | 	close(FH);
106 | 
107 | 	foreach (keys %white) { delete($passwd{$_}); }
108 | 	foreach (keys %passwd) { print $passwd{$_}; }
109 | EOP
110 | 
111 | rm -f users-whitelist.txt
112 | 


--------------------------------------------------------------------------------
/webdiff.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | # Скрипт проверяет документы на обновления и шлёт диффы изменений на email
 3 | # Зависит от: wget, w3m, diff, md5sum, mail (sendmail)
 4 | 
 5 | DIR="$HOME/documents/"
 6 | EMAIL="user@example.com"
 7 | 
 8 | LIST="url1
 9 | url2
10 | url3"
11 | 
12 | function test_ping() {
13 |     if ! ping -q -c 3  $1; then
14 | 	echo "не пингуется $1"
15 | 	exit 1
16 |     fi
17 | }
18 | 
19 | ping_host="ya.ru"
20 | test_ping $ping_host
21 | 
22 | for url in $LIST; do
23 |     md5this=$(echo $url | md5sum | sed 's/\ .*$//')
24 |     checkfile="$HOME/etc/.pagecheck.$md5this.md5"
25 |     # Если нет $checkfile, значит страница проверяется первый раз
26 |     if [ -f $checkfile ];
27 |     then
28 | 	w3m -dump $url | md5sum | diff - $checkfile # Проверяем md5 на изменения
29 | 	if [ $? = 1 ]; then
30 | 	    echo "changed: $url"
31 | 	    w3m -dump $url | md5sum > $checkfile # обновляем md5 дампа
32 | 	    mv $HOME/etc/.pagecheck.$md5this.content $HOME/etc/.pagecheck.$md5this.content-old # Перемещаем дамп в резерв
33 | 	    w3m -dump $url > $HOME/etc/.pagecheck.$md5this.content # Скачиваем новый дамп
34 | 	    diff $HOME/etc/.pagecheck.$md5this.content $HOME/etc/.pagecheck.$md5this.content-old | mail -s "UPDATED: $url" $EMAIL # Делаем diff дампа и шлём на email
35 | 	    cd $DIR && wget -p $url # Скачиваем страничку
36 | 	fi
37 |     else
38 | 	w3m -dump $url | md5sum > $checkfile # запоминаем md5sum для последующих проверок
39 | 	w3m -dump $url > $HOME/etc/.pagecheck.$md5this.content # Скачиваем дамп
40 | 	# Скачиваем страничку
41 | 	cd $DIR && wget -p $url
42 |     fi
43 | done;


--------------------------------------------------------------------------------
/whatsapp_install.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | set -x
 3 | 
 4 | if [ $# -ne 1 ]; then
 5 |     echo "usage: $0 VERSION"
 6 |     echo "Get VERSION at https://www.whatsapp.com/android/"
 7 |     exit 1
 8 | fi
 9 | 
10 | app_ver=$1
11 | cd /tmp
12 | wget -qO /tmp/WhatsApp.apk https://www.cdn.whatsapp.net/android/${app_ver}/WhatsApp.apk  > /dev/null 2>&1
13 | adb install -r /tpm/WhatsApp.apk


--------------------------------------------------------------------------------
/win_installed_pkg_list.ps:
--------------------------------------------------------------------------------
  1 | Write-Output ("`n`t`Приступаю к анализу системы...`n") 
  2 | Write-Output ("`n`---------------------------------------------------------")
  3 |  
  4 | #Объявляем функцию содержащую способ вывода и сорт. по свойству DisplayName.
  5 | function Grid-Output
  6 |  
  7 | {
  8 |     param (
  9 |     <#
 10 |       Объявляем, что наличие массива элементов указанного ниже для работы
 11 |       данной функции явлется строго обязательным
 12 |     #>
 13 |      [Parameter (Mandatory = $true)]
 14 |         [Array] $Massive            
 15 |     )
 16 |  
 17 |     <#
 18 |       Сортируем вывод по свойству DisplayName, далее указываем формат вывода
 19 |       GridView
 20 |     #>
 21 |     $Massive |sort-object -property DisplayName | Out-GridView
 22 | }
 23 |  
 24 | <#
 25 |   Получаем объекты из реестра.
 26 |   
 27 |   На данном этапе из реестра мы получ. объекты типа:
 28 |   System.MarshalByRefObject.RegistryKey (Microsoft.Win32.RegistryKey)
 29 |   Отдельный объект для этих целей был создан потому что:
 30 |      
 31 |     1.Возможно данный объект, в последующем, необходимо будет изменить.
 32 |       Скорее всего даже на функцию анализирующую массивы
 33 |       элементов описанных ниже, формируя единый массив:
 34 |        1.1: $soft = Get-WmiObject -Class Win32_Product
 35 |        1.2: $soft32 = gci "HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall"
 36 |        1.3: $soft64 = gci "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"
 37 |  
 38 |        В связи с этим мы изолируем его для упрощения последующих модификаций.
 39 |  
 40 |     2. Улучшает читабельность кода.
 41 | #>
 42 | [array]$RegUnistValues = Get-ChildItem HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall
 43 |  
 44 | <#
 45 |   Генерируем объекты Automation.PSCustomObject для каждого свойства полученных ранее объектов Win32.RegistryKey
 46 |   Более подр. информацию по Get-ItemProperty можно почитать тут:
 47 |   https://technet.microsoft.com/ru-ru/library/hh849851.aspx
 48 | #>
 49 | [String]$temp = 'Здесь будут временно содержаться значения'
 50 | [Array]$temp = $RegUnistValues | ForEach-object {(Get-ItemProperty Microsoft.PowerShell.Core\Registry::$_)}
 51 |  
 52 | <#
 53 |    Создаём запрос на активацию фильтра.
 54 |    Для этого мы генерируем popup запрос вывод которого записываем в объект $result.
 55 |     
 56 |    object.Popup(strText,[nSecondsToWait],[strTitle],[nType]) в данном случае имеет следующие параметры:
 57 |     
 58 |    strText = "Активировать фильтрацию столбцов?" / Текст запроса
 59 |    nSecondsToWait = 10 / время ожидания ответа от пользователя
 60 |    strTitle =  "Question" / Не обязательное значение. Данная строка будет отображаться в сообщения.
 61 |    nType = 4+32 / Типы кнопок во всплывающем сообщении. В данном случае :
 62 |         4 = Сочетание кнопок "Да" и "Нет"
 63 |         32 = Рисунок знака вопроса в сообщении
 64 |  
 65 |         Более подробную информацию можно взять тут:
 66 |         https://msdn.microsoft.com/en-us/library/x83z1d9f(v=vs.84).aspx
 67 | #>
 68 | $shell = new-object -comobject "WScript.Shell"
 69 | $result = $shell.popup("Активировать фильтрацию столбцов?",10,"Question",4+32)
 70 |  
 71 | <#
 72 |   Используем оператор Switch для анализа знчений объект $result
 73 |   (ВНИМАНИЕ!! использование данного оператору в больших проектах с .Net объектами неприемлимо
 74 |   и считается дурным тоном, так как сильно затрудняет читабильность кода. Аналогов в данном
 75 |   случае я, к сожалению, не нашёл)
 76 |   В данном случае объект $result у нас может иметь 3 варианта:
 77 |      
 78 |     1. -1 : если в popup окне пользователь не нажал ни одну кнопку, и окно было закрыто по Тайм-Ауту.
 79 |     2.  6 : если в popup окне пользователь нажал "Да"
 80 |     3.  7 : если в popup окне пользователь нажал "Нет"
 81 |  
 82 |     Соответственно, в зависимости от значения $result выполняется сценарий.
 83 |     P.S.: значение -1 и все остальные возможные значения исключая 6 и 7 у меня перекрывает сценарий: Default.
 84 |     Сделано на случай если $result вернёт вместо значения ошибку.
 85 | #>
 86 |  
 87 | Switch ($result) {
 88 |  
 89 |     6 {
 90 |         Write-Output ("`n`t`Фильтр активирован.`n")
 91 |  
 92 |         <#
 93 |             В данном конкретном случае меня интересовали свойста DisplayName, DIsplayVersion, PSChildName.
 94 |             Однако никто не запрещает выбрать самостоятельно. Напоминаю, что все доступные свойтсва объекта
 95 |             можно получить: $тут_будет_указан_объект_свойства_которого_хотим_посмотреть | Get-Member
 96 |                          
 97 |             В это конкретном случае $temp | Get-Member
 98 |             Далее выбираем из свойств NoteProperty, указываем через запятую после Select-Object -Property.
 99 |             Выбранные нами свойства будут являться заголовками столбцов при выводе.
100 |         #>
101 |         #вывод полученных данных с помощью ранее написанной функции Grid-Output
102 |         Grid-Output -Massive ($temp | Select-Object -Property DisplayName, DIsplayVersion, PSChildName)
103 |              
104 |     }
105 |  
106 |     7 {
107 |         Write-Output ("`n`t`Фильтр отключен.`n")
108 |         #вывод полученных данных с помощью ранее написанной функции Grid-Output#
109 |         Grid-Output -Massive $temp
110 |          
111 |     }
112 |      
113 |     Default {
114 |                 Write-Output ("`n`t`Время на подтверждение активации фильтра истекло. Фильтр отключен.`n")
115 |                 #вывод полученных данных с помощью ранее написанной функции Grid-Output
116 |                 Grid-Output -Massive $temp
117 |      
118 |     }
119 |  
120 | }
121 |  
122 | #Обнуляем значение, дабы не оставлять после себя артефактов со значениями реестра.
123 | [String]$RegUnistValues = 'Здесь содержались значения реестра'
124 | [String]$temp = 'Здесь временно содержались значения'
125 |  
126 | Write-Output ("`n`t`Запрос успешно обработан.`n")
127 | Write-Output ("`n`---------------------------------------------------------")
128 | Write-Output ("`n`t`Работа скрипта завершена.`n")
129 |  
130 | <#
131 |   Блокируем автоматическое закрытие окна PowerShell после выполнения скрипта. В данном конкретном случае,
132 |   мне необходимо было сделать именно таким образом, однако правильнее будет запустить скрипт с ключом:
133 |   powershell.exe -NoExit -command c:\myscript.ps1
134 |   Ибо вносить для этого отдельные изменения в сценарий не рекомендуется.
135 | #>
136 | $host.ui.RawUI.ReadKey(6)|out-null


--------------------------------------------------------------------------------