def stop(self, request, pk=None):
indata = StartStopSerializer(data=request.data)
if not indata.is_valid():
return Response(indata.errors, status=status.HTTP_400_BAD_REQUEST)
logger.info("Stopping VPS: %s" % indata.data)
# hardcoded backend
cloud = CmdbCloudConfig()
backend = ProxMoxJBONServiceBackend(cloud)
tracker = backend.stop_vps(**indata.data)
serializer = CloudTaskTrackerSerializer(tracker)
return Response(serializer.data)
def create(self, request, *args, **kwargs):
indata = CreateVpsSerializer(data=request.data)
if not indata.is_valid():
return Response(indata.errors, status=status.HTTP_400_BAD_REQUEST)
logger.info("Creating VPS: %s" % indata.data)
# hardcoded backend
cloud = CmdbCloudConfig()
backend = ProxMoxJBONServiceBackend(cloud)
tracker = backend.create_vps(**indata.data)
serializer = CloudTaskTrackerSerializer(tracker)
return Response(serializer.data)
def stop(self, request, pk=None):
indata = StartStopSerializer(data=request.data)
if not indata.is_valid():
return Response(indata.errors,
status=status.HTTP_400_BAD_REQUEST)
logger.info("Stopping VPS: %s" % indata.data)
# hardcoded backend
cloud = CmdbCloudConfig()
backend = ProxMoxJBONServiceBackend(cloud)
tracker = backend.stop_vps(**indata.data)
serializer = CloudTaskTrackerSerializer(tracker)
return Response(serializer.data)
def create(self, request, *args, **kwargs):
indata = CreateVpsSerializer(data=request.data)
if not indata.is_valid():
return Response(indata.errors,
status=status.HTTP_400_BAD_REQUEST)
logger.info("Creating VPS: %s" % indata.data)
# hardcoded backend
cloud = CmdbCloudConfig()
backend = ProxMoxJBONServiceBackend(cloud)
tracker = backend.create_vps(**indata.data)
serializer = CloudTaskTrackerSerializer(tracker)
return Response(serializer.data)
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name='Moscow')
self.dc1 = Datacenter.objects.create(name='Test DC 1', parent=self.moscow)
self.rack1 = Rack.objects.create(name='Test Rack 1', parent=self.dc1)
self.srv1 = Server.objects.create(name='Test hypervisor 1', role='hypervisor', parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(name='Test DC 1 IP Pools', parent=self.dc1)
self.pool1 = IPNetworkPool.objects.create(network='192.168.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_FREE)
self.pool11 = IPNetworkPool.objects.create(network='192.169.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_INUSE)
self.srv1.set_option('agentd_taskqueue', 'test_task_queue')
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name='Moscow')
self.dc1 = Datacenter.objects.create(name='Test DC 1',
parent=self.moscow)
self.rack1 = Rack.objects.create(name='Test Rack 1', parent=self.dc1)
self.srv1 = Server.objects.create(name='Test hypervisor 1',
role='hypervisor',
parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(
name='Test DC 1 IP Pools', parent=self.dc1)
self.pool1 = IPAddressPoolFactory.from_network(
'192.168.0.0/23',
parent=self.pools_group1,
dns1='46.17.46.200',
dns2='46.17.40.200')
GlobalIPManager.get_ip('192.168.0.1').lock()
self.pool11 = IPAddressPoolFactory.from_network(
'192.169.0.0/23',
parent=self.pools_group1,
dns1='46.17.46.200',
dns2='46.17.40.200')
self.pool11.use()
GlobalIPManager.get_ip('192.169.0.1').lock()
self.srv1.set_option('agentd_taskqueue', 'test_task_queue')
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def setUp(self):
super(ResourcesAPITests, self).setUp()
user_name = 'admin'
user, created = User.objects.get_or_create(username=user_name,
password=user_name,
email='*****@*****.**',
is_staff=True)
token, created = Token.objects.get_or_create(user=user)
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name='Moscow')
self.dc1 = Datacenter.objects.create(name='Test DC 1',
parent=self.moscow)
self.rack1 = Rack.objects.create(name='Test Rack 1', parent=self.dc1)
self.srv1 = Server.objects.create(name='Test hypervisor 1',
role='hypervisor',
parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(
name='Test DC 1 IP Pools', parent=self.dc1)
self.pool1 = IPAddressPoolFactory.from_network(
'192.168.0.0/23',
parent=self.pools_group1,
dns1='46.17.46.200',
dns2='46.17.40.200')
GlobalIPManager.get_ip('192.168.0.1').lock()
self.pool11 = IPAddressPoolFactory.from_network(
'192.169.0.0/23',
parent=self.pools_group1,
dns1='46.17.46.200',
dns2='46.17.40.200')
self.pool11.use()
GlobalIPManager.get_ip('192.169.0.1').lock()
self.srv1.set_option('agentd_taskqueue', 'test_task_queue')
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name="Moscow")
self.dc1 = Datacenter.objects.create(name="Test DC 1", parent=self.moscow)
self.rack1 = Rack.objects.create(name="Test Rack 1", parent=self.dc1)
self.srv1 = Server.objects.create(name="Test hypervisor 1", role="hypervisor", parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(name="Test DC 1 IP Pools", parent=self.dc1)
self.pool1 = IPNetworkPool.objects.create(
network="192.168.0.0/23", parent=self.pools_group1, status=Resource.STATUS_FREE
)
self.pool11 = IPNetworkPool.objects.create(
network="192.169.0.0/23", parent=self.pools_group1, status=Resource.STATUS_INUSE
)
self.srv1.set_option("agentd_taskqueue", "test_task_queue")
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name='Moscow')
self.dc1 = Datacenter.objects.create(name='Test DC 1', parent=self.moscow)
self.rack1 = Rack.objects.create(name='Test Rack 1', parent=self.dc1)
self.srv1 = Server.objects.create(name='Test hypervisor 1', role='hypervisor', parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(name='Test DC 1 IP Pools', parent=self.dc1)
self.pool1 = IPNetworkPool.objects.create(network='192.168.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_FREE,
dns1='46.17.46.200', dns2='46.17.40.200')
self.pool11 = IPNetworkPool.objects.create(network='192.169.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_INUSE,
dns1='46.17.46.200', dns2='46.17.40.200')
self.srv1.set_option('agentd_taskqueue', 'test_task_queue')
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def __init__(self, stdout=None, stderr=None, no_color=False):
super(Command, self).__init__(stdout, stderr, no_color)
self.cloud = CmdbCloudConfig()
self.task_tracker = self.cloud.task_tracker
self.backend = ProxMoxJBONServiceBackend(self.cloud)
class Command(BaseCommand):
registered_handlers = {}
def __init__(self, stdout=None, stderr=None, no_color=False):
super(Command, self).__init__(stdout, stderr, no_color)
self.cloud = CmdbCloudConfig()
self.task_tracker = self.cloud.task_tracker
self.backend = ProxMoxJBONServiceBackend(self.cloud)
def add_arguments(self, parser):
"""
Add custom arguments and subcommands
"""
subparsers = parser.add_subparsers(title="Cloud management commands",
help="Commands help",
dest='manager_name',
parser_class=ArgumentParser)
# Tasks
tracker_cmd_parser = subparsers.add_parser('tracker', help='Manage task trackers.')
tracker_cmd_parser.add_argument('--new', action="store_true", help="Show submitted tasks.")
tracker_cmd_parser.add_argument('--failed', action="store_true", help="Show failed tasks.")
tracker_cmd_parser.add_argument('--success', action="store_true", help="Show success tasks.")
tracker_cmd_parser.add_argument('--progress', action="store_true", help="Show running tasks.")
tracker_cmd_parser.add_argument('--limit', type=int, default=10, help="Limit the output.")
tracker_cmd_parser.add_argument('--attach', type=int, metavar='TRACKER-ID', help="Attach to the task console.")
tracker_cmd_parser.add_argument('--cancel', type=int, metavar='TRACKER-ID', help="Cancel task.")
self.register_handler('tracker', self._handle_trackers)
# Cloud Services
vps_cmd_parser = subparsers.add_parser('vps', help='Manage VPS services.')
vps_cmd_parser.add_argument('--create', action="store_true", help="Create VPS server.")
vps_cmd_parser.add_argument('--start', action="store_true", help="Start VPS server.")
vps_cmd_parser.add_argument('--stop', action="store_true", help="Stop VPS server.")
vps_cmd_parser.add_argument('--driver', default='kvm',
help="Hypervisor driver, used to manage VPS (must be supported by backend).")
vps_cmd_parser.add_argument('--template', help="VPS template.", default='centos.6.64bit')
vps_cmd_parser.add_argument('--node', type=int, default=0,
help="CMDB node ID. Scheduling is used if not specified.")
vps_cmd_parser.add_argument('--vmid', type=int, help="Set ID of the VM..", required=True)
vps_cmd_parser.add_argument('--user', help="Specify user name for the VM.")
vps_cmd_parser.add_argument('--ip', help="Specify IP address for the VM.")
vps_cmd_parser.add_argument('--ram', type=int, help="Set RAM amount (Mb).", default=512)
vps_cmd_parser.add_argument('--hdd', type=int, help="Set HDD amount (Gb).", default=5)
vps_cmd_parser.add_argument('--cpu', type=int, help="Number of vCPU cores.", default=1)
self.register_handler('vps', self._handle_vps)
hv_cmd_parser = subparsers.add_parser('hypervisors', help='Manage hypervisors.')
hv_cmd_parser.add_argument('--list', action="store_true", help="List known hypervisors.")
self.register_handler('hypervisors', self._handle_hypervisors)
def _handle_hypervisors(self, *args, **options):
if options['list']:
table = PrettyTable(['node', 'group', 'label', 'hypervisor_driver', 'rating', 'agentd_heartbeat'])
table.padding_width = 1
table.sortby = 'rating'
for hypervisor in self.cloud.get_hypervisors():
hyper_driver = hypervisor.get_option_value('hypervisor_driver', default=None)
if hyper_driver:
current_time_stamp = int(time.time())
agentd_heartbeat = hypervisor.get_option_value('agentd_heartbeat', default=0)
agentd_heartbeat_value = agentd_heartbeat if (current_time_stamp - int(
agentd_heartbeat)) < 90 else "%s (!)" % agentd_heartbeat
table.add_row([hypervisor.id,
hypervisor.get_option_value('group'),
hypervisor.get_option_value('label'),
hypervisor.get_option_value('hypervisor_driver'),
hypervisor.get_option_value('rating', default=0),
agentd_heartbeat_value,
])
logger.info(table.get_string(reversesort=True))
def _handle_vps(self, *args, **options):
tracker = None
vmid = int(options['vmid'])
user_name = options['user']
node_id = int(options['node'])
if options['create']:
ram = int(options['ram'])
hdd = int(options['hdd'])
cpu = int(options['cpu'])
template = options['template']
ip_addr = options['ip']
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=ip_addr)
elif options['stop']:
hyper_driver = options['driver']
tracker = self.backend.stop_vps(
node=node_id,
vmid=vmid,
user=user_name,
driver=hyper_driver)
elif options['start']:
hyper_driver = options['driver']
tracker = self.backend.start_vps(
node=node_id,
vmid=vmid,
user=user_name,
driver=hyper_driver)
if tracker:
logger.info("Attached to the task tracker %s. Ctrl-C to exit." % tracker.id)
try:
result_data = tracker.wait()
logger.info(result_data)
except Exception, ex:
logger.error(ex.message)
class ProxMoxJBONServiceBackendTest(TestCase):
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name="Moscow")
self.dc1 = Datacenter.objects.create(name="Test DC 1", parent=self.moscow)
self.rack1 = Rack.objects.create(name="Test Rack 1", parent=self.dc1)
self.srv1 = Server.objects.create(name="Test hypervisor 1", role="hypervisor", parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(name="Test DC 1 IP Pools", parent=self.dc1)
self.pool1 = IPNetworkPool.objects.create(
network="192.168.0.0/23", parent=self.pools_group1, status=Resource.STATUS_FREE
)
self.pool11 = IPNetworkPool.objects.create(
network="192.169.0.0/23", parent=self.pools_group1, status=Resource.STATUS_INUSE
)
self.srv1.set_option("agentd_taskqueue", "test_task_queue")
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def test_start_vps_kvm(self):
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_KVM)
tracker = self.backend.start_vps(node=node_id, vmid=vmid, user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("unittest", check_data_opts["user"])
def test_stop_vps_kvm(self):
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_KVM)
tracker = self.backend.stop_vps(node=node_id, vmid=vmid, user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("unittest", check_data_opts["user"])
def test_start_vps_openvz(self):
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_OPENVZ)
tracker = self.backend.start_vps(node=node_id, vmid=vmid, user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("unittest", check_data_opts["user"])
def test_stop_vps_openvz(self):
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_OPENVZ)
tracker = self.backend.stop_vps(node=node_id, vmid=vmid, user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("unittest", check_data_opts["user"])
def test_create_vps_openvz(self):
"""
Test creating VPS KVM
:return:
"""
ram = 1024
hdd = 50
cpu = 2
template = "centos6"
ip_addr = "192.168.0.25"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_OPENVZ)
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
tracker = self.backend.create_vps(
node=node_id, vmid=vmid, template=template, user=user_name, ram=ram, hdd=hdd, cpu=cpu, ip=ip_addr
)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context["cmdb_node_id"])
self.assertEqual("test_task_queue", tracker.context["queue"])
self.assertEqual(CmdbCloudConfig.TECH_HV_OPENVZ, check_data_opts["driver"])
self.assertEqual("centos6", check_data_opts["template"])
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("v11111.openvz.pytin", check_data_opts["hostname"])
self.assertEqual("unittest", check_data_opts["user"])
self.assertEqual("192.168.0.2", check_data_opts["ip"])
self.assertEqual("192.168.0.1", check_data_opts["gateway"])
self.assertEqual("255.255.254.0", check_data_opts["netmask"])
self.assertEqual(50, check_data_opts["hdd"])
self.assertEqual(1024, check_data_opts["ram"])
self.assertEqual(2, check_data_opts["cpu"])
self.assertEqual("46.17.46.200", check_data_opts["dns1"])
self.assertEqual("46.17.40.200", check_data_opts["dns2"])
def test_create_vps_kvm(self):
"""
Test creating VPS KVM
:return:
"""
ram = 1024
hdd = 50
cpu = 2
template = "centos6"
ip_addr = "192.169.0.15"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
# ip parameter is ignored
tracker = self.backend.create_vps(
node=node_id, vmid=vmid, template=template, user=user_name, ram=ram, hdd=hdd, cpu=cpu, ip=ip_addr
)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context["cmdb_node_id"])
self.assertEqual("test_task_queue", tracker.context["queue"])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts["driver"])
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("v11111.kvm.pytin", check_data_opts["hostname"])
self.assertEqual("unittest", check_data_opts["user"])
self.assertEqual("192.168.0.2", check_data_opts["ip"])
self.assertEqual("192.168.0.1", check_data_opts["gateway"])
self.assertEqual("255.255.254.0", check_data_opts["netmask"])
self.assertEqual(50, check_data_opts["hdd"])
self.assertEqual(1024, check_data_opts["ram"])
self.assertEqual(2, check_data_opts["cpu"])
self.assertEqual("46.17.46.200", check_data_opts["dns1"])
self.assertEqual("46.17.40.200", check_data_opts["dns2"])
def test_create_vps_kvm_rent_ip(self):
"""
Создание VPS без указания IP. IP будет выделен автоматически из свободного пула.
"""
ram = 1024
hdd = 50
cpu = 2
template = "centos6"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
# ip=, we need to lease IP
)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context["cmdb_node_id"])
self.assertEqual("test_task_queue", tracker.context["queue"])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts["driver"])
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("v11111.kvm.pytin", check_data_opts["hostname"])
self.assertEqual("unittest", check_data_opts["user"])
self.assertEqual("192.168.0.2", check_data_opts["ip"])
self.assertEqual("192.168.0.1", check_data_opts["gateway"])
self.assertEqual("255.255.254.0", check_data_opts["netmask"])
self.assertEqual(50, check_data_opts["hdd"])
self.assertEqual(1024, check_data_opts["ram"])
self.assertEqual(2, check_data_opts["cpu"])
self.assertEqual("46.17.46.200", check_data_opts["dns1"])
self.assertEqual("46.17.40.200", check_data_opts["dns2"])
def test_create_vps_kvm_rent_ip__ip_is_empty(self):
"""
Создание VPS с указанным пустым IP. IP будет выделен автоматически из свободного пула.
"""
ram = 1024
hdd = 50
cpu = 2
template = "centos6"
self.srv1.set_option("hypervisor_driver", CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = "unittest"
tracker = self.backend.create_vps(
node=node_id, vmid=vmid, template=template, user=user_name, ram=ram, hdd=hdd, cpu=cpu, ip=None
)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context["cmdb_node_id"])
self.assertEqual("test_task_queue", tracker.context["queue"])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts["driver"])
self.assertEqual(11111, check_data_opts["vmid"])
self.assertEqual("v11111.kvm.pytin", check_data_opts["hostname"])
self.assertEqual("unittest", check_data_opts["user"])
self.assertEqual("192.168.0.2", check_data_opts["ip"])
self.assertEqual("192.168.0.1", check_data_opts["gateway"])
self.assertEqual("255.255.254.0", check_data_opts["netmask"])
self.assertEqual(50, check_data_opts["hdd"])
self.assertEqual(1024, check_data_opts["ram"])
self.assertEqual(2, check_data_opts["cpu"])
self.assertEqual("46.17.46.200", check_data_opts["dns1"])
self.assertEqual("46.17.40.200", check_data_opts["dns2"])
def test_create_vps_kvm_schedule_node_rent_ip(self):
"""
Создание VPS без указания ноды (автовыбор) и без указания IP (выделить)
"""
s1 = Server.objects.create(
name="CN1",
rating=10,
role="hypervisor",
parent=self.rack1,
agentd_taskqueue="s1",
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_INUSE,
)
s2 = Server.objects.create(
name="CN2",
role="hypervisor",
parent=self.rack1,
agentd_taskqueue="s2",
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_LOCKED,
)
s3 = Server.objects.create(
name="CN3",
role="hypervisor",
parent=self.rack1,
agentd_taskqueue="s3",
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_INUSE,
)
s4 = Server.objects.create(
name="CN4",
rating=15,
role="hypervisor",
parent=self.rack1,
agentd_taskqueue="s4",
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_INUSE,
)
s5 = Server.objects.create(name="Some server", status=Resource.STATUS_INUSE, parent=self.rack1)
s6 = Server.objects.create(
name="CN6",
role="hypervisor",
parent=self.rack1,
agentd_taskqueue="s6",
hypervisor_driver=CmdbCloudConfig.TECH_HV_OPENVZ,
status=Resource.STATUS_INUSE,
)
ram = 1024
hdd = 50
cpu = 2
template = "kvm.centos6"
hv_tech = CmdbCloudConfig.TECH_HV_KVM
vmid = 11111
user_name = "unittest"
tracker = self.backend.create_vps(
vmid=vmid, template=template, user=user_name, ram=ram, hdd=hdd, cpu=cpu, driver=hv_tech
)
self.assertEqual(s4.id, tracker.context["cmdb_node_id"])
self.assertEqual("s4", tracker.context["queue"])
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]["options"] = check_data[2]["options"]
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual("tasks.async.mock_vps_control", check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts["vmid"])
# selected best node for the VPS
self.assertEqual(s4.id, tracker.context["cmdb_node_id"])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts["driver"])
self.assertEqual("v11111.kvm.pytin", check_data_opts["hostname"])
self.assertEqual("unittest", check_data_opts["user"])
self.assertEqual("192.168.0.2", check_data_opts["ip"])
self.assertEqual("192.168.0.1", check_data_opts["gateway"])
self.assertEqual("255.255.254.0", check_data_opts["netmask"])
self.assertEqual(50, check_data_opts["hdd"])
self.assertEqual(1024, check_data_opts["ram"])
self.assertEqual(2, check_data_opts["cpu"])
self.assertEqual("46.17.46.200", check_data_opts["dns1"])
self.assertEqual("46.17.40.200", check_data_opts["dns2"])
class ProxMoxJBONServiceBackendTest(TestCase):
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name='Moscow')
self.dc1 = Datacenter.objects.create(name='Test DC 1', parent=self.moscow)
self.rack1 = Rack.objects.create(name='Test Rack 1', parent=self.dc1)
self.srv1 = Server.objects.create(name='Test hypervisor 1', role='hypervisor', parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(name='Test DC 1 IP Pools', parent=self.dc1)
self.pool1 = IPNetworkPool.objects.create(network='192.168.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_FREE)
self.pool11 = IPNetworkPool.objects.create(network='192.169.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_INUSE)
self.srv1.set_option('agentd_taskqueue', 'test_task_queue')
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def test_start_vps_kvm(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
tracker = self.backend.start_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_stop_vps_kvm(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
tracker = self.backend.stop_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_start_vps_openvz(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_OPENVZ)
tracker = self.backend.start_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_stop_vps_openvz(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_OPENVZ)
tracker = self.backend.stop_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_create_vps_openvz(self):
"""
Test creating VPS KVM
:return:
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
ip_addr = '192.168.0.25'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_OPENVZ)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=ip_addr)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_OPENVZ, check_data_opts['driver'])
self.assertEqual('centos6', check_data_opts['template'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.openvz.pytin', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def test_create_vps_kvm(self):
"""
Test creating VPS KVM
:return:
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
ip_addr = '192.169.0.15'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
# ip parameter is ignored
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=ip_addr)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.kvm.pytin', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def test_create_vps_kvm_rent_ip(self):
"""
Создание VPS без указания IP. IP будет выделен автоматически из свободного пула.
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
# ip=, we need to lease IP
)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.kvm.pytin', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def test_create_vps_kvm_rent_ip__ip_is_empty(self):
"""
Создание VPS с указанным пустым IP. IP будет выделен автоматически из свободного пула.
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=None)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.kvm.pytin', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def test_create_vps_kvm_schedule_node_rent_ip(self):
"""
Создание VPS без указания ноды (автовыбор) и без указания IP (выделить)
"""
s1 = Server.objects.create(name='CN1', rating=10, role='hypervisor', parent=self.rack1, agentd_taskqueue='s1',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM, status=Resource.STATUS_INUSE)
s2 = Server.objects.create(name='CN2', role='hypervisor', parent=self.rack1, agentd_taskqueue='s2',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_LOCKED)
s3 = Server.objects.create(name='CN3', role='hypervisor', parent=self.rack1, agentd_taskqueue='s3',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_INUSE)
s4 = Server.objects.create(name='CN4', rating=15, role='hypervisor', parent=self.rack1, agentd_taskqueue='s4',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM, status=Resource.STATUS_INUSE)
s5 = Server.objects.create(name='Some server', status=Resource.STATUS_INUSE, parent=self.rack1)
s6 = Server.objects.create(name='CN6', role='hypervisor', parent=self.rack1, agentd_taskqueue='s6',
hypervisor_driver=CmdbCloudConfig.TECH_HV_OPENVZ,
status=Resource.STATUS_INUSE)
ram = 1024
hdd = 50
cpu = 2
template = 'kvm.centos6'
hv_tech = CmdbCloudConfig.TECH_HV_KVM
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
driver=hv_tech)
self.assertEqual(s4.id, tracker.context['cmdb_node_id'])
self.assertEqual('s4', tracker.context['queue'])
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
# selected best node for the VPS
self.assertEqual(s4.id, tracker.context['cmdb_node_id'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual('v11111.kvm.pytin', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
class ProxMoxJBONServiceBackendTest(TestCase):
def setUp(self):
Resource.objects.all().delete()
self.moscow = RegionResource.objects.create(name='Moscow')
self.dc1 = Datacenter.objects.create(name='Test DC 1', parent=self.moscow)
self.rack1 = Rack.objects.create(name='Test Rack 1', parent=self.dc1)
self.srv1 = Server.objects.create(name='Test hypervisor 1', role='hypervisor', parent=self.rack1)
self.pools_group1 = RegionResource.objects.create(name='Test DC 1 IP Pools', parent=self.dc1)
self.pool1 = IPNetworkPool.objects.create(network='192.168.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_FREE,
dns1='46.17.46.200', dns2='46.17.40.200')
self.pool11 = IPNetworkPool.objects.create(network='192.169.0.0/23', parent=self.pools_group1,
status=Resource.STATUS_INUSE,
dns1='46.17.46.200', dns2='46.17.40.200')
self.srv1.set_option('agentd_taskqueue', 'test_task_queue')
MockVpsControlTask.REMOTE_WORKER.sent_tasks = []
self.cloud = CmdbCloudConfig()
self.backend = ProxMoxJBONServiceBackend(self.cloud)
ProxMoxJBONServiceBackend.TASK_CREATE = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_START = MockVpsControlTask
ProxMoxJBONServiceBackend.TASK_STOP = MockVpsControlTask
def test_start_vps_kvm(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
tracker = self.backend.start_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_stop_vps_kvm(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
tracker = self.backend.stop_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_start_vps_openvz(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_OPENVZ)
tracker = self.backend.start_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_stop_vps_openvz(self):
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_OPENVZ)
tracker = self.backend.stop_vps(
node=node_id,
vmid=vmid,
user=user_name)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('unittest', check_data_opts['user'])
def test_create_vps_openvz(self):
"""
Test creating VPS KVM
:return:
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
ip_addr = '192.168.0.25'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_OPENVZ)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=ip_addr)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_OPENVZ, check_data_opts['driver'])
self.assertEqual('centos6', check_data_opts['template'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.openvz.unittest', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.25', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
self.assertEqual(15, len(check_data_opts['rootpass']))
def test_create_vps_kvm(self):
"""
Test creating VPS KVM
:return:
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
ip_addr = '192.169.0.15'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
# ip parameter is ignored
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=ip_addr)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.kvm.unittest', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.169.0.15', check_data_opts['ip'])
self.assertEqual('192.169.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
self.assertEqual(15, len(check_data_opts['rootpass']))
def test_create_vps_kvm_rent_ip(self):
"""
Создание VPS без указания IP. IP будет выделен автоматически из свободного пула.
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
# ip=, we need to lease IP
)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.kvm.unittest', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def test_create_vps_kvm_rent_ip__ip_is_empty(self):
"""
Создание VPS с указанным пустым IP. IP будет выделен автоматически из свободного пула.
"""
ram = 1024
hdd = 50
cpu = 2
template = 'centos6'
self.srv1.set_option('hypervisor_driver', CmdbCloudConfig.TECH_HV_KVM)
node_id = self.srv1.id
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=None)
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(self.srv1.id, tracker.context['cmdb_node_id'])
self.assertEqual('test_task_queue', tracker.context['queue'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual(11111, check_data_opts['vmid'])
self.assertEqual('v11111.kvm.unittest', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def test_create_vps_kvm_schedule_node_rent_ip(self):
"""
Создание VPS без указания ноды (автовыбор) и без указания IP (выделить)
"""
s1 = Server.objects.create(name='CN1', rating=10, role='hypervisor', parent=self.rack1, agentd_taskqueue='s1',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM, status=Resource.STATUS_INUSE)
s2 = Server.objects.create(name='CN2', role='hypervisor', parent=self.rack1, agentd_taskqueue='s2',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_LOCKED)
s3 = Server.objects.create(name='CN3', role='hypervisor', parent=self.rack1, agentd_taskqueue='s3',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM,
status=Resource.STATUS_INUSE)
s4 = Server.objects.create(name='CN4', rating=15, role='hypervisor', parent=self.rack1, agentd_taskqueue='s4',
hypervisor_driver=CmdbCloudConfig.TECH_HV_KVM, status=Resource.STATUS_INUSE)
s5 = Server.objects.create(name='Some server', status=Resource.STATUS_INUSE, parent=self.rack1)
s6 = Server.objects.create(name='CN6', role='hypervisor', parent=self.rack1, agentd_taskqueue='s6',
hypervisor_driver=CmdbCloudConfig.TECH_HV_OPENVZ,
status=Resource.STATUS_INUSE)
ram = 1024
hdd = 50
cpu = 2
template = 'kvm.centos6'
hv_tech = CmdbCloudConfig.TECH_HV_KVM
vmid = 11111
user_name = 'unittest'
tracker = self.backend.create_vps(
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
driver=hv_tech)
self.assertEqual(s4.id, tracker.context['cmdb_node_id'])
self.assertEqual('s4', tracker.context['queue'])
self.assertEqual(TaskTrackerStatus.STATUS_NEW, tracker.status)
check_data = tracker.wait()
check_data_opts = check_data[2]['options'] = check_data[2]['options']
self.assertEqual(TaskTrackerStatus.STATUS_SUCCESS, tracker.status)
# Задача, которая будет выполнена на агенте.
self.assertEqual('tasks.async.mock_vps_control', check_data[0])
self.assertEqual(None, check_data[1])
# параметры VPS
self.assertEqual(11111, check_data_opts['vmid'])
# selected best node for the VPS
self.assertEqual(s4.id, tracker.context['cmdb_node_id'])
self.assertEqual(CmdbCloudConfig.TECH_HV_KVM, check_data_opts['driver'])
self.assertEqual('v11111.kvm.unittest', check_data_opts['hostname'])
self.assertEqual('unittest', check_data_opts['user'])
self.assertEqual('192.168.0.2', check_data_opts['ip'])
self.assertEqual('192.168.0.1', check_data_opts['gateway'])
self.assertEqual('255.255.254.0', check_data_opts['netmask'])
self.assertEqual(50, check_data_opts['hdd'])
self.assertEqual(1024, check_data_opts['ram'])
self.assertEqual(2, check_data_opts['cpu'])
self.assertEqual('46.17.46.200', check_data_opts['dns1'])
self.assertEqual('46.17.40.200', check_data_opts['dns2'])
def __init__(self, stdout=None, stderr=None, no_color=False):
super(Command, self).__init__(stdout, stderr, no_color)
self.cloud = CmdbCloudConfig()
self.task_tracker = self.cloud.task_tracker
self.backend = ProxMoxJBONServiceBackend(self.cloud)
class Command(BaseCommand):
registered_handlers = {}
def __init__(self, stdout=None, stderr=None, no_color=False):
super(Command, self).__init__(stdout, stderr, no_color)
self.cloud = CmdbCloudConfig()
self.task_tracker = self.cloud.task_tracker
self.backend = ProxMoxJBONServiceBackend(self.cloud)
def add_arguments(self, parser):
"""
Add custom arguments and subcommands
"""
subparsers = parser.add_subparsers(title="Cloud management commands",
help="Commands help",
dest='manager_name',
parser_class=ArgumentParser)
# Tasks
tracker_cmd_parser = subparsers.add_parser(
'tracker', help='Manage task trackers.')
tracker_cmd_parser.add_argument('--new',
action="store_true",
help="Show submitted tasks.")
tracker_cmd_parser.add_argument('--failed',
action="store_true",
help="Show failed tasks.")
tracker_cmd_parser.add_argument('--success',
action="store_true",
help="Show success tasks.")
tracker_cmd_parser.add_argument('--progress',
action="store_true",
help="Show running tasks.")
tracker_cmd_parser.add_argument('--limit',
type=int,
default=10,
help="Limit the output.")
tracker_cmd_parser.add_argument('--attach',
type=int,
metavar='TRACKER-ID',
help="Attach to the task console.")
tracker_cmd_parser.add_argument('--cancel',
type=int,
metavar='TRACKER-ID',
help="Cancel task.")
self.register_handler('tracker', self._handle_trackers)
# Cloud Services
vps_cmd_parser = subparsers.add_parser('vps',
help='Manage VPS services.')
vps_cmd_parser.add_argument('--create',
action="store_true",
help="Create VPS server.")
vps_cmd_parser.add_argument('--start',
action="store_true",
help="Start VPS server.")
vps_cmd_parser.add_argument('--stop',
action="store_true",
help="Stop VPS server.")
vps_cmd_parser.add_argument(
'--driver',
default='kvm',
help=
"Hypervisor driver, used to manage VPS (must be supported by backend)."
)
vps_cmd_parser.add_argument('--template',
help="VPS template.",
default='centos.6.64bit')
vps_cmd_parser.add_argument(
'--node',
type=int,
default=0,
help="CMDB node ID. Scheduling is used if not specified.")
vps_cmd_parser.add_argument('--vmid',
type=int,
help="Set ID of the VM..",
required=True)
vps_cmd_parser.add_argument('--user',
help="Specify user name for the VM.")
vps_cmd_parser.add_argument('--ip',
help="Specify IP address for the VM.")
vps_cmd_parser.add_argument('--ram',
type=int,
help="Set RAM amount (Mb).",
default=512)
vps_cmd_parser.add_argument('--hdd',
type=int,
help="Set HDD amount (Gb).",
default=5)
vps_cmd_parser.add_argument('--cpu',
type=int,
help="Number of vCPU cores.",
default=1)
self.register_handler('vps', self._handle_vps)
hv_cmd_parser = subparsers.add_parser('hypervisors',
help='Manage hypervisors.')
hv_cmd_parser.add_argument('--list',
action="store_true",
help="List known hypervisors.")
self.register_handler('hypervisors', self._handle_hypervisors)
def _handle_hypervisors(self, *args, **options):
if options['list']:
table = PrettyTable([
'node', 'group', 'label', 'hypervisor_driver', 'rating',
'agentd_heartbeat'
])
table.padding_width = 1
table.sortby = 'rating'
for hypervisor in self.cloud.get_hypervisors():
hyper_driver = hypervisor.get_option_value('hypervisor_driver',
default=None)
if hyper_driver:
current_time_stamp = int(time.time())
agentd_heartbeat = hypervisor.get_option_value(
'agentd_heartbeat', default=0)
agentd_heartbeat_value = agentd_heartbeat if (
current_time_stamp - int(agentd_heartbeat)
) < 90 else "%s (!)" % agentd_heartbeat
table.add_row([
hypervisor.id,
hypervisor.get_option_value('group'),
hypervisor.get_option_value('label'),
hypervisor.get_option_value('hypervisor_driver'),
hypervisor.get_option_value('rating', default=0),
agentd_heartbeat_value,
])
logger.info(table.get_string(reversesort=True))
def _handle_vps(self, *args, **options):
tracker = None
vmid = int(options['vmid'])
user_name = options['user']
node_id = int(options['node'])
if options['create']:
ram = int(options['ram'])
hdd = int(options['hdd'])
cpu = int(options['cpu'])
template = options['template']
ip_addr = options['ip']
tracker = self.backend.create_vps(node=node_id,
vmid=vmid,
template=template,
user=user_name,
ram=ram,
hdd=hdd,
cpu=cpu,
ip=ip_addr)
elif options['stop']:
hyper_driver = options['driver']
tracker = self.backend.stop_vps(node=node_id,
vmid=vmid,
user=user_name,
driver=hyper_driver)
elif options['start']:
hyper_driver = options['driver']
tracker = self.backend.start_vps(node=node_id,
vmid=vmid,
user=user_name,
driver=hyper_driver)
if tracker:
logger.info("Attached to the task tracker %s. Ctrl-C to exit." %
tracker.id)
try:
result_data = tracker.wait()
logger.info(result_data)
except Exception, ex:
logger.error(ex.message)
