コード例 #1
1
ファイル: tbhost.py プロジェクト: esnet/enos
def stoplxc(host):
    """ Stop lxc in proxmox using given hostresource configuration """
    
    #check if container is running and ask user to stop it
    if not exists(host):
    	raise ValueError("Host template is missing. Please create host template")
    
    container = Container.getContainer(HOST_CONTAINER)
    hostresource = container.loadResource(host)
        #get proxmox user and hypervisor 
    userresource = proxmoxutil.listuser()
    if userresource is None:
    	raise ValueError("No proxmox user found!! Please use proxmoxutil command to update user credentials")
    		
    user = userresource.properties[PROPERTIES_USER]
    password = userresource.properties[PROPERTIES_PASSWORD]
    authrealm = userresource.properties[PROPERTIES_AUTHREALM]
    puser = user+'@'+authrealm
    	  	
    primary = proxmoxutil.listprimary()
    		
    if primary is None:
    	raise ValueError("Primary proxmox hypervisor not found!! Please use proxmoxutil command to update primary hypervisor")
    	
    hypervisor = primary.properties[PROPERTIES_HYPERVISOR]
    print "Authenticating "+puser +" on "+ hypervisor
  
    proxmox = ProxmoxAPI(hypervisor, user=puser, password=password, verify_ssl=False)
    node = proxmox.nodes(hostresource.properties[HYPERVISOR])
    vmid = int(hostresource.properties[HOSTID])
    print "Stopping  container"
    node.lxc(vmid).status.stop.post()
    time.sleep(30)
    print "Stopped  container"
コード例 #2
0
    def __init__(self):
        # Read args.
        parser = argparse.ArgumentParser()
        parser.add_argument('-d', '--dry', action='store_true')
        args = parser.parse_args()
        self.dry = args.dry

        # Read config, sanitize, fire up the API.
        with open(
                os.path.dirname(os.path.abspath(__file__)) + '/config.yaml',
                'r') as stream:
            try:
                config = yaml.safe_load(stream)
                if 'method' not in config:
                    config['method'] = 'current'
                if 'allowed_disparity' not in config:
                    config['allowed_disparity'] = 20
                if 'rules' not in config:
                    config['rules'] = {}
                if 'async' not in config:
                    config['async'] = True
                if 'separate' not in config['rules']:
                    config['rules']['separate'] = {}
            except yaml.YAMLError as exc:
                print(exc)
                sys.exit(1)

        self.config = config
        self.proxmox = ProxmoxAPI(config['host'],
                                  user=config['user'],
                                  password=config['password'],
                                  backend='https',
                                  verify_ssl=False)
コード例 #3
0
ファイル: vmbr.py プロジェクト: DzeCin/Cassiopee2021
class Vmbr:
    """
    Vmbr class defining an Proxmox vmbr
    """

    def __init__(self, hostname, user, token_name, token_value):
        self.proxmox = ProxmoxAPI(
            hostname,
            user=user,
            token_name=token_name,
            token_value=token_value,
            verify_ssl=False,
        )

    def create_vmbr(self, number):
        for i in self.proxmox.nodes.get():
            self.proxmox.nodes(i["node"]).network.create(
                iface="vmbr" + str(number),
                type="bridge"
            )

            try:
                self.proxmox.nodes(i["node"]).network.put()
            except ResourceException as e:
                print(str(e) + "===> Processing without reloading configuration, you will have to reboot your nodes")
            print("Vmbr created on " + i["node"])
コード例 #4
0
	def __init__(self, px_config):
		self.px_config = px_config
		self.px = ProxmoxAPI(px_config['fqdn'],
				user=px_config['user'],
				password=px_config['passwd'],
				verify_ssl=px_config['tls'])
		self.ceph_storage = self.__get_ceph_storage()
コード例 #5
0
 def __init__(self, vms):
     self.vms = vms
     self.proxmox = ProxmoxAPI('172.18.13.36',
                               user='******',
                               password='******',
                               verify_ssl=False)
     self.run()
コード例 #6
0
ファイル: hvinfo.py プロジェクト: RemiZOffAlex/pytin-agent
class HVInfo():
    def __init__(self, host, password):
        self.proxmox=ProxmoxAPI(host, user='******',
                                password=password,
                                verify_ssl=False)

    def getUsers(self):
        """
        Получить список пользователей
        """
        result = self.proxmox.access.users.get()
        return result

    def ACL(self):
        result = self.proxmox.access.acl.get()
        return result

    def getNodes(self):
        result = self.proxmox.nodes.get()
        return result

    def getKVM(self, node):
        result = self.proxmox.nodes(node).qemu.get()
        return result

    def getOpenVZ(self, node):
        result = self.proxmox.nodes(node).openvz.get()
        return result
コード例 #7
0
    def find_vm(self, label):
        """Find a VM in the Proxmox cluster and return its node and vm proxy
        objects for extraction of additional data by other methods.

        @param label: the label of the VM to be compared to the VM's name in
                      Proxmox.
        @raise CuckooMachineError: if the VM cannot be found."""
        proxmox = ProxmoxAPI(self.options.proxmox.hostname,
                             user=self.options.proxmox.username,
                             password=self.options.proxmox.password,
                             verify_ssl=False)

        # /cluster/resources[type=vm] will give us all VMs no matter which node
        # they reside on
        try:
            vms = proxmox.cluster.resources.get(type="vm")
        except ResourceException as e:
            raise CuckooMachineError("Error enumerating VMs: %s" % e)

        for vm in vms:
            if vm["name"] == label:
                # dynamically address
                # /nodes/<node>/{qemu,lxc,openvz,...}/<vmid> to get handle on
                # VM
                node = proxmox.nodes(vm["node"])
                hv = node.__getattr__(vm["type"])
                vm = hv.__getattr__(str(vm["vmid"]))

                # remember various request proxies for subsequent actions
                return vm, node

        raise CuckooMachineError("Not found")
コード例 #8
0
def connect(server_url: str,
            username: str,
            *,
            password: Optional[str] = None,
            token_name: Optional[str] = None,
            token_value: Optional[str] = None,
            verify_ssl: bool = False,
            use_ssh: bool = False):

    api = ProxmoxAPI(server_url,
                     user=username,
                     password=password,
                     token_name=token_name,
                     token_value=token_value,
                     verify_ssl=verify_ssl,
                     backend=('ssh_paramiko' if use_ssh else 'https'))

    # check if API is working.
    a, b = api.get_tokens()
    if not (a or b):
        raise Exception(
            f"Failed to connect to Proxmox server '{server_url}@{username}', verify credentials"
        )

    return api
コード例 #9
0
 def __init__(self, env_info, args):
     buttlib.common.ButtBuilder.__init__(self, env_info, args)
     self.__ssl_helper = buttlib.helpers.SSLHelper(
         self._env_info['clusterDomain'],
         "%s/ssl" % self._cluster_info['buttdir'])
     self.__net_device = "eth0"
     with open("butt-templates/network/network_config.yaml", 'r') as file:
         self.__network_config = file.read()
     self._cluster_info['kube_masters'] = self.get_kube_masters()
     self._cluster_info['etcd_hosts'] = self.get_master_hosts()
     self._cluster_info['etcd_initial_cluster'] = self.get_initial_cluster()
     self._cluster_info['master_port'] = 10443
     self._cluster_info['kube_master'] = "127.0.0.1"
     self.__proxmox_host = self._env_info['proxmoxHost']
     self.__proxmox_user = self._env_info['proxmoxUser']
     self.__proxmox_storage_path = self._env_info['storagePath']
     self.__proxmox_storage_name = "local"
     self.__proxmox_instances = {}
     self.__proxmox_tmpl_name = "coreosbase"
     self.__butt_net = env_info['bridge']
     self.__max_vmid = 0
     self.__proxmox = ProxmoxAPI('127.0.0.1',
                                 user='******',
                                 password='******',
                                 verify_ssl=False)
コード例 #10
0
ファイル: proxmox.py プロジェクト: mmasquelin/pveflask
def get_openvz_hosts(ct_node):
    isc = ProxmoxAPI(host=ct_node, port=app.config["PROXMOX_PORT"],
                     user=app.config["PROXMOX_USERNAME"] + '@' + app.config["PROXMOX_REALM"],
                     password=app.config["PROXMOX_PASSWORD"],
                     verify_ssl=False)
    openvz_host_details = {}

    try:
        nodes = []
        for node in isc.nodes.get():
            for vm in isc.nodes(node['node']).openvz.get():
                pve_iface = []
                for vmcfg in isc.nodes(node['node']).openvz(vm['vmid']).config.get():
                    if 'net' in vmcfg:
                        pve_iface_name = vmcfg
                        pve_iface_details = isc.nodes(node['node']).openvz(vm['vmid']).config.get()[pve_iface_name]
                        pve_iface.append({
                            "pve_iface_name": pve_iface_name,
                            "pve_iface_details": pve_iface_details
                        })
                nodes.append({
                    "node": node['node'], "vmid": vm['vmid'], "type": vm['type'], "name": vm['name'],
                    "status": vm['status'], "network_info": pve_iface})
        openvz_host_details.update({"status": "Host details", "vms": nodes})
        return openvz_host_details
    except:
        pass
コード例 #11
0
def proxmox_pci_switcher(name, config=False):
    """Switcher virtual machine to use one pci resource like GPU"""

    if config == False and os.name == 'nt':
        config = '~\\AppData\\Local\\proxmox-pci-switcher\\config.yaml'
    else:
        config = '~/.config/proxmox-pci-switcher/config.yaml'

    with open(os.path.expanduser(config)) as file:
        proxmox_config = yaml.load(file, Loader=yaml.FullLoader)

    proxmox = ProxmoxAPI(proxmox_config['proxmox']['host'],
                         user=proxmox_config['proxmox']['user'],
                         password=proxmox_config['proxmox']['password'],
                         verify_ssl=proxmox_config['proxmox']['verify_ssl'])

    # use first node
    node = proxmox.nodes.get()[0]

    target = False
    for t in proxmox_config['targets']:
        if name == t['name']:
            target = t
            break

    if target:
        if proxmox.nodes(node['node']).qemu(
                target['vmid']).status('current').get()['status'] == "stopped":
            print(f"power on vm '{name}', see you later!")
            proxmox.nodes(node['node']).qemu(
                target['vmid']).status('start').post()
        else:
            print(f"target vm '{name}' is running.")
    else:
        print(f"vm '{name}', not found in '{config}' file.")
コード例 #12
0
ファイル: views.py プロジェクト: Tomcuzz/OctaHomeAutomation
def ProxmoxMain(request):
	if not request.user.is_authenticated():
		return redirect('/Login?next=%s' % request.path)
	
	proxmoxIpAddress = settings.PROXMOX_SERVER_IP_ADDRESS
	proxmoxUsername = settings.PROXMOX_USER
	proxmoxPassword = settings.PROXMOX_PASSWORD
	proxmoxVerifySsl = settings.PROXMOX_VERIFY_SSL
	
	proxmox = ProxmoxAPI(proxmoxIpAddress, user=proxmoxUsername, password=proxmoxPassword, verify_ssl=proxmoxVerifySsl)
	
	command = request.GET.get('command', 'none')
	currentNode = request.GET.get('node', 'none')
	currentVz = request.GET.get('openvz', 'none')
	currentVm = request.GET.get('qemu', 'none')
	
	if command != 'none':
		return runcommand(request, proxmox)
	elif currentVz != 'none':
		vms = getVmDict(proxmox)
		tasks = getAllServerTasks(proxmox)
		return render(request, 'OctaHomeProxmox/CT.html', {'links': getSideBar(request, proxmox), 'serverInfo':addWizardVeriables(request, proxmox), 'node':currentNode, 'Vz':vms[currentNode][currentVz], 'StorageDevices':getStorageDetails(proxmox), 'ServerStatuses':getServerStatuses(proxmox), 'tasks':tasks})
	elif currentVm != 'none':
		raise Http404
	elif currentNode != 'none':
		tasks = proxmox.nodes(currentNode).get('tasks')
		return render(request, 'OctaHomeProxmox/Node.html', {'links': getSideBar(request, proxmox), 'serverInfo':addWizardVeriables(request, proxmox), 'Node':currentNode, 'StorageDevices':getStorageDetails(proxmox), 'ServerStatuses':getServerStatuses(proxmox), 'tasks':tasks})
	else:
		tasks = getAllServerTasks(proxmox)
		return render(request, 'OctaHomeProxmox/AllNodes.html', {'links': getSideBar(request, proxmox), 'serverInfo':addWizardVeriables(request, proxmox), 'StorageDevices':getStorageDetails(proxmox), 'ServerStatuses':getServerStatuses(proxmox), 'tasks':tasks})
	raise Http404
コード例 #13
0
ファイル: forms.py プロジェクト: zujko/manage-vm
 def __init__(self, *args, **kwargs):
     super(CD_DVD, self).__init__(*args,**kwargs)
     isos = []
     proxmox = ProxmoxAPI(secrets.PROXMOX_HOST,user=secrets.PROXMOX_USER,password=secrets.PROXMOX_PASS,verify_ssl=False)
     for item in proxmox.nodes('proxmox01').storage('NFS-ISOs').content.get():
         isos.append(item['volid'])
     
     self.fields['iso'] = forms.ChoiceField(choices=[(iso,iso) for iso in isos])
コード例 #14
0
ファイル: proxmox.py プロジェクト: mmasquelin/pveflask
def get_kvm_hosts(ct_node):
    isc = ProxmoxAPI(host=ct_node, port=app.config["PROXMOX_PORT"],
                     user=app.config["PROXMOX_USERNAME"] + '@' + app.config["PROXMOX_REALM"],
                     password=app.config["PROXMOX_PASSWORD"], verify_ssl=False)
    for node in isc.nodes.get():
        for vm in isc.nodes(node['node']).qemu.get():
            print("{0}. {1} => {2}".format(vm['vmid'], vm['name'], vm['status']))
    return None
コード例 #15
0
ファイル: https_tests.py プロジェクト: jhollowe/proxmoxer
def test_https_api_token():
    p = ProxmoxAPI('proxmox',
                   user='******',
                   token_name='test',
                   token_value='ab27beeb-9ac4-4df1-aa19-62639f27031e',
                   verify_ssl=False)
    eq_(p.get_tokens()[0], None)
    eq_(p.get_tokens()[1], None)
コード例 #16
0
ファイル: proxmox.py プロジェクト: snus-b/proxmoxcuckoo
 def _connect_proxmox( self ):
     self.proxmox = ProxmoxAPI( self.host, user=self.username, password=self.password, verify_ssl=False)
     self.nodes = self.proxmox.nodes()
     if len(self.nodes.get()) == 0:
         raise CuckooCriticalError( "Proxmox found no Nodes.")
         
     self._verifyNodes()
     self.vm_label_id = self._getVMID()
コード例 #17
0
ファイル: vmbr.py プロジェクト: DzeCin/Cassiopee2021
 def __init__(self, hostname, user, token_name, token_value):
     self.proxmox = ProxmoxAPI(
         hostname,
         user=user,
         token_name=token_name,
         token_value=token_value,
         verify_ssl=False,
     )
コード例 #18
0
    def __init__(self) -> None:
        super().__init__()
        log.info(f"Proxmox host: {PROXMOX_API_HOST}")
        log.info(f"Proxmox user: {PROXMOX_API_USER}")

        self.pve = ProxmoxAPI(host=PROXMOX_API_HOST,
                              user=PROXMOX_API_USER,
                              password=PROXMOX_API_PASSWORD,
                              verify_ssl=PROXMOX_API_VERIFY_SSL)
コード例 #19
0
 def setUp(self, session):
     response = {'ticket': 'ticket',
                 'CSRFPreventionToken': 'CSRFPreventionToken'}
     session.request.return_value = response
     self.proxmox = ProxmoxAPI('proxmox', user='******', password='******', port=123, verify_ssl=False)
     self.serializer = MagicMock()
     self.session = MagicMock()
     self.session.request.return_value.status_code = 200
     self.proxmox._store['session'] = self.session
     self.proxmox._store['serializer'] = self.serializer
コード例 #20
0
class ProxmoxKvmChaotic(Chaotic):
    def __init__(self) -> None:
        super().__init__()
        log.info(f"Proxmox host: {PROXMOX_API_HOST}")
        log.info(f"Proxmox user: {PROXMOX_API_USER}")

        self.pve = ProxmoxAPI(host=PROXMOX_API_HOST,
                              user=PROXMOX_API_USER,
                              password=PROXMOX_API_PASSWORD,
                              verify_ssl=PROXMOX_API_VERIFY_SSL)

    def action(self) -> None:
        vms = self.pve.cluster.resources.get(type='vm')

        denylist = self.configs.get('denylist') or []
        vms = [
            vm for vm in vms
            if vm['status'] == "running" and vm['name'] not in denylist
        ]

        if vms:
            vm = random.choice(vms)
            log.info(
                f"Choose VM ID={vm['vmid']}, name={vm['name']} on node={vm['node']}"
            )

            min_uptime = self.configs.get('min_uptime')
            if min_uptime is not None:
                current = self.pve.nodes(vm['node']).qemu(
                    vm['vmid']).status.current.get()
                required_uptime = min_uptime * 60
                if current['uptime'] < required_uptime:
                    log.info(
                        f"VM {vm['name']} required uptime lower then {min_uptime} min: {current['uptime'] / 60:.2f}, skipping"
                    )
                    log.info(f"done")
                    return

            if not self.dry_run:
                log.info(f"Stopping VM {vm['name']}")
                self.pve.nodes(vm['node']).qemu(
                    vm['vmid']).status.shutdown.post(forceStop=1)

                wait_before_restart = int(
                    self.configs.get('wait_before_restart', 60))
                log.info(f"Sleeping for {wait_before_restart} seconds")
                time.sleep(wait_before_restart)

                log.info(f"Starting VM {vm['name']}")
                self.pve.nodes(vm['node']).qemu(vm['vmid']).status.start.post()

        else:
            log.info("No VMs found")

        log.info(f"done")
コード例 #21
0
 def __init__(self,
              host,
              user,
              password,
              backend='https',
              verify_ssl=False):
     self.client = ProxmoxAPI(host=host,
                              user=user,
                              password=password,
                              backend=backend,
                              verify_ssl=verify_ssl)
コード例 #22
0
 def __init__(self,
              proxmox_host,
              password,
              user: str = 'root@pam',
              verify_ssl=True,
              port=443):
     self.prox = ProxmoxAPI(proxmox_host,
                            user=user,
                            password=password,
                            port=port,
                            verify_ssl=verify_ssl)
コード例 #23
0
ファイル: proxmox.py プロジェクト: ivan-is/proxmox-confluence
    def setup_conn(self):
        if self._conn is None:
            try:
                self._conn = ProxmoxAPI(host=PROXMOX_HOST,
                                        user='******'.format(PROXMOX_USER),
                                        password=PROXMOX_PASS,
                                        verify_ssl=False)
                logger.debug('connected to the "{}"'.format(PROXMOX_HOST))

            except ConnectionError as e:
                logger.critical(
                    '"{}" while connecting to the proxmox'.format(e))
コード例 #24
0
def get_nodes(host, *args, **kwargs):
    """Get and returns a list of all nodes on the PVE cluster.
    """
    pve = ProxmoxAPI(host, *args, **kwargs)
    nodes = pve.nodes.get()
    # Add to this list to get more info on node.
    properties = ['network', 'services']

    for node in nodes:
        for p in properties:
            node[p] = pve.nodes(node['node']).get(p)

    return nodes
コード例 #25
0
ファイル: forms.py プロジェクト: peacedata0/manage-vm
    def __init__(self, *args, **kwargs):
        super(CD_DVD, self).__init__(*args, **kwargs)
        isos = []
        proxmox = ProxmoxAPI(secrets.PROXMOX_HOST,
                             user=secrets.PROXMOX_USER,
                             password=secrets.PROXMOX_PASS,
                             verify_ssl=False)
        for item in proxmox.nodes('proxmox01').storage(
                'NFS-ISOs').content.get():
            isos.append(item['volid'])

        self.fields['iso'] = forms.ChoiceField(choices=[(iso, iso)
                                                        for iso in isos])
コード例 #26
0
ファイル: tbhost.py プロジェクト: esnet/enos
def rebuildlxc(host):
    """ Creates lxc in proxmox using given hostresource configuration """
    
    #check if container is running and ask user to stop it
    if not exists(host):
    	raise ValueError("Host template is missing. Please create host template")
    
    container = Container.getContainer(HOST_CONTAINER)
    hostresource = container.loadResource(host)
    
    #get proxmox user and hypervisor 
    userresource = proxmoxutil.listuser()
    if userresource is None:
    	raise ValueError("No proxmox user found!! Please use proxmoxutil command to update user credentials")
    		
    user = userresource.properties[PROPERTIES_USER]
    password = userresource.properties[PROPERTIES_PASSWORD]
    authrealm = userresource.properties[PROPERTIES_AUTHREALM]
    puser = user+'@'+authrealm
    	  	
    primary = proxmoxutil.listprimary()
    		
    if primary is None:
    	raise ValueError("Primary proxmox hypervisor not found!! Please use proxmoxutil command to update primary hypervisor")
    	
    hypervisor = primary.properties[PROPERTIES_HYPERVISOR]
    print "Authenticating "+puser +" on "+ hypervisor
    proxmox = ProxmoxAPI(hypervisor, user=puser, password=password, verify_ssl=False)
    node = proxmox.nodes(hostresource.properties[HYPERVISOR])
    
    hostname = hostresource.properties[HOSTNAME]  		
    vmid = int(hostresource.properties[HOSTID])
    memory = int(hostresource.properties[PROPERTIES_MEMORY])
    swap = int(hostresource.properties[PROPERTIES_SWAP])
    interfaces = hostresource.properties[INTERFACES]
    
    i=0
    netconfig = dict()
    for interface in interfaces:
    	print "Configuring %s" %interface    	
    	netconfig["net"+str(i)] = hostresource.properties[interface]
    	i=i+1
    	
    print "Reconfiguring LXC with the following parameters:"
    print "Vmid: %d" %vmid
    print "Memory: %d" %memory
    print "Swap: %d" %swap
    
    node.lxc(vmid).config.put(memory=memory, swap=swap, **netconfig)
    print "Reconfiguring LXC....."
    time.sleep(30)
コード例 #27
0
def main():
    module = AnsibleModule(
        argument_spec=dict(args=dict(type='str', default=None),
                           api_host=dict(required=True),
                           api_user=dict(required=True),
                           api_password=dict(no_log=True),
                           validate_certs=dict(type='bool', default='no'),
                           node=dict(type='str', default='no')))
    api_user = module.params['api_user']
    api_host = module.params['api_host']
    api_password = module.params['api_password']
    validate_certs = module.params['validate_certs']
    node = module.params['node']

    try:
        proxmox = ProxmoxAPI(api_host,
                             user=api_user,
                             password=api_password,
                             verify_ssl=validate_certs)
        global VZ_TYPE
        global PVE_MAJOR_VERSION
        PVE_MAJOR_VERSION = 3 if proxmox_version(proxmox) < LooseVersion(
            '4.0') else 4
    except Exception as e:
        module.fail_json(
            msg='authorization on proxmox cluster failed with exception: %s' %
            e)

    try:
        node = proxmox.nodes(node)
        vms = node.qemu.get()
    except Exception as e:
        module.fail_json(
            msg='Getting information for VMs failed with exception: %s' % e)

    vm_list = []
    vm_dict = {}

    for vm in vms:
        try:
            vm_dict[vm['name']] = node.qemu(vm['vmid']).config.get()
        except Exception as e:
            module.fail_json(
                msg=
                'Getting information for VM with vmid = %s failed with exception: %s'
                % (vmid, e))
        vm_dict[vm['name']]['vmid'] = vm['vmid']

    response = vm_dict
    module.exit_json(changed=False, vm_configs=response)
コード例 #28
0
ファイル: proxmox_vm.py プロジェクト: tiewei/ansible-extras
    def __init__(self, backend, host, user, **kwargs):
        """A wrapper object for ProxmoxAPI.

        :param backend: the backend of proxmoxer
        :param host: the host of proxmox server
        :param user: the api user name of proxmox server (default 'root')
        :param kwargs: other args ProxmoxAPI accepted
        :returns: ProxmoxBroker -- ProxmoxBroker object for module usage.
        """

        # here timeout is task timeout, not connection timeout
        self.timeout = kwargs.pop('timeout', 30)
        self.backend = backend
        self.proxmox = ProxmoxAPI(host, backend=backend, user=user, **kwargs)
コード例 #29
0
def main():
    module = AnsibleModule(
        argument_spec=dict(args=dict(type='str', default=None),
                           api_host=dict(required=True),
                           api_user=dict(required=True),
                           api_password=dict(no_log=True),
                           validate_certs=dict(type='bool', default='no'),
                           node=dict(type='str', default='no'),
                           vm_id=dict(type='int', required=True),
                           vm_ip_type=dict(type='str', default='ipv4'),
                           vm_interface=dict(type='str', default='eth0')))
    api_user = module.params['api_user']
    api_host = module.params['api_host']
    api_password = module.params['api_password']
    validate_certs = module.params['validate_certs']
    node = module.params['node']
    vm_id = module.params['vm_id']
    vm_ip_type = module.params['vm_ip_type']
    vm_interface = module.params['vm_interface']

    try:
        proxmox = ProxmoxAPI(api_host,
                             user=api_user,
                             password=api_password,
                             verify_ssl=validate_certs)
        global VZ_TYPE
        global PVE_MAJOR_VERSION
        PVE_MAJOR_VERSION = 3 if proxmox_version(proxmox) < LooseVersion(
            '4.0') else 4
    except Exception as e:
        module.fail_json(
            msg='authorization on proxmox cluster failed with exception: %s' %
            e)

    try:
        vm_ip = proxmox.nodes(node).qemu(vm_id).agent(
            'network-get-interfaces').get()
    except Exception as e:
        module.fail_json(
            msg='Getting IP for VM with vmid %s failed with exception: %s' %
            (vm_id, e))

    vm_ip_info = [i for i in vm_ip['result'] if i['name'] == vm_interface]
    vm_ip4_addr = [
        i for i in vm_ip_info[0]['ip-addresses']
        if i['ip-address-type'] == vm_ip_type
    ][0]['ip-address']

    response = vm_ip4_addr
    module.exit_json(changed=False, ip=response)
コード例 #30
0
class Proxmox(App):
    """
       Skeleton example app to build other apps off of
    
       Args:
           app_name (str): Name of the app
           device (list[str]): List of associated device names
           context (dict): Information about the context in which the App is operating
           
    """

    def __init__(self, app_name, device, context):
        App.__init__(self, app_name, device, context)  # Required to call superconstructor
        self.proxmox = ProxmoxAPI(self.host, user=self.device_fields["username"],
                                  password=self.device.get_encrypted_field("password"), verify_ssl=False)

    @action
    def get_all_nodes(self):
        return self.proxmox.nodes.get()

    @action
    def get_all_vms(self):
        nodes_vms = []
        for node in self.proxmox.nodes.get():
            node['vms'] = []
            for vm in self.proxmox.nodes(node['node']).openvz.get():
                node['vms'].append(vm)
            nodes_vms.append(node)


    @action
    def get_all_vms_for_node(self, node_name):
        for node in self.proxmox.nodes.get():
コード例 #31
0
    def _connnect(self, module):
        api_host = module.params['api_host']
        api_user = module.params['api_user']
        api_password = module.params['api_password']
        validate_certs = module.params['validate_certs']

        if not api_host:
            module.fail_json(msg='The api_host paramater is missing.'
                             'Please specify this paramter in the task or'
                             'use the environment variable PROXMOX_HOST')

        if not api_user:
            module.fail_json(msg='The api_user paramater is missing.'
                             'Please specify this paramter in the task or'
                             'use the environment variable PROXMOX_USER')

        if not api_password:
            module.fail_json(msg='The api_password paramater is missing.'
                             'Please specify this paramter in the task or'
                             'use the environment variable PROXMOX_PASSWORD')

        try:
            return ProxmoxAPI(api_host,
                              user=api_user,
                              password=api_password,
                              verify_ssl=validate_certs)
        except Exception as e:
            module.fail_json(msg='%s' % e, exception=traceback.format_exc())
コード例 #32
0
ファイル: proxmox.py プロジェクト: iac-projects/proxmox-maas
    def __proxmox_login(self,system_id,context):
        """Login to proxmox server."""

        api_host = context.get('power_address')
        api_user = context.get('power_user')
        api_password = context.get('power_pass')
        vm_id = context.get('power_vm_name')
        api_ssl_val = (context.get('power_validate_ssl')==PROXMOX_YES)
       
        try:
            api = ProxmoxAPI(api_host, user=api_user, 
                    password=api_password, verify_ssl=api_ssl_val)

            con_vm=None
            for vm in api.cluster.resources.get(type="vm"):
                if (str(vm['vmid'])==vm_id) or (vm['name']==vm_id):
                    con_vm=vm
                    break

        except Exception:
            raise ProxmoxError(
                    "Can't connect to proxmox cluster %s" % (api_host))

        if con_vm is None:
            """vm not found"""
            raise ProxmoxError(
                    "Virtual machine %s not found on proxmox cluster %s" % (vm_id, api_host))

        #extract node object
        vm_obj=getattr(getattr(getattr(api.nodes,con_vm['node']),
            con_vm['type']),
            str(con_vm['vmid']))

        return vm_obj
コード例 #33
0
 def setUp(self, _):
     super(TestParamikoSuiteWithSudo, self).__init__(sudo=True)
     self.proxmox = ProxmoxAPI('proxmox', user='******', backend='ssh_paramiko', port=123, sudo=True)
     self.client = self.proxmox._store['session'].ssh_client
     self.session = self.client.get_transport().open_session()
     self._set_stderr('200 OK')
     self._set_stdout('')
コード例 #34
0
ファイル: __init__.py プロジェクト: PLUTEX/pve_checks
def call_function(f: Callable):
    parser = argh.helpers.ArghParser()
    parser.add_argument(
        'config_file',
        type=argparse.FileType('r'),
        help='path to config file with PVE credentials',
    )
    parser.add_argument(
        '--section',
        help='config section to use',
        action='append',
    )
    parser.set_default_command(
        argh.arg(
            '--pve',
            help=argparse.SUPPRESS,
            default=argparse.SUPPRESS,
        )(f))
    args = parser.parse_args()
    var_args = dict(vars(args))
    del var_args['config_file']
    del var_args['section']
    del var_args['_functions_stack']

    import configparser

    config = configparser.ConfigParser()
    config.read_file(args.config_file)

    problems = tuple(
        itertools.chain.from_iterable(
            f(ProxmoxAPI(**config[section]), **var_args)
            for section in args.section or config.sections()))
    handle_result(merge_results(problems))
コード例 #35
0
ファイル: paramiko_tests.py プロジェクト: jhollowe/proxmoxer
def test_paramiko_invalid_backend(_):
    with assert_raises(NotImplementedError):
        ProxmoxAPI('proxmox',
                   user='******',
                   backend='ssh_paramiko',
                   port=123,
                   service='PBS')
コード例 #36
0
ファイル: https_tests.py プロジェクト: heartshare/proxmoxer
 def setUp(self, session):
     response = {"ticket": "ticket", "CSRFPreventionToken": "CSRFPreventionToken"}
     session.request.return_value = response
     self.proxmox = ProxmoxAPI("proxmox", user="******", password="******", port=123, verify_ssl=False)
     self.serializer = MagicMock()
     self.session = MagicMock()
     self.session.request.return_value.status_code = 200
     self.proxmox._store["session"] = self.session
     self.proxmox._store["serializer"] = self.serializer
コード例 #37
0
ファイル: views.py プロジェクト: zujko/manage-vm
def create_vm(request):
    vm_form = VM_Form(data=request.POST or None)
    drive_form = CD_DVD(data=request.POST or None)
    disk_form = Disk(data=request.POST or None)
    cpu_form = CPU(data=request.POST or None)
    net_form = Network(data=request.POST or None)
    
    if request.method == 'POST':
        if vm_form.is_valid() and drive_form.is_valid() and disk_form.is_valid() and cpu_form.is_valid() and net_form.is_valid():
            
            if '_request' in request.POST:
                # Request VM
                use = User.objects.get_or_create(username='******')
                request_vm(vm_form, drive_form, disk_form, cpu_form, net_form,use[0])
                return redirect('/')

            if check_limits(vm_form.cleaned_data['memory'],cpu_form.cleaned_data['cores'],disk_form.cleaned_data['size']):
                return render(request, 'create.html',{'vm_form': vm_form,'drive_form': drive_form,'disk_form': disk_form,'cpu_form': cpu_form,'net_form': net_form,'request_vm': True})

            proxmox = ProxmoxAPI(secrets.PROXMOX_HOST,user=secrets.PROXMOX_USER,password=secrets.PROXMOX_PASS,verify_ssl=False)

            node = proxmox.nodes(vm_form.cleaned_data['node'])
            vm_id = int(proxmox.cluster.nextid.get())
            testdata = node.qemu.create(vmid=vm_id,
                        name=vm_form.cleaned_data['name'],
                        ostype=vm_form.cleaned_data['ostype'],
                        ide2=drive_form.cleaned_data['iso']+',media=cdrom',
                        ide0='ceph_pool:'+str(disk_form.cleaned_data['size'])+',format='+disk_form.cleaned_data['disk_format'],
                        sockets=1,
                        cores=cpu_form.cleaned_data['cores'],
                        numa=0,
                        pool=secrets.PROXMOX_POOL,
                        memory=vm_form.cleaned_data['memory'],
                        net0=net_form.cleaned_data['model']+',bridge='+net_form.cleaned_data['bridge'])
            # Testing
            use = User.objects.get_or_create(username='******')
            vm = VM(user=use[0],vmid=vm_id,name=vm_form.cleaned_data['name'],nodename=vm_form.cleaned_data['node'])
            vm.save()
            return redirect('/manage/') 
    
    return render(request, 'create.html',{'vm_form': vm_form,'drive_form': drive_form,'disk_form': disk_form,'cpu_form': cpu_form,'net_form': net_form})
コード例 #38
0
ファイル: https_tests.py プロジェクト: heartshare/proxmoxer
class TestSuite:
    proxmox = None
    serializer = None
    session = None

    # noinspection PyMethodOverriding
    @patch("requests.sessions.Session")
    def setUp(self, session):
        response = {"ticket": "ticket", "CSRFPreventionToken": "CSRFPreventionToken"}
        session.request.return_value = response
        self.proxmox = ProxmoxAPI("proxmox", user="******", password="******", port=123, verify_ssl=False)
        self.serializer = MagicMock()
        self.session = MagicMock()
        self.session.request.return_value.status_code = 200
        self.proxmox._store["session"] = self.session
        self.proxmox._store["serializer"] = self.serializer

    def test_get(self):
        self.proxmox.nodes("proxmox").storage("local").get()
        eq_(self.session.request.call_args[0], ("GET", "https://proxmox:123/api2/json/nodes/proxmox/storage/local"))

    def test_delete(self):
        self.proxmox.nodes("proxmox").openvz(100).delete()
        eq_(self.session.request.call_args[0], ("DELETE", "https://proxmox:123/api2/json/nodes/proxmox/openvz/100"))
        self.proxmox.nodes("proxmox").openvz("101").delete()
        eq_(self.session.request.call_args[0], ("DELETE", "https://proxmox:123/api2/json/nodes/proxmox/openvz/101"))

    def test_post(self):
        node = self.proxmox.nodes("proxmox")
        node.openvz.create(
            vmid=800,
            ostemplate="local:vztmpl/debian-6-turnkey-core_12.0-1_i386.tar.gz",
            hostname="test",
            storage="local",
            memory=512,
            swap=512,
            cpus=1,
            disk=4,
            password="******",
            ip_address="10.0.100.222",
        )
        eq_(self.session.request.call_args[0], ("POST", "https://proxmox:123/api2/json/nodes/proxmox/openvz"))
        ok_("data" in self.session.request.call_args[1])
        data = self.session.request.call_args[1]["data"]
        eq_(data["cpus"], 1)
        eq_(data["disk"], 4)
        eq_(data["hostname"], "test")
        eq_(data["ip_address"], "10.0.100.222")
        eq_(data["memory"], 512)
        eq_(data["ostemplate"], "local:vztmpl/debian-6-turnkey-core_12.0-1_i386.tar.gz")
        eq_(data["password"], "secret")
        eq_(data["storage"], "local")
        eq_(data["swap"], 512)
        eq_(data["vmid"], 800)

        node = self.proxmox.nodes("proxmox1")
        node.openvz.post(
            vmid=900,
            ostemplate="local:vztmpl/debian-7-turnkey-core_12.0-1_i386.tar.gz",
            hostname="test1",
            storage="local1",
            memory=1024,
            swap=1024,
            cpus=2,
            disk=8,
            password="******",
            ip_address="10.0.100.111",
        )
        eq_(self.session.request.call_args[0], ("POST", "https://proxmox:123/api2/json/nodes/proxmox1/openvz"))
        ok_("data" in self.session.request.call_args[1])
        data = self.session.request.call_args[1]["data"]
        eq_(data["cpus"], 2)
        eq_(data["disk"], 8)
        eq_(data["hostname"], "test1")
        eq_(data["ip_address"], "10.0.100.111")
        eq_(data["memory"], 1024)
        eq_(data["ostemplate"], "local:vztmpl/debian-7-turnkey-core_12.0-1_i386.tar.gz")
        eq_(data["password"], "secret1")
        eq_(data["storage"], "local1")
        eq_(data["swap"], 1024)
        eq_(data["vmid"], 900)

    def test_put(self):
        node = self.proxmox.nodes("proxmox")
        node.openvz(101).config.set(cpus=4, memory=1024, ip_address="10.0.100.100", onboot=True)
        eq_(self.session.request.call_args[0], ("PUT", "https://proxmox:123/api2/json/nodes/proxmox/openvz/101/config"))
        data = self.session.request.call_args[1]["data"]
        eq_(data["cpus"], 4)
        eq_(data["memory"], 1024)
        eq_(data["ip_address"], "10.0.100.100")
        eq_(data["onboot"], True)

        node = self.proxmox.nodes("proxmox1")
        node.openvz(102).config.put(cpus=2, memory=512, ip_address="10.0.100.200", onboot=False)
        eq_(
            self.session.request.call_args[0], ("PUT", "https://proxmox:123/api2/json/nodes/proxmox1/openvz/102/config")
        )
        data = self.session.request.call_args[1]["data"]
        eq_(data["cpus"], 2)
        eq_(data["memory"], 512)
        eq_(data["ip_address"], "10.0.100.200")
        eq_(data["onboot"], False)
コード例 #39
0
from proxmoxer import ProxmoxAPI

# apiuser: "******"
# apipass: "******"
# cluster:
#   - "cluster1"
#   - "cluster2"
pve_config = yaml.load(open('/root/proxmox/proxmox.yml', 'r'))
pve_apiuser = pve_config['apiuser']
pve_apipass = pve_config['apipass']
pve_cluster = pve_config['cluster']

print('{cluster:<16} {node:<16} {id:<4} {name:<16} {status:<12}'.format(
                                                        cluster="CLUSTER",
                                                        node="NODE",
                                                        id="ID",
                                                        name="NAME",
                                                        status="STATUS"))

for cluster in pve_cluster:
    pve = ProxmoxAPI(cluster, user=pve_apiuser, password=pve_apipass, verify_ssl=False)

    for node in pve.nodes.get():
        for vm in pve.nodes(node['node']).qemu.get():
            print('{cluster:<16} {node:<16} {id:<4} {name:<16} {status:<12}'.format(
                                                        cluster=cluster,
                                                        node=node['node'],
                                                        id=vm['vmid'],
                                                        name=vm['name'],
                                                        status=vm['status']))
コード例 #40
0
ファイル: proxmox_kvm.py プロジェクト: ernstp/ansible
def main():
    module = AnsibleModule(
        argument_spec=dict(
            acpi=dict(type='bool', default='yes'),
            agent=dict(type='bool'),
            args=dict(type='str', default=None),
            api_host=dict(required=True),
            api_user=dict(required=True),
            api_password=dict(no_log=True),
            autostart=dict(type='bool', default='no'),
            balloon=dict(type='int', default=0),
            bios=dict(choices=['seabios', 'ovmf']),
            boot=dict(type='str', default='cnd'),
            bootdisk=dict(type='str'),
            clone=dict(type='str', default=None),
            cores=dict(type='int', default=1),
            cpu=dict(type='str', default='kvm64'),
            cpulimit=dict(type='int'),
            cpuunits=dict(type='int', default=1000),
            delete=dict(type='str', default=None),
            description=dict(type='str'),
            digest=dict(type='str'),
            force=dict(type='bool', default=None),
            format=dict(type='str', default='qcow2', choices=['cloop', 'cow', 'qcow', 'qcow2', 'qed', 'raw', 'vmdk']),
            freeze=dict(type='bool'),
            full=dict(type='bool', default='yes'),
            hostpci=dict(type='dict'),
            hotplug=dict(type='str'),
            hugepages=dict(choices=['any', '2', '1024']),
            ide=dict(type='dict', default=None),
            keyboard=dict(type='str'),
            kvm=dict(type='bool', default='yes'),
            localtime=dict(type='bool'),
            lock=dict(choices=['migrate', 'backup', 'snapshot', 'rollback']),
            machine=dict(type='str'),
            memory=dict(type='int', default=512),
            migrate_downtime=dict(type='int'),
            migrate_speed=dict(type='int'),
            name=dict(type='str'),
            net=dict(type='dict'),
            newid=dict(type='int', default=None),
            node=dict(),
            numa=dict(type='dict'),
            numa_enabled=dict(type='bool'),
            onboot=dict(type='bool', default='yes'),
            ostype=dict(default='l26', choices=['other', 'wxp', 'w2k', 'w2k3', 'w2k8', 'wvista', 'win7', 'win8', 'l24', 'l26', 'solaris']),
            parallel=dict(type='dict'),
            pool=dict(type='str'),
            protection=dict(type='bool'),
            reboot=dict(type='bool'),
            revert=dict(type='str', default=None),
            sata=dict(type='dict'),
            scsi=dict(type='dict'),
            scsihw=dict(choices=['lsi', 'lsi53c810', 'virtio-scsi-pci', 'virtio-scsi-single', 'megasas', 'pvscsi']),
            serial=dict(type='dict'),
            shares=dict(type='int'),
            skiplock=dict(type='bool'),
            smbios=dict(type='str'),
            snapname=dict(type='str'),
            sockets=dict(type='int', default=1),
            startdate=dict(type='str'),
            startup=dict(),
            state=dict(default='present', choices=['present', 'absent', 'stopped', 'started', 'restarted', 'current']),
            storage=dict(type='str'),
            tablet=dict(type='bool', default='no'),
            target=dict(type='str'),
            tdf=dict(type='bool'),
            template=dict(type='bool', default='no'),
            timeout=dict(type='int', default=30),
            update=dict(type='bool', default='no'),
            validate_certs=dict(type='bool', default='no'),
            vcpus=dict(type='int', default=None),
            vga=dict(default='std', choices=['std', 'cirrus', 'vmware', 'qxl', 'serial0', 'serial1', 'serial2', 'serial3', 'qxl2', 'qxl3', 'qxl4']),
            virtio=dict(type='dict', default=None),
            vmid=dict(type='int', default=None),
            watchdog=dict(),
        ),
        mutually_exclusive=[('delete', 'revert'), ('delete', 'update'), ('revert', 'update'), ('clone', 'update'), ('clone', 'delete'), ('clone', 'revert')],
        required_one_of=[('name', 'vmid',)],
        required_if=[('state', 'present', ['node'])]
    )

    if not HAS_PROXMOXER:
        module.fail_json(msg='proxmoxer required for this module')

    api_user = module.params['api_user']
    api_host = module.params['api_host']
    api_password = module.params['api_password']
    clone = module.params['clone']
    cpu = module.params['cpu']
    cores = module.params['cores']
    delete = module.params['delete']
    memory = module.params['memory']
    name = module.params['name']
    newid = module.params['newid']
    node = module.params['node']
    revert = module.params['revert']
    sockets = module.params['sockets']
    state = module.params['state']
    timeout = module.params['timeout']
    update = bool(module.params['update'])
    vmid = module.params['vmid']
    validate_certs = module.params['validate_certs']

    # If password not set get it from PROXMOX_PASSWORD env
    if not api_password:
        try:
            api_password = os.environ['PROXMOX_PASSWORD']
        except KeyError as e:
            module.fail_json(msg='You should set api_password param or use PROXMOX_PASSWORD environment variable')

    try:
        proxmox = ProxmoxAPI(api_host, user=api_user, password=api_password, verify_ssl=validate_certs)
        global VZ_TYPE
        global PVE_MAJOR_VERSION
        PVE_MAJOR_VERSION = 3 if float(proxmox.version.get()['version']) < 4.0 else 4
    except Exception as e:
        module.fail_json(msg='authorization on proxmox cluster failed with exception: %s' % e)

    # If vmid not set get the Next VM id from ProxmoxAPI
    # If vm name is set get the VM id from ProxmoxAPI
    if not vmid:
        if state == 'present' and (not update and not clone) and (not delete and not revert):
            try:
                vmid = get_nextvmid(module, proxmox)
            except Exception as e:
                module.fail_json(msg="Can't get the next vimd for VM {} automatically. Ensure your cluster state is good".format(name))
        else:
            try:
                if not clone:
                    vmid = get_vmid(proxmox, name)[0]
                else:
                    vmid = get_vmid(proxmox, clone)[0]
            except Exception as e:
                if not clone:
                    module.fail_json(msg="VM {} does not exist in cluster.".format(name))
                else:
                    module.fail_json(msg="VM {} does not exist in cluster.".format(clone))

    if clone is not None:
        if get_vmid(proxmox, name):
            module.exit_json(changed=False, msg="VM with name <%s> already exists" % name)
        if vmid is not None:
            vm = get_vm(proxmox, vmid)
            if not vm:
                module.fail_json(msg='VM with vmid = %s does not exist in cluster' % vmid)
        if not newid:
            try:
                newid = get_nextvmid(module, proxmox)
            except Exception as e:
                module.fail_json(msg="Can't get the next vimd for VM {} automatically. Ensure your cluster state is good".format(name))
        else:
            vm = get_vm(proxmox, newid)
            if vm:
                module.exit_json(changed=False, msg="vmid %s with VM name %s already exists" % (newid, name))

    if delete is not None:
        try:
            settings(module, proxmox, vmid, node, name, timeout, delete=delete)
            module.exit_json(changed=True, msg="Settings has deleted on VM {} with vmid {}".format(name, vmid))
        except Exception as e:
            module.fail_json(msg='Unable to delete settings on VM {} with vimd {}: '.format(name, vmid) + str(e))
    elif revert is not None:
        try:
            settings(module, proxmox, vmid, node, name, timeout, revert=revert)
            module.exit_json(changed=True, msg="Settings has reverted on VM {} with vmid {}".format(name, vmid))
        except Exception as e:
            module.fail_json(msg='Unable to revert settings on VM {} with vimd {}: Maybe is not a pending task...   '.format(name, vmid) + str(e))

    if state == 'present':
        try:
            if get_vm(proxmox, vmid) and not (update or clone):
                module.exit_json(changed=False, msg="VM with vmid <%s> already exists" % vmid)
            elif get_vmid(proxmox, name) and not (update or clone):
                module.exit_json(changed=False, msg="VM with name <%s> already exists" % name)
            elif not (node, name):
                module.fail_json(msg='node, name is mandatory for creating/updating vm')
            elif not node_check(proxmox, node):
                module.fail_json(msg="node '%s' does not exist in cluster" % node)

            create_vm(module, proxmox, vmid, newid, node, name, memory, cpu, cores, sockets, timeout, update,
                      acpi=module.params['acpi'],
                      agent=module.params['agent'],
                      autostart=module.params['autostart'],
                      balloon=module.params['balloon'],
                      bios=module.params['bios'],
                      boot=module.params['boot'],
                      bootdisk=module.params['bootdisk'],
                      cpulimit=module.params['cpulimit'],
                      cpuunits=module.params['cpuunits'],
                      description=module.params['description'],
                      digest=module.params['digest'],
                      force=module.params['force'],
                      freeze=module.params['freeze'],
                      hostpci=module.params['hostpci'],
                      hotplug=module.params['hotplug'],
                      hugepages=module.params['hugepages'],
                      ide=module.params['ide'],
                      keyboard=module.params['keyboard'],
                      kvm=module.params['kvm'],
                      localtime=module.params['localtime'],
                      lock=module.params['lock'],
                      machine=module.params['machine'],
                      migrate_downtime=module.params['migrate_downtime'],
                      migrate_speed=module.params['migrate_speed'],
                      net=module.params['net'],
                      numa=module.params['numa'],
                      numa_enabled=module.params['numa_enabled'],
                      onboot=module.params['onboot'],
                      ostype=module.params['ostype'],
                      parallel=module.params['parallel'],
                      pool=module.params['pool'],
                      protection=module.params['protection'],
                      reboot=module.params['reboot'],
                      sata=module.params['sata'],
                      scsi=module.params['scsi'],
                      scsihw=module.params['scsihw'],
                      serial=module.params['serial'],
                      shares=module.params['shares'],
                      skiplock=module.params['skiplock'],
                      smbios1=module.params['smbios'],
                      snapname=module.params['snapname'],
                      startdate=module.params['startdate'],
                      startup=module.params['startup'],
                      tablet=module.params['tablet'],
                      target=module.params['target'],
                      tdf=module.params['tdf'],
                      template=module.params['template'],
                      vcpus=module.params['vcpus'],
                      vga=module.params['vga'],
                      virtio=module.params['virtio'],
                      watchdog=module.params['watchdog'])

            if not clone:
                get_vminfo(module, proxmox, node, vmid,
                           ide=module.params['ide'],
                           net=module.params['net'],
                           sata=module.params['sata'],
                           scsi=module.params['scsi'],
                           virtio=module.params['virtio'])
            if update:
                module.exit_json(changed=True, msg="VM %s with vmid %s updated" % (name, vmid))
            elif clone is not None:
                module.exit_json(changed=True, msg="VM %s with newid %s cloned from vm with vmid %s" % (name, newid, vmid))
            else:
                module.exit_json(changed=True, msg="VM %s with vmid %s deployed" % (name, vmid), **results)
        except Exception as e:
            if update:
                module.fail_json(msg="Unable to update vm {} with vimd {}=".format(name, vmid) + str(e))
            elif clone is not None:
                module.fail_json(msg="Unable to clone vm {} from vimd {}=".format(name, vmid) + str(e))
            else:
                module.fail_json(msg="creation of %s VM %s with vmid %s failed with exception=%s" % (VZ_TYPE, name, vmid, e))

    elif state == 'started':
        try:
            vm = get_vm(proxmox, vmid)
            if not vm:
                module.fail_json(msg='VM with vmid <%s> does not exist in cluster' % vmid)
            if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'running':
                module.exit_json(changed=False, msg="VM %s is already running" % vmid)

            if start_vm(module, proxmox, vm, vmid, timeout):
                module.exit_json(changed=True, msg="VM %s started" % vmid)
        except Exception as e:
            module.fail_json(msg="starting of VM %s failed with exception: %s" % (vmid, e))

    elif state == 'stopped':
        try:
            vm = get_vm(proxmox, vmid)
            if not vm:
                module.fail_json(msg='VM with vmid = %s does not exist in cluster' % vmid)

            if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'stopped':
                module.exit_json(changed=False, msg="VM %s is already stopped" % vmid)

            if stop_vm(module, proxmox, vm, vmid, timeout, force=module.params['force']):
                module.exit_json(changed=True, msg="VM %s is shutting down" % vmid)
        except Exception as e:
            module.fail_json(msg="stopping of VM %s failed with exception: %s" % (vmid, e))

    elif state == 'restarted':
        try:
            vm = get_vm(proxmox, vmid)
            if not vm:
                module.fail_json(msg='VM with vmid = %s does not exist in cluster' % vmid)
            if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'stopped':
                module.exit_json(changed=False, msg="VM %s is not running" % vmid)

            if stop_vm(module, proxmox, vm, vmid, timeout, force=module.params['force']) and start_vm(module, proxmox, vm, vmid, timeout):
                module.exit_json(changed=True, msg="VM %s is restarted" % vmid)
        except Exception as e:
            module.fail_json(msg="restarting of VM %s failed with exception: %s" % (vmid, e))

    elif state == 'absent':
        try:
            vm = get_vm(proxmox, vmid)
            if not vm:
                module.exit_json(changed=False, msg="VM %s does not exist" % vmid)

            if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'running':
                module.exit_json(changed=False, msg="VM %s is running. Stop it before deletion." % vmid)

            taskid = getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE).delete(vmid)
            while timeout:
                if (proxmox.nodes(vm[0]['node']).tasks(taskid).status.get()['status'] == 'stopped' and
                        proxmox.nodes(vm[0]['node']).tasks(taskid).status.get()['exitstatus'] == 'OK'):
                    module.exit_json(changed=True, msg="VM %s removed" % vmid)
                timeout -= 1
                if timeout == 0:
                    module.fail_json(msg='Reached timeout while waiting for removing VM. Last line in task before timeout: %s'
                                     % proxmox.nodes(vm[0]['node']).tasks(taskid).log.get()[:1])

                time.sleep(1)
        except Exception as e:
            module.fail_json(msg="deletion of VM %s failed with exception: %s" % (vmid, e))

    elif state == 'current':
        status = {}
        try:
            vm = get_vm(proxmox, vmid)
            if not vm:
                module.fail_json(msg='VM with vmid = %s does not exist in cluster' % vmid)
            current = getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status']
            status['status'] = current
            if status:
                module.exit_json(changed=False, msg="VM %s with vmid = %s is %s" % (name, vmid, current), **status)
        except Exception as e:
            module.fail_json(msg="Unable to get vm {} with vmid = {} status: ".format(name, vmid) + str(e))
コード例 #41
0
ファイル: new_ovz.py プロジェクト: RemiZOffAlex/pytin-agent
 def connect(self, hostname, password, nodename):
     self.proxmox = ProxmoxAPI(hostname, user='******',
                               password=password,
                               verify_ssl=False)
     self.node = self.proxmox.nodes(nodename)
     self.password = pwgen()
コード例 #42
0
ファイル: proxmox_vm_backup.py プロジェクト: jtyocum/scripts
def main():
    '''
    Example configuration file:

    apiuser: "******"
    apipass: "******"
    cluster:
      - "cluster1"
      - "cluster2"
    '''
    conf_path = os.path.dirname(os.path.abspath(__file__)) + r'/../conf/proxmox.yml'

    try:
        pve_config = yaml.load(open(conf_path, 'r'))
        pve_apiuser = pve_config['apiuser']
        pve_apipass = pve_config['apipass']
        pve_cluster = pve_config['cluster']
    except:
        print('{0} ERROR: Unable to load configuration from {1}'.format(
            str(datetime.now()), conf_path))
        return 1

    parser = argparse.ArgumentParser(description='Backup a VM by name')
    parser.add_argument('vmname', nargs='+', help='VM to Backup')
    parser.add_argument('--target', required=True, help='Backup Location')
    parser.add_argument('--notify', required=True, help='Notification Email Address')
    args = parser.parse_args()

    # Track all VMs that are backed up
    backup_list = set()

    for cluster in pve_cluster:
        try:
            pve = ProxmoxAPI(cluster, user=pve_apiuser, password=pve_apipass, verify_ssl=False)
        except:
            print('{0} ERROR: Unable to access cluster {1}. Skipping!'.format(
                str(datetime.now()), cluster))
            continue

        for node in pve.nodes.get():
            target_exists = False
            # Track all VMs backed up on a node
            backup_list_node = set()
            backup_list_node_vmid = set()

            for target in pve.nodes(node['node']).storage.get():
                if target['storage'] == args.target:
                    target_exists = True

            if target_exists == True:
                for vm in pve.nodes(node['node']).qemu.get():
                    if vm['name'] in args.vmname:
                        backup_list.add(vm['name'])
                        backup_list_node.add(vm['name'])
                        backup_list_node_vmid.add(vm['vmid'])

                if len(backup_list_node) >= 1:
                    backup_vmname = str()
                    backup_vmid = str()

                    for vmid in backup_list_node_vmid:
                        backup_vmid = backup_vmid + '{0},'.format(vmid)

                    for name in backup_list_node:
                        backup_vmname = backup_vmname + ' {0}'.format(name)

                    try:
                        print('{0} INFO: Starting backup(s) for {1} on node {2}'.format(
                            str(datetime.now()),
                            backup_vmname.strip().upper(),
                            node['node']))

                        pve.nodes(node['node']).vzdump.create(
                            vmid=backup_vmid.rstrip(','),
                            storage=args.target,
                            mode='snapshot',
                            compress='lzo',
                            mailto=args.notify,
                            mailnotification='always')
                    except:
                        print('{0} ERROR: Failed to submit backup job to node {1}. Skipping!'.format(
                            str(datetime.now()), node['node']))
            else:
                print('{0} WARN: Backup target not found on node {1}'.format(
                    str(datetime.now()), node['node']))

    for vm in args.vmname:
        if vm not in backup_list:
            print('{0} ERROR: VM {1} backup request failed'.format(
                str(datetime.now()), vm))
コード例 #43
0
# cluster:
#   - "cluster1"
#   - "cluster2"
pve_config = yaml.load(open('/root/proxmox/proxmox.yml', 'r'))
pve_apiuser = pve_config['apiuser']
pve_apipass = pve_config['apipass']
pve_cluster = pve_config['cluster']

parser = argparse.ArgumentParser(description='Display VM Configuration')
parser.add_argument('vmname', nargs='+', help='VM to look up')
args = parser.parse_args()

vm_found = None

for cluster in pve_cluster:
    pve = ProxmoxAPI(cluster, user=pve_apiuser, password=pve_apipass, verify_ssl=False)

    for node in pve.nodes.get():
        for vm in pve.nodes(node['node']).qemu.get():
            if vm['name'] in args.vmname:
                # Print a blank line between matching VMs
                if vm_found == True:
                    print()
                vm_found = True

                # Print VM configuration
                vmconfig = pve.nodes(node['node']).qemu(vm['vmid']).get('config')
                vmconfig.update({'cluster' : cluster, 'node' : node['node']})
                for k, v in sorted(vmconfig.items()):
                    print('{0:>10}: {1}'.format(k, v))
コード例 #44
0
  disk = module.params['disk']
  cpus = module.params['cpus']
  memory = module.params['memory']
  swap = module.params['swap']
  storage = module.params['storage']
  timeout = module.params['timeout']

  # If password not set get it from PROXMOX_PASSWORD env
  if not api_password:
    try:
      api_password = os.environ['PROXMOX_PASSWORD']
    except KeyError, e:
      module.fail_json(msg='You should set api_password param or use PROXMOX_PASSWORD environment variable')

  try:
    proxmox = ProxmoxAPI(api_host, user=api_user, password=api_password, verify_ssl=validate_certs)
  except Exception, e:
    module.fail_json(msg='authorization on proxmox cluster failed with exception: %s' % e)

  if state == 'present':
    try:
      if get_instance(proxmox, vmid) and not module.params['force']:
        module.exit_json(changed=False, msg="VM with vmid = %s is already exists" % vmid)
      elif not (node, module.params['hostname'] and module.params['password'] and module.params['ostemplate']):
        module.fail_json(msg='node, hostname, password and ostemplate are mandatory for creating vm')
      elif not node_check(proxmox, node):
        module.fail_json(msg="node '%s' not exists in cluster" % node)
      elif not content_check(proxmox, node, module.params['ostemplate'], storage):
        module.fail_json(msg="ostemplate '%s' not exists on node %s and storage %s"
                         % (module.params['ostemplate'], node, storage))
コード例 #45
0
ファイル: proxmox_vm.py プロジェクト: TieWei/ansible-extras
class ProxmoxBroker(object):

    def __init__(self, backend, host, user, **kwargs):
        """A wrapper object for ProxmoxAPI.

        :param backend: the backend of proxmoxer
        :param host: the host of proxmox server
        :param user: the api user name of proxmox server (default 'root')
        :param kwargs: other args ProxmoxAPI accepted
        :returns: ProxmoxBroker -- ProxmoxBroker object for module usage.
        """

        # here timeout is task timeout, not connection timeout
        self.timeout = kwargs.pop('timeout', 30)
        self.backend = backend
        self.proxmox = ProxmoxAPI(host, backend=backend, user=user, **kwargs)

    def _proxmox_node(self, node):
        """Get ProxmoxResource object for given node.

        :param node: the node name
        :returns: ProxmoxResource -- ProxmoxResource object for given node.
        """
        return self.proxmox.nodes(node)

    def _is_int(self, string):
        """Verify if given string could be convert to integer.

        :param string: the given string
        :returns: bool -- if given string could be convert to integer.
        """
        try:
            int(string)
            return True
        except ValueError:
            return False

    def _is_node_valid(self, node):
        """Verify if given node could be found in proxmox cluster.

        :param string: the node name
        :returns: bool -- if given node could be found in proxmox cluster.
        """
        for nd in self.proxmox.nodes.get():
            if nd['node'] == node:
                return True
        return False

    def _get_snapshot(self, node, vmid, snapname):
        """Get snapshot resource of given instance.

        :param node: the node name of instance
        :param vmid: the vmid of instance
        :param snapname: the snapshot name
        :returns: ProxmoxResource -- snampshot resource of the instance.
        """
        for snap in self._proxmox_node(node).qemu(vmid).snapshot.get():
            if snap.get('name') == snapname:
                return snap
        return None

    def _wait_until_timeout(self, node, taskid, vmstatus={}):
        """Wait until a task completed and meet expected vm status.

        :param node: the node name of the task
        :param taskid: the taskid
        :param vmstatus: expected vm status,
                         e.g. {"vmid": "foo", "status": "bar"}
        :returns: (bool, string): task result, message
        """
        if self.backend is not 'https':
            taskid = [data for data in taskid.split('\n') if 'UPID' in data][0]

        proxmox_node = self._proxmox_node(node)
        timeout = self.timeout
        while timeout >= 0:
            task_status = proxmox_node.tasks(taskid).status.get()
            if (task_status['status'] == 'stopped' and
                    task_status['exitstatus'] == 'OK'):

                if not vmstatus:
                    return True, "OK"
                else:
                    if vmstatus['status'] in ('absent', 'present'):
                        vms = [vm for vm in proxmox_node.qemu().get()
                               if vm['vmid'] == vmstatus['vmid']]
                        if vmstatus['status'] == 'absent' and len(vms) == 0:
                            return True, "OK"
                        elif vmstatus['status'] == 'present' and len(vms) == 1:
                            return True, vms[0]
                    else:
                        vm = proxmox_node.qemu(vmstatus['vmid']
                                               ).status.current.get()
                        if vm['status'] == vmstatus['status']:
                            return True, vm

            timeout = timeout - 1
            if timeout == 0:
                msg = proxmox_node.tasks(taskid).log.get()[:1]
                return False, msg
            time.sleep(1)
        return False, msg

    def get_instance(self, vmid_or_name, node=None):
        """Get info of an instance.

        :param vmid_or_name: the instance name or vmid
        :param node: node name of the instance (default None)
        :returns: (bool, string) -- (result of the task, vm info if success
                                     or error message if fail)
        """
        if self._is_int(vmid_or_name):
            field = 'vmid'
            vmid_or_name = int(vmid_or_name)
        else:
            field = 'name'
            vmid_or_name = str(vmid_or_name)
        vms = []
        for vm in self.proxmox.cluster.resources.get(type='vm'):
            if vm.get(field) == vmid_or_name and (not node or
                                                  vm.get('node') == node):
                vms.append(vm)

        if len(vms) == 1:
            return True, vms[0]
        elif len(vms) == 0:
            return False, "No instance with name or id %s found" % vmid_or_name
        else:
            return (False, "More than one instance with name or id %s found" %
                    vmid_or_name)

    def clone_instance(self, name, template, node):
        """Create new instance based on a template.

        Create a new instance based on given template, it will use the max_id+1
        as vmid, and will wait until the task done and the vm is present on the
        node.

        :param name: the new instance name
        :param template: the template name or vmid
        :param node: node name for the new instance
        :returns: (bool, bool,string) -- (result of the task, changed or not on
                                          proxmox, message for user)
        """
        existed, _ = self.get_instance(name, node)
        if existed:
            return False, False, "VM with name = %s already exists" % name
        if not self._is_node_valid(node):
            return False, False, "node '%s' not exists in cluster" % node
        template_existed, t_vm = self.get_instance(template, node=node)
        if not template_existed:
            return False, False, "%s is not existed" % template
        elif template_existed and t_vm['template'] == 0:
            return False, False, "%s is not a valid template" % template
        else:
            proxmox_node = self._proxmox_node(node)
            next_id = max([vm['vmid'] for vm in proxmox_node.qemu.get()]) + 1
            taskid = proxmox_node.qemu(t_vm['vmid']).clone.post(newid=next_id,
                                                                name=name)
            expected_status = {"vmid": next_id, "status": 'present'}
            result, log = self._wait_until_timeout(node, taskid,
                                                   expected_status)

            if not result:
                return (False, True, "Reached timeout while waiting for clone "
                        "VM, last line in task before timeout %s" % log)
            else:
                return True, True, "cloned"

    def start_instance(self, name, node=None):
        """Start an instance.

        Start an instance with given name or id, it will wait until the task
        done and vm in 'running' status.

        :param name: the instance name or id
        :param node: node name for the instance, (default None)
        :returns: (bool, bool,string) -- (result of the task, changed or not on
                                          proxmox, message for user)
        """
        rc, msg = self.get_instance(name, node)
        if not rc:
            return (rc, False, msg)
        elif msg['status'] == 'running':
            msg = "VM %s is already running" % name
            return True, False, msg
        else:
            vm = msg
            proxmox_node = self._proxmox_node(vm['node'])
            taskid = proxmox_node.qemu(vm['vmid']).status.start.post()

            expected_status = {"vmid": vm['vmid'], "status": 'running'}
            success, log = self._wait_until_timeout(vm['node'], taskid,
                                                    expected_status)

            if not success:
                return (False, True, "Reached timeout while waiting for "
                                     "starting VM, last line in task before "
                                     "timeout %s" % log)
            else:
                return True, True, "started"

    def stop_instance(self, name, node=None, force=False):
        """Stop an instance.

        Stop an instance with given name or id, it will wait until the task
        done and vm in 'stopped' status. if force=True, it will call stop for
        the instance, otherwise will call (ACPI) shutdown.

        :param name: the instance name or id
        :param node: node name for the instance, (default None)
        :param force: stop (True) or shutdown (False), (default False)
        :returns: (bool, bool,string) -- (result of the task, changed or not on
                                          proxmox, message for user)
        """
        rc, msg = self.get_instance(name, node)
        if not rc:
            return rc, False, msg
        elif msg['status'] == 'stopped':
            msg = "VM %s is already stopped" % name
            return True, False, msg
        else:
            vm = msg
            proxmox_node = self._proxmox_node(vm['node'])
            if force:
                taskid = proxmox_node.qemu(vm['vmid']).status.stop.post()
            else:
                taskid = proxmox_node.qemu(vm['vmid']).status.shutdown.post()

            expected_status = {"vmid": vm['vmid'], "status": 'stopped'}
            success, log = self._wait_until_timeout(vm['node'], taskid,
                                                    expected_status)

            if not success:
                return (False, True, "Reached timeout while waiting for "
                                     "stopping VM, last line in task before "
                                     "timeout %s" % log)
            else:
                return True, True, "stopped"

    def delete_instance(self, name, node=None, force=False):
        """Delete an instance.

        Stop an instance with given name or id, it will wait until the task
        done and vm in absent on node. if force=True, it will stop the instance
        first if it's still in 'running' status, otherwise the task will fail.

        :param name: the instance name or id
        :param node: node name for the instance, (default None)
        :param force: force delete or not, (default False)
        :returns: (bool, bool,string) -- (result of the task, changed or not on
                                          proxmox, message for user)
        """
        rc, msg = self.get_instance(name, node)
        if not rc:
            msg = "VM %s is already absent" % name
            return True, False, msg
        elif msg['status'] != 'stopped' and not force:
            msg = "VM %s is not stopped" % name
            return False, False, msg
        else:
            vm = msg
            proxmox_node = self._proxmox_node(vm['node'])
            if msg['status'] != 'stopped' and force:
                self.stop_instance(name, node, force=True)
            taskid = proxmox_node.qemu(vm['vmid']).delete()

            expected_status = {"vmid": vm['vmid'], "status": 'absent'}
            success, log = self._wait_until_timeout(vm['node'], taskid,
                                                    expected_status)
            if not success:
                return (False, True, "Reached timeout while waiting for "
                                     "deleting VM, last line in task before "
                                     "timeout %s" % log)
            else:
                return True, True, "deleted"

    def snapshot_instance(self, name, snapname, node=None):
        """Take a snapshot for an instance.

        :param name: the instance name or id
        :param snapname: the name of the snapshot
        :param node: node name for the instance, (default None)
        :returns: (bool, bool,string) -- (result of the task, changed or not on
                                          proxmox, message for user)
        """
        rc, msg = self.get_instance(name, node)
        if not rc:
            return rc, False, msg
        else:
            vm = msg
            snap = self._get_snapshot(vm['node'], vm['vmid'], snapname)
            if snap:
                return True, False, "Snapshot %s exists" % snapname
            proxmox_node = self._proxmox_node(vm['node'])
            taskid = proxmox_node.qemu(vm['vmid']).snapshot().post(
                snapname=snapname, vmstate="1")

            success, log = self._wait_until_timeout(vm['node'], taskid)

            if not success:
                return (False, True, "Reached timeout while waiting for "
                                     "snapshot VM, last line in task before "
                                     "timeout %s" % log)
            else:
                return True, True, "snapshotted"

    def restore_instance(self, name, snapname, node=None):
        """Restore an instance from a snapshot.

        :param name: the instance name or id
        :param snapname: the name of the snapshot to restore from
        :param node: node name for the instance, (default None)
        :returns: (bool, bool,string) -- (result of the task, changed or not on
                                          proxmox, message for user)
        """
        rc, msg = self.get_instance(name, node)
        if not rc:
            return rc, False, msg
        else:
            vm = msg
            snap = self._get_snapshot(vm['node'], vm['vmid'], snapname)
            if not snap:
                return False, False, "Snapshot %s not found" % snapname
            proxmox_node = self._proxmox_node(vm['node'])
            taskid = proxmox_node.qemu(vm['vmid']).snapshot(
                snapname).rollback.post()

            success, log = self._wait_until_timeout(vm['node'], taskid)

            if not success:
                return (False, True, "Reached timeout while waiting for "
                                     "restore VM, last line in task before "
                                     "timeout %s" % log)
            else:
                return True, True, "restored"
コード例 #46
0
ファイル: new_kvm.py プロジェクト: RemiZOffAlex/pytin-agent
class KVM():
    def __init__(self, uuid=None):
        self.proxmox = None
        self.node = None
        self.password = None
        self.uuid = uuid
        self.log = []
        self.result = []

    def connect(self, hostname, password, nodename):
        self.proxmox = ProxmoxAPI(hostname, user='******',
                              password=password,
                              verify_ssl=False)
        self.node = self.proxmox.nodes(nodename)
        self.password = pwgen()

    def create(self,
               vmid=100,
               hostname='newvm',
               mem=512,
               cpus=1):
        try:
            self.node.qemu.create(vmid=vmid,
                    ostype='l26',
                   name=hostname,
                   storage='local',
                   memory=mem,
                   sockets=1,
                   cores=cpus,
                   net0='rtl8139,rate=50,bridge=vmbr0',
                   virtio0='local:' + str(vmid) + '/vm-' + str(vmid) + '-disk-1.qcow2,cache=writeback,mbps_rd=5,mbps_wr=5',
                   cdrom='none')
        except:
            return False
        finally:
            self.result.append('<result action="create" state="ready"/>')

        # Время на создание VM
        time.sleep(15)

        #self.node.qemu(vmid).config.post(onboot=1)

        return True

    def createstorage(self, vmid=100, size=5):
        """
        Создать диск для ВМ
        """
        try:
            self.node.storage.local.content.post(
                filename='vm-' + str(vmid) + '-disk-1.qcow2',
                format='qcow2', size=str(size) + 'G', vmid=vmid)
        except BaseException as err:
            self.log.append(err)
            return False
        finally:
            self.log.append('<result action="createstorage" state="ready"/>')
        return True

    def startvm(self, vmid=100, args=None):
        """
        Запустить ВМ
        """
        self.node.qemu(vmid).config.post(delete="args")
        #self.node.qemu(vmid).config.set(args='')
        if args:
            if len(args)>0:
                self.node.qemu(vmid).config.post(args=args)
        else:
            args = '-kernel /root/ipxe.lkrn -append \"dhcp && chain http://pxe.justhost.ru/uuid/' + self.uuid + '.boot.php\"'
            self.node.qemu(vmid).config.set(args=args)
            #self.node.qemu(int(vmid)).config.post(args=arguments)
            
        self.node.qemu(vmid).status.start.post()

    def stopvm(self, vmid=100):
        """
        Остановить ВМ
        """
        if self.isVMExist(vmid):
            self.node.qemu(vmid).status.stop.post()

    def deletevm(self, vmid=100):
        """
        Удалить ВМ
        """
        if self.isVMExist(vmid):
            self.node.qemu(vmid).delete()
            time.sleep(15)

    def isVMExist(self, vmid=100):
        """
        Проверка на существование ВМ с указанным ID
        """
        result = False
        for item in self.node.openvz.get():
            if item['vmid'] == str(vmid):
                result=True
        for item in self.node.qemu.get():
            if item['vmid'] == str(vmid):
                result=True
        return result

    def task(self, tasks):
        """
        Пакетный режим
        """
        result = []
        flagerror = False
        for item in tasks:
            self.log.append(item)
            if item['action'] == 'connect':
                if self.connect(item['hostname'],
                     item['password'], item['node']):
                    result.append({'action': 'connect',
                        'status': 'error'})
                else:
                    result.append({'action': 'connect',
                        'status': 'error'})
            elif item['action'] == 'create':
                self.createstorage(vmid=int(item['vmid']),
                                   size=item['hdd'])
                self.create(vmid=int(item['vmid']),
                            hostname=item['hostname'],
                            mem=item['mem'],
                            cpus=item['cpu'])
                time.sleep(10)
                result.append({'action': 'create',
                    'status': 'ready'})
            elif item['action'] == 'delete':
                self.log.append('Удаление KVM ' + str(item['vmid']))
                self.deletevm(vmid=item['vmid'])
                time.sleep(10)
                self.log.append('Удалена KVM ' + str(item['vmid']))
                result.append({'action': 'delete',
                    'status': 'ready'})
            elif item['action'] == 'start':
                if 'args' in item.keys():
                    self.startvm(vmid=item['vmid'], args=item['args'])
                else:
                    self.startvm(vmid=item['vmid'])
                result.append({'action': 'start',
                    'status': 'ready'})
            elif item['action'] == 'stop':
                self.stopvm(vmid=item['vmid'])
                result.append({'action': 'stop',
                    'status': 'ready'})
            elif item['action'] == 'wait':
                time.sleep(300)
        if flagerror:
            return {'result': 'kvm', 'status': 'ready',
                'actions': result}
        else:
            return {'result': 'kvm', 'status': 'error',
                'actions': result}
コード例 #47
0
                        default='dir', choices=['dir', 'lvm'],
                        help='Virtual machine storage backend')

    args = parser.parse_args()

    vmid = str(args.vmid)
    name = args.name
    flavor_type = args.flavor
    storage_type = args.storage

    # customize flavor
    instance, flavor = instance_customize(instance, vmid, name, flavor_type)

    # proxmoxer initialize
    proxmox_api = ProxmoxAPI(proxmox['host'], user=proxmox['user'],
                             password=proxmox['password'],
                             verify_ssl=proxmox['verify_ssl'])

    node = proxmox_api.nodes(proxmox['node'])

    # create kvm machine
    node.qemu.create(vmid=vmid, name=name, sockets=flavor['sockets'],
                     cores=flavor['cores'], balloon=flavor['balloon'],
                     memory=flavor['memory'], net0=instance['net'])

    # seeding
    seed(vmid, instance, proxmox)

    # set seed iso
    node.qemu(vmid).config.set(virtio1=instance['hd_seed'])
コード例 #48
0
ファイル: tbhost.py プロジェクト: esnet/enos
def buildlxc(host):
    """ Creates lxc in proxmox using given hostresource configuration """
    
    if not exists(host):
    	raise ValueError("Host template is missing. Please create host template")
    
    container = Container.getContainer(HOST_CONTAINER)
    hostresource = container.loadResource(host)
    
    #get proxmox user and hypervisor 
    userresource = proxmoxutil.listuser()
    if userresource is None:
    	raise ValueError("No proxmox user found!! Please use proxmoxutil command to update user credentials")
    		
    user = userresource.properties[PROPERTIES_USER]
    password = userresource.properties[PROPERTIES_PASSWORD]
    authrealm = userresource.properties[PROPERTIES_AUTHREALM]
    puser = user+'@'+authrealm
    	  	
    primary = proxmoxutil.listprimary()
    		
    if primary is None:
    	raise ValueError("Primary proxmox hypervisor not found!! Please use proxmoxutil command to update primary hypervisor")
    	
    hypervisor = primary.properties[PROPERTIES_HYPERVISOR]
    print "Authenticating "+puser +" on "+ hypervisor
    proxmox = ProxmoxAPI(hypervisor, user=puser, password=password, verify_ssl=False)
    node = proxmox.nodes(hostresource.properties[HYPERVISOR])
    
    hostname = hostresource.properties[HOSTNAME]  		
    vmid = int(hostresource.properties[HOSTID])
    ostemplate = str(hostresource.properties[PROPERTIES_OSTEMPLATE])
    cpulimit = int(hostresource.properties[PROPERTIES_CPULIMIT])
    cpuunits = int(hostresource.properties[PROPERTIES_CPUUNITS])
    memory = int(hostresource.properties[PROPERTIES_MEMORY])
    swap = int(hostresource.properties[PROPERTIES_SWAP])
    storage = hostresource.properties[PROPERTIES_STORAGE]
    disk = int(hostresource.properties[PROPERTIES_DISK])    
    disksize="%dG"%(disk)    
    interfaces = hostresource.properties[INTERFACES]
    
    i=0
    netconfig = dict()
    for interface in interfaces:
    	print "Configuring %s" %interface    	
    	netconfig["net"+str(i)] = hostresource.properties[interface]
    	i=i+1
    	
    print "Building LXC with the following parameters:"
    print "Vmid: %d" %vmid
    print "Template: %s" %ostemplate
    print "Cpu Limit: %d" %cpulimit
    print "Cpu Units: %d" %cpuunits
    print "Memory: %d" %memory
    print "Swap: %d" %swap
    print "Storage: %s" %storage
    print "Disk: %d" %disk 
    
    node.lxc.create(vmid=vmid, hostname=hostname, ostemplate=ostemplate, password=DEFAULT_PASSWORD, cpuunits=cpuunits, cpulimit=cpulimit, memory=memory, swap=swap, **netconfig)
    print "Creating LXC....."
    time.sleep(30)
    
    print "Resizing rootfs"	
    node.lxc(vmid).resize.put(disk='rootfs', size=disksize)
    time.sleep(30)
    print "LXC created"    
コード例 #49
0
  disk = module.params['disk']
  cpus = module.params['cpus']
  memory = module.params['memory']
  swap = module.params['swap']
  storage = module.params['storage']
  timeout = module.params['timeout']

  # If password not set get it from PROXMOX_PASSWORD env
  if not api_password:
    try:
      api_password = os.environ['PROXMOX_PASSWORD']
    except KeyError, e:
      module.fail_json(msg='You should set api_password param or use PROXMOX_PASSWORD environment variable')

  try:
    proxmox = ProxmoxAPI(api_host, user=api_user, password=api_password, verify_ssl=validate_certs)
    global VZ_TYPE
    VZ_TYPE = 'openvz' if float(proxmox.version.get()['version']) < 4.0 else 'lxc'

  except Exception, e:
    module.fail_json(msg='authorization on proxmox cluster failed with exception: %s' % e)

  if state == 'present':
    try:
      if get_instance(proxmox, vmid) and not module.params['force']:
        module.exit_json(changed=False, msg="VM with vmid = %s is already exists" % vmid)
      elif not (node, module.params['hostname'] and module.params['password'] and module.params['ostemplate']):
        module.fail_json(msg='node, hostname, password and ostemplate are mandatory for creating vm')
      elif not node_check(proxmox, node):
        module.fail_json(msg="node '%s' not exists in cluster" % node)
      elif not content_check(proxmox, node, module.params['ostemplate'], storage):
コード例 #50
0
## Determine variables
online_api_token = "YOUR_ONLINE_API_TOKEN"
proxmox_api_server = "127.0.0.1"
proxmox_api_login = "******"
proxmox_api_password = "******"

## Initialize Online API
online_api_session = requests.session()
online_api_session.headers['Authorization'] = "Bearer " + online_api_token
online_api = slumber.API('https://api.online.net/api/v1', session=online_api_session)

## Retrieve IPFAILOVER informations
failover_info = online_api.server.failover.get()

## Initialize Proxmox API
proxmox_api = ProxmoxAPI(proxmox_api_server, user=proxmox_api_login, password=proxmox_api_password, verify_ssl=False)

## Check Cluster Status
proxmox_cluster = proxmox_api.cluster.status.get()
proxmox_members = proxmox_api.nodes.get()

checked_mac=[]

## For each node in cluster
for node_member in proxmox_members:
    # Check if member is node
    for member in proxmox_cluster:
        if member["type"]=="node" and node_member["node"] == member["name"]:
            cluster_member=member
            
    # If host is alive (if is not alive, don't ask the node)
コード例 #51
0
ファイル: new_ovz.py プロジェクト: itnihao/pytin
userID=''
vmid=100
hvname='node1'

nodes={'node1': {'name': 'IPorHOSTNAME', 'password': '******'},
       'node2': {'name': 'IPorHOSTNAME', 'password': '******'}}

ostemplates=['local:vztmpl/debian-7.0-x86.tar.gz',
    'local:vztmpl/ubuntu-14.04-x86.tar.gz',
    'local:vztmpl/ubuntu-14.04-x86_64.tar.gz',
    'local:vztmpl/centos-6-x86.tar.gz',
    'local:vztmpl/centos-6-x86_64.tar.gz',
    'local:vztmpl/centos-7-x86_64.tar.gz']

proxmox = ProxmoxAPI(nodes[hvname]['name'], user='******',
                     password=nodes[hvname]['password'],
                     verify_ssl=False)

def isUserExist(proxmox, user):
    result = False
    for item in proxmox.access.users.get():
        if item['userid'] == user:
            result = True
    return result

if not isUserExist(proxmox, 'u' + userID + '@pve'):
    proxmox.access.users.create(userid='u' + userID + '@pve', password='******')

node = proxmox.nodes(hvname)
node.openvz.create(vmid=vmid,
                   ostemplate=ostemplates[4],
コード例 #52
0
ファイル: hvinfo.py プロジェクト: RemiZOffAlex/pytin-agent
 def __init__(self, host, password):
     self.proxmox=ProxmoxAPI(host, user='******',
                             password=password,
                             verify_ssl=False)
コード例 #53
0
ファイル: new_ovz.py プロジェクト: RemiZOffAlex/pytin-agent
class OVZ():
    def __init__(self):
        self.proxmox = None
        self.node = None
        self.password = None
        self.log = []

    def connect(self, hostname, password, nodename):
        self.proxmox = ProxmoxAPI(hostname, user='******',
                                  password=password,
                                  verify_ssl=False)
        self.node = self.proxmox.nodes(nodename)
        self.password = pwgen()

    def create(self,
               vmid=100,
               template='local:vztmpl/centos-6-x86_64.tar.gz',
               hostname='newvm',
               mem=512,
               hdd=5,
               cpus=1,
               iplist=[],
               nameserver='8.8.8.8'):
        if not self.isVMExist(vmid):
            try:
                self.node.openvz.create(vmid=vmid,
                                        ostemplate=template,
                                        hostname=hostname,
                                        storage='local',
                                        memory=mem,
                                        swap=0,
                                        cpus=cpus,
                                        disk=hdd,
                                        password=self.password,
                                        ip_address=iplist,
                                        nameserver=nameserver)
            except:
                return False
            # Время на распаковку архива контейнера
            time.sleep(30)

            self.node.openvz(vmid).config.set(onboot=1)
        return True

    def startvm(self, vmid=100):
        if self.isVMExist(vmid):
            self.node.openvz(vmid).status.start.post()

    def stopvm(self, vmid=100):
        if self.isVMExist(vmid):
            self.node.openvz(vmid).status.stop.post()

    def deletevm(self, vmid=100):
        if self.isVMExist(vmid):
            self.node.openvz(vmid).delete()

    def isVMExist(self, vmid=100):
        result = False
        for item in self.node.openvz.get():
            if item['vmid'] == vmid:
                result=True
        for item in self.node.qemu.get():
            if item['vmid'] == vmid:
                result=True
        return result

    def machines(self):
        result = self.node.openvz.get()
        return result

    def task(self, xml):
        """
        Пакетный режим
        """
        result=[]
        self.log.append('OVZ task begin')
        for item in xml:
            self.log.append(item.tag)
            if item.tag == 'connect':
                self.connect(item.attrib['hostname'],
                             item.attrib['password'],
                             item.attrib['node'])
            elif item.tag == 'create':
                iplist=[]
                for ip in item:
                    iplist.append(ip.text)
                if self.create(vmid=item.attrib['vmid'],
                   template='local:vztmpl/' + item.attrib['template'],
                   hostname=item.attrib['hostname'],
                   mem=item.attrib['mem'],
                   hdd=item.attrib['hdd'],
                   cpus=item.attrib['cpu'],
                   iplist=iplist,
                   nameserver='46.17.40.200 46.17.46.200'):
                    result.append('<result type="openvz" status="error" description="Ошибка создания"/>')
                else:
                    time.sleep(10)
                    result.append('<result type="openvz" status="ready" password="******"/>')
            elif item.tag == 'delete':
                self.deletevm(vmid=xml.attrib['vmid'])
            elif item.tag == 'start':
                self.startvm(vmid=item.attrib['vmid'])
            elif item.tag == 'wait':
                time.sleep(300)
        self.log.append('OVZ task end')
        return result
コード例 #54
0
def main():
  module = AnsibleModule(
    argument_spec = dict(
      api_host = dict(required=True),
      api_user = dict(required=True),
      api_password = dict(no_log=True),
      vmid = dict(required=True),
      validate_certs = dict(type='bool', default='no'),
      node = dict(),
      password = dict(no_log=True),
      hostname = dict(),
      ostemplate = dict(),
      disk = dict(type='str', default='3'),
      cpus = dict(type='int', default=1),
      memory = dict(type='int', default=512),
      swap = dict(type='int', default=0),
      netif = dict(type='dict'),
      mounts = dict(type='dict'),
      ip_address = dict(),
      onboot = dict(type='bool', default='no'),
      storage = dict(default='local'),
      cpuunits = dict(type='int', default=1000),
      nameserver = dict(),
      searchdomain = dict(),
      timeout = dict(type='int', default=30),
      force = dict(type='bool', default='no'),
      state = dict(default='present', choices=['present', 'absent', 'stopped', 'started', 'restarted']),
    )
  )

  if not HAS_PROXMOXER:
    module.fail_json(msg='proxmoxer required for this module')

  state = module.params['state']
  api_user = module.params['api_user']
  api_host = module.params['api_host']
  api_password = module.params['api_password']
  vmid = module.params['vmid']
  validate_certs = module.params['validate_certs']
  node = module.params['node']
  disk = module.params['disk']
  cpus = module.params['cpus']
  memory = module.params['memory']
  swap = module.params['swap']
  storage = module.params['storage']
  if module.params['ostemplate'] is not None:
    template_store = module.params['ostemplate'].split(":")[0]
  timeout = module.params['timeout']

  # If password not set get it from PROXMOX_PASSWORD env
  if not api_password:
    try:
      api_password = os.environ['PROXMOX_PASSWORD']
    except KeyError as e:
      module.fail_json(msg='You should set api_password param or use PROXMOX_PASSWORD environment variable')

  try:
    proxmox = ProxmoxAPI(api_host, user=api_user, password=api_password, verify_ssl=validate_certs)
    global VZ_TYPE
    VZ_TYPE = 'openvz' if float(proxmox.version.get()['version']) < 4.0 else 'lxc'

  except Exception as e:
    module.fail_json(msg='authorization on proxmox cluster failed with exception: %s' % e)

  if state == 'present':
    try:
      if get_instance(proxmox, vmid) and not module.params['force']:
        module.exit_json(changed=False, msg="VM with vmid = %s is already exists" % vmid)
      elif not (node, module.params['hostname'] and module.params['password'] and module.params['ostemplate']):
        module.fail_json(msg='node, hostname, password and ostemplate are mandatory for creating vm')
      elif not node_check(proxmox, node):
        module.fail_json(msg="node '%s' not exists in cluster" % node)
      elif not content_check(proxmox, node, module.params['ostemplate'], template_store):
        module.fail_json(msg="ostemplate '%s' not exists on node %s and storage %s"
                         % (module.params['ostemplate'], node, template_store))

      create_instance(module, proxmox, vmid, node, disk, storage, cpus, memory, swap, timeout,
                      password = module.params['password'],
                      hostname = module.params['hostname'],
                      ostemplate = module.params['ostemplate'],
                      netif = module.params['netif'],
                      mounts = module.params['mounts'],
                      ip_address = module.params['ip_address'],
                      onboot = int(module.params['onboot']),
                      cpuunits = module.params['cpuunits'],
                      nameserver = module.params['nameserver'],
                      searchdomain = module.params['searchdomain'],
                      force = int(module.params['force']))

      module.exit_json(changed=True, msg="deployed VM %s from template %s"  % (vmid, module.params['ostemplate']))
    except Exception as e:
      module.fail_json(msg="creation of %s VM %s failed with exception: %s" % ( VZ_TYPE, vmid, e ))

  elif state == 'started':
    try:
      vm = get_instance(proxmox, vmid)
      if not vm:
        module.fail_json(msg='VM with vmid = %s not exists in cluster' % vmid)
      if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'running':
        module.exit_json(changed=False, msg="VM %s is already running" % vmid)

      if start_instance(module, proxmox, vm, vmid, timeout):
        module.exit_json(changed=True, msg="VM %s started" % vmid)
    except Exception as e:
      module.fail_json(msg="starting of VM %s failed with exception: %s" % ( vmid, e ))

  elif state == 'stopped':
    try:
      vm = get_instance(proxmox, vmid)
      if not vm:
        module.fail_json(msg='VM with vmid = %s not exists in cluster' % vmid)

      if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'mounted':
        if module.params['force']:
          if umount_instance(module, proxmox, vm, vmid, timeout):
            module.exit_json(changed=True, msg="VM %s is shutting down" % vmid)
        else:
          module.exit_json(changed=False, msg=("VM %s is already shutdown, but mounted. "
                                               "You can use force option to umount it.") % vmid)

      if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'stopped':
        module.exit_json(changed=False, msg="VM %s is already shutdown" % vmid)

      if stop_instance(module, proxmox, vm, vmid, timeout, force = module.params['force']):
        module.exit_json(changed=True, msg="VM %s is shutting down" % vmid)
    except Exception as e:
      module.fail_json(msg="stopping of VM %s failed with exception: %s" % ( vmid, e ))

  elif state == 'restarted':
    try:
      vm = get_instance(proxmox, vmid)
      if not vm:
        module.fail_json(msg='VM with vmid = %s not exists in cluster' % vmid)
      if ( getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'stopped'
          or getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'mounted' ):
        module.exit_json(changed=False, msg="VM %s is not running" % vmid)

      if ( stop_instance(module, proxmox, vm, vmid, timeout, force = module.params['force']) and
          start_instance(module, proxmox, vm, vmid, timeout) ):
        module.exit_json(changed=True, msg="VM %s is restarted" % vmid)
    except Exception as e:
      module.fail_json(msg="restarting of VM %s failed with exception: %s" % ( vmid, e ))

  elif state == 'absent':
    try:
      vm = get_instance(proxmox, vmid)
      if not vm:
        module.exit_json(changed=False, msg="VM %s does not exist" % vmid)

      if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'running':
        module.exit_json(changed=False, msg="VM %s is running. Stop it before deletion." % vmid)

      if getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE)(vmid).status.current.get()['status'] == 'mounted':
        module.exit_json(changed=False, msg="VM %s is mounted. Stop it with force option before deletion." % vmid)

      taskid = getattr(proxmox.nodes(vm[0]['node']), VZ_TYPE).delete(vmid)
      while timeout:
        if ( proxmox.nodes(vm[0]['node']).tasks(taskid).status.get()['status'] == 'stopped'
            and proxmox.nodes(vm[0]['node']).tasks(taskid).status.get()['exitstatus'] == 'OK' ):
          module.exit_json(changed=True, msg="VM %s removed" % vmid)
        timeout = timeout - 1
        if timeout == 0:
          module.fail_json(msg='Reached timeout while waiting for removing VM. Last line in task before timeout: %s'
                           % proxmox_node.tasks(taskid).log.get()[:1])

        time.sleep(1)
    except Exception as e:
      module.fail_json(msg="deletion of VM %s failed with exception: %s" % ( vmid, e ))
コード例 #55
0
ファイル: https_tests.py プロジェクト: Maldita/proxmoxer
class TestSuite():
    proxmox = None
    serializer = None
    session = None

    # noinspection PyMethodOverriding
    @patch('requests.sessions.Session')
    def setUp(self, session):
        response = {'ticket': 'ticket',
                    'CSRFPreventionToken': 'CSRFPreventionToken'}
        session.request.return_value = response
        self.proxmox = ProxmoxAPI('proxmox', user='******', password='******', port=123, verify_ssl=False)
        self.serializer = MagicMock()
        self.session = MagicMock()
        self.session.request.return_value.status_code = 200
        self.proxmox._store['session'] = self.session
        self.proxmox._store['serializer'] = self.serializer

    def test_get(self):
        self.proxmox.nodes('proxmox').storage('local').get()
        eq_(self.session.request.call_args[0], ('GET', 'https://proxmox:123/api2/json/nodes/proxmox/storage/local'))

    def test_delete(self):
        self.proxmox.nodes('proxmox').openvz(100).delete()
        eq_(self.session.request.call_args[0], ('DELETE', 'https://proxmox:123/api2/json/nodes/proxmox/openvz/100'))
        self.proxmox.nodes('proxmox').openvz('101').delete()
        eq_(self.session.request.call_args[0], ('DELETE', 'https://proxmox:123/api2/json/nodes/proxmox/openvz/101'))

    def test_post(self):
        node = self.proxmox.nodes('proxmox')
        node.openvz.create(vmid=800,
                           ostemplate='local:vztmpl/debian-6-turnkey-core_12.0-1_i386.tar.gz',
                           hostname='test',
                           storage='local',
                           memory=512,
                           swap=512,
                           cpus=1,
                           disk=4,
                           password='******',
                           ip_address='10.0.100.222')
        eq_(self.session.request.call_args[0], ('POST', 'https://proxmox:123/api2/json/nodes/proxmox/openvz'))
        ok_('data' in self.session.request.call_args[1])
        data = self.session.request.call_args[1]['data']
        eq_(data['cpus'], 1)
        eq_(data['disk'], 4)
        eq_(data['hostname'], 'test')
        eq_(data['ip_address'], '10.0.100.222')
        eq_(data['memory'], 512)
        eq_(data['ostemplate'], 'local:vztmpl/debian-6-turnkey-core_12.0-1_i386.tar.gz')
        eq_(data['password'], 'secret')
        eq_(data['storage'], 'local')
        eq_(data['swap'], 512)
        eq_(data['vmid'], 800)

        node = self.proxmox.nodes('proxmox1')
        node.openvz.post(vmid=900,
                         ostemplate='local:vztmpl/debian-7-turnkey-core_12.0-1_i386.tar.gz',
                         hostname='test1',
                         storage='local1',
                         memory=1024,
                         swap=1024,
                         cpus=2,
                         disk=8,
                         password='******',
                         ip_address='10.0.100.111')
        eq_(self.session.request.call_args[0], ('POST', 'https://proxmox:123/api2/json/nodes/proxmox1/openvz'))
        ok_('data' in self.session.request.call_args[1])
        data = self.session.request.call_args[1]['data']
        eq_(data['cpus'], 2)
        eq_(data['disk'], 8)
        eq_(data['hostname'], 'test1')
        eq_(data['ip_address'], '10.0.100.111')
        eq_(data['memory'], 1024)
        eq_(data['ostemplate'], 'local:vztmpl/debian-7-turnkey-core_12.0-1_i386.tar.gz')
        eq_(data['password'], 'secret1')
        eq_(data['storage'], 'local1')
        eq_(data['swap'], 1024)
        eq_(data['vmid'], 900)

    def test_put(self):
        node = self.proxmox.nodes('proxmox')
        node.openvz(101).config.set(cpus=4, memory=1024, ip_address='10.0.100.100', onboot=True)
        eq_(self.session.request.call_args[0], ('PUT', 'https://proxmox:123/api2/json/nodes/proxmox/openvz/101/config'))
        data = self.session.request.call_args[1]['data']
        eq_(data['cpus'], 4)
        eq_(data['memory'], 1024)
        eq_(data['ip_address'], '10.0.100.100')
        eq_(data['onboot'], True)

        node = self.proxmox.nodes('proxmox1')
        node.openvz(102).config.put(cpus=2, memory=512, ip_address='10.0.100.200', onboot=False)
        eq_(self.session.request.call_args[0],
            ('PUT', 'https://proxmox:123/api2/json/nodes/proxmox1/openvz/102/config'))
        data = self.session.request.call_args[1]['data']
        eq_(data['cpus'], 2)
        eq_(data['memory'], 512)
        eq_(data['ip_address'], '10.0.100.200')
        eq_(data['onboot'], False)