Merge remote branch 'cros/upstream' into tempbranch3

client/common_lib/utils.py

 #
 # Copyright 2008 Google Inc. Released under the GPL v2
 
 import os, pickle, random, re, resource, select, shutil, signal, StringIO
 import socket, struct, subprocess, sys, time, textwrap, urlparse
 import warnings, smtplib, logging, urllib2
 try:
     import hashlib
 except ImportError:
     import md5, sha
@@ skipping 184 matching lines @@
 
 
 def open_write_close(filename, data):
     f = open(filename, 'w')
     try:
         f.write(data)
     finally:
         f.close()
 
 
+def matrix_to_string(matrix, header=None):
+    """
+    Return a pretty, aligned string representation of a nxm matrix.
+
+    This representation can be used to print any tabular data, such as
+    database results. It works by scanning the lengths of each element
+    in each column, and determining the format string dynamically.
+
+    @param matrix: Matrix representation (list with n rows of m elements).
+    @param header: Optional tuple with header elements to be displayed.
+    """
+    lengths = []
+    for row in matrix:
+        for column in row:
+            i = row.index(column)
+            cl = len(column)
+            try:
+                ml = lengths[i]
+                if cl > ml:
+                    lengths[i] = cl
+            except IndexError:
+                lengths.append(cl)
+
+    lengths = tuple(lengths)
+    format_string = ""
+    for length in lengths:
+        format_string += "%-" + str(length) + "s "
+    format_string += "\n"
+
+    matrix_str = ""
+    if header:
+        matrix_str += format_string % header
+    for row in matrix:
+        matrix_str += format_string % tuple(row)
+
+    return matrix_str
+
+
 def read_keyval(path):
     """
     Read a key-value pair format file into a dictionary, and return it.
     Takes either a filename or directory name as input. If it's a
     directory name, we assume you want the file to be called keyval.
     """
     if os.path.isdir(path):
         path = os.path.join(path, 'keyval')
     keyval = {}
     if os.path.exists(path):
@@ skipping 1008 matching lines @@
     arg_re = re.compile(r'(\w+)[:=](.*)$')
     dict = {}
     for arg in args:
         match = arg_re.match(arg)
         if match:
             dict[match.group(1).lower()] = match.group(2)
         else:
             logging.warning("args_to_dict: argument '%s' doesn't match "
                             "'%s' pattern. Ignored." % (arg, arg_re.pattern))
     return dict
+
+
+def get_unused_port():
+    """
+    Finds a semi-random available port. A race condition is still
+    possible after the port number is returned, if another process
+    happens to bind it.
+
+    Returns:
+        A port number that is unused on both TCP and UDP.
+    """
+
+    def try_bind(port, socket_type, socket_proto):
+        s = socket.socket(socket.AF_INET, socket_type, socket_proto)
+        try:
+            try:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind(('', port))
+                return s.getsockname()[1]
+            except socket.error:
+                return None
+        finally:
+            s.close()
+
+    # On the 2.6 kernel, calling try_bind() on UDP socket returns the
+    # same port over and over. So always try TCP first.
+    while True:
+        # Ask the OS for an unused port.
+        port = try_bind(0, socket.SOCK_STREAM, socket.IPPROTO_TCP)
+        # Check if this port is unused on the other protocol.
+        if port and try_bind(port, socket.SOCK_DGRAM, socket.IPPROTO_UDP):
+            return port