mpdlib(1)

NAME
mpdlib

FILE
/sandbox/balaji/maint/mpich2-1.2.1-tmp/src/pm/mpd/mpdlib.py

DESCRIPTION

#   (C) 2001 by Argonne National Laboratory.

#   See COPYRIGHT in top-level directory. #

CLASSES
__builtin__.dict(__builtin__.object) MPDParmDB __builtin__.object MPDRing MPDSock MPDConClientSock MPDListenSock MPDConListenSock MPDStreamHandler MPDTest

class MPDConClientSock(MPDSock)

    |   Method resolution order:

    |   MPDConClientSock

    |   MPDSock

    |   __builtin__.object

    |

    |   Methods defined here:

    |

    |   __init__(self, name='console_to_mpd', mpdroot='', secretword='', **kargs)

    |

    |   ----------------------------------------------------------------------

    |   Methods inherited from MPDSock:

    |

    |   accept(self, name='accepter')

    |

    |   close(self)

    |

    |   connect(self, *args)

    |

    |   fileno(self)

    |

    |   getsockname(self)

    |

    |   recv(self, nbytes)

    |

    |   recv_char_msg(self)

    |

    |   recv_dict_msg(self, timeout=None)

    |

    |   recv_one_line(self)

    |

    |   send_char_msg(self, msg, errprint=1)

    |

    |   send_dict_msg(self, msg, errprint=1)

    |   # The default behavior on an error needs to be to handle and/or report

    |   # it. Otherwise, we all waste time trying to figure out why

    |   # the code is silently failing. I've set the default for errprint

    |   # to YES rather than NO.

    |

    |   sendall(self, data)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors inherited from MPDSock:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

class MPDConListenSock(MPDListenSock)

    |   Method resolution order:

    |   MPDConListenSock

    |   MPDListenSock

    |   MPDSock

    |   __builtin__.object

    |

    |   Methods defined here:

    |

    |   __init__(self, name='console_listen', secretword='', **kargs)

    |

    |   ----------------------------------------------------------------------

    |   Methods inherited from MPDSock:

    |

    |   accept(self, name='accepter')

    |

    |   close(self)

    |

    |   connect(self, *args)

    |

    |   fileno(self)

    |

    |   getsockname(self)

    |

    |   recv(self, nbytes)

    |

    |   recv_char_msg(self)

    |

    |   recv_dict_msg(self, timeout=None)

    |

    |   recv_one_line(self)

    |

    |   send_char_msg(self, msg, errprint=1)

    |

    |   send_dict_msg(self, msg, errprint=1)

    |   # The default behavior on an error needs to be to handle and/or report

    |   # it. Otherwise, we all waste time trying to figure out why

    |   # the code is silently failing. I've set the default for errprint

    |   # to YES rather than NO.

    |

    |   sendall(self, data)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors inherited from MPDSock:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

class MPDListenSock(MPDSock)

    |   Method resolution order:

    |   MPDListenSock

    |   MPDSock

    |   __builtin__.object

    |

    |   Methods defined here:

    |

    |   __init__(self, host='', port=0, filename='', listen=5, name='listener', **kargs)

    |

    |   ----------------------------------------------------------------------

    |   Methods inherited from MPDSock:

    |

    |   accept(self, name='accepter')

    |

    |   close(self)

    |

    |   connect(self, *args)

    |

    |   fileno(self)

    |

    |   getsockname(self)

    |

    |   recv(self, nbytes)

    |

    |   recv_char_msg(self)

    |

    |   recv_dict_msg(self, timeout=None)

    |

    |   recv_one_line(self)

    |

    |   send_char_msg(self, msg, errprint=1)

    |

    |   send_dict_msg(self, msg, errprint=1)

    |   # The default behavior on an error needs to be to handle and/or report

    |   # it. Otherwise, we all waste time trying to figure out why

    |   # the code is silently failing. I've set the default for errprint

    |   # to YES rather than NO.

    |

    |   sendall(self, data)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors inherited from MPDSock:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

class MPDParmDB(__builtin__.dict)

    |   Method resolution order:

    |   MPDParmDB

    |   __builtin__.dict

    |   __builtin__.object

    |

    |   Methods defined here:

    |

    |   __getitem__(self, key)

    |

    |   __init__(self, orderedSources=[])

    |

    |   __setitem__(self, sk_tup, val)

    |

    |   get_parms_from_env(self, parmsToOverride)

    |

    |   get_parms_from_rcfile(self, parmsToOverride, errIfMissingFile=0)

    |

    |   has_key(self, key)

    |

    |   printall(self)

    |

    |   printdef(self)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors defined here:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

    |

    |   ----------------------------------------------------------------------

    |   Methods inherited from __builtin__.dict:

    |

    |   __cmp__(...)

    |   x.__cmp__(y) <==> cmp(x,y)

    |

    |   __contains__(...)

    |   D.__contains__(k) -> True if D has a key k, else False

    |

    |   __delitem__(...)

    |   x.__delitem__(y) <==> del x[y]

    |

    |   __eq__(...)

    |   x.__eq__(y) <==> x==y

    |

    |   __ge__(...)

    |   x.__ge__(y) <==> x>=y

    |

    |   __getattribute__(...)

    |   x.__getattribute__('name') <==> x.name

    |

    |   __gt__(...)

    |   x.__gt__(y) <==> x>y

    |

    |   __hash__(...)

    |   x.__hash__() <==> hash(x)

    |

    |   __iter__(...)

    |   x.__iter__() <==> iter(x)

    |

    |   __le__(...)

    |   x.__le__(y) <==> x<=y

    |

    |   __len__(...)

    |   x.__len__() <==> len(x)

    |

    |   __lt__(...)

    |   x.__lt__(y) <==> x<y

    |

    |   __ne__(...)

    |   x.__ne__(y) <==> x!=y

    |

    |   __repr__(...)

    |   x.__repr__() <==> repr(x)

    |

    |   clear(...)

    |   D.clear() -> None. Remove all items from D.

    |

    |   copy(...)

    |   D.copy() -> a shallow copy of D

    |

    |   get(...)

    |   D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

    |

    |   items(...)

    |   D.items() -> list of D's (key, value) pairs, as 2-tuples

    |

    |   iteritems(...)

    |   D.iteritems() -> an iterator over the (key, value) items of D

    |

    |   iterkeys(...)

    |   D.iterkeys() -> an iterator over the keys of D

    |

    |   itervalues(...)

    |   D.itervalues() -> an iterator over the values of D

    |

    |   keys(...)

    |   D.keys() -> list of D's keys

    |

    |   pop(...)

    |   D.pop(k[,d]) -> v, remove specified key and return the corresponding value

    |   If key is not found, d is returned if given, otherwise KeyError is raised

    |

    |   popitem(...)

    |   D.popitem() -> (k, v), remove and return some (key, value) pair as a

    |   2-tuple; but raise KeyError if D is empty

    |

    |   setdefault(...)

    |   D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

    |

    |   update(...)

    |   D.update(E, **F) -> None. Update D from E and F: for k in E: D[k] = E[k]

    |   (if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]

    |

    |   values(...)

    |   D.values() -> list of D's values

    |

    |   ----------------------------------------------------------------------

    |   Data and other attributes inherited from __builtin__.dict:

    |

    |   __new__ = <built-in method __new__ of type object at 0x72b260>

    |   T.__new__(S, ...) -> a new object with type S, a subtype of T

    |

    |   fromkeys = <built-in method fromkeys of type object at 0x88eb50>

    |   dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.

    |   v defaults to None.

class MPDRing(__builtin__.object)

    |   Methods defined here:

    |

    |   __init__(self, listenSock=None, streamHandler=None, secretword='', myIfhn='', entryIfhn='', entryPort=0, zcMyLevel=0)

    |

    |   accept_lhs(self, lhsHandler=None)

    |

    |   accept_rhs(self, rhsHandler=None)

    |

    |   connect_lhs(self, lhsIfhn='', lhsPort=0, lhsHandler=None, numTries=1)

    |

    |   connect_rhs(self, rhsIfhn='', rhsPort=0, rhsHandler=None, numTries=1)

    |

    |   create_single_mem_ring(self, ifhn='', port=0, lhsHandler=None, rhsHandler=None)

    |

    |   enter_ring(self, entryIfhn='', entryPort=0, lhsHandler='', rhsHandler='', ntries=1)

    |

    |   handle_lhs_challenge_response(self, sock)

    |

    |   handle_rhs_challenge_response(self, sock)

    |

    |   handle_ring_listener_connection(self, sock)

    |

    |   reenter_ring(self, entryIfhn='', entryPort=0, lhsHandler='', rhsHandler='', ntries=5)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors defined here:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

class MPDSock(__builtin__.object)

    |   Methods defined here:

    |

    |   __init__(self, family=2, socktype=1, proto=0, sock=None, name='')

    |

    |   accept(self, name='accepter')

    |

    |   close(self)

    |

    |   connect(self, *args)

    |

    |   fileno(self)

    |

    |   getsockname(self)

    |

    |   recv(self, nbytes)

    |

    |   recv_char_msg(self)

    |

    |   recv_dict_msg(self, timeout=None)

    |

    |   recv_one_line(self)

    |

    |   send_char_msg(self, msg, errprint=1)

    |

    |   send_dict_msg(self, msg, errprint=1)

    |   # The default behavior on an error needs to be to handle and/or report

    |   # it. Otherwise, we all waste time trying to figure out why

    |   # the code is silently failing. I've set the default for errprint

    |   # to YES rather than NO.

    |

    |   sendall(self, data)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors defined here:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

class MPDStreamHandler(__builtin__.object)

    |   Methods defined here:

    |

    |   __init__(self)

    |

    |   close_all_active_streams(self)

    |

    |   del_handler(self, stream)

    |

    |   handle_active_streams(self, streams=None, timeout=0.10000000000000001)

    |

    |   set_handler(self, stream, handler, args=())

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors defined here:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

class MPDTest(__builtin__.object)

    |   Methods defined here:

    |

    |   __init__(self)

    |

    |   run(self, cmd='', expIn='', chkEC=0, expEC=0, chkOut=0, expOut='', ordOut=0, grepOut=0, exitOnFail=1)

    |

    |   ----------------------------------------------------------------------

    |   Data descriptors defined here:

    |

    |   __dict__

    |   dictionary for instance variables (if defined)

    |

    |   __weakref__

    |   list of weak references to the object (if defined)

FUNCTIONS
dumps(...) dumps(obj, protocol=0) -- Return a string containing an object in pickle format.

    See the Pickler docstring for the meaning of optional argument proto.

loads(...) loads(string) -- Load a pickle from the given string

md5new = openssl_md5(...) Returns a md5 hash object; optionally initialized with a string

mpd_check_python_version()

mpd_close_zc()

mpd_find_zc_peer(peer_level)

mpd_get_groups_for_username(username)

mpd_get_my_id()

mpd_get_my_username()

mpd_get_ranks_in_binary_tree(myRank, nprocs)

mpd_handle_signal(signum, frame)

mpd_init_zc(ifhn, my_level) #### experimental code for zeroconf

mpd_print(*args)

mpd_print_tb(*args)

mpd_read_nbytes(fd, nbytes)

mpd_register_zc(ifhn, level)

mpd_same_ips(host1, host2)

mpd_set_cli_app(app)

mpd_set_dbg_level(flag)

mpd_set_my_id(myid='')

mpd_set_procedures_to_trace(procs)

mpd_set_tmpdir(tmpdir)

mpd_sockpair()

mpd_trace_calls(frame, event, args)

mpd_trace_returns(frame, event, args)

mpd_uncaught_except_tb(arg1, arg2, arg3)

mpd_version()

mpd_which(execName, user_path=None)

random(...) random() -> x in the interval [0, 1).

sleep(...) sleep(seconds)

    Delay execution for a given number of seconds.
        The argument may be a floating point number for subsecond precision.

DATA
ECONNREFUSED = 111 ECONNRESET = 104 EINTR = 4 EISCONN = 106 EPIPE = 32 grp_module_available = 1 mpd_cli_app = '' mpd_dbg_level = 0 mpd_my_hostname = '' mpd_my_id = '' mpd_procedures_to_trace = [] mpd_signum = 0 mpd_tmpdir = '/tmp' mpd_zc = 0 pwd_module_available = 1 subprocess_module_available = 1 syslog_module_available = 1