def testAttrAndQueryEqual(self):
d1 = clusto.get_by_name('d1')
d2 = clusto.get_by_name('d2')
d3 = clusto.get_by_name('d3')
self.assertEqual(d1.attrs('a'), d1.attr_query('a'))
self.assertEqual(d1.attrs('a', 1), d1.attr_query('a', 1))
self.assertEqual(d1.attrs('a', 1, number=True),
d1.attr_query('a', 1, number=True))
self.assertEqual(d1.attrs('a', 1, number=5),
d1.attr_query('a', 1, number=5))
self.assertEqual(d1.attrs(value='dee'),
d1.attr_query(value='dee'))
self.assertEqual(d1.attrs(value='_foo'),
d1.attr_query(value='_foo'))
self.assertEqual(d1.attrs(key='_foo'),
d1.attr_query(key='_foo'))
self.assertEqual(d1.attrs(key='a', subkey=None),
d1.attr_query(key='a', subkey=None))
self.assertEqual(d1.attrs(value=d2),
d1.attr_query(value=d2))
self.assertEqual(d1.attrs(subkey='z'),
d1.attr_query(subkey='z'))
def testVMDestroy(self):
vmm = clusto.get_by_name("vmm")
vs1 = BasicVirtualServer("vs1")
vs1.set_attr("system", subkey="memory", value=1000)
vs1.set_attr("system", subkey="disk", value=50)
vs1.set_attr("system", subkey="cpucount", value=2)
vs2 = BasicVirtualServer("vs2")
vs2.set_attr("system", subkey="memory", value=5000)
vs2.set_attr("system", subkey="disk", value=50)
vs2.set_attr("system", subkey="cpucount", value=2)
vs3 = BasicVirtualServer("vs3")
vs3.set_attr("system", subkey="memory", value=1000)
vs3.set_attr("system", subkey="disk", value=50)
vs3.set_attr("system", subkey="cpucount", value=1)
s1 = clusto.get_by_name("s1")
s2 = clusto.get_by_name("s2")
vmm.allocate(vs1)
vmm.allocate(vs2)
self.assertRaises(ResourceException, vmm.allocate, vs3)
vmm.deallocate(vs2)
vmm.allocate(vs3)
self.assertEqual([r.value for r in vmm.resources(vs3)], [clusto.get_by_name("s2")])
def get_action(self, request, match):
group = match.groupdict()
try:
obj = clusto.get_by_name(group['name'])
except LookupError:
return Response(status=404, body='404 Not Found\n')
if obj.type != group['objtype']:
response = Response(status=302)
response.headers.add(
'Location',
str('/%s/%s/%s' %
(obj.type, obj.name, group.get('action', ''))))
return response
action = group.get('action', 'show')
handler = self.types.get(group['objtype'], EntityAPI)
if not obj:
obj = clusto.get_by_name(group['name'])
h = handler(obj)
if hasattr(h, action):
f = getattr(h, action)
response = f(request)
else:
response = Response(status=404,
body='404 Not Found\nInvalid action\n')
return response
def testVMManagerAllocate(self):
s1 = clusto.get_by_name("s1")
s2 = clusto.get_by_name("s2")
vs1 = BasicVirtualServer("vs1")
vs1.set_attr("system", subkey="memory", value=1000)
vs1.set_attr("system", subkey="disk", value=50)
vs1.set_attr("system", subkey="cpucount", value=1)
vs2 = BasicVirtualServer("vs2")
vs2.set_attr("system", subkey="memory", value=8000)
vs2.set_attr("system", subkey="disk", value=1000)
vs2.set_attr("system", subkey="cpucount", value=1)
vs3 = BasicVirtualServer("vs3")
vs3.set_attr("system", subkey="memory", value=800)
vs3.set_attr("system", subkey="disk", value=100)
vs3.set_attr("system", subkey="cpucount", value=3)
vmm = clusto.get_by_name("vmm")
vmm.allocate(vs1)
self.assertEqual(len(vmm.resources(vs1)), 1)
self.assert_(vmm.resources(vs1)[0].value in [s1, s2])
vmm.allocate(vs2)
self.assertEqual([r.value for r in vmm.resources(vs2)], [s2])
self.assertRaises(ResourceException, vmm.allocate, vs3)
def testAttrAndQueryEqual(self):
d1 = clusto.get_by_name('d1')
d2 = clusto.get_by_name('d2')
self.assertEqual(d1.attrs('a'), d1.attr_query('a'))
self.assertEqual(d1.attrs('a', 1), d1.attr_query('a', 1))
self.assertEqual(d1.attrs('a', 1, number=True),
d1.attr_query('a', 1, number=True))
self.assertEqual(d1.attrs('a', 1, number=5),
d1.attr_query('a', 1, number=5))
self.assertEqual(d1.attrs(value='dee'), d1.attr_query(value='dee'))
self.assertEqual(d1.attrs(value='_foo'), d1.attr_query(value='_foo'))
self.assertEqual(d1.attrs(key='_foo'), d1.attr_query(key='_foo'))
self.assertEqual(d1.attrs(key='a', subkey=None),
d1.attr_query(key='a', subkey=None))
self.assertEqual(d1.attrs(value=d2), d1.attr_query(value=d2))
self.assertEqual(d1.attrs(subkey='z'), d1.attr_query(subkey='z'))
def testVMDestroy(self):
vmm = clusto.get_by_name('vmm')
vs1 = BasicVirtualServer('vs1')
vs1.set_attr('system', subkey='memory', value=1000)
vs1.set_attr('system', subkey='disk', value=50)
vs1.set_attr('system', subkey='cpucount', value=2)
vs2 = BasicVirtualServer('vs2')
vs2.set_attr('system', subkey='memory', value=5000)
vs2.set_attr('system', subkey='disk', value=50)
vs2.set_attr('system', subkey='cpucount', value=2)
vs3 = BasicVirtualServer('vs3')
vs3.set_attr('system', subkey='memory', value=1000)
vs3.set_attr('system', subkey='disk', value=50)
vs3.set_attr('system', subkey='cpucount', value=1)
s1 = clusto.get_by_name('s1')
s2 = clusto.get_by_name('s2')
vmm.allocate(vs1)
vmm.allocate(vs2)
self.assertRaises(ResourceException, vmm.allocate, vs3)
vmm.deallocate(vs2)
vmm.allocate(vs3)
self.assertEqual([r.value for r in vmm.resources(vs3)],
[clusto.get_by_name('s2')])
def testAddingAndRemovingHosts(self):
s1 = clusto.get_by_name('s1')
s2 = clusto.get_by_name('s2')
s3 = BasicServer('s3')
s3.set_attr('system', subkey='memory', value=16000)
s3.set_attr('system', subkey='disk', value=2500)
s3.set_attr('system', subkey='cpucount', value=2)
vmm = clusto.get_by_name('vmm')
vs1 = BasicVirtualServer('vs1')
vs1.set_attr('system', subkey='memory', value=1000)
vs1.set_attr('system', subkey='disk', value=50)
vs1.set_attr('system', subkey='cpucount', value=2)
self.assertRaises(ResourceException, vmm.allocate, vs1, s3)
vmm.allocate(vs1, s1)
self.assertRaises(ResourceException, vmm.remove, s1)
vmm.deallocate(vs1)
vmm.remove(s1)
vmm.insert(s3)
vmm.allocate(vs1, s3)
def testVMManagerAllocate(self):
s1 = clusto.get_by_name('s1')
s2 = clusto.get_by_name('s2')
vs1 = BasicVirtualServer('vs1')
vs1.set_attr('system', subkey='memory', value=1000)
vs1.set_attr('system', subkey='disk', value=50)
vs1.set_attr('system', subkey='cpucount', value=1)
vs2 = BasicVirtualServer('vs2')
vs2.set_attr('system', subkey='memory', value=8000)
vs2.set_attr('system', subkey='disk', value=1000)
vs2.set_attr('system', subkey='cpucount', value=1)
vs3 = BasicVirtualServer('vs3')
vs3.set_attr('system', subkey='memory', value=800)
vs3.set_attr('system', subkey='disk', value=100)
vs3.set_attr('system', subkey='cpucount', value=3)
vmm = clusto.get_by_name('vmm')
vmm.allocate(vs1)
self.assertEqual(len(vmm.resources(vs1)), 1)
self.assert_(vmm.resources(vs1)[0].value in [s1, s2])
vmm.allocate(vs2)
self.assertEqual([r.value for r in vmm.resources(vs2)], [s2])
self.assertRaises(ResourceException, vmm.allocate, vs3)
def testfqdn(self):
s1 = clusto.get_by_name('bs1')
s2 = clusto.get_by_name('bs2')
self.assertEqual(s1.fqdns, [])
s2.add_fqdn("test.example.com")
self.assertEqual(["test.example.com"],
s2.fqdns)
s2.add_fqdn("test2.example.com")
clusto.flush()
self.assertEqual(sorted(["test.example.com",
"test2.example.com"]),
sorted(s2.fqdns))
s2.remove_fqdn("test.example.com")
self.assertEqual(["test2.example.com"],
s2.fqdns)
def testfqdn(self):
s1 = clusto.get_by_name('bs1')
s2 = clusto.get_by_name('bs2')
self.assertEqual(s1.fqdns, [])
s2.add_fqdn("test.example.com")
self.assertEqual(["test.example.com"],
s2.fqdns)
s2.add_fqdn("test2.example.com")
clusto.flush()
self.assertEqual(sorted(["test.example.com",
"test2.example.com"]),
sorted(s2.fqdns))
s2.remove_fqdn("test.example.com")
self.assertEqual(["test2.example.com"],
s2.fqdns)
def get(name, driver=None):
"""
Tries to fetch a clusto object from a given name, optionally validating
the driver given. Returns:
* HTTP Error 404 if the object could not be found
* HTTP Error 409 if the object does not match the expected driver
* Clusto object otherwise
"""
status = None
obj = None
msg = None
if driver and driver not in clusto.driverlist:
status = 412
msg = u'The driver "%s" is not a valid driver' % (driver,)
else:
try:
if driver:
obj = clusto.get_by_name(name, assert_driver=clusto.driverlist[driver])
else:
obj = clusto.get_by_name(name)
except LookupError as le:
status = 404
msg = u'Object "%s" not found (%s)' % (name, str(le),)
except TypeError:
status = 409
msg = u'The driver for object "%s" is not "%s"' % (name, driver,)
return obj, status, msg
def testAddingAndRemovingHosts(self):
s1 = clusto.get_by_name("s1")
s2 = clusto.get_by_name("s2")
s3 = BasicServer("s3")
s3.set_attr("system", subkey="memory", value=16000)
s3.set_attr("system", subkey="disk", value=2500)
s3.set_attr("system", subkey="cpucount", value=2)
vmm = clusto.get_by_name("vmm")
vs1 = BasicVirtualServer("vs1")
vs1.set_attr("system", subkey="memory", value=1000)
vs1.set_attr("system", subkey="disk", value=50)
vs1.set_attr("system", subkey="cpucount", value=2)
self.assertRaises(ResourceException, vmm.allocate, vs1, s3)
vmm.allocate(vs1, s1)
self.assertRaises(ResourceException, vmm.remove, s1)
vmm.deallocate(vs1)
vmm.remove(s1)
vmm.insert(s3)
vmm.allocate(vs1, s3)
def testBindingIPtoOSPort(self):
s1 = clusto.get_by_name('bs1')
s2 = clusto.get_by_name('bs2')
ipm = IPManager('ipman', netmask='255.255.255.0', baseip='192.168.1.0')
s1.bind_ip_to_osport('192.168.1.20', 'eth0', porttype='nic-eth', portnum=1)
def testBasicServerCreation(self):
s1 = clusto.get_by_name('bs1')
s2 = clusto.get_by_name('bs2')
self.assertEqual(s1.model, '7000')
self.assertEqual(s1.manufacturer, 'ibm')
self.assertEqual(s2.model, 'ab1200')
self.assertEqual(s2.manufacturer, 'sun')
def testAllocateManyNames(self):
ngen = clusto.get_by_name('foonamegen')
for i in xrange(50):
ngen.allocate(Driver)
self.assertRaises(LookupError, clusto.get_by_name, 'foo0051')
self.assertEqual(clusto.get_by_name('foo0050').name, 'foo0050')
def testAllocateManyNames(self):
ngen = clusto.get_by_name('foonamegen')
for i in xrange(50):
ngen.allocate(Driver)
self.assertRaises(LookupError, clusto.get_by_name, 'foo0051')
self.assertEqual(clusto.get_by_name('foo0050').name, 'foo0050')
def testBasicServerCreation(self):
s1 = clusto.get_by_name('bs1')
s2 = clusto.get_by_name('bs2')
self.assertEqual(s1.model, '7000')
self.assertEqual(s1.manufacturer, 'ibm')
self.assertEqual(s2.model, 'ab1200')
self.assertEqual(s2.manufacturer, 'sun')
def lookup(self, name):
try:
server = clusto.get_by_name(name)
return server
except LookupError:
try:
server = clusto.get_by_name(name.split('.', 1)[0])
return server
except LookupError:
return False
def testNamedDriverCreation(self):
ngen = clusto.get_by_name('foonamegen')
s1 = ngen.allocate(Driver)
clusto.flush()
d1 = clusto.get_by_name('foo0001')
self.assertEquals(s1.name, d1.name)
def testTransactionRollback3(self):
d1 = Entity('d1')
clusto.begin_transaction()
d2 = Entity('d2')
clusto.rollback_transaction()
clusto.get_by_name('d1')
self.assertRaises(LookupError, clusto.get_by_name, 'd2')
def testBindingIPtoOSPort(self):
s1 = clusto.get_by_name('bs1')
s2 = clusto.get_by_name('bs2')
ipm1 = IPManager('ipman1', netmask='255.255.255.0', baseip='192.168.1.0')
ipm2 = IPManager('ipman2', netmask='255.255.255.0', baseip='192.168.2.0')
s1.bind_ip_to_osport('192.168.1.20', 'eth0', porttype='nic-eth', portnum=1)
s1.bind_ip_to_osport('192.168.2.20', 'eth1', porttype='nic-eth', portnum=2)
def testNamedDriverCreation(self):
ngen = clusto.get_by_name('foonamegen')
s1 = ngen.allocate(Driver)
clusto.flush()
d1 = clusto.get_by_name('foo0001')
self.assertEquals(s1.name, d1.name)
def testTransactionRollback3(self):
d1 = Entity('d1')
clusto.begin_transaction()
d2 = Entity('d2')
clusto.rollback_transaction()
clusto.get_by_name('d1')
self.assertRaises(LookupError, clusto.get_by_name, 'd2')
def testGetByNames(self):
names = ['e3','e1','e2']
entities = [clusto.get_by_name(x) for x in names]
self.assertEqual(entities, clusto.get_by_names(names))
self.assertEqual([clusto.get_by_name('e3'),
None,
clusto.get_by_name('e1')],
clusto.get_by_names(['e3', 'shouldfail', 'e1']))
def testTransactionCommit(self):
try:
clusto.begin_transaction()
c1 = Entity('c1')
clusto.commit()
except Exception:
clusto.rollback_transaction()
clusto.get_by_name('c1')
def testGetByNames(self):
names = ['e3', 'e1', 'e2']
entities = [clusto.get_by_name(x) for x in names]
self.assertEqual(entities, clusto.get_by_names(names))
self.assertEqual(
[clusto.get_by_name('e3'), None,
clusto.get_by_name('e1')],
clusto.get_by_names(['e3', 'shouldfail', 'e1']))
def testTransactionCommit(self):
try:
clusto.begin_transaction()
c1 = Entity('c1')
clusto.commit()
except Exception:
clusto.rollback_transaction()
clusto.get_by_name('c1')
def testPoolCreate(self):
p3 = Pool('p3')
d3 = Driver('d3')
clusto.flush()
q = clusto.get_by_name('p3')
self.assertTrue(isinstance(q, Pool))
self.assertFalse(isinstance(clusto.get_by_name('d3'), Pool))
def testPoolCreate(self):
p3 = Pool('p3')
d3 = Driver('d3')
clusto.flush()
q = clusto.get_by_name('p3')
self.assertTrue(isinstance(q, Pool))
self.assertFalse(isinstance(clusto.get_by_name('d3'), Pool))
def testServerRackLocation(self):
r = clusto.get_by_name('r1')
s = clusto.get_by_name('s1')
self.assertEqual(BasicRack.get_rack_and_u(s)['RU'], [1])
self.assertEqual(r.get_device_in(12), clusto.get_by_name('sw1'))
self.assertEqual(r.get_device_in(10), clusto.get_by_name('p1'))
self.assertEqual(r.get_device_in(11), clusto.get_by_name('p1'))
def testBadRollback(self):
clusto.begin_transaction()
d1 = Entity('d1')
clusto.get_by_name('d1')
d2 = Entity('d2')
clusto.commit()
self.assertRaises(TransactionException, clusto.rollback_transaction)
def testBadRollback(self):
clusto.begin_transaction()
d1 = Entity('d1')
clusto.get_by_name('d1')
d2 = Entity('d2')
clusto.commit()
self.assertRaises(TransactionException, clusto.rollback_transaction)
def testEntityRename(self):
curver = clusto.get_latest_version_number()
e1 = Entity('e1')
e1.add_attr('foo',1)
e1.add_attr('foo',2)
e1attrs = [a.to_tuple for a in e1.attrs]
midver = clusto.get_latest_version_number()
clusto.rename('e1', 't1')
postrenamever = clusto.get_latest_version_number()
t1 = clusto.get_by_name('t1')
self.assertEqual(sorted(e1attrs),
sorted([a.to_tuple for a in t1.entity.attrs]))
t1.del_attrs('foo', 2)
self.assertRaises(LookupError, clusto.get_by_name, 'e1')
self.assertEqual(sorted(t1.attrs('foo',1)),
sorted(t1.attrs()))
SESSION.clusto_version = midver
self.assertRaises(LookupError, clusto.get_by_name, 't1')
e = clusto.get_by_name('e1')
self.assertEqual(sorted(e1attrs),
sorted([a.to_tuple for a in e.attrs()]))
for a in e.attrs():
self.assertEqual(e.entity.deleted_at_version,
a.deleted_at_version)
SESSION.clusto_version = postrenamever
self.assertEqual(e.entity.deleted_at_version,
t1.entity.version)
for a in t1.attrs():
self.assertEqual(e.entity.deleted_at_version,
a.version)
def test_log_event_creation(self):
l = LogEvent(source_entity = self.host,
user="******",
event_type=clusto.get_by_name("test event"),
timestamp=datetime.datetime.utcnow(),
description="test description",
test_param = "test")
self.assertEquals(l.source_entity, self.host)
self.assertEquals(l.user, "test")
self.assertEquals(l.event_type, clusto.get_by_name("test event"))
self.assertEquals(type(l.timestamp), datetime.datetime)
self.assertEquals(l.description, "test description")
self.assertEquals(l.test_param, "test")
self.assertRaises(TypeError, LogEvent)
def testServerRackLocation(self):
r = clusto.get_by_name('r1')
s = clusto.get_by_name('s1')
self.assertEqual(BasicRack.get_rack_and_u(s)['RU'], [1])
self.assertEqual(r.get_device_in(12),
clusto.get_by_name('sw1'))
self.assertEqual(r.get_device_in(10),
clusto.get_by_name('p1'))
self.assertEqual(r.get_device_in(11),
clusto.get_by_name('p1'))
def testReservingResource(self):
s1 = clusto.get_by_name('s1')
s2 = clusto.get_by_name('s2')
vmm = clusto.get_by_name('vmm')
vs1 = BasicVirtualServer('vs1')
vs1.set_attr('system', subkey='memory', value=1000)
vs1.set_attr('system', subkey='disk', value=50)
vs1.set_attr('system', subkey='cpucount', value=2)
vmm.allocate(vmm, s1)
self.assertRaises(ResourceException, vmm.allocate, vs1, s1)
def testReservingResource(self):
s1 = clusto.get_by_name("s1")
s2 = clusto.get_by_name("s2")
vmm = clusto.get_by_name("vmm")
vs1 = BasicVirtualServer("vs1")
vs1.set_attr("system", subkey="memory", value=1000)
vs1.set_attr("system", subkey="disk", value=50)
vs1.set_attr("system", subkey="cpucount", value=2)
vmm.allocate(vmm, s1)
self.assertRaises(ResourceException, vmm.allocate, vs1, s1)
def testDeleteVersion(self):
curver = clusto.get_latest_version_number()
e1 = Entity('e1')
etest = clusto.get_by_name('e1')
e1.delete()
self.assertRaises(LookupError, clusto.get_by_name, 'e1')
e1a = Entity('e1')
etest = clusto.get_by_name('e1')
self.assertEqual(etest.entity.version, curver + 3)
def testPoolDelete(self):
p5 = Pool('p5')
d1 = clusto.get_by_name('d1')
p5.insert(d1)
clusto.flush()
self.assertTrue(isinstance(clusto.get_by_name('p5'), Pool))
clusto.get_by_name('p5').entity.delete()
clusto.flush()
self.assertRaises(LookupError, clusto.get_by_name, 'p5')
def testPoolsIterator(self):
A = Pool('A')
d1, d2 = [clusto.get_by_name(i) for i in ['d1', 'd2']]
B = Pool('B')
C = Pool('C')
A1 = Pool('A1')
B2 = Pool('B2')
B1 = Pool('B1')
C1 = Pool('C1')
C1.insert(C)
B1.insert(B)
A1.insert(B)
A1.insert(A)
B2.insert(A)
A.insert(d1)
B.insert(d1)
C.insert(d1)
clusto.flush()
self.assertEqual([x.name for x in Pool.get_pools(d1)],
[u'A', u'B', u'C', u'A1', u'B2', u'B1', u'A1', u'C1'])
self.assertEqual([x.name for x in Pool.get_pools(d1, allPools=False)],
[u'A', u'B', u'C'])
def __init__(self, source_entity, user, event_type, timestamp, description=None, **kwargs):
"""Create a new LogEvent instance
Keyword arguments:
source_entity -- the source entity that is associated with the log event
user -- the user that triggered the log event
event_type -- the type of event that occured
time_stamp -- the datetime when the log event occured
description -- the string describing the event (default None)
"""
try:
name_manager = clusto.get_by_name("LogEvent_name_manager")
except LookupError:
name_manager = SimpleNameManager("LogEvent_name_manager", basename="Log", digits=10)
try:
clusto.begin_transaction()
name, num = name_manager.allocator()
super(LogEvent, self).__init__(name, event_type = event_type,
source_entity =source_entity,
timestamp = timestamp,
user = user,
description = description)
name_manager.allocate(self, name)
for key in kwargs:
self.add_attr(key=key, value=kwargs[key])
clusto.commit()
except:
clusto.rollback_transaction()
raise
def testRackContents(self):
rackname = 'ashrack101'
rack = Rack(rackname)
t1 = Thing('t1')
t2 = Thing('t2')
t3 = Thing('t3')
rack.addToRack(t3, [1, 2])
rack.addToRack(t2, [32])
rack.addToRack(t1, [23, 24, 25])
clusto.flush()
contents = rack.getRackContents()
self.assert_(contents[1].name == contents[2].name == 't3')
self.assert_(contents[32].name == 't2')
self.assert_(
contents[23].name == contents[24].name == contents[25].name == 't1'
)
t1.delete()
clusto.flush()
rack = clusto.get_by_name(rackname)
contents = rack.getRackContents()
clusto.flush()
self.assertEqual(len(contents), 3)
def setattr(self, request):
'''
Set an attribute on this object.
Requires HTTP parameters "key" and "value"
Optional parameters are "subkey", "number" and "datatype"
where "datatype" could be "relation", "int" or string by default
'''
kwargs = dict(request.params.items())
datatype = kwargs.get('datatype', None)
kwargs.pop('datatype', None)
if datatype == 'relation':
try:
kwargs['value'] = clusto.get_by_name(kwargs['value'].rsplit('/', 1)[1])
except LookupError:
return Response(status=400, body='400 Element Not Found\n')
elif datatype == 'int':
kwargs['value'] = int(kwargs['value'])
else:
kwargs['value'] = str(kwargs['value'])
if 'number' in kwargs:
kwargs['number'] = int(kwargs['number'])
self.obj.set_attr(**kwargs)
return self.show(request)
def run(self, args):
try:
obj = clusto.get_by_name(args.oldname[0])
except LookupError, e:
self.debug(e)
self.error('"%s" does not exist' % args.oldname[0])
return -1
def _get_pool(self, pool):
p = clusto.get_by_name(pool)
self.debug('%s is %s' % (pool, p))
if not p or not isinstance(p, clusto.drivers.pool.Pool):
self.error('The pool "%s" does not exist or is not a pool' % pool)
return False
return p
def testAllocateGivenName(self):
ngen = clusto.get_by_name('foonamegen')
d = ngen.allocate(Driver, 'testname')
self.assertEqual(d.name, 'testname')
def testAddingToRack(self):
r1 = clusto.get_by_name('r1')
s1 = BasicServer('s1')
r1.insert(s1, 1)
rt = clusto.get_by_name('r1')
st = clusto.get_by_name('s1')
self.assertEqual(len(r1.contents(subkey='ru')), 1)
self.assertEqual(r1.contents(subkey='ru')[0].name, 's1')
self.assertEqual(s1.parents(clusto_drivers=[BasicRack])[0].name, 'r1')
def run(self, args):
"Main run method"
objects = []
for _ in args.instances:
try:
objects.append(clusto.get_by_name(_))
except LookupError:
self.warn('Could not find instance %s in the clusto database' % (_,))
if args.command == 'create':
self.info('Creating clusto object for %s' % (_,))
objects.append(self._instance_driver(_))
except Exception as e:
self.critical(e)
return
kwargs = dict(args.__dict__.items())
for _ in ('command', 'config', 'dsn', 'loglevel', 'instances',):
kwargs.pop(_)
kwargs['objects'] = objects
self.debug(kwargs)
# Only the create command should (and in fact, *must*) receive an empty list of objects
if not objects:
self.error('Cannot run with an empty list of instances')
return 1
return (getattr(self, 'run_%s' % (args.command, ))(**kwargs))
def testDeleteVersion(self):
curver = clusto.get_latest_version_number()
e1 = Entity('e1')
etest = clusto.get_by_name('e1')
e1.delete()
self.assertRaises(LookupError, clusto.get_by_name, 'e1')
e1a = Entity('e1')
etest = clusto.get_by_name('e1')
self.assertEqual(etest.entity.version, curver+3)
def testTransactionRollback2(self):
try:
clusto.begin_transaction()
c1 = Entity('c1')
raise Exception()
except Exception:
clusto.rollback_transaction()
c2 = Entity('c2')
self.assertRaises(LookupError, clusto.get_by_name, 'c1')
clusto.get_by_name('c2')
def testTransactionRollback2(self):
try:
clusto.begin_transaction()
c1 = Entity('c1')
raise Exception()
except Exception:
clusto.rollback_transaction()
c2 = Entity('c2')
self.assertRaises(LookupError, clusto.get_by_name, 'c1')
clusto.get_by_name('c2')
def testRackContents(self):
rackname = 'ashrack101'
rack = Rack(rackname)
t1 = Thing('t1')
t2 = Thing('t2')
t3 = Thing('t3')
rack.addToRack(t3, [1,2])
rack.addToRack(t2, [32])
rack.addToRack(t1, [23,24,25])
clusto.flush()
contents = rack.getRackContents()
self.assert_(contents[1].name == contents[2].name =='t3')
self.assert_(contents[32].name == 't2')
self.assert_(contents[23].name == contents[24].name
== contents[25].name == 't1')
t1.delete()
clusto.flush()
rack = clusto.get_by_name(rackname)
contents = rack.getRackContents()
clusto.flush()
self.assertEqual(len(contents), 3)
def update_clusto(trap):
ts = strftime('[%Y-%m-%d %H:%M:%S]')
if trap['operation'] != 1:
return
if not trap['mac'].startswith('00'):
return
switch = IPManager.get_devices(trap['switch'])
if not switch:
log.warning('Unknown trap source: %s' % trap['switch'])
return
else:
switch = switch[0]
if not switch.attrs(
key='snmp', subkey='discovery', value=1,
merge_container_attrs=True):
log.debug(
'key=snmp, subkey=discovery for %s not set to 1, ignoring trap' %
switch.name)
return
rack = switch.parents(clusto_types=['rack'])[0]
try:
factory = rackfactory.get_factory(rack.name)
if not factory:
log.warning('Unable to locate rack factory for %s' % rack.name)
return
except:
log.error(format_exc())
return
server = switch.get_connected('nic-eth', trap['port'])
if not server:
servernames = clusto.get_by_name('servernames')
clusto.SESSION.clusto_description = 'SNMP allocate new server'
driver = factory.get_driver(trap['port'])
server = servernames.allocate(driver)
log.info('Created new %s on %s port %s: %s' %
(driver.__name__, trap['switch'], trap['port'], server.name))
try:
clusto.begin_transaction()
if not trap['mac'] in server.attr_values(
key='bootstrap', subkey='mac', value=trap['mac']):
log.debug('Adding bootstrap mac to', server.name)
server.add_attr(key='bootstrap', subkey='mac', value=trap['mac'])
factory.add_server(server, trap['port'])
switch.set_port_attr('nic-eth', trap['port'], 'vlan', trap['vlan'])
clusto.SESSION.clusto_description = 'SNMP update MAC and connections on %s' % server.name
clusto.commit()
except:
log.error(format_exc())
clusto.rollback_transaction()
log.debug(repr(trap))
def __init__(self, name_driver_entity, **kwargs):
if not isinstance(name_driver_entity, (str, unicode, Entity, Driver)):
raise TypeError("First argument must be a string, "
"Driver, or Entity.")
if isinstance(name_driver_entity, Driver):
return
if isinstance(name_driver_entity, Entity):
self.entity = name_driver_entity
self._choose_best_driver()
return
elif isinstance(name_driver_entity, (str, unicode)):
try:
existing = clusto.get_by_name(name_driver_entity)
except LookupError, x:
existing = None
if existing:
raise NameException("Driver with the name %s already exists."
% (name_driver_entity))
self.entity = Entity(name_driver_entity,
driver=self._driver_name,
clustotype=self._clusto_type)
def _get_pool(self, pool):
p = clusto.get_by_name(pool)
self.debug('%s is %s' % (pool, p))
if not p or not isinstance(p, clusto.drivers.pool.Pool):
self.error('The pool "%s" does not exist or is not a pool')
return False
return p
def testAllocateGivenName(self):
ngen = clusto.get_by_name('foonamegen')
d = ngen.allocate(Driver, 'testname')
self.assertEqual(d.name, 'testname')
def testPoolsIterator(self):
A = Pool('A')
d1, d2 = [clusto.get_by_name(i) for i in ['d1', 'd2']]
B = Pool('B')
C = Pool('C')
A1 = Pool('A1')
B2 = Pool('B2')
B1 = Pool('B1')
C1 = Pool('C1')
C1.insert(C)
B1.insert(B)
A1.insert(B)
A1.insert(A)
B2.insert(A)
A.insert(d1)
B.insert(d1)
C.insert(d1)
clusto.flush()
self.assertEqual([x.name for x in Pool.get_pools(d1)],
[u'A', u'B', u'C', u'A1', u'B2', u'B1', u'A1', u'C1'])
self.assertEqual([x.name for x in Pool.get_pools(d1, allPools=False)],
[u'A', u'B', u'C'])
def run(self, args):
serverset = None
for pool in args.pool:
pool = clusto.get_by_name(pool)
contents = pool.contents(search_children=args.recursive)
if args.type:
contents = [x for x in contents if x.type == args.type]
contents = set(contents)
if serverset is None:
serverset = contents
else:
serverset = serverset.intersection(pool)
for server in serverset:
if args.names:
print server.name
else:
try:
ip = server.get_ips()
ip.sort(key=lambda x: IP(x))
except Exception, e:
self.debug(e)
ip = None
if ip:
print ' '.join(ip)
else:
print server.name
