def on_get(self, req, resp, tenant_id, target_id):
target = Target.get_target(tenant_id, target_id)
if target:
resp.body = self.format_response_body(target.as_dict())
else:
msg = 'Cannot find target: {target_id}'.format(target_id=target_id)
resp.status = falcon.HTTP_404
resp.body = json.dumps({'description': msg})
def can_deserialize_from_a_dictionary(self):
tenant_id = str(uuid.uuid4())
test_target = Target.build_target_from_dict(tenant_id,
self.example_dict)
expect(test_target.id).to.equal(self.example_dict['id'])
expect(test_target.name).to.equal(self.example_dict['name'])
expect(test_target.target_type).to.equal(self.example_dict['type'])
def on_get(self, req, resp, tenant_id, target_id):
target = Target.get_target(tenant_id, target_id)
if target:
resp.body = self.format_response_body(target.as_dict())
else:
msg = 'Cannot find target: {target_id}'.format(target_id=target_id)
resp.status = falcon.HTTP_404
resp.body = json.dumps({'description': msg})
def on_post(self, req, resp, tenant_id):
target_id = str(uuid.uuid4())
body = self.load_body(req, self.validator)
body['id'] = target_id
target = Target.build_target_from_dict(tenant_id, body)
duplicate_target = Target.get_target(tenant_id, target_id=target.name)
if duplicate_target:
raise falcon.exceptions.HTTPConflict(
'Duplicate Target Name',
'Target names must be unique: {0}'.format(target.name))
Target.save_target(target)
resp.status = falcon.HTTP_201
resp.body = self.format_response_body({'target_id': target_id})
def on_post(self, req, resp, tenant_id):
target_id = str(uuid.uuid4())
body = self.load_body(req, self.validator)
body['id'] = target_id
target = Target.build_target_from_dict(tenant_id, body)
duplicate_target = Target.get_target(tenant_id, target_id=target.name)
if duplicate_target:
raise falcon.exceptions.HTTPConflict(
'Duplicate Target Name',
'Target names must be unique: {0}'.format(target.name))
Target.save_target(target)
resp.status = falcon.HTTP_201
resp.body = self.format_response_body({'target_id': target_id})
def execute_action(self, job, action):
# TODO: Replace with actual logging
print('Executing a sample action')
print('Tenant ID: {0}'.format(job.tenant_id))
print('Target IDs: {0}'.format(action.targets))
targets = [Target.get_target(job.tenant_id, target_id)
for target_id in action.targets]
print('Targets: {0}'.format(targets))
print('Type: {0}'.format(action.action_type))
print('Params: {0}'.format(action.parameters))
def execute_action(self, job, action):
# TODO: Replace with actual logging
print('Executing a sample action')
print('Tenant ID: {0}'.format(job.tenant_id))
print('Target IDs: {0}'.format(action.targets))
targets = [
Target.get_target(job.tenant_id, target_id)
for target_id in action.targets
]
print('Targets: {0}'.format(targets))
print('Type: {0}'.format(action.action_type))
print('Params: {0}'.format(action.parameters))
def execute_action(self, job, action):
cmd = action.parameters.get("command")
for target_id in action.targets:
target = Target.get_target(job.tenant_id, target_id)
ip = target.address.address_child
ssh = target.authentication.get("ssh")
creds = SSHKeyCredentials(username=ssh.get("username"), key_contents=ssh.get("private_key"))
client = SSHClient(host=ip.address, port=ip.port, credentials=creds)
client.connect()
LOG.info("Remote command plugin executing: %s", cmd)
resp = client.execute(command=cmd)
client.close()
LOG.info("Remote command plugin execution response: %s", resp)
def on_get(self, req, resp, tenant_id, target_id):
target = Target.get_target(tenant_id, target_id)
if target:
address = target.address
# Nova
if 'nova' in address.as_dict().keys():
nova_address = address.address_child
auth = target.authentication
try:
if 'rackspace' in auth:
cls = get_driver(Provider.RACKSPACE)
cls(auth['rackspace']['username'],
auth['rackspace']['api_key'],
region=nova_address.region.lower())
resp.status = falcon.HTTP_200
else:
raise Exception("No supported providers in target: {0}"
.format(target.as_dict()))
except Exception:
resp.status = falcon.HTTP_404
# SSH
else:
ip = address.address_child
ssh = target.authentication.get('ssh')
creds = SSHKeyCredentials(
username=ssh.get('username'),
key_contents=ssh.get('private_key')
)
client = SSHClient(
host=ip.address,
port=ip.port,
credentials=creds
)
try:
client.connect()
resp.status = falcon.HTTP_200
client.close()
except SSHException:
resp.status = falcon.HTTP_404
else:
msg = 'Cannot find target: {target_id}'.format(target_id=target_id)
resp.status = falcon.HTTP_404
resp.body = json.dumps({'description': msg})
def on_get(self, req, resp, tenant_id, target_id):
target = Target.get_target(tenant_id, target_id)
if target:
address = target.address
# Nova
if 'nova' in address.as_dict().keys():
nova_address = address.address_child
auth = target.authentication
try:
if 'rackspace' in auth:
cls = get_driver(Provider.RACKSPACE)
cls(auth['rackspace']['username'],
auth['rackspace']['api_key'],
region=nova_address.region.lower())
resp.status = falcon.HTTP_200
else:
raise Exception(
"No supported providers in target: {0}".format(
target.as_dict()))
except Exception:
resp.status = falcon.HTTP_404
# SSH
else:
ip = address.address_child
ssh = target.authentication.get('ssh')
creds = SSHKeyCredentials(username=ssh.get('username'),
key_contents=ssh.get('private_key'))
client = SSHClient(host=ip.address,
port=ip.port,
credentials=creds)
try:
client.connect()
resp.status = falcon.HTTP_200
client.close()
except SSHException:
resp.status = falcon.HTTP_404
else:
msg = 'Cannot find target: {target_id}'.format(target_id=target_id)
resp.status = falcon.HTTP_404
resp.body = json.dumps({'description': msg})
def before_each(self):
self.plugin = remote_command.RemoteCommandPlugin()
self.job = stub(tenant_id=lambda: 'test_tenant')
self.paramiko_stub = create_paramiko_client_stub()
self.target = Target.build_target_from_dict(
'test_tenant', {
'id': 'test_id',
'type': 'something',
'address': {
'ip': {
'address': '10.0.0.1',
'port': 21
}
},
'authentication': {
'ssh': {
'username': '******',
'private_key': GARBAGE_PRIVATE_KEY_FOR_TEST,
}
},
'name': 'test_target'
})
def before_each(self):
self.plugin = remote_command.RemoteCommandPlugin()
self.job = stub(tenant_id=lambda: 'test_tenant')
self.paramiko_stub = create_paramiko_client_stub()
self.target = Target.build_target_from_dict(
'test_tenant',
{
'id': 'test_id',
'type': 'something',
'address': {
'ip': {
'address': '10.0.0.1',
'port': 21
}
},
'authentication': {
'ssh': {
'username': '******',
'private_key': GARBAGE_PRIVATE_KEY_FOR_TEST,
}
},
'name': 'test_target'
}
)
def create_target():
return Target.build_target_from_dict(str(uuid4()), example_target_dict())
class TestNovaSoftRebootPlugin(Spec):
def before_each(self):
self.plugin = NovaSoftReboot()
self.job = stub(tenant_id='test_tenant')
self.action = stub(targets=['d8659253-ce8e-48dc-9c93-495fa39fe7ad'])
@patch('rift.plugins.nova.get_driver')
@patch('rift.data.models.target.Target.get_target')
def can_execute_action(self, get_target, get_driver):
target = self.VALID_TARGET
nodes = [
stub(name="my.server.com", reboot=call_recorder(lambda: True)),
stub(name="not.my.server.com", reboot=call_recorder(lambda: True)),
]
driver_stub = self._get_libcloud_driver_stub(nodes)
get_target.return_value = target
get_driver.return_value = driver_stub
self.plugin.execute_action(self.job, self.action)
get_target.assert_called_with(self.job.tenant_id,
self.action.targets[0])
expect(driver_stub.calls).to.equal(
[call('myusername', 'myapikey', region='dfw')])
expect(len(nodes[0].reboot.calls)).to.equal(1)
expect(len(nodes[1].reboot.calls)).to.equal(0)
@patch('rift.plugins.nova.get_driver')
@patch('rift.data.models.target.Target.get_target')
def raises_exception_on_invalid_address(self, get_target, get_driver):
target = self.TARGET_WITH_IP_ADDRESS
driver_stub = self._get_libcloud_driver_stub([])
get_target.return_value = target
get_driver.return_value = driver_stub
expect(self.plugin.execute_action, [self.job, self.action]) \
.to.raise_a(Exception)
@patch('rift.plugins.nova.get_driver')
@patch('rift.data.models.target.Target.get_target')
def raises_exception_on_unsupported_provider(self, get_target, get_driver):
target = self.TARGET_WITH_UNSUPPORTED_PROVIDER
driver_stub = self._get_libcloud_driver_stub([])
get_target.return_value = target
get_driver.return_value = driver_stub
expect(self.plugin.execute_action, [self.job, self.action]) \
.to.raise_a(Exception)
def plugin_returns_a_name(self):
expect(self.plugin.get_name()).to.equal('nova-soft-reboot')
def _get_libcloud_driver_stub(self, nodes):
libcloud_stub = stub(list_nodes=call_recorder(lambda: nodes))
def driver_class(user, key, region):
return libcloud_stub
return call_recorder(driver_class)
VALID_TARGET = Target.build_target_from_dict(
'test_tenant', {
"name": "a valid nova target with rax auth",
"type": "cloud-server",
"address": {
"nova": {
"name": "my.server.com",
"region": "DFW",
}
},
"authentication": {
"rackspace": {
"username": "******",
"api_key": "myapikey"
}
},
})
TARGET_WITH_IP_ADDRESS = Target.build_target_from_dict(
'test_tenant', {
"name": "a nova target with an ip address",
"type": "cloud-server",
"address": {
"ip": {
"address": "127.0.0.1",
"port": 21,
}
},
"authentication": {
"rackspace": {
"username": "******",
"api_key": "myapikey"
}
},
})
TARGET_WITH_UNSUPPORTED_PROVIDER = Target.build_target_from_dict(
'test_tenant', {
"name": "a nova target with invalid auth",
"type": "cloud-server",
"address": {
"nova": {
"name": "my.server.com",
"region": "DFW",
}
},
"authentication": {
"azure": {
"username": "******",
"api_key": "myapikey"
}
},
})
def execute_action(self, job, action):
for target_id in action.targets:
target = Target.get_target(job.tenant_id, target_id)
self._reboot_target(target)
def execute_action(self, job, action):
for target_id in action.targets:
target = Target.get_target(job.tenant_id, target_id)
self._reboot_target(target)
def create_target():
return Target.build_target_from_dict(str(uuid4()), example_target_dict())
def on_get(self, req, resp, tenant_id):
targets = Target.get_targets(tenant_id)
target_list = [target.summary_dict() for target in targets]
resp.body = self.format_response_body({'targets': target_list})
def on_delete(self, req, resp, tenant_id, target_id):
Target.delete_target(target_id=target_id)
def on_delete(self, req, resp, tenant_id, target_id):
Target.delete_target(target_id=target_id)
def on_get(self, req, resp, tenant_id):
targets = Target.get_targets(tenant_id)
target_list = [target.summary_dict() for target in targets]
resp.body = self.format_response_body({'targets': target_list})