def freezify(cls, frameCount=1):
"""Returns a 'frozen' namedtuple type of the given SlotCompare subclass."""
assert issubclass(cls, SlotCompare)
frozenName = 'Frozen' + cls.__name__
# namedtuple constructs the base class.
baseType = namedtuple(frozenName, cls.__slots__)
# Subclass the namedtuple to add a thaw() mixin and to copy read-only
# versions of the thawed class' properties.
frozenDict = {'__slots__': (), '_thawedType': cls}
for name, value in inspect.getmembers(cls):
if isinstance(value, property):
frozenDict[name] = property(value.fget)
frozenType = type(frozenName, (baseType, _Thawable), frozenDict)
# Stash forward and backward type references.
cls._frozenType = frozenType
frozenType._thawedType = cls
# Frozen types are always safe to unpickle.
module = sys._getframe(frameCount).f_globals.get('__name__', '__main__')
frozenType.__module__ = module
chutney.register(frozenType, _force=True)
return frozenType
def slottype(name, attrs):
attrs = attrs.replace(',', ' ').split()
module = sys._getframe(1).f_globals.get('__name__', '__main__')
cls = type(name, (SlotCompare,), {
'__slots__': attrs,
'__module__': module,
})
chutney.register(cls, _force=True)
return cls
@property
def short(self):
return str(self)[24:]
def __copy__(self, memo=None):
return self
__deepcopy__ = __copy__
def __getnewargs__(self):
return None, None, None, None, long(self), None
from rmake.lib import chutney
chutney.register(UUID)
def _find_mac(command, args, hw_identifiers, get_index):
import os
for dir in ['', '/sbin/', '/usr/sbin']:
executable = os.path.join(dir, command)
if not os.path.exists(executable):
continue
try:
# LC_ALL to get English output, 2>/dev/null to
# prevent output on stderr
cmd = 'LC_ALL=C %s %s 2>/dev/null' % (executable, args)
pipe = os.popen(cmd)
except IOError:
def __init__(self, started=None, updated=None, finished=None,
expires_after=None, ticks=-1):
self.started = started
self.updated = updated
self.finished = finished
self.expires_after = expires_after
self.ticks = ticks
FrozenJobTimes = freezify(JobTimes)
class VersionCapability(namedtuple('VersionCapability', 'versions')):
"""Worker supports these protocol versions."""
chutney.register(VersionCapability)
class TaskCapability(namedtuple('TaskCapability', 'taskType')):
"""Worker is capable of running the given task type."""
chutney.register(TaskCapability)
class ZoneCapability(namedtuple('ZoneCapability', 'zoneName')):
"""Worker participates in the given zone."""
chutney.register(ZoneCapability)
class CapabilitySet(object):
def __init__(self, caps=()):
msg.info.sender = jmsg.sender
msg.info.id = jmsg.seq
return msg
def __getstate__(self):
return {'payload': self.payload, 'info': self.info}
def __setstate__(self, state):
self.payload = state['payload']
self.info = state['info']
class MessagePayload(object):
"""Dummy object used as an attribute store for messages."""
chutney.register(MessagePayload)
class MessageInfo(object):
id = None
sender = None
class Event(Message):
"""Event published by the sender and subscribed by the receiver."""
messageType = 'event'
_payload_slots = ('event', 'args', 'kwargs')
def publish(self, publisher):
"""Publish this event to the given "publisher"."""
publisher._send(self.payload.event, self.info, *self.payload.args,
