def vmwareplugin_datastores(request):
from pysphere import VIServer
data = {
'error': False,
}
if request.POST.get('oid'):
vmware = models.VMWarePlugin.objects.get(id=request.POST.get('oid'))
else:
vmware = None
try:
if request.POST.get('password'):
password = request.POST.get('password')
elif not request.POST.get('password') and vmware:
password = vmware.get_password()
else:
password = ''
server = VIServer()
server.connect(
request.POST.get('hostname'),
request.POST.get('username'),
password,
sock_timeout=7,
)
data['value'] = server.get_datastores().values()
server.disconnect()
except Exception, e:
data['error'] = True
data['errmsg'] = unicode(e).encode('utf8')
def main():
module = AnsibleModule(argument_spec=dict(
vcenter_hostname=dict(required=True, aliases=['vcenter']),
username=dict(required=True, aliases=['user']),
password=dict(required=True),
guest=dict(required=True),
validate_certs=dict(required=False, type='bool', default=True),
disk=dict(required=True, aliases=['unit']),
size=dict(required=True)),
supports_check_mode=True)
host = module.params.get('vcenter_hostname')
login = module.params.get('username')
password = module.params.get('password')
guest = module.params.get('guest')
validate_certs = module.params['validate_certs']
disk_unit = int(module.params.get('disk'))
disk_size = int(module.params.get('size'))
if disk_unit < 1 or disk_unit > 6:
module.fail_json(msg='Dubious disk unit')
if disk_size < 8 or disk_unit > 2000:
module.fail_json(msg='Dubious disk size')
server = VIServer()
if not validate_certs:
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
try:
server.connect(host, login, password)
except Exception, e:
module.fail_json(msg='Failed to connect to %s: %s' % (host, e))
def main():
module = AnsibleModule(argument_spec=dict(
vcenter_hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
guest=dict(required=True),
validate_certs=dict(required=False, type='bool', default=True),
),
supports_check_mode=True)
host = module.params.get('vcenter_hostname')
login = module.params.get('username')
password = module.params.get('password')
guest = module.params.get('guest')
validate_certs = module.params['validate_certs']
server = VIServer()
if not validate_certs:
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
try:
server.connect(host, login, password)
except Exception, e:
module.fail_json(msg='Failed to connect to %s: %s' % (host, e))
def main(argv=None):
if argv is None:
argv = sys.argv
server = VIServer()
server.connect(sys.argv[1], sys.argv[2], sys.argv[3])
print "{"
print "\t\"data\":[\n"
first = 1
for ds_mor, name in server.get_datastores().items():
props = VIProperty(server, ds_mor)
if not first:
sys.stdout.write(",")
first = 0
pfree = float(props.summary.freeSpace) / float(props.summary.capacity) * 100
print "\n\t{"
print "\t\t\"{#DSNAME}\":\"%s\"," % name
print "\t\t\"{#DSACCESS}\":\"%d\"," % props.summary.accessible
print "\t\t\"{#DSCAP}\":\"%s\"," % props.summary.capacity
print "\t\t\"{#DSFREE}\":\"%s\"," % props.summary.freeSpace
print "\t\t\"{#DSPFREE}\":\"%s\"" % pfree
sys.stdout.write("\t}")
print "\n\t]"
print "}"
server.disconnect()
def host_connect(host):
""" Connect to a host. """
server = VIServer()
server.connect(host, CREDS.get('Host', 'user'),
CREDS.get('Host', 'pass'))
return server
def _connect_server(bot):
try:
server = VIServer()
server.connect(bot.config.pysphere.server, bot.config.pysphere.login, bot.config.pysphere.password)
except Exception, e:
bot.say("No connection to the server")
return False
class ESXI():
def __init__(self, host, name, passwd):
self.host = host # the host's ip
self.name = name # the host's name
self.passwd = passwd # the host's password
self.esxiInst = None # the esxi's handler
self.VMBuf = [] # the all vms in the vcenter
self.datastores = {} # the host's datastores
self.hosts = {} # the host's host
self.esxiInst = VIServer() # get init the handles of the host
self.esxiType = "" # the type(esxi or vcneter) of the host connected
self.VGList = [] # the vms you get from the vm's buffer
self.vm = None # the handler of the vm you got
# connect to ESXI
def esxiConnect(self):
if self.esxiInst == None:
logging.fatal("ESXI connect failed...")
return False
try:
if not self.esxiInst.is_connected():
self.esxiInst.connect(self.host, self.name, self.passwd)
self.esxiType = self.esxiInst.get_api_type()
else:
logging.fatal("esxi already connected")
return False
except VIApiException, e:
logging.fatal(str(e))
return False
except error, e:
logging.fatal(str(e) + " " + "Host Unreachable...")
return False
def main():
u"""Main method
Create session.
Excute subcommand.
"""
# Import
import socket
import getpass
import sys
from pysphere import VIApiException, VIServer
import argument
# Get argument
args = argument.args()
s = VIServer()
# Set information
host = args.host if args.host else raw_input('Host> ')
user = args.user if args.user else raw_input('User> ')
passwd = args.passwd if args.passwd else getpass.getpass('Password> ')
try:
print 'Connecting...'
s.connect(host, user, passwd)
# Execute function
args.func(args, s)
except socket.error:
print >> sys.stderr, "Cannot connected."
except VIApiException:
print >> sys.stderr, "Incorrect user name or password."
except Exception, e:
print >> sys.stderr, e.message
def main(argv=None):
if argv is None:
argv=sys.argv
server = VIServer()
try:
server.connect(sys.argv[1], sys.argv[2], sys.argv[3])
hosts = server.get_hosts()
for h_mor, h_name in hosts.items():
props = VIProperty(server, h_mor)
try:
f = open("/tmp/esxi_hosts_" + sys.argv[1] + ".txt", "w")
try:
f.write("memorySize=" + str(props.hardware.memorySize) + "\n")
f.write("overallCpuUsage=" + str(props.summary.quickStats.overallCpuUsage) + "\n")
f.write("overallMemoryUsage=" + str(props.summary.quickStats.overallMemoryUsage) + "\n")
f.write("uptime=" + str(props.summary.quickStats.uptime) + "\n")
# $CPUTotalMhz = $_.Summary.hardware.CPUMhz * $_.Summary.Hardware.NumCpuCores
# $row."CpuUsage%" = [math]::round( ($row.CpuUsageMhz / $CPUTotalMhz), 2) * 100
f.write("cpuMhz=" + str(props.summary.hardware.cpuMhz) + "\n")
f.write("numCpuCores=" + str(props.summary.hardware.numCpuCores) + "\n")
finally:
f.close()
except IOError:
print "0"
sys.exit(0)
def connect_VI(vcenter_hostname, user, password):
# Create the connection to vCenter Server
server = VIServer()
try:
server.connect(vcenter_hostname, user, password)
except VIApiException, err:
module.fail_json(msg="Cannot connect to %s: %s" % (vcenter_hostname, err))
def vm_status(self, vm_name):
m = Info_log(time.strftime('%Y-%m-%d', time.localtime(time.time())))
log = m.log()
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
# servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
except Exception as e:
server_obj.disconnect()
log.info(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
if vm.is_powered_off() == False:
server_obj.disconnect()
return 1
if vm.is_powered_off() == True:
server_obj.disconnect()
return 2
except Exception as e:
server_obj.disconnect()
return 3
def del_datas(self, vm_name, guster_user, guster_pwd, del_dir):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
# print(e)
return 0
print(vm.get_tools_status())
if vm.get_tools_status() == 'RUNNING': #判断tools状态
print(f'{vm_name} tools is RUNING--------------------')
try:
vm.login_in_guest(guster_user, guster_pwd)
vm.delete_directory(del_dir, recursive=True) # 清空数据盘
except Exception as e:
# print(e)
pass
finally:
print(f'{vm_name} 数据盘清空完毕！！！！！')
else:
print(f'{vm_name} tools is not RUNING--------------------')
def vmwareplugin_datastores(request):
from pysphere import VIServer
data = {
'error': False,
}
if request.POST.get('oid'):
vmware = models.VMWarePlugin.objects.get(id=request.POST.get('oid'))
else:
vmware = None
try:
if request.POST.get('password'):
password = request.POST.get('password')
elif not request.POST.get('password') and vmware:
password = vmware.get_password()
else:
password = ''
server = VIServer()
server.connect(
request.POST.get('hostname'),
request.POST.get('username'),
password,
sock_timeout=7,
)
data['value'] = server.get_datastores().values()
server.disconnect()
except Exception, e:
data['error'] = True
data['errmsg'] = unicode(e).encode('utf8')
def get_connection(host_ip, username, password):
server = VIServer()
if host_ip is not None and username is not None and password is not None:
server.connect(host_ip, username, password)
else:
return None
return server
def vm_status(self, vm_name):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
# servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
except Exception as e:
server_obj.disconnect()
print e
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
if vm.is_powered_off() == False:
server_obj.disconnect()
return 1
if vm.is_powered_off() == True:
server_obj.disconnect()
return 2
except Exception as e:
server_obj.disconnect()
return 3
def viConnect(vCenter,username,password,vmname):
server = VIServer()
server.connect(vCenter,username,password)
#print "vCenter: {} User: {} Pass: {}".format(vCenter,username,password)
#return server
#print viConnect("192.168.219.129","root","vmware")
return getVm(server,vmname)
def vmaction(self, vm_name, vm_hz):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print e
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# print (type(int(vm_hz)))
for i in range(1, int(vm_hz)):
print u'虚拟机%s 正在重置中。。。。，请等待注册\n' % (vm_name)
time.sleep(1)
print u'重置完成'
server_obj.disconnect()
return 1
except Exception as e:
print e
if vm.is_powered_off() == True:
try:
vm.power_on()
print u'虚拟机%s 正在开机中。。。。' % (vm_name)
server_obj.disconnect()
except Exception as e:
return 2
def main(argv):
try:
opts, args = getopt.getopt(
argv, "i:u:p:n:h",
["iphost=", "vuser="******"vpass="******"vmname=", "help"])
except getopt.GetoptError:
print 'test.py -i <vhost> -u <name> -p <vpass> -n <vmname>'
sys.exit(4)
for opt, arg in opts:
if opt == '-h':
print 'test.py -i <vhost> -u <vname> -p <vpass> -n <vmname>'
sys.exit()
elif opt in ("-i", "--vhost"):
iphost = arg
elif opt in ("-u", "--vname"):
vuser = arg
elif opt in ("-p", "--vpass"):
vpass = arg
elif opt in ("-n", "--vmname"):
vmname = arg
ssl._create_default_https_context = ssl._create_unverified_context
server = VIServer()
server.connect(iphost, vuser, vpass)
vm1 = server.get_vm_by_name(vmname)
print vm1.get_properties().get('ip_address')
def host_connect(host):
""" Connect to a host. """
server = VIServer()
server.connect(host, CREDS.get('Host', 'user'),
CREDS.get('Host', 'pass'))
return server
def connectToHost(host,host_user,host_pw):
#create server object
s=VIServer()
#connect to the host
try:
s.connect(host,host_user,host_pw)
return s
def main():
vm = None
module = AnsibleModule(
argument_spec=dict(
vcenter_hostname=dict(required=True, type='str'),
vcenter_username=dict(required=True, type='str'),
vcenter_password=dict(required=True, type='str'),
datacenter_name=dict(required=True, type='str'),
folder_structure=dict(required=True, type='list'),
guest_list=dict(required=True, type='list'),
),
supports_check_mode=False,
)
if not HAS_PYSPHERE:
module.fail_json(msg='pysphere module required')
vcenter_hostname = module.params['vcenter_hostname']
vcenter_username = module.params['vcenter_username']
vcenter_password = module.params['vcenter_password']
guest_list = module.params['guest_list']
folder_structure = module.params['folder_structure']
base_datacenter = module.params['datacenter_name']
# CONNECT TO THE SERVER
viserver = VIServer()
try:
viserver.connect(vcenter_hostname, vcenter_username, vcenter_password)
except VIApiException, err:
module.fail_json(msg="Cannot connect to %s: %s" %
(vcenter_hostname, err))
def esx_connect(host, user, password):
esx = VIServer()
try:
esx.connect(host, user, password)
except VIApiException, e:
print("There was an error while connecting to esx: %s" % e)
return 1
def connect_VI(vcenter_hostname, user, password):
# Create the connection to vCenter Server
server = VIServer()
try:
server.connect(vcenter_hostname, user, password)
except VIApiException, err:
module.fail_json(msg="Cannot connect to %s: %s" % (vcenter_hostname, err))
def main():
vm = None
module = AnsibleModule(
argument_spec=dict(
vcenter_hostname=dict(required=True, type='str'),
vcenter_username=dict(required=True, type='str'),
vcenter_password=dict(required=True, type='str'),
datacenter_name=dict(required=True, type='str'),
folder_structure=dict(required=True, type='list'),
guest_list=dict(required=True, type='list'),
),
supports_check_mode=False,
)
if not HAS_PYSPHERE:
module.fail_json(msg='pysphere module required')
vcenter_hostname = module.params['vcenter_hostname']
vcenter_username = module.params['vcenter_username']
vcenter_password = module.params['vcenter_password']
guest_list = module.params['guest_list']
folder_structure = module.params['folder_structure']
base_datacenter = module.params['datacenter_name']
# CONNECT TO THE SERVER
viserver = VIServer()
try:
viserver.connect(vcenter_hostname, vcenter_username, vcenter_password)
except VIApiException, err:
module.fail_json(msg="Cannot connect to %s: %s" %
(vcenter_hostname, err))
def connect_vcenter(vcenter_address, vcenter_username, vcenter_password):
ssl._create_default_https_context = ssl._create_unverified_context
vcenter_server = VIServer()
vcenter_server.connect(host=vcenter_address,
user=vcenter_username,
password=vcenter_password)
print "connect to vcenter."
return vcenter_server
def vcenter_connect():
""" Connect to the vcenter. """
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
return server
def vcenter_connect():
""" Connect to the vcenter. """
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
return server
def _connect_server(bot):
try:
server = VIServer()
server.connect(bot.config.pysphere.server, bot.config.pysphere.login,
bot.config.pysphere.password)
except Exception, e:
bot.say("No connection to the server")
return False
def connect_host(host, user, pswd):
server = VIServer()
try:
server.connect(host, user, pswd)
LOG.info("Connected to %s %s", server.get_server_type(), host)
return server
except:
print "unable to connect to host: " + host + " error message: "
def __init__(self, vcip, vcuser, vcpassword, dc, clu):
self.vcip = vcip
self.translation = {'POWERED OFF':'down', 'POWERED ON':'up'}
s = VIServer()
s.connect(vcip, vcuser, vcpassword)
self.s = s
self.clu = clu
self.dc = dc
def main():
module = AnsibleModule(
argument_spec=dict(
vcenter_vx=dict(required=True, type='str'),
user=dict(required=True, type='str'),
password=dict(required=True, type='str'),
ansible_resource_pool=dict(required=False,
default=None,
type='str'),
cluster=dict(required=False, default=None, type='str'),
datacenter=dict(required=True, type='str'),
datastore=dict(required=True, type='str'),
esxi_hostname=dict(required=True, type='str'),
power_on=dict(required=False, default='no', type='bool'),
vm_name=dict(required=True, type='str'),
vm_memory_mb=dict(required=False, default=1024),
vm_num_cpus=dict(required=False, default=1),
vm_scsi=dict(required=False, default="paravirtual", type='str'),
vm_disk=dict(required=False, default=None, type='dict'),
vm_nic=dict(required=False, default=None, type='dict'),
vm_notes=dict(required=False, default=None, type='str'),
vm_cdrom=dict(required=False, default=None, type='dict'),
vm_extra_config=dict(required=False, default=None, type='dict'),
guestosid=dict(required=True, type='str'),
),
supports_check_mode=False,
required_together=[['ansible_resource_pool', 'cluster']],
)
if not HAS_PYSPHERE:
module.fail_json(msg="pysphere is not installed")
vcenter_vx = module.params['vcenter_vx']
user = module.params['user']
password = module.params['password']
ansible_resource_pool = module.params['ansible_resource_pool']
cluster_name = module.params['cluster']
datacenter = module.params['datacenter']
datastore = module.params['datastore']
esxi_hostname = module.params['esxi_hostname']
power_on = module.params['power_on']
vm_name = module.params['vm_name']
vm_memory_mb = int(module.params['vm_memory_mb'])
vm_num_cpus = int(module.params['vm_num_cpus'])
vm_scsi = module.params['vm_scsi']
vm_disk = module.params['vm_disk']
vm_nic = module.params['vm_nic']
vm_notes = module.params['vm_notes']
vm_cdrom = module.params['vm_cdrom']
vm_extra_config = module.params['vm_extra_config']
guestosid = module.params['guestosid']
# CONNECT TO THE SERVER
s = VIServer()
try:
s.connect(vcenter_vx, user, password)
except VIApiException, err:
module.fail_json(msg="Cannot connect to %s: %s" % (vcenter_vx, err))
class VSphereConnection(ConnectionUserAndKey):
def __init__(self, user_id, key, secure=True,
host=None, port=None, url=None, timeout=None, **kwargs):
if host and url:
raise ValueError('host and url arguments are mutually exclusive')
if host:
host_or_url = host
elif url:
host_or_url = url
else:
raise ValueError('Either "host" or "url" argument must be '
'provided')
self.host_or_url = host_or_url
self.client = None
super(VSphereConnection, self).__init__(user_id=user_id,
key=key, secure=secure,
host=host, port=port,
url=url, timeout=timeout,
**kwargs)
def connect(self):
self.client = VIServer()
trace_file = os.environ.get('LIBCLOUD_DEBUG', None)
try:
self.client.connect(host=self.host_or_url, user=self.user_id,
password=self.key,
sock_timeout=DEFAULT_CONNECTION_TIMEOUT,
trace_file=trace_file)
except Exception as e:
message = e.message
if hasattr(e, 'strerror'):
message = getattr(e, 'strerror', e.message)
fault = getattr(e, 'fault', None)
if fault == 'InvalidLoginFault':
raise InvalidCredsError(message)
raise LibcloudError(value=message, driver=self.driver)
atexit.register(self.disconnect)
def disconnect(self):
if not self.client:
return
try:
self.client.disconnect()
except Exception:
# Ignore all the disconnect errors
pass
def run_client_method(self, method_name, **method_kwargs):
method = getattr(self.client, method_name, None)
return method(**method_kwargs)
class VSphereConnection(ConnectionUserAndKey):
def __init__(self, user_id, key, secure=True,
host=None, port=None, url=None, timeout=None, **kwargs):
if host and url:
raise ValueError('host and url arguments are mutually exclusive')
if host:
host_or_url = host
elif url:
host_or_url = url
else:
raise ValueError('Either "host" or "url" argument must be '
'provided')
self.host_or_url = host_or_url
self.client = None
super(VSphereConnection, self).__init__(user_id=user_id,
key=key, secure=secure,
host=host, port=port,
url=url, timeout=timeout,
**kwargs)
def connect(self):
self.client = VIServer()
trace_file = os.environ.get('LIBCLOUD_DEBUG', None)
try:
self.client.connect(host=self.host_or_url, user=self.user_id,
password=self.key,
sock_timeout=DEFAULT_CONNECTION_TIMEOUT,
trace_file=trace_file)
except Exception:
e = sys.exc_info()[1]
message = e.message
if hasattr(e, 'strerror'):
message = e.strerror
fault = getattr(e, 'fault', None)
if fault == 'InvalidLoginFault':
raise InvalidCredsError(message)
raise LibcloudError(value=message, driver=self.driver)
atexit.register(self.disconnect)
def disconnect(self):
if not self.client:
return
try:
self.client.disconnect()
except Exception:
# Ignore all the disconnect errors
pass
def run_client_method(self, method_name, **method_kwargs):
method = getattr(self.client, method_name, None)
return method(**method_kwargs)
def conexion_viserver(self):
self.logger.debug(self)
esxi = VIServer()
esxi.connect(self.creds['ip'], self.creds['user'],
self.creds['pw'], trace_file=self.config.logpysphere)
self.logger.debug("Conectado a %s %s", esxi.get_server_type(),
esxi.get_api_version())
return esxi
def create_vmware_connection(vmware_settings):
try:
server = VIServer()
server.connect(vmware_settings['host'], vmware_settings['user'],
vmware_settings['password'])
except:
print traceback.format_exc()
raise
return server
def test_vmware_version_vcenter(self):
""" Is the Vmware version at 5.1?"""
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
api = server.get_api_version()
self.assertEqual('5.1', api)
server.disconnect()
def vs_connect(host, user, password, unverify=True):
if unverify:
try:
ssl._create_default_https_context = ssl._create_unverified_context
except:
pass
con = VIServer()
con.connect(host, user, password, '/var/log/pysphere.log')
return con
def main():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
try:
vm = s.get_vm_by_name(opts.name)
vm.shutdown_guest()
count = 1
wait_for = 60
try:
while count < wait_for and vm.is_powered_off() == False:
count += 1
time.sleep(1)
print "Elapsed %s seconds ..." % str(count)
except Exception as e:
if count >= wait_for:
print "Failed to shutdown the VM (%s) even after %s seconds." % (vmname, str(wait_for))
print "Please login to the EXSi server and fix the issue. Exception: %s" % str(e)
sys.exit(1)
check_count(count, wait_for)
except Exception as e:
print "Failed to locate and shutdown the new VM using:", opts.name
print "VM could not be deleted."
print "Exception:", str(e)
# Invoke Destroy_Task
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = s._proxy.Destroy_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, s)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "VM successfully deleted from disk"
elif status == task.STATE_ERROR:
print "Error removing vm:", task.get_error_message()
# disconnect from the server
s.disconnect()
def vcenter_connect(host, username, password):
print 'Connecting to vcenter "%s"...' % (host)
sys.stdout.flush()
server = VIServer()
server.connect(host.strip(), username.strip(), password.strip())
sys.stdout.flush()
print 'Vcenter connected'
sys.stdout.flush()
return server
def connectToHost(host, host_user, host_pw):
#create server object
s = VIServer()
#connect to the host
try:
s.connect(host, host_user, host_pw)
return s
except VIApiException, err:
print "Cannot connect to host: '%s', error message: %s" % (host, err)
def esxi_version(self):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
server_obj.disconnect()
return servertype, version
except Exception as e:
print e
def connectToHost(host,host_user,host_pw):
#create server object
s=VIServer()
#connect to the host
try:
s.connect(host,host_user,host_pw)
return s
except VIApiException, err:
print "Cannot connect to host: '%s', error message: %s" %(host,err)
def test_vmware_version_vcenter(self):
""" Is the Vmware version at 5.1?"""
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
api = server.get_api_version()
self.assertEqual('5.1', api)
server.disconnect()
def connectToHost(host,host_user,host_pw):
#create server object
s=VIServer()
#connect to the host
try:
s.connect(host,host_user,host_pw)
return s
except VIApiException:
print ("Cannot connect to host: ")+host+(" error message: ")+err
def revert(datastore):
#vmsphear username and password
server = VIServer()
server.connect("101.91.1.21", "root", "Vsphear_root_password")
vm1 = server.get_vm_by_path(datastore)
print "Cuurrent Status",vm1.get_status()
print "Reverting VM:", datastore
vm1.revert_to_snapshot()
print "Vm reverted"
def GetHostConfig(host, user, password):
from pysphere import VIServer
server = VIServer()
try:
server.connect(host, user, password)
except Exception, e:
print "Error while connecting to %s:" % host
print "%s" % e
return None, False
def connectToHost(host, hostUsername, hostPassword):
# create server object
server = VIServer()
try:
server.connect(host, hostUsername, hostPassword)
return server
except VIApiException:
raise
def get_center():
serve = VIServer()
try:
serve.connect(get_arg('server[vcenter_ip]'), get_arg('server[vcenter_username]'), get_arg('server[vcenter_password]'), sock_timeout=60)
except:
return None
return serve
def create_vmware_connection(vmware_settings):
try:
server = VIServer()
server.connect(vmware_settings['host'],
vmware_settings['user'],
vmware_settings['password'])
except:
print traceback.format_exc()
raise
return server
def connect_vcenter(vcenter):
#default_context = ssl._create_default_https_context
server = VIServer()
try:
#ssl._create_default_https_context = ssl._create_unverified_context
server.connect(vcenter.host_name, vcenter.user_name, vcenter.user_password)
return server
except AttributeError, e:
print "ERROR: " + str(e)
pass
def revert(datastore):
#vmsphear username and password
server = VIServer()
server.connect("101.91.1.21", "root", "Vsphear_root_password")
vm1 = server.get_vm_by_path(datastore)
print "Cuurrent Status", vm1.get_status()
print "Reverting VM:", datastore
vm1.revert_to_snapshot()
print "Vm reverted"
def vm_stop(server, username, password, vmID):
s_server=str(server)
s_username=str(username)
s_password=str(password)
s_vm=str(vmID)
server = VIServer()
server.connect(s_server, s_username, s_password)
vm1 = server.get_vm_by_name(s_vm)
vm1.suspend()
return
def StartConnect(self):
vc_info = self.GetVcenterInfo()
if vc_info != 1:
Server = VIServer()
try:
Server.connect(**vc_info)
self.server = Server
except Exception, e:
self.VCErrorReport(e.message)
return Server if Server.is_connected() else 1
def setupConnection(host, user, password):
server = VIServer()
try:
server.connect(host, user, password)
print "[+] Host: " + host + " Version: " + server.get_server_type() + " " + server.get_api_version() + "\n"
closeConnection(server)
return True
except Exception, err:
print "[-] Cannot connect to host: "+host+" error message: " +err.message
return None
def setupConnection(host, user, password):
server = VIServer()
try:
server.connect(host, user, password)
print "Host: " + host
print "Version: " + server.get_server_type() + " " + server.get_api_version() + "\n"
return server
except Exception, err:
print "Cannot connect to host: "+host+" error message: " +err.message
sys.exit(2)
def main():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
template = opts.template
cd_iso_location = opts.iso
datastorename = opts.datastore # if None, will use the first datastore available
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
# Clone the VM.
try:
template_vm = s.get_vm_by_name(template)
except Exception as e:
print "Failed to locate the template."
print "Exception:", str(e)
sys.exit(1)
vm = template_vm.clone(vmname, power_on=False)
cdrom = None
for dev in vm.properties.config.hardware.device:
if dev._type == "VirtualCdrom":
cdrom = dev._obj
break
change_cdrom_type(cdrom, "ISO", "[%s] %s" % (datastorename, cd_iso_location))
apply_changes(vm, s, cdrom)
# Here you should power your VM (refer to the pysphere documentation)
# So it boots from the specified ISO location
try:
new_vm = s.get_vm_by_name(opts.name)
connect_vm_cdroms(new_vm, s)
try:
new_vm.power_on()
except Exception as e:
print "Failed to power-on the new VM using:", opts.name
print "Exception:", str(e)
except Exception as e:
print "Failed to locate the new VM using:", opts.name
print "Exception:", str(e)
# disconnect from the server
s.disconnect()
def check(self):
super(zstack_vcenter_image_file_checker, self).check()
server = VIServer()
server.connect(vcenter_ip, domain_name, password)
all_vms = server._get_managed_objects(MORTypes.VirtualMachine)
for mor, name in all_vms.iteritems():
if name == sync_image_name:
return self.judge(True)
else:
return self.judge(False)
def main():
"""Sets up the module parameters, validates them and perform the change"""
module = AnsibleModule(
argument_spec=dict(
vcenter_hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
guest=dict(required=True),
resource_pool=dict(required=True),
cluster=dict(required=True),
sync=dict(required=False, type='bool', default=True)
),
supports_check_mode=True
)
server = VIServer()
server.connect(
module.params['vcenter_hostname'],
module.params['username'],
module.params['password'])
virtualmachine = server.get_vm_by_name(module.params['guest'])
old_name = virtualmachine.get_resource_pool_name()
new_name = module.params['resource_pool']
# find the clusters ManagedObjectReference
cluster = None
clusters = server.get_clusters()
for mor, name in clusters.iteritems():
if name == module.params['cluster']:
cluster = mor
break
if cluster is None:
module.fail_json(msg='Cluster %s not found on server %s' %
(module.params['cluster'], module.params['vcenter_hostname']))
# find the new resource pools Managed Object Reference and migrate the VM
rps = server.get_resource_pools(from_mor=cluster)
for mor, path in rps.iteritems():
if re.match('.*%s$' % new_name, path):
if not re.match('.*%s$' % old_name, path):
if not module.check_mode:
virtualmachine.migrate(
resource_pool=mor,
host=virtualmachine.get_property('hostname'),
sync_run=module.params['sync'])
module.exit_json(changed=True, changes=module.params)
module.exit_json(changed=False, changes=module.params)
module.fail_json(msg='Resource pool %s not found' %
module.params['resource_pool'])
