def test_reset_character_sequence(self):
"""
Ensure that a sequence can be reset
"""
sequence = CharacterSequence()
for idx in xrange(27): sequence.next()
self.assertEqual(sequence.value, "aa")
sequence.reset()
self.assertEqual(sequence.next(), "a")
def test_reset_character_sequence(self):
"""
Ensure that a sequence can be reset
"""
sequence = CharacterSequence()
for idx in xrange(27):
sequence.next()
self.assertEqual(sequence.value, "aa")
sequence.reset()
self.assertEqual(sequence.next(), "a")
def test_character_sequence_upper(self):
"""
Ensure that uppercase in the character sequence works as expected
"""
letters = 'ABCDEFGHIJKLMNOPQRSTUVWYZ'
sequence = CharacterSequence(upper=True)
self.assertEqual(sequence.next(), 'A')
for idx in xrange(1, 1000):
val = sequence.next()
self.assertEqual(len(val), int(math.log(idx, 26)) + 1)
self.assertEqual(val[-1], letters[idx % 26])
def test_character_sequence(self):
"""
Ensure that an "infinite" character sequence works as expected
"""
letters = 'abcdefghijklmnopqrstuvwxyz'
sequence = CharacterSequence()
self.assertEqual(sequence.next(), 'a')
for idx in xrange(1, 1000):
val = sequence.next()
self.assertEqual(len(val), int(math.log(idx, 26)) + 1)
self.assertEqual(val[-1], letters[idx % 26])
def test_character_sequence_upper(self):
"""
Ensure that uppercase in the character sequence works as expected
"""
letters = 'ABCDEFGHIJKLMNOPQRSTUVWYZ'
sequence = CharacterSequence(upper=True)
self.assertEqual(sequence.next(), 'A')
for idx in xrange(1, 1000):
val = sequence.next()
self.assertEqual(len(val), int(math.log(idx, 26)) + 1)
self.assertEqual(val[-1], letters[idx % 26])
def test_character_sequence(self):
"""
Ensure that an "infinite" character sequence works as expected
"""
letters = 'abcdefghijklmnopqrstuvwxyz'
sequence = CharacterSequence()
self.assertEqual(sequence.next(), 'a')
for idx in xrange(1, 1000):
val = sequence.next()
self.assertEqual(len(val), int(math.log(idx, 26)) + 1)
self.assertEqual(val[-1], letters[idx % 26])
def test_log_index(self):
"""
Test finding the index of a version in a log
"""
versions = CharacterSequence(upper=True)
log = WriteLog()
for term in xrange(5):
for _ in xrange(10):
log.append(versions.next(), term)
versions.reset()
for idx in xrange(1, len(log)):
version = versions.next()
self.assertEqual(log.index(version), idx)
self.assertEqual(log[log.index(version)].version, version)
def test_log_index(self):
"""
Test finding the index of a version in a log
"""
versions = CharacterSequence(upper=True)
log = WriteLog()
for term in xrange(5):
for _ in xrange(10):
log.append(versions.next(), term)
versions.reset()
for idx in xrange(1, len(log)):
version = versions.next()
self.assertEqual(log.index(version), idx)
self.assertEqual(log[log.index(version)].version, version)
def handle(self, args):
"""
Uses built in workloads and the TracesWriter to generate a trace file.
"""
# Disable logging during trace generation
logger = logging.getLogger('cloudscope.simulation')
logger.disabled = True
# Update settings arguments
settings.simulation.conflict_prob = args.conflict
settings.simulation.access_mean = args.access_mean
settings.simulation.access_stddev = args.access_stddev
# Simulation arguments
kwargs = {
'users': args.users,
'objects': args.objects,
'max_sim_time': args.timesteps,
'trace': None,
}
# Create simulation
simulation = ConsistencySimulation.load(args.data[0], **kwargs)
simulation.trace = None
# Create or select the correct simulation
if args.best_case or args.tiered:
workload = BestCaseAllocation(
simulation,
args.objects,
selection='random',
)
workload.allocate_many(args.users)
elif args.ping_pong:
factory = CharacterSequence(upper=True)
objects = [factory.next() for _ in range(args.objects)]
workload = PingPongWorkload(
simulation,
simulation.replicas[:args.users],
objects=objects,
)
else:
simulation.script()
workload = simulation.workload
# Create the traces writer and write the traces to disk
writer = TracesWriter(workload, args.timesteps)
counts = writer.write(args.output)
return (
"traced {rows:,} accesses on {devices:,} devices over {timesteps:,} timesteps ({realtime})\n"
"object space contains {objects:,} object names:\n"
" {mean_objects_per_device:,} average objects per device | "
"{mean_devices_per_object:,} average devices per object\n"
" {mean_accesses_per_device:,} average accesses per device | "
"{mean_accesses_per_object:,} average accesses per object\n"
"wrote the trace file to {0}").format(args.output.name, **counts)
def test_log_remove(self):
"""
Test the remove of an item from a log
"""
log = WriteLog()
versions = CharacterSequence(upper=True)
for term in xrange(5):
for _ in xrange(10):
log.append(versions.next(), term)
loglen = len(log)
versions.reset()
for idx in xrange(1, loglen):
version = versions.next()
self.assertEqual(version, log.remove(version), "log must return the removed version")
self.assertEqual(len(log), loglen-idx, "log must decrease in size")
self.assertNotIn(version, log, "log must not contain version")
def handle(self, args):
"""
Uses built in workloads and the TracesWriter to generate a trace file.
"""
# Disable logging during trace generation
logger = logging.getLogger('cloudscope.simulation')
logger.disabled = True
# Update settings arguments
settings.simulation.conflict_prob = args.conflict
settings.simulation.access_mean = args.access_mean
settings.simulation.access_stddev = args.access_stddev
# Simulation arguments
kwargs = {
'users': args.users,
'objects': args.objects,
'max_sim_time': args.timesteps,
'trace': None,
}
# Create simulation
simulation = ConsistencySimulation.load(args.data[0], **kwargs)
simulation.trace = None
# Create or select the correct simulation
if args.best_case or args.tiered:
workload = BestCaseAllocation(
simulation, args.objects, selection='random',
)
workload.allocate_many(args.users)
elif args.ping_pong:
factory = CharacterSequence(upper=True)
objects = [factory.next() for _ in range(args.objects)]
workload = PingPongWorkload(
simulation, simulation.replicas[:args.users], objects=objects,
)
else:
simulation.script()
workload = simulation.workload
# Create the traces writer and write the traces to disk
writer = TracesWriter(workload, args.timesteps)
counts = writer.write(args.output)
return (
"traced {rows:,} accesses on {devices:,} devices over {timesteps:,} timesteps ({realtime})\n"
"object space contains {objects:,} object names:\n"
" {mean_objects_per_device:,} average objects per device | "
"{mean_devices_per_object:,} average devices per object\n"
" {mean_accesses_per_device:,} average accesses per device | "
"{mean_accesses_per_object:,} average accesses per object\n"
"wrote the trace file to {0}"
).format(args.output.name, **counts)
def test_log_remove(self):
"""
Test the remove of an item from a log
"""
log = WriteLog()
versions = CharacterSequence(upper=True)
for term in xrange(5):
for _ in xrange(10):
log.append(versions.next(), term)
loglen = len(log)
versions.reset()
for idx in xrange(1, loglen):
version = versions.next()
self.assertEqual(version, log.remove(version),
"log must return the removed version")
self.assertEqual(len(log), loglen - idx,
"log must decrease in size")
self.assertNotIn(version, log, "log must not contain version")
class ObjectFactory(object):
"""
Creates a new object class with versioning.
"""
def __init__(self, namespace=None):
self.namespace = namespace or Namespace()
self.counter = CharacterSequence(upper=True)
def __call__(self):
return self.namespace(self.counter.next())
def reset(self):
"""
Resets the namespace
"""
self.namespace.reset()
class ObjectFactory(object):
"""
Creates a new object class with versioning.
"""
def __init__(self, namespace=None):
self.namespace = namespace or Namespace()
self.counter = CharacterSequence(upper=True)
def __call__(self):
return self.namespace(self.counter.next())
def reset(self):
"""
Resets the namespace
"""
self.namespace.reset()
