Today while working on a function to perform server discovery from a customer ID, I looked back at some code I wrote over a year when I first starting out. It’s pretty amazing to see how far my writing has come and how much better efficient it has gotten.
Server discovery 101
One of the nice things about my environment is customer servers have a fairly consistent naming convention and it’s only been modified a couple of time. In general, servers follow a customerID + serverID + domain, naming convention.
I had written my discovery function(s) to look up servers, get their IP addresses and then fill out a table in a MOP so I didn’t have to do it manually. In my original scripts, I supplied the customerID, then pinged a variety of server name permutations and looked for the proper response, then pinged the rest of the servers based on the successful response. Although this had the benefit of verifying connectivity to the servers, it could take a couple of minutes to fail when connectivity wasn’t present for some reason.
Today, I re-wrote it to use nslookup results to build a dictionary of server role and name values. The benefit here, it runs quickly and returns the dictionary much quicker. The downside is I don’t get server reachability.
To resolve that, I decided to generate the dictionary then ping each server in the dictionary
def find_cucm_pub(customerID: str) -> str:
fqdn_format = {
'format1': customerID + '-cucmpub.example.com',
'format2': customerID + '-cucmpub.example2.com',
}
name_format = None
for name in fqdn_format:
nslookup = subprocess.run(['nslookup', fqdn_format[name]], capture_output=True)
nslookup_resp = nslookup.stdout.decode('UTF-8')
if 'Name:' in nslookup_resp:
name_format = name
return name_format
def uc_cluster(customerID: str) -> dict:
customerID = customerID.lower()
fqdn_format = find_cucm_pub(customerID)
cluster = None
if not fqdn_format:
pass
elif fqdn_format == 'format1:
cluster = {
'cucm_pub': customerID + '-cucmpub.example.com',
'cucm_sub1': customerID + '-cucmsub1.example.com',
...
return cluster
cluster = uc_cluster(customerID)
for s in cluster:
subprocess.run(['ping', '-c', '4', cluster[s]])
String generator
Another thing I worked on when I trying to understand lists in the very beginning was generating lists of strings of varying length. I found I could only build lists of a certain length before my laptop sounded like a jet engine taking off. I simply trying to generate a list of all the potential characters from a length 1 through a specified length.
My original “finished” product is here. It was interesting to me because I found the limitations of my laptop, but it was also interesting because I learned how much random stuff I could create.
Today I built this why sitting a conference call bored:
import string
import itertools
letters = string.ascii_lowercase
numbers = string.digits
def build_a(x):
abc = []
for a in itertools.product(letters, repeat=x):
abc.append(''.join(a))
return abc
def build_n(y):
nnnn = []
for n in itertools.product(numbers, repeat=y):
nnnn.append(''.join(n))
return nnnn
def build_an(x, y):
abc = build_a(x)
nnnn = build_n(y)
ccmid = []
for a, n in itertools.product(abc, nnnn):
with open('customerID.txt', 'a') as f:
f.write(a + n + '\n')
f.close()
Feels like a slightly more elegant way to generate random customerIDs than my original attempts at creating data strings.
Random string generator number 2
import random
import string
characters = string.ascii_letters + string.digits + string.punctuation
def build_string(x):
word = []
while len(word) < x:
word.append(random.choice(characters))
return ''.join(word)
