def setUp(self):
config = self.mock_config.return_value
test_site_config = config.TestSite
test_site_config.end_point = 'https://test.cloudstack.local/compute'
test_site_config.api_key = '1234567890abcdef'
test_site_config.api_secret = 'fedcba0987654321'
test_site_config.MachineTypeConfiguration = \
AttributeDict(test2large=AttributeDict(templateid="1b0b9253-929e-4865-874b-7d2c3491987b",
serviceofferingid="74bfaf4e-7d67-4adf-9322-12b9a36e84f7",
zoneid="35eb7739-d19e-45f7-a581-4687c54d6d02",
keypair="MG",
rootdisksize=500))
test_site_config.MachineMetaData = AttributeDict(
test2large=AttributeDict(Cores=128))
cloudstack_api = self.mock_cloudstack_api.return_value
self.deploy_return_value = AttributeDict(virtualmachine=AttributeDict(
name='testsite-089123', id='123456', state='Present'))
cloudstack_api.deployVirtualMachine.return_value = async_return(
return_value=self.deploy_return_value)
self.list_vm_return_value = AttributeDict(virtualmachine=[
AttributeDict(name='testsite-089123', id='123456', state='Running')
])
cloudstack_api.listVirtualMachines.return_value = async_return(
return_value=self.list_vm_return_value)
cloudstack_api.stopVirtualMachine.return_value = async_return(
return_value=None)
cloudstack_api.destroyVirtualMachine.return_value = async_return(
return_value=None)
self.cloudstack_adapter = CloudStackAdapter(machine_type='test2large',
site_name='TestSite')
def test_get_resource_state(self):
self.clear_lru_cache()
self.mock_crud.get_resource_state.return_value = async_return(
return_value=[{
"drone_uuid": "test-0123456789",
"state": "AvailableState"
}])
response = run_async(self.client.get,
"/resources/test-0123456789/state",
headers=self.headers)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"drone_uuid": "test-0123456789",
"state": "AvailableState"
},
)
self.mock_crud.get_resource_state.return_value = async_return(
return_value=[])
response = run_async(self.client.get,
"/resources/test-1234567890/state",
headers=self.headers)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.json(), {"detail": "Drone not found"})
response = run_async(self.client.get,
"/resources/test-invalid/state",
headers=self.headers)
self.assertEqual(response.status_code, 422)
self.assertEqual(
response.json(),
{
"detail": [{
"ctx": {
"pattern": "^\\S+-[A-Fa-f0-9]{10}$"
},
"loc": ["path", "drone_uuid"],
"msg":
'string does not match regex "^\\S+-[A-Fa-f0-9]{10}$"',
"type": "value_error.str.regex",
}]
},
)
response = run_async(self.client.get,
"/resources/state",
headers=self.headers)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.json(), {"detail": "Not Found"})
def setUp(self):
self.cpu_ratio = 0.5
self.memory_ratio = 0.25
self.command = 'sinfo --Format="statelong,cpusstate,allocmem,memory,features,nodehost" -e --noheader -r --partition=test_part' # noqa B950
self.command_wo_options = 'sinfo --Format="statelong,cpusstate,allocmem,memory,features,nodehost" -e --noheader -r' # noqa B950
return_value = "\n".join([
"mixed 2/2/0/4 6000 24000 VM-1 host-10-18-1-1",
"mixed 3/1/0/4 15853 22011 VM-2 host-10-18-1-2",
"mixed 1/3/0/4 18268 22011 VM-3 host-10-18-1-4",
"mixed 3/1/0/4 17803 22011 VM-4 host-10-18-1-7",
"draining 0/4/0/4 17803 22011 draining_m draining_m",
"idle 0/4/0/4 17803 22011 idle_m idle_m",
"drained 0/4/0/4 17803 22011 drained_m drained_m",
"powerup 0/4/0/4 17803 22011 pwr_up_m pwr_up_m",
])
self.mock_async_run_command.return_value = async_return(
return_value=return_value)
self.setup_config_mock(
options=AttributeDict({"long": {
"partition": "test_part"
}}))
self.slurm_adapter = SlurmAdapter()
def setUp(self):
self.cpu_ratio = 0.9
self.memory_ratio = 0.8
self.command = "condor_status -af:t Machine State Activity TardisDroneUuid " \
"'Real(TotalSlotCpus-Cpus)/TotalSlotCpus' " \
"'Real(TotalSlotCpus-Cpus)/TotalSlotCpus' -constraint PartitionableSlot=?=True" \
" -pool my-htcondor.local -test"
self.command_wo_options = "condor_status -af:t Machine State Activity TardisDroneUuid " \
"'Real(TotalSlotCpus-Cpus)/TotalSlotCpus' " \
"'Real(TotalSlotCpus-Cpus)/TotalSlotCpus' -constraint PartitionableSlot=?=True"
return_value = "\n".join([
f"test\tUnclaimed\tIdle\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}",
f"test_drain\tDrained\tRetiring\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}",
f"test_drained\tDrained\tIdle\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}",
f"test_owner\tOwner\tIdle\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}",
f"test_uuid_plus\tUnclaimed\tIdle\ttest_uuid\t{self.cpu_ratio}\t{self.memory_ratio}",
"exoscale-26d361290f\tUnclaimed\tIdle\tundefined\t0.125\t0.125"
])
self.mock_async_run_command.return_value = async_return(
return_value=return_value)
self.config = self.mock_config.return_value
self.config.BatchSystem.ratios = {
'cpu_ratio': 'Real(TotalSlotCpus-Cpus)/TotalSlotCpus',
'memory_ratio': 'Real(TotalSlotCpus-Cpus)/TotalSlotCpus'
}
self.config.BatchSystem.max_age = 10
self.config.BatchSystem.options = {
'pool': 'my-htcondor.local',
'test': None
}
self.htcondor_adapter = HTCondorAdapter()
def test_get_resources(self):
self.clear_lru_cache()
full_expected_resources = [
{
"remote_resource_uuid": "14fa5640a7c146e482e8be41ec5dffea",
"state": "AvailableState",
"drone_uuid": "test-0125bc9fd8",
"site_name": "Test",
"machine_type": "m1.test",
"created": "2021-10-08T12:42:16.354400",
"updated": "2021-10-08T12:42:28.382025",
},
{
"remote_resource_uuid": "b3efcc5bc8b741af9222987e0434ca61",
"state": "AvailableState",
"drone_uuid": "test-6af3cfef14",
"site_name": "Test",
"machine_type": "m1.test",
"created": "2021-10-08T12:42:16.373454",
"updated": "2021-10-08T12:42:30.648325",
},
]
self.mock_crud.get_resources.return_value = async_return(
return_value=full_expected_resources)
response = run_async(self.client.get,
"/resources/",
headers=self.headers)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
full_expected_resources,
)
def setUp(self):
self.cpu_ratio = 0.9
self.memory_ratio = 0.8
self.command = (
"condor_status -af:t Machine Name State Activity TardisDroneUuid "
"'Real(TotalSlotCpus-Cpus)/TotalSlotCpus' "
"'Real(TotalSlotMemory-Memory)/TotalSlotMemory' -constraint PartitionableSlot=?=True" # noqa: B950
" -pool my-htcondor.local -test")
self.command_wo_options = (
"condor_status -af:t Machine Name State Activity TardisDroneUuid "
"'Real(TotalSlotCpus-Cpus)/TotalSlotCpus' "
"'Real(TotalSlotMemory-Memory)/TotalSlotMemory' -constraint PartitionableSlot=?=True" # noqa: B950
)
return_value = "\n".join([
f"test\tslot1@test\tUnclaimed\tIdle\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}", # noqa: B950
f"test_drain\tslot1@test\tDrained\tRetiring\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}", # noqa: B950
f"test_drained\tslot1@test\tDrained\tIdle\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}", # noqa: B950
f"test_owner\tslot1@test\tOwner\tIdle\tundefined\t{self.cpu_ratio}\t{self.memory_ratio}", # noqa: B950
f"test_uuid_plus\tslot1@test_uuid@test\tUnclaimed\tIdle\ttest_uuid\t{self.cpu_ratio}\t{self.memory_ratio}", # noqa: B950
"exoscale-26d361290f\tslot1@exoscale-26d361290f\tUnclaimed\tIdle\tundefined\t0.125\t0.125", # noqa: B950
])
self.mock_async_run_command.return_value = async_return(
return_value=return_value)
self.setup_config_mock(options={
"pool": "my-htcondor.local",
"test": None
})
self.htcondor_adapter = HTCondorAdapter()
def update_read_return(self, replicas, available_replicas):
kubernetes_api = self.mock_kubernetes_api.return_value
self.read_return_value.spec.replicas = replicas
self.read_return_value.status.available_replicas = available_replicas
kubernetes_api.read_namespaced_deployment.return_value = async_return(
return_value=self.read_return_value
)
def test_run_command(self):
self.assertIsNone(run_async(self.executor.run_command, command="Test").stdout)
self.mock_asyncssh.connect.assert_called_with(
host="test_host", username="******", client_keys=["TestKey"]
)
self.mock_asyncssh.reset_mock()
response = run_async(
self.executor.run_command, command="Test", stdin_input="Test"
)
self.assertEqual(response.stdout, "Test")
self.assertEqual(response.stderr, "TestError")
self.assertEqual(response.exit_code, 0)
raising_executor = SSHExecutor(**self.test_asyncssh_params)
self.mock_asyncssh.connect.return_value = async_return(
return_value=MockConnection(
exception=ProcessError,
env="Test",
command="Test",
subsystem="Test",
exit_status=1,
exit_signal=None,
returncode=1,
stdout="TestError",
stderr="TestError",
)
)
with self.assertRaises(CommandExecutionFailure):
run_async(raising_executor.run_command, command="Test", stdin_input="Test")
raising_executor = SSHExecutor(**self.test_asyncssh_params)
self.mock_asyncssh.connect.return_value = async_return(
return_value=MockConnection(
exception=ChannelOpenError, reason="test_reason", code=255
)
)
with self.assertRaises(CommandExecutionFailure):
run_async(raising_executor.run_command, command="Test", stdin_input="Test")
def setUp(self) -> None:
self.response = AttributeDict(stderr="", exit_status=0)
self.mock_asyncssh.connect.return_value = async_return(
return_value=MockConnection()
)
self.test_asyncssh_params = AttributeDict(
host="test_host", username="******", client_keys=["TestKey"]
)
self.executor = SSHExecutor(**self.test_asyncssh_params)
self.mock_asyncssh.reset_mock()
def setUp(self):
config = self.mock_config.return_value
test_site_config = config.TestSite
test_site_config.auth_url = 'https://test.nova.client.local'
test_site_config.username = '******'
test_site_config.password = '******'
test_site_config.project_name = 'TestProject'
test_site_config.user_domain_name = 'TestDomain'
test_site_config.project_domain_name = 'TestProjectDomain'
test_site_config.MachineTypeConfiguration = \
AttributeDict(test2large=AttributeDict(imageRef='bc613271-6a54-48ca-9222-47e009dc0c29'))
test_site_config.MachineMetaData = AttributeDict(test2large=AttributeDict(Cores=128))
openstack_api = self.mock_openstack_api.return_value
openstack_api.init_api.return_value = async_return(return_value=None)
self.create_return_value = AttributeDict(server=AttributeDict(name='testsite-089123'))
openstack_api.servers.create.return_value = async_return(return_value=self.create_return_value)
self.get_return_value = AttributeDict(server=AttributeDict(name='testsite-089123', id='029312-1231-123123',
status='ACTIVE'))
openstack_api.servers.get.return_value = async_return(return_value=self.get_return_value)
openstack_api.servers.run_action.return_value = async_return(return_value=None)
openstack_api.servers.force_delete.return_value = async_return(return_value=None)
self.mock_openstack_api.return_value.init_api.return_value = async_return(return_value=True)
self.openstack_adapter = OpenStackAdapter(machine_type='test2large', site_name='TestSite')
def setUp(self):
config = self.mock_config.return_value
test_site_config = config.TestSite
# Endpoint of Kube cluster
test_site_config.host = "https://127.0.0.1:443"
# Barer token we are going to use to authenticate
test_site_config.token = "31ada4fd-adec-460c-809a-9e56ceb75269"
test_site_config.MachineTypeConfiguration = AttributeDict(
test2large=AttributeDict(
namespace="default",
image="busybox:1.26.1",
args=["sleep", "3600"],
hpa="True",
min_replicas="1",
max_replicas="2",
cpu_utilization="50",
)
)
test_site_config.MachineMetaData = AttributeDict(
test2large=AttributeDict(Cores=2, Memory=4)
)
kubernetes_api = self.mock_kubernetes_api.return_value
kubernetes_hpa = self.mock_kubernetes_hpa.return_value
spec = client.V1DeploymentSpec(
replicas=1,
selector=client.V1LabelSelector(match_labels={"app": "testsite-089123"}),
template=client.V1PodTemplateSpec(),
)
container = client.V1Container(
image="busybox:1.26.1",
args=["sleep", "3600"],
name="testsite-089123",
resources=client.V1ResourceRequirements(
requests={
"cpu": test_site_config.MachineMetaData.test2large.Cores,
"memory": test_site_config.MachineMetaData.test2large.Memory * 1e9,
}
),
env=[
client.V1EnvVar(name="TardisDroneCores", value="2"),
client.V1EnvVar(name="TardisDroneMemory", value="4096"),
client.V1EnvVar(name="TardisDroneUuid", value="testsite-089123"),
],
)
spec.template.metadata = client.V1ObjectMeta(
name="testsite-089123",
labels={"app": "testsite-089123"},
)
spec.template.spec = client.V1PodSpec(containers=[container])
self.body = client.V1Deployment(
metadata=client.V1ObjectMeta(name="testsite-089123"),
spec=spec,
)
self.create_return_value = client.V1Deployment(
metadata=client.V1ObjectMeta(name="testsite-089123", uid="123456"),
spec=spec,
)
kubernetes_api.create_namespaced_deployment.return_value = async_return(
return_value=self.create_return_value
)
condition_list = [
client.V1DeploymentCondition(
status="True",
type="Progressing",
)
]
self.read_return_value = client.V1Deployment(
metadata=client.V1ObjectMeta(name="testsite-089123", uid="123456"),
spec=spec,
status=client.V1DeploymentStatus(conditions=condition_list),
)
kubernetes_api.read_namespaced_deployment.return_value = async_return(
return_value=self.read_return_value
)
kubernetes_api.replace_namespaced_deployment.return_value = async_return(
return_value=None
)
kubernetes_api.delete_namespaced_deployment.return_value = async_return(
return_value=None
)
kubernetes_hpa.create_namespaced_horizontal_pod_autoscaler.return_value = (
async_return(return_value=None)
)
kubernetes_hpa.delete_namespaced_horizontal_pod_autoscaler.return_value = (
async_return(return_value=None)
)
self.kubernetes_adapter = KubernetesAdapter(
machine_type="test2large", site_name="TestSite"
)