import paramiko

class SSHClient:
def __init__(self, host, port, user, pkey):
self.ssh_host = host
self.ssh_port = port
self.ssh_user = user
self.private_key = paramiko.RSAKey.from_private_key_file(pkey)
self.ssh = None
self._connect()

def _connect(self):
self.ssh = paramiko.SSHClient()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
self.ssh.connect(hostname=self.ssh_host, port=self.ssh_port, username=self.ssh_user, pkey=self.private_key, timeout=10)
except:
return \'ssh connect fail\'

def execute_command(self, command):
stdin, stdout, stderr = self.ssh.exec_command(command)
out = stdout.read()
err = stderr.read()
return out, err

import requests
import json
import copy

class SaltApi:
\\\"\\\"\\\"
定义salt api接口的类
初始化获得token
\\\"\\\"\\\"
def __init__(self):
self.url = \\\"http://172.85.10.21:8000/\\\"
self.username = \\\"saltapi\\\"
self.password = \\\"saltapi\\\"
self.headers = {\\\"Content-type\\\": \\\"application/json\\\"}
self.params = {\'client\': \'local\', \'fun\': None, \'tgt\': None, \'arg\': None}
self.login_url = self.url + \\\"login\\\"
self.login_params = {\'username\': self.username, \'password\': self.password, \'eauth\': \'pam\'}
self.token = self.get_data(self.login_url, self.login_params)[\'token\']
self.headers[\'X-Auth-Token\'] = self.token

def get_data(self, url, params):
\'\'\'
请求url获取数据
:param url: 请求的url地址
:param params: 传递给url的参数
:return: 请求的结果
\'\'\'
send_data = json.dumps(params)
request = requests.post(url, data=send_data, headers=self.headers)
response = request.json()
result = dict(response)
return result[\'return\'][0]

def get_auth_keys(self):
\'\'\'
获取所有已经认证的key
:return:
\'\'\'
data = copy.deepcopy(self.params)
data[\'client\'] = \'wheel\'
data[\'fun\'] = \'key.list_all\'
result = self.get_data(self.url, data)
try:
return result[\'data\'][\'return\'][\'minions\']
except Exception as e:
return str(e)

def get_grains(self, tgt, arg=\'id\'):
\\\"\\\"\\\"
获取系统基础信息
:tgt: 目标主机
:return:
\\\"\\\"\\\"
data = copy.deepcopy(self.params)
if tgt:
data[\'tgt\'] = tgt
else:
data[\'tgt\'] = \'*\'
data[\'fun\'] = \'grains.item\'
data[\'arg\'] = arg
result = self.get_data(self.url, data)

return result

def execute_command(self, tgt, fun=\'cmd.run\', arg=None, tgt_type=\'list\', salt_async=False):
\\\"\\\"\\\"
执行saltstack 模块命令，类似于salt \'*\' cmd.run \'command\'
:param tgt: 目标主机
:param fun: 模块方法 可为空
:param arg: 传递参数 可为空
:return: 执行结果
\\\"\\\"\\\"
data = copy.deepcopy(self.params)

if not tgt: return {\'status\': False, \'msg\': \'target host not exist\'}
if not arg:
data.pop(\'arg\')
else:
data[\'arg\'] = arg
if tgt != \'*\':
data[\'tgt_type\'] = tgt_type
if salt_async: data[\'client\'] = \'local_async\'
data[\'fun\'] = fun
data[\'tgt\'] = tgt
result = self.get_data(self.url, data)

return result

def jobs(self, fun=\'detail\', jid=None):
\\\"\\\"\\\"
任务
:param fun: active, detail
:param jod: Job ID
:return: 任务执行结果
\\\"\\\"\\\"

data = {\'client\': \'runner\'}
data[\'fun\'] = fun
if fun == \'detail\':
if not jid: return {\'success\': False, \'msg\': \'job id is none\'}
data[\'fun\'] = \'jobs.lookup_jid\'
data[\'jid\'] = jid
else:
return {\'success\': False, \'msg\': \'fun is active or detail\'}
result = self.get_data(self.url, data)

class Vmware:
def __init__(self, ip, user, password, port, idc, vcenter_id):
self.ip = ip
self.user = user
self.password = password
self.port = port
self.idc_id = idc
self.vcenter_id = vcenter_id

def get_obj(self, content, vimtype, name=None):
\'\'\'
列表返回,name 可以指定匹配的对象
\'\'\'
container = content.viewManager.CreateContainerView(content.rootFolder, vimtype, True)
obj = [ view for view in container.view ]
return obj

def get_esxi_info(self):
# 宿主机信息
esxi_host = {}
res = {\\\"connect_status\\\": True, \\\"msg\\\": None}

try:
# connect this thing
si = SmartConnectNoSSL(host=self.ip, user=self.user, pwd=self.password, port=self.port, connectionPoolTimeout=60)
except Exception as e:
res[\'connect_status\'] = False
try:
res[\'msg\'] = (\\\"%s Caught vmodl fault : \\\" + e.msg) % (self.ip)
except Exception as e:
res[\'msg\'] = \'%s: connection error\' % (self.ip)
return res
# disconnect this thing
atexit.register(Disconnect, si)
content = si.RetrieveContent()
esxi_obj = self.get_obj(content, [vim.HostSystem])

for esxi in esxi_obj:
esxi_host[esxi.name] = {}
esxi_host[esxi.name][\'idc_id\'] = self.idc_id
esxi_host[esxi.name][\'vcenter_id\'] = self.vcenter_id
esxi_host[esxi.name][\'server_ip\'] = esxi.name
esxi_host[esxi.name][\'manufacturer\'] = esxi.summary.hardware.vendor
esxi_host[esxi.name][\'server_model\'] = esxi.summary.hardware.model

for i in esxi.summary.hardware.otherIdentifyingInfo:
if isinstance(i, vim.host.SystemIdentificationInfo):
esxi_host[esxi.name][\'server_sn\'] = i.identifierValue

# 系统名称
esxi_host[esxi.name][\'system_name\'] = esxi.summary.config.product.fullName
# cpu总核数
esxi_cpu_total = esxi.summary.hardware.numCpuThreads
# 内存总量 GB
esxi_memory_total = esxi.summary.hardware.memorySize / 1024 / 1024 / 1024

# 获取硬盘总量 GB
esxi_disk_total = 0
for ds in esxi.datastore:
esxi_disk_total += ds.summary.capacity / 1024 / 1024 / 1024

# 默认配置4核8G100G，根据这个配置计算剩余可分配虚拟机
default_configure = {
\'cpu\': 4,
\'memory\': 8,
\'disk\': 100
}

esxi_host[esxi.name][\'vm_host\'] = []
vm_usage_total_cpu = 0
vm_usage_total_memory = 0
vm_usage_total_disk = 0

# 虚拟机信息
for vm in esxi.vm:
host_info = {}
host_info[\'vm_name\'] = vm.name
host_info[\'power_status\'] = vm.runtime.powerState
host_info[\'cpu_total_kernel\'] = str(vm.config.hardware.numCPU) + \'核\'
host_info[\'memory_total\'] = str(vm.config.hardware.memoryMB) + \'MB\'
host_info[\'system_info\'] = vm.config.guestFullName

disk_info = \'\'
disk_total = 0
for d in vm.config.hardware.device:
if isinstance(d, vim.vm.device.VirtualDisk):
disk_total += d.capacityInKB / 1024 / 1024
disk_info += d.deviceInfo.label + \\\": \\\" + str((d.capacityInKB) / 1024 / 1024) + \' GB\' + \',\'

host_info[\'disk_info\'] = disk_info
esxi_host[esxi.name][\'vm_host\'].append(host_info)

# 计算当前宿主机可用容量：总量 - 已分配的
if host_info[\'power_status\'] == \'poweredOn\':
vm_usage_total_cpu += vm.config.hardware.numCPU
vm_usage_total_disk += disk_total
vm_usage_total_memory += (vm.config.hardware.memoryMB / 1024)

esxi_cpu_free = esxi_cpu_total - vm_usage_total_cpu
esxi_memory_free = esxi_memory_total - vm_usage_total_memory
esxi_disk_free = esxi_disk_total - vm_usage_total_disk

esxi_host[esxi.name][\'cpu_info\'] = \'Total: %d核, Free: %d核\' % (esxi_cpu_total, esxi_cpu_free)
esxi_host[esxi.name][\'memory_info\'] = \'Total: %dGB, Free: %dGB\' % (esxi_memory_total, esxi_memory_free)
esxi_host[esxi.name][\'disk_info\'] = \'Total: %dGB, Free: %dGB\' % (esxi_disk_total, esxi_disk_free)

# 计算cpu 内存 磁盘按照默认资源分配的最小值，即为当前可分配资源
if esxi_cpu_free < 4 or esxi_memory_free < 8 or esxi_disk_free < 100:
free_allocation_vm_host = 0
else:
free_allocation_vm_host = int(min(
[
esxi_cpu_free / default_configure[\'cpu\'],
esxi_memory_free / default_configure[\'memory\'],
esxi_disk_free / default_configure[\'disk\']
]
))
esxi_host[esxi.name][\'free_allocation_vm_host\'] = free_allocation_vm_host
esxi_host[\'connect_status\'] = True
return esxi_host

def write_to_db(self):
esxi_host = self.get_esxi_info()
# 连接失败
if not esxi_host[\'connect_status\']:
return esxi_host

del esxi_host[\'connect_status\']

for machine_ip in esxi_host:
# 物理机信息
esxi_host_dict = esxi_host[machine_ip]
# 虚拟机信息
virtual_host = esxi_host[machine_ip][\'vm_host\']
del esxi_host[machine_ip][\'vm_host\']

obj = models.EsxiHost.objects.create(**esxi_host_dict)
obj.save()

def main(domain):
f = StringIO()
comm = f\\\"curl -Ivs https://{domain} --connect-timeout 10\\\"

result = subprocess.getstatusoutput(comm)
f.write(result[1])

try:
m = re.search(\'start date: (.*?)\\n.*?expire date: (.*?)\\n.*?common name: (.*?)\\n.*?issuer: CN=(.*?)\\n\', f.getvalue(), re.S)
start_date = m.group(1)
expire_date = m.group(2)
common_name = m.group(3)
issuer = m.group(4)
except Exception as e:
return 999999999

# time 字符串转时间数组
start_date = time.strptime(start_date, \\\"%b %d %H:%M:%S %Y GMT\\\")
start_date_st = time.strftime(\\\"%Y-%m-%d %H:%M:%S\\\", start_date)
# datetime 字符串转时间数组
expire_date = datetime.strptime(expire_date, \\\"%b %d %H:%M:%S %Y GMT\\\")
expire_date_st = datetime.strftime(expire_date,\\\"%Y-%m-%d %H:%M:%S\\\")

# 剩余天数
remaining = (expire_date-datetime.now()).days

return remaining