mpdlib(1)

NAME

mpdlib

FILE

/Users/goodell/svn/mpich2-1.2.1p1-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='', secret
word='', **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, errIfMiss
ingFile=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
0x1eeec0>
| T.__new__(S, ...) -> a new object with type S, a subtype
of T
|
| fromkeys = <built-in method fromkeys of type object at
0x339390>
| 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, lhsHan
dler=None, rhsHandler=None)
|
| enter_ring(self, entryIfhn='', entryPort=0, lhsHan
dler='', 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, lhsHan
dler='', 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, time
out=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 = 61 ECONNRESET = 54 EINTR = 4 EISCONN = 56 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

22 February 2010 mpdlib(1)

Copyright © 2010-2025 Platon Technologies, s.r.o.           Index | Man stránky | tLDP | Dokumenty | Utilitky | O projekte
Design by styleshout