PLACES=['Afghanistan','Albania','Algeria','Samoa','Andorra','Angola','Anguilla','Antarctica','Antigua','Barbuda','Argentina','Armenia','Aruba','Australia','Austria','Azerbaijan','Bahamas','Bahrain','Bangladesh','Barbados','Belarus','Belgium','Belize','Benin','Bermuda','Bhutan','Bolivia','Bosnia','Herzegovina','Botswana','Bouvet','Brazil','Brunei','Darussalam','Bulgaria','Burkina','Faso','Burundi','Cambodia','Cameroon','Canada','Verde','Cayman','Chad','Chile','China','Colombia','Comoros','Congo','Costa','Rica','Croatia','Cuba','Cyprus','Czech','Denmark','Djibouti','Dominica','Ecuador','Egypt','Salvador','Guinea','Eritrea','Estonia','Ethiopia','Falklands','Faroe','Fiji','Finland','France','Guiana','Polynesia','Gabon','Gambia','Georgia','Germany','Ghana','Gibraltar','Greece','Greenland','Grenada','Guadeloupe','Guam','Guatemala','Guinea','Bissau','Guyana','Haiti','Honduras','Hungary','Iceland','India','Indonesia','Iran','Iraq','Ireland','Israel','Italy','Jamaica','Japan','Jordan','Kazakhstan','Kenya','Kiribati','Kuwait','Kyrgyzstan','Laos','Latvia','Lebanon','Lesotho','Liberia','Libya','Liechtenstein','Lithuania','Luxembourg','Macau','Macedonia','Madagascar','Malawi','Malaysia','Maldives','Mali','Malta','Martinique','Mauritania','Mauritius','Mayotte','Mexico','Moldova','Monaco','Mongolia','Montserrat','Morocco','Mozambique','Myanmar','Namibia','Nauru','Nepal','Netherlands','Caledonia','Zealand','Nicaragua','Niger','Nigeria','Niue','Korea','Mariana','Norway','Oman','Pakistan','Palau','Palestine','Panama','Papua','Paraguay','Peru','Philippines','Pitcairn','Poland','Portugal','Puerto','Rico','Qatar','Reunion','Romania','Russia','Rwanda','Samoa','Marino','Saudi','Arabia','Senegal','Seychelles','Sierra','Leone','Singapore','Slovakia','Slovenia','Somalia','Spain','Sudan','Suriname','Swaziland','Sweden','Switzerland','Syria','Taiwan','Tajikistan','Tanzania','Thailand','Togo','Tokelau','Tonga','Trinidad','Tobago','Tunisia','Turkey','Turkmenistan','Tuvalu','Uganda','Ukraine','Britain','England','Scotland','Wales','America','Uruguay','Uzbekistan','Vanuatu','Vatican','Venezuela','Vietnam','Wallis','Futuna','Sahara','Yemen','Yugoslavia','Zambia','Zimbabwe']

import random

class Mdict:
    def __init__(self):
        self.d = {}
    def __getitem__(self, key):
        if key in self.d:
            return self.d[key]
        else:
            raise KeyError(key)
    def add_key(self, prefix, suffix):
        if prefix in self.d:
            self.d[prefix].append(suffix)
        else:
            self.d[prefix] = [suffix]
    def get_suffix(self,prefix):
        l = self[prefix]
        return random.choice(l)

class MName:
    # A name from a Markov chain
    def __init__(self, chainlen = 2):
        # Building the dictionary
        if chainlen > 10 or chainlen < 1:
            print "Chain length must be between 1 and 10, inclusive"
            sys.exit(0)

        self.mcd = Mdict()
        oldnames = []
        self.chainlen = chainlen

        for l in PLACES:
            l = l.strip()
            oldnames.append(l)
            s = " " * chainlen + l
            for n in range(0,len(l)):
                self.mcd.add_key(s[n:n+chainlen], s[n+chainlen])
            self.mcd.add_key(s[len(l):len(l)+chainlen], "\n")

    def New(self):
        # New name from the Markov chain
        prefix = " " * self.chainlen
        name = ""
        suffix = ""
        while True:
            suffix = self.mcd.get_suffix(prefix)
            if suffix == "\n" or len(name) > 9:
                break
            else:
                name = name + suffix
                prefix = prefix[1:] + suffix
        return name.capitalize()

for i in range(100):
    print MName().New()

#!/usr/bin/env python -t
# encoding: utf-8
# origin:   http://overt.org/2010/02/15/off-site-backup-for-010gb-using-dirvish-and-amazon-ec2-and-ebs/
"""
run_offsite_backups.py
 
Wake up the EC2 backup server, run dirvish backup, then shut it down
 
Created by Bryan Klingner (code.b@overt.org) on 2010-02-02.
Feel free to use this code yourself. Maybe email me if you do :)
"""
 
import sys
import os
import boto
import time
import subprocess
 
BACKUP_INSTANCE_ID = 'YOUR_INSTANCE_ID'
 
def main():
 
    conn = boto.connect_ec2()
 
    # get the backup instance object
    instance = conn.get_all_instances(instance_ids=(BACKUP_INSTANCE_ID,))[0].instances[0]
 
    # if the instance is stopped, start it up
    if instance.state != 'running':
        conn.start_instances(instance_ids=(BACKUP_INSTANCE_ID,))
        waited = 0
        while instance.state != 'running':
            instance.update()
            sys.stdout.write("\rInstance starting up (%d sec)..." % (waited))
            sys.stdout.flush()
            time.sleep(1)
            waited += 1
 
    print "\n"
    print "Backup instance running:"
    print "    ID:       ", instance.id
    print "    State:    ", instance.state
    print "    DNS name: ", instance.dns_name
 
    # chill for a few seconds so the SSH server is listening
    time.sleep(10)
 
    print ""
    print "Initiating backup..."
    retcode = ssh_cmd('dirvish-expire; dirvish-runall', instance.dns_name, user='username')
    print ""
 
    # backup is done; shut down the instance
    conn.stop_instances(instance_ids=(BACKUP_INSTANCE_ID,))
    waited = 0
    while instance.state != 'stopped':
        instance.update()
        sys.stdout.write("\rInstance shutting down (%d sec)..." % (waited))
        sys.stdout.flush()
        time.sleep(1)
        waited += 1
    print ""
 
def ssh_cmd(cmd, host, user='root'):
    """ Run a shell command on a remote server via ssh """
 
    ssh_cmd = 'ssh -o ConnectTimeout=5 -o StrictHostKeyChecking=no ' + user + '@' + host + " '%s'" % (cmd)
    print "Running SSH command: %s" % ssh_cmd
    returncode = subprocess.call(ssh_cmd, shell=True)
 
    #logging.debug( output, returncode )
    return returncode
 
if __name__ == '__main__':
    main()

# Origin: some challenge on reddit

import socket, base64, ssl

user = "user"
server = "jabber.org"
port = 5222
password = "password"
recipient = "foo@bar.com"
message = "hello"
useSSL = True

def waitfor(socket, element) :
  input = ""  
  while not ("<" + element) in input or not input.endswith(">") :
    input += s.recv(1024)

s = socket.socket()
s.connect((server, port))
header = "<stream:stream version='1.0' xmlns:stream='http://etherx.jabber.org/streams' xmlns='jabber:client' to='" + server + "' xmlns:xml='http://www.w3.org/XML/1998/namespace'>"
if useSSL :
  s.send(header + "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")
  waitfor(s, "proceed")
  s = ssl.wrap_socket(s)
s.send(header + "<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='PLAIN'>" + base64.b64encode("\0" + user + "\0" + password)+ "</auth>")
waitfor(s, "success")
s.send(header + "<iq type='set'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/></iq><iq type='set'><session xmlns='urn:ietf:params:xml:ns:xmpp-session'/></iq><message to='" + recipient + "'><body>" + message + "</body></message>")
s.close()

#!/usr/bin/env python

import os
import zipfile


def main():
    zipper('/path/to/test', '/new/path/to/test.zip')


def zipper(dir, zip_file):
    zip = zipfile.ZipFile(zip_file, 'w', compression=zipfile.ZIP_DEFLATED)
    root_len = len(os.path.abspath(dir))
    for root, dirs, files in os.walk(dir):
        archive_root = os.path.abspath(root)[root_len:]
        for f in files:
            fullpath = os.path.join(root, f)
            archive_name = os.path.join(archive_root, f)
            print f
            zip.write(fullpath, archive_name, zipfile.ZIP_DEFLATED)
    zip.close()
    return zip_file


if __name__ == '__main__':
    main()

#!/usr/bin/python

import smtplib
from email.MIMEText import MIMEText

GMAIL_LOGIN = '__me__@gmail.com'
GMAIL_PASSWORD = '__secret__'
TO_EMAIL = '__you__@gmail.com'

def send_email(subject, message,to_addr=GMAIL_LOGIN,from_addr=GMAIL_LOGIN):
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = from_addr
    msg['To'] = to_addr

    server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
    server.ehlo()
    server.starttls()
    server.ehlo()
    server.login(GMAIL_LOGIN,GMAIL_PASSWORD)
    server.sendmail(from_addr, to_addr, msg.as_string())
    server.close()

if __name__=="__main__":
    send_email('test', 'This is a test email', TO_EMAIL)

import os, sys, time

# Main loop
def main():
    # Drop privs.
    os.setgid(1000) # Replace with desired GID
    os.setuid(1000) # Replace with desired UID

    time.sleep(10)
    sys.exit(0)

if (not os.fork()):
    os.setsid() # Become session leader
    pid = os.fork()

    if (pid):
        # Parent, write PID file
        fp = open('/var/run/my-daemon.pid', 'w')
        fp.write(str(pid))
        fp.flush()

        # Forcibly sync disk
        os.fsync(fp.fileno())
        fp.close()

        os._exit(0)
    else:
        # Child, call main
        main()
else:
    # Parent
    os._exit(0)

#/usr/bin/env python

__doc__ = """Tiny HTTP Proxy.

This module implements GET, HEAD, POST, PUT and DELETE methods
on BaseHTTPServer, and behaves as an HTTP proxy.  The CONNECT
method is also implemented experimentally, but has not been
tested yet.

Any help will be greatly appreciated.		SUZUKI Hisao
"""

__version__ = "0.2.1"

import BaseHTTPServer, select, socket, SocketServer, urlparse

class ProxyHandler (BaseHTTPServer.BaseHTTPRequestHandler):
    __base = BaseHTTPServer.BaseHTTPRequestHandler
    __base_handle = __base.handle

    server_version = "TinyHTTPProxy/" + __version__
    rbufsize = 0                        # self.rfile Be unbuffered

    def handle(self):
        (ip, port) =  self.client_address
        if hasattr(self, 'allowed_clients') and ip not in self.allowed_clients:
            self.raw_requestline = self.rfile.readline()
            if self.parse_request(): self.send_error(403)
        else:
            self.__base_handle()

    def _connect_to(self, netloc, soc):
        i = netloc.find(':')
        if i >= 0:
            host_port = netloc[:i], int(netloc[i+1:])
        else:
            host_port = netloc, 80
        print "\t" "connect to %s:%d" % host_port
        try: soc.connect(host_port)
        except socket.error, arg:
            try: msg = arg[1]
            except: msg = arg
            self.send_error(404, msg)
            return 0
        return 1

    def do_CONNECT(self):
        soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            if self._connect_to(self.path, soc):
                self.log_request(200)
                self.wfile.write(self.protocol_version +
                                 " 200 Connection established\r\n")
                self.wfile.write("Proxy-agent: %s\r\n" % self.version_string())
                self.wfile.write("\r\n")
                self._read_write(soc, 300)
        finally:
            print "\t" "bye"
            soc.close()
            self.connection.close()

    def do_GET(self):
        (scm, netloc, path, params, query, fragment) = urlparse.urlparse(
            self.path, 'http')
        if scm != 'http' or fragment or not netloc:
            self.send_error(400, "bad url %s" % self.path)
            return
        soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            if self._connect_to(netloc, soc):
                self.log_request()
                soc.send("%s %s %s\r\n" % (
                    self.command,
                    urlparse.urlunparse(('', '', path, params, query, '')),
                    self.request_version))
                self.headers['Connection'] = 'close'
                del self.headers['Proxy-Connection']
                for key_val in self.headers.items():
                    soc.send("%s: %s\r\n" % key_val)
                soc.send("\r\n")
                self._read_write(soc)
        finally:
            print "\t" "bye"
            soc.close()
            self.connection.close()

    def _read_write(self, soc, max_idling=20):
        iw = [self.connection, soc]
        ow = []
        count = 0
        while 1:
            count += 1
            (ins, _, exs) = select.select(iw, ow, iw, 3)
            if exs: break
            if ins:
                for i in ins:
                    if i is soc:
                        out = self.connection
                    else:
                        out = soc
                    data = i.recv(8192)
                    if data:
                        out.send(data)
                        count = 0
            else:
                print "\t" "idle", count
            if count == max_idling: break

    do_HEAD = do_GET
    do_POST = do_GET
    do_PUT  = do_GET
    do_DELETE=do_GET

class ThreadingHTTPServer (SocketServer.ThreadingMixIn,
                           BaseHTTPServer.HTTPServer): pass

if __name__ == '__main__':
    from sys import argv
    if argv[1:] and argv[1] in ('-h', '--help'):
        print argv[0], "[port [allowed_client_name ...]]"
    else:
        if argv[2:]:
            allowed = []
            for name in argv[2:]:
                client = socket.gethostbyname(name)
                allowed.append(client)
                print "Accept: %s (%s)" % (client, name)
            ProxyHandler.allowed_clients = allowed
            del argv[2:]
        else:
            print "Any clients will be served..."
        BaseHTTPServer.test(ProxyHandler, ThreadingHTTPServer)

#!/usr/bin/python

# logproxy.py takes a hostname as its argument and redirects all requests to that host, 
# in the meantime logging the headers and content body (if content has been sent). 
# The response is also logged, and then sent back to the client accordingly.

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

import httplib
import logging
import os
import socket
import sys
import time

global redirecthost
redirecthost = "

log = logging.getLogger('log')
hdlr = logging.FileHandler('dav.log')
formatter = logging.Formatter('%(message)s')
hdlr.setFormatter(formatter)
log.addHandler(hdlr)
log.setLevel(logging.DEBUG)

#
# a logging http-method handler
#
def do_HTTP(self):
    try:
        log.info('%s %s' % (self.command, self.path))

        headers = {}
        for header in self.headers.headers:
            s = header.strip().split(': ')
            if len(s) == 2:
                headers[s[0]] = s[1]
                log.info('%s: %s' % (s[0], s[1]))

        if len(headers) == 0:
            log.info('no headers')

        if headers.has_key('Content-Length'):
            cl = int(headers['Content-Length'])
            body = self.rfile.read(cl)
            log.info(body)
        else:
            body = "

        log.info('n-------------------------------------------n')

        conn = httplib.HTTPConnection(redirecthost)

        conn.request(self.command, self.path, body, headers)
        resp = conn.getresponse()

        status = resp.status
        reason = resp.reason

        if resp.msg.has_key('Content-Length'):
            body = resp.read(int(resp.msg['Content-Length']))
        elif resp.msg.has_key('Transfer-Encoding') and resp.msg['Transfer-Encoding'] == 'chunked':
            body = resp.read()
        elif not resp.msg.has_key('Content-Length'):
            body = resp.read()
        else:
            body = "

        self.send_response(status, reason)

        for header in resp.msg.headers:
            s = header.strip().split(': ')
            if s[0] == 'Transfer-Encoding':
                self.send_header('Content-Length', len(body))
            else:
                self.send_header(s[0], s[1])
            log.info('%s: %s' % (s[0], s[1]))

        log.info(")
        self.end_headers()

        log.info(body)
        self.wfile.write(body)
        self.wfile.flush()

        log.info('n================================================================n')

    except IOError, e:
        self.send_error(500, e)        

class MyHandler(BaseHTTPRequestHandler): pass

#
# http methods we'll handle
#
MyHandler.do_COPY = do_HTTP
MyHandler.do_DELETE = do_HTTP
MyHandler.do_GET = do_HTTP
MyHandler.do_LOCK = do_HTTP
MyHandler.do_MKCOL = do_HTTP
MyHandler.do_MOVE = do_HTTP
MyHandler.do_OPTIONS = do_HTTP
MyHandler.do_POST = do_HTTP
MyHandler.do_PROPFIND = do_HTTP
MyHandler.do_PROPPATCH = do_HTTP
MyHandler.do_PUT = do_HTTP
MyHandler.do_TRACE = do_HTTP
MyHandler.do_UNLOCK = do_HTTP

def main():
    global redirecthost
    redirecthost = sys.argv[1]

    rtn = os.fork()

    if rtn == 0:
        try:
            server = HTTPServer((", 19080), MyHandler)
            server.serve_forever()
        except KeyboardInterrupt:
            log.info('^C received, shutting down server')
            server.socket.close()
    else:
        try:
            while 1:
                line = sys.stdin.readline()
                log.info('************** %s' % line)
        except KeyboardInterrupt:
            pass

if __name__ == '__main__':
    main()