def test_double_lock(self):
node_name = 'goldfish'
user = '******'
node = Node(name=node_name)
node.update(dict(locked=True, locked_by=user))
with pytest.raises(ForbiddenRequestError):
node.update(dict(locked=True, locked_by=user))
def index_post(self):
"""
Create a new node
"""
try:
data = request.json
name = data.get('name')
except ValueError:
rollback()
error('/errors/invalid/', 'could not decode JSON body')
# we allow empty data to be pushed
if not name:
error('/errors/invalid/', "could not find required key: 'name'")
if Node.filter_by(name=name).first():
error('/errors/invalid/',
"Node with name %s already exists" % name)
else:
self.node = Node(name=name)
try:
self.node.update(data)
except PaddlesError as exc:
error(exc.url, str(exc))
log.info("Created {node}: {data}".format(
node=self.node,
data=data,
))
return dict()
def test_basic_deletion(self):
new_node = Node('test_basic_deletion')
models.commit()
new_node.delete()
models.commit()
query = Node.query.filter(Node.name == 'test_basic_deletion')
assert not query.count()
def update_node(self, node_json):
name = node_json['name'].split('@')[1]
query = Node.query.filter(Node.name == name)
if query.count():
node = query.one()
verb = "Updated"
else:
node = Node(name)
verb = "Created"
vm_host_name = node_json.get('vpshost', '')
is_vm = vm_host_name not in (None, '')
if is_vm:
self.vm_hosts[name] = node_json['vpshost']
locked_since_local = datetime.strptime(node_json['locked_since'],
'%Y-%m-%dT%H:%M:%S')
locked_since = local_datetime_to_utc(locked_since_local)
node.machine_type = node_json.get('type')
node.arch = node_json.get('arch')
node.distro = node_json.get('distro')
node.up = bool(node_json.get('up', 0))
node.is_vm = is_vm
node.mac_address = node_json.get('mac').lower()
node.ssh_pub_key = node_json.get('sshpubkey')
node.locked = node_json.get('locked') == 1
node.locked_by = node_json.get('locked_by')
node.locked_since = locked_since
node.description = node_json.get('description')
return verb
def test_init(self):
name = 'test_init'
mtype = 'vps'
Node(name=name, machine_type=mtype)
models.commit()
query = Node.query.filter(Node.name == name)\
.filter(Node.machine_type == mtype)
assert query.one()
def test_locked_since_unlocked(self):
node_name = 'cats'
user = '******'
old_locked_since = datetime(2000, 1, 1, 0, 0)
node = Node(name=node_name)
node.update(dict(locked=True, locked_by=user))
node.locked_since = old_locked_since
node.update(dict(locked=False, locked_by=user))
assert node.locked_since is None
def test_locked_since_locked(self):
node_name = 'cats'
user = '******'
node = Node(name=node_name)
node.update(dict(locked=True, locked_by=user))
# This used to take <100us; since we started flushing on node updates,
# it takes around 2-3ms.
assert (datetime.utcnow() -
node.locked_since) < timedelta(milliseconds=5)
def test_job_adds_node(self):
run_name = 'test_job_adds_node'
node_name = 'added_node'
assert Node.query.filter(Node.name == node_name).all() == []
node = Node(name=node_name)
targets = {'foo@' + node_name: ''}
new_run = Run(run_name)
job = Job(dict(targets=targets), new_run)
assert Node.query.filter(Node.name == node_name).one()
assert Job.query.filter(Job.target_nodes.contains(node)).one() == job
def test_vm_host(self):
vm_host_name = 'vm_host'
vm_guest_names = ['vm_guest_1', 'vm_guest_2']
host_node = Node(name=vm_host_name)
guest_nodes = []
for name in vm_guest_names:
node = Node(name=name)
node.vm_host = host_node
guest_nodes.append(node)
models.commit()
query = Node.query.filter(Node.vm_host == host_node)
assert query.count() == len(vm_guest_names)
# Test that the backref 'vm_guests' works as well. I am intentionally
# testing two things here.
query = Node.query
for guest in guest_nodes:
query = query.filter(Node.vm_guests.contains(guest))
assert host_node == query.one()
def _populate(self, job):
#print "Job: %s/%s" % (job.name, job.job_id)
if not job.targets:
return
for key in job.targets.keys():
name = key.split('@')[1]
mtype = self.parse_machine_type(name)
node_q = Node.query.filter(Node.name == name)
#print " node: exists={count}, name={name}".format(
# count=node_q.count(),
# name=name,
#)
if node_q.count() == 0:
#print " Creating Node with name: %s" % name
node = Node(name=name)
else:
node = node_q.one()
if mtype:
node.machine_type = mtype
if node not in job.target_nodes:
job.target_nodes.append(node)
def test_invalid(self):
name = 'test_invalid'
Node(name=name, is_vm='invalid')
with pytest.raises(StatementError):
models.commit()
def test_basic_creation(self):
Node(name='new_node')
models.commit()
assert Node.get(1).name == 'new_node'
def test_locked_since_locked(self):
node_name = 'cats'
user = '******'
node = Node(name=node_name)
node.update(dict(locked=True, locked_by=user))
assert (datetime.utcnow() - node.locked_since) < timedelta(0, 0, 100)
