cloudstack/client/bindir/cloud-update-xenserver-licenses.in

#!/usr/bin/python3 -W ignore::DeprecationWarning
# -*- coding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.


import os
import sys
import glob
from random import choice
import string
from optparse import OptionParser
import mysql.connector
import paramiko
from threading import Thread

# ---- This snippet of code adds the sources path and the waf configured PYTHONDIR to the Python path ----
# ---- We do this so cloud_utils can be looked up in the following order:
# ---- 1) Sources directory
# ---- 2) waf configured PYTHONDIR
# ---- 3) System Python path
for pythonpath in (
		"@PYTHONDIR@",
		os.path.join(os.path.dirname(__file__),os.path.pardir,os.path.pardir,"python","lib"),
	):
		if os.path.isdir(pythonpath): sys.path.insert(0,pythonpath)
# ---- End snippet of code ----
from cloud_utils import check_call, CalledProcessError, read_properties

cfg = "@MSCONF@/db.properties"

#---------------------- option parsing and command line checks ------------------------


usage = """%prog <license file> <-a | host names / IP addresses...>

This command deploys the license file specified in the command line into a specific XenServer host or all XenServer hosts known to the management server."""

parser = OptionParser(usage=usage)
parser.add_option("-a", "--all", action="store_true", dest="all", default=False,
                  help="deploy to all known hosts rather that a single host")

#------------------ functions --------------------

def e(msg): parser.error(msg)

def getknownhosts(host,username,password):
	conn = mysql.connector.connect(host=host, user=username, password=password)
	cur = conn.cursor()
	cur.execute("SELECT h.private_ip_address,d.value FROM cloud.host h inner join cloud.host_details d on (h.id = d.host_id) where d.name = 'username' and setup = 1")
	usernames = dict(cur.fetchall())
	cur.execute("SELECT h.private_ip_address,d.value FROM cloud.host h inner join cloud.host_details d on (h.id = d.host_id) where d.name = 'password' and setup = 1")
	passwords = dict(cur.fetchall())
	creds = dict( [ [x,(usernames[x],passwords[x])] for x in list(usernames.keys()) ] )
	cur.close()
	conn.close()
	return creds

def splitlast(string,splitter):
	splitted = string.split(splitter)
	first,last = splitter.join(splitted[:-1]),splitted[-1]
	return first,last

def parseuserpwfromhosts(hosts):
	creds = {}
	for host in hosts:
		user = "root"
		password = ""
		if "@" in host:
			user,host = splitlast(host,"@")
			if ":" in user:
				user,password = splitlast(user,":")
		creds[host] = (user,password)
	return creds

class XenServerConfigurator(Thread):

	def __init__(self,host,user,password,keyfiledata):
		Thread.__init__(self)
		self.host = host
		self.user = user
		self.password = password
		self.keyfiledata = keyfiledata
		self.retval = None # means all's good
		self.stdout = ""
		self.stderr = ""
		self.state = 'initialized'

	def run(self):
		try:
			self.state = 'running'
			c = paramiko.SSHClient()
			c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
			c.connect(self.host,username=self.user,password=self.password)
			sftp = c.open_sftp()
			sftp.chdir("/tmp")
			f = sftp.open("xen-license","w")
			f.write(self.keyfiledata)
			f.close()
			sftp.close()
			stdin,stdout,stderr = c.exec_command("xe host-license-add license-file=/tmp/xen-license")
			c.exec_command("false")
			self.stdout = stdout.read(-1)
			self.stderr = stderr.read(-1)
			self.retval = stdin.channel.recv_exit_status()
			c.close()
			if self.retval != 0: self.state = 'failed'
			else: self.state = 'finished'

		except Exception as e:
			self.state = 'failed'
			self.retval = e
			#raise

	def __str__(self):
		if self.state == 'failed':
			return "<%s XenServerConfigurator on %s@%s: %s>"%(self.state,self.user,self.host,str(self.retval))
		else:
			return "<%s XenServerConfigurator on %s@%s>"%(self.state,self.user,self.host)

#------------- actual code --------------------

(options, args) = parser.parse_args()

try:
	licensefile,args = args[0],args[1:]
except IndexError: e("The first argument must be the license file to use")

if options.all:
	if len(args) != 0: e("IP addresses cannot be specified if -a is specified")
	config = read_properties(cfg)
	creds = getknownhosts(config["db.cloud.host"],config["db.cloud.username"],config["db.cloud.password"])
	hosts = list(creds.keys())
else:
	if not args: e("You must specify at least one IP address, or -a")
	hosts = args
	creds = parseuserpwfromhosts(hosts)

try:
	keyfiledata = file(licensefile).read(-1)
except OSError as e:
	sys.stderr.write("The file %s cannot be opened"%licensefile)
	sys.exit(1)

configurators = []
for host,(user,password) in list(creds.items()):
	configurators.append ( XenServerConfigurator(host,user,password,keyfiledata ) )


for c in configurators: c.start()

for c in configurators:
	print(c.host + "...", end=' ')
	c.join()
	if c.state == 'failed':
		if c.retval:
			msg = "failed with return code %s: %s%s"%(c.retval,c.stdout,c.stderr)
			msg = msg.strip()
			print(msg)
		else: print("failed: %s"%c.retval)
	else:
		print("done")

successes = len( [ a for a in configurators if not a.state == 'failed' ] )
failures = len( [ a for a in configurators if a.state == 'failed' ] )

print("%3s successes"%successes)
print("%3s failures"%failures)