SequenceLogic/Sleds
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
b56ef122dd
Sleds/buildvm/lib/sleds_utilities.py

376 lines
11 KiB
Python
Raw Blame History

#!/bin/python3
'''
Created on Mar 31, 2014
@author: tpweis
'''
import os
import sys
import subprocess
import syslog
import pymongo
from datetime import datetime, date, time
from calendar import timegm
import iso8601
import time
import json
import re
def get_addrlist(start_addr=0, count=0, roll_over='yes'):
"function get_addrlist()"
argv = sys.argv[1:]
empty_list = []
# check for values
if start_addr == 0:
slscatlog('E','Missing IP address. Try again')
return empty_list
addr_count = 0
try:
addr_count = int(count)
except:
slscatlog('E',"Address count is bad: " + count)
if addr_count == 0:
slscatlog('E','Missing address count. Try again')
return empty_list
if roll_over not in ["no", "yes"]:
roll_over = "yes"
slscatlog('D',"args: " + start_addr + ", " + str(addr_count) + ", " + roll_over)
# First break apart the input address to its respective octets
octet_list = re.split(r'(\.)',start_addr)
# Do a little error checking.
# We must have at least 7 elements in the list, or it cannot be an IP4 address
if len(octet_list) < 7 :
slscatlog('E',"Octet list incomplete. Len = " + str(len(octet_list)))
return empty_list
# the IP address values are in the list, separated by '.' (dot)
first_octet = octet_list[0]
second_octet = octet_list[2]
third_octet = octet_list[4]
fourth_octet = octet_list[6]
# Ensure the starting address is valid
bad_address = False
if int(first_octet) not in range(0,255):
slscatlog('E',"first octet is bad: " + first_octet)
bad_address = True
if int(second_octet) not in range(0,255):
slscatlog('E',"second octet is bad: " + second_octet)
bad_address = True
if int(third_octet) not in range(0,255):
slscatlog('E',"third octet is bad: " + third_octet)
bad_address = True
if int(fourth_octet) not in range(0,255):
slscatlog('E',"fourth_octet is bad: " + fourth_octet)
bad_address = True
if bad_address:
return empty_list
slscatlog('D',"Input octet list: " + ', '.join(octet_list))
# Start constructing the new address list
ipcount = 0
a = int(first_octet)
b = int(second_octet)
c = int(third_octet)
d = int(fourth_octet)
addr_list = []
# Do this loop 'addr_count' times, unless we run out of numbers.
while ipcount < addr_count:
# Increment the counter
ipcount += 1
d +=1
# check for any octet overflow
if d > 254:
if roll_over == "yes":
d = 0
c += 1
slscatlog('D',"rollover: d = 0, c = " + str(c))
else:
# Note that we only need to check this in one place
# because we cannot increment the following octets without
# rolling over the last octet. If we can't roll over, but haven't
# satisfied the addr_count, this is an error and produces an empty list
slscatlog('I',"Roll over set to no, ran out of available addresses at: " + '.'.join([str(a),str(b),str(c),str(d)]))
return empty_list
if c > 254:
c = 0
b += 1
if b > 254:
b = 0
a += 1
if a > 254:
# We ran out of numbers. Error out
slscatlog('E'," Ran out of available addresses: " + '.'.join([str(a),str(b),str(c),str(d)]))
return empty_list
# Compose the new address
new_addr = '.'.join([str(a),str(b),str(c),str(d)])
slscatlog('I',"New address: " + new_addr)
addr_list.append(new_addr)
return addr_list
def slscatfunction( cmd, ipaddr, user, urn, mongo ):
"function slscatfunction"
q1=subprocess.Popen(["echo", cmd, user, urn, mongo], stdout=subprocess.PIPE)
q2=subprocess.Popen(["nc", "-n", ipaddr, str(52525)], stdin=q1.stdout, stdout=subprocess.PIPE)
qdata=q2.communicate()[0]
qdata=qdata.decode()
qdata=qdata.rstrip()
slscatlog('D',"run: " + cmd + ", result is " + qdata)
return qdata
def slscatlog(level, message):
"function slscatlog()"
try:
from scatconf import scat_loglevel
except ImportError:
scat_loglevel = 7
msgpri4 = 6 | syslog.LOG_LOCAL4
# msgpri5 = 6 | syslog.LOG_LOCAL5
syslog.syslog(msgpri4,"INFO: No scat logging config in place")
# syslog.syslog(msgpri5,"INFO: No scat logging config in place")
syslog.openlog(ident='scat', facility=syslog.LOG_LOCAL4)
# syslog.openlog(ident='scattest', facility=syslog.LOG_LOCAL5)
# logmask = syslog.LOG_UPTO(scat_loglevel)
# syslog.setlogmask(logmask)
if level=='D':
outmsg = "DEBUG: " + message
outlevel = 7
elif level=='I':
outmsg = "INFO: " + message
outlevel = 6
elif level=='W':
outmsg = "WARN: " + message
outlevel = 4
elif level=='E':
outmsg = "ERROR: " + message
outlevel = 3
else:
outmsg = "BAD LOG ENTRY: " + message
outlevel = 2
msgpri4 = outlevel | syslog.LOG_LOCAL4
# msgpri5 = outlevel | syslog.LOG_LOCAL5
syslog.syslog(msgpri4,outmsg)
# syslog.syslog(msgpri5,outmsg)
return outmsg
def slscatargs( arglist):
"function slscatargs()"
if(len(arglist)< 1):
slscatlog('E','Missing IP address. Try again')
sys.exit(3)
else:
IPADDR = arglist[0]
if(len(arglist) < 2):
USER = 'NO_USER'
else:
USER = arglist[1]
if(len(arglist) < 3):
URN = 'NO_URN'
else:
URN = arglist[2]
if(len(arglist) < 4):
MONGO = 'NO_MONGO'
else:
MONGO = arglist[3]
slscatlog('D',"slscatargs: " + IPADDR + ", " + USER + ", " + URN + ", " + MONGO)
good_args = IPADDR, USER, URN, MONGO
return good_args
def slbinget():
"function slbinget"
return "/sl/bin/"
def slscatget():
"function slscatget"
return "/sl/scat/"
def slhomeget():
"function slhomeget()"
return "/sl/"
def sllogget():
"function sllogget()"
return "/sl/logs/"
def slrunget():
"function slrunget()"
return "/sl/run/"
def sltomcatbinget():
"function sltomcatbinget()"
return "/usr/local/tomcat/bin/"
def slsetvars():
"function slsetvars"
os.environ["SEQUENCE_LOGIC_ENV"] = "system"
os.environ["SEQUENCELOGICHOME"] = "/sl"
os.environ["PLATFORM"] = "lin64"
os.environ["SLSYNC"] = slhomeget() +"/SLSync"
os.environ["EYE_DIR"] = slbinget()
os.environ["CRYPTO_DIR"] = os.environ.get("EYE_DIR", "Not Set")
os.environ["K2C_DIR"] = os.environ.get("EYE_DIR", "Not Set")
os.environ["CPP_DIR"] = os.environ.get("EYE_DIR", "Not Set")
os.environ["JAR"] = os.environ.get("EYE_DIR", "Not Set") + "/robot-1.0.0.one-jar.jar"
os.environ["LD_LIBRARY_PATH"] = \
os.environ.get("K2C_DIR", "Not Set") + ":" + \
os.environ.get("CRYPTO_DIR", "Not Set") + ":" + \
os.environ.get("EYE_DIR", "Not Set") + ":" + \
os.environ.get("CPP_DIR", "Not Set") + ":" + \
"/usr/local/lib"
os.environ["java_library_path"] = \
os.environ.get("EYE_DIR", "Not Set") + ":" + \
os.environ.get("CRYPTO_DIR", "Not Set") + ":" + \
os.environ.get("K2C_DIR", "Not Set") + ":" + \
os.environ.get("CPP_DIR", "Not Set")
"""
subprocess.call(["echo", "PLATFORM=", os.environ.get("PLATFORM", "Not Set")])
subprocess.call(["echo", "SLSYNC=", os.environ.get("SLSYNC", "Not Set")])
subprocess.call(["echo", "EYE_DIR=", os.environ.get("EYE_DIR", "Not Set")])
subprocess.call(["echo", "CRYPTO_DIR=", os.environ.get("CRYPTO_DIR", "Not Set")])
subprocess.call(["echo", "K2C_DIR=", os.environ.get("K2C_DIR", "Not Set")])
subprocess.call(["echo", "CPP_DIR=", os.environ.get("CPP_DIR", "Not Set")])
subprocess.call(["echo", "JAR=", os.environ.get("JAR", "Not Set")])
subprocess.call(["echo", "LD_LIBRARY_PATH=", os.environ.get("LD_LIBRARY_PATH", "Not Set")])
subprocess.call(["echo", "java_library_path=", os.environ.get("java_library_path", "Not Set")])
"""
def utctimenow():
#############################################################
## return the current time in utc format (iso8601)
timenow=datetime.utcnow().isoformat()+"Z"
return(timenow)
###############################################################
def getutcfromtimestamp(timestamp):
#############################################################
## This routine converts from a timestamp to a utc string.
tstring=datetime.utcfromtimestamp(timestamp).isoformat()+"Z"
return(tstring)
###############################################################
def gettimestampfromutc(iso_string):
#############################################################
## This routine takes a date string that is formated as UTC
## and returns a unix timestamp (seconds since 1970-Jan-01)
m=0
iso_string=iso_string.rstrip('Z')
iso_string=iso_string.rstrip('T')
print("\n\n---ISO_STRING:",iso_string)
try:
### First, letst convert to datetime so we can collect u_sec
uu=datetime.strptime(iso_string,'%Y-%m-%dT%H:%M:%S.%f')
m=uu.microsecond
### Convert to a shorter datetime struct
uu=uu.strftime('%Y-%m-%dT%H:%M:%S')
du=datetime.strptime(uu,'%Y-%m-%dT%H:%M:%S')
### Convert to a time struct from shortened format
ru=time.strptime(uu,'%Y-%m-%dT%H:%M:%S')
uu=ru
except:
o=1
try:
## string without milliseconds
uu=time.strptime(iso_string,'%Y-%m-%dT%H:%M:%S')
except:
o=1
try:
## date without time
uu=time.strptime(iso_string,'%Y-%m-%d')
except:
o=1
ts = timegm( uu )
## if u_secs were saved off, add back on to the end of the string
if (m):
ts=ts + m/1000000
print("RETURN:", ts)
return(ts)
############ Write a Fact ##############
# Assumes a global of "factsdir" this should be fixed
def writeFact( string, filename, factsdir = "/etc/sleds/facts" ):
filename=factsdir+"/"+filename
f = open(filename,"w")
print("Writing to filename: "+filename)
f.write(string)
f.write("\n")
f.close()
############ go issue a sub command / shell ###########
def pipe (cmd):
proc = subprocess.Popen( cmd ,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
)
data=proc.communicate()[0]
data=data.decode()
return(data)
def myipaddr():
### Second, lets collect our current IP address
cmd="facter ipaddress"
cmd=cmd.split()
data=pipe(cmd)
data=data.rstrip()
ip=data
return(ip)
def myregkey():
### lets collect our current Registration Key Value
cmd="facter sleds-regkey"
cmd=cmd.split()
data=pipe(cmd)
data=data.rstrip()
rkey=data
return(rkey)
###############################################################
def main():
"function main"
slsetvars()
# execute only if run as a script
if __name__ == "__main__":
# execute only if run as a script
main()
Reference in New Issue View Git Blame Copy Permalink