def build_pools(active_ltm, vs_dnsname, vs_port, vs_env, vs_poolmon, pool_membername, pool_memberip, pool_memberport, pool_membermon): admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) membernames = json.loads(pool_membername) memberips = json.loads(pool_memberip) memberports = json.loads(pool_memberport) membermons = json.loads(pool_membermon) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("build_pools()- Use Standard Global naming : " + useGlobalNaming ) idx = 1 strReturn = {str(idx) : 'Pool Creation Report'} idx += 1 if useGlobalNaming == '1': std_poolname = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'POOL', '', vs_dnsname) else: #std_poolname = build_std_names.build_std_pool_name(str(vs_env), str(vs_dnsname), str(vs_port)) std_poolname = str(vs_dnsname) logger.info("Pool Creation process has been initiated. Pool Name: " + std_poolname) if check_poolname_conflict(mr, std_poolname): strReturn.update({str(idx) : 'Pool Name conflict'}) idx += 1 return json.dumps(strReturn) logger.info("No Pool name conflict. Now creating a pool") #Create a pool mypool = mr.tm.ltm.pools.pool.create(name=std_poolname, partition='Common', loadBalancingMode='least-connections-member', monitor='/Common/'+vs_poolmon) mypool_1 = mr.tm.ltm.pools.pool.load(name=std_poolname, partition='Common') #for membername, memberip, memberport, membermon in map(None, membernames, memberips, memberports, membermons): for membername, memberip, memberport, membermon in zip(membernames, memberips, memberports, membermons): logger.info("Member Name: " + membername + " IP: " + memberip + " port: " + memberport + " mon: " + membermon) # Pool member creation issue - Calling Pool creation method too fast?? if useGlobalNaming == '1': membername = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'NODE', '', membername) if (str(membermon) == 'Inherit'): poolm = mypool_1.members_s.members.create(name=membername+':'+memberport, partition='Common', address=memberip, monitor=vs_poolmon ) logger.info("Inherit") else: poolm = mypool_1.members_s.members.create(name=membername+':'+memberport, partition='Common', address=memberip, monitor=membermon ) logger.info("Standard TCP") logger.info("Member Name: " + membername + " IP: " + memberip + " Port: " + memberport + " Monitor: " + membermon + " Pool Monitor: " + vs_poolmon) strReturn[str(idx)] = 'Member(' + membername + ' IP:' + memberip + ':' + memberport + ' Monitor: ' + membermon + ') has been created' idx += 1 return json.dumps(strReturn)
def build_vs_s(active_ltm, vs_dnsname, vs_dest, vs_port, vs_desc, vs_env, vs_tcpprofile, vs_persistence, vs_redirect, vs_type, vs_httpprofile, vs_sslclient, vs_sslserver, vs_irule, vs_snatpool, vs_policy): admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("build_vs_s()- Use Standard Global naming : " + useGlobalNaming ) idx = 1 strReturn = {str(idx) : 'VS Creation Report'} idx += 1 logger.info(str(active_ltm) + " " + str(vs_dnsname) + " " + str(vs_dest) + " " + str(vs_port) + " " + str(vs_desc) + " " + str(vs_env) + " " + str(vs_tcpprofile) + " " + str(vs_persistence) + " " + str(vs_redirect) + " " + str(vs_type) + " " + str(vs_httpprofile) + " " + str(vs_sslclient) + " " + str(vs_sslserver) ) logger.info("Before VS Build - Env Name: " + str(vs_env) + " DNS name: " + str(vs_dnsname) + " Port: " + str(vs_port)) if useGlobalNaming == '1': std_vsname = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'VIRTUAL_SERVER', '', vs_dnsname) std_poolname = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'POOL', '', vs_dnsname) #std_vsname = build_std_names.build_std_vs_name(str(vs_env), str(vs_dnsname), str(vs_port)) #std_poolname = build_std_names.build_std_pool_name(str(vs_env), str(vs_dnsname), str(vs_port)) std_vsname = str(vs_dnsname) std_poolname = str(vs_dnsname) logger.info("VS Creation process has been initiated. VS Name: " + std_vsname) try: #Create a VS myvs = mr.tm.ltm.virtuals.virtual.create(name=std_vsname, partition='Common', destination='/Common/'+vs_dest+':'+vs_port, \ ipProtocol='tcp', pool='/Common/' + std_poolname) logger.info("VS Name: " + std_vsname + " Destination: " + vs_dest + ':' + vs_port + " Pool Name: " + std_poolname) #Load additional profiles loadedvs = mr.tm.ltm.virtuals.virtual.load(name=std_vsname) loadedvs.profiles = ['/Common/' + vs_httpprofile, '/Common/' + vs_sslclient, '/Common/' + vs_sslserver] loadedvs.update() loadedvs.rules = ['/Common/' + vs_irule] loadedvs.update() loadedvs.persist = ['/Common/' + vs_persistence] loadedvs.update() loadedvs.policys = ['/Common/' + vs_policy] loadedvs.update() loadedvs.snatpools = ['/Common/' + vs_snatpool] loadedvs.update() strReturn[str(idx)] = 'VS Name: ' + std_vsname + ' (Destination: ' + vs_dest + ':' + vs_port + ' Pool Name: ' + std_poolname + ') has been created' idx += 1 except Exception, e: logger.error(err)
def build_nodes(active_ltm, pool_membername, pool_memberip): global namebit, ipbit admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) nodenames = json.loads(pool_membername) nodeips = json.loads(pool_memberip) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("build_node()- Use Standard Global naming : " + useGlobalNaming) bitmove = 0 idx = 1 strReturn = {str(idx): 'Node Creation Report'} logger.info("build_node() : " + str(idx) + "th Node creation") idx += 1 for nodeip, nodename, in zip(nodeips, nodenames): logger.info("node IP: " + nodeip + " node name: " + nodename) if useGlobalNaming == '1': nodename = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'NODE', '', nodename) logger.info("build_node()- Standard Name created : " + nodename) nodes = mr.tm.ltm.nodes.get_collection() check_node_conflict(mr, nodeip, nodename) logger.info("build_node() : namebit: " + str(namebit) + " bitmove:" + str(bitmove) + " ipbit: " + str(ipbit)) # No Node name and Node IP conflict - Create a new node with standard name if (not (namebit >> bitmove) & 1) and not ((ipbit >> bitmove) & 1): mr.tm.ltm.nodes.node.create(name=nodename, partition='Common', address=nodeip) strReturn.update({str(idx): nodename + " has been added"}) # Both of Node name and Node IP conflict - Use standard Name elif ((namebit >> bitmove) & 1) and ((ipbit >> bitmove) & 1): strReturn.update({str(idx): "Existing node will be used"}) else: pass idx += 1 bitmove += 1 return json.dumps(strReturn)
def new_snatpool_build(active_ltm, snat_name, snat_addresses): admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_snatpool_build()- Use Standard Global naming : " + useGlobalNaming) idx = 1 strReturn = {str(idx): 'Snatpool Creation Report'} idx += 1 if useGlobalNaming == '1': snat_name = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'SNAT_POOL', '', snat_name) logger.info( str(active_ltm) + " Snatpool DNS:" + str(snat_name) + " Snatpool DEST:" + str(snat_addresses)) logger.info( "Snatpool Creation process has been initiated. Snatpool Name: " + snat_name) try: snat_members = [] for aMember in snat_addresses.split(':'): snat_members.append(aMember) mysnat = mr.tm.ltm.snatpools.snatpool.create(name=snat_name, members=snat_members) strReturn[str( idx )] = 'Snatpool (' + snat_name + ') has been succssfully created' idx += 1 except Exception as e: logger.info("Exception during Snatpool creation") strReturn[str(idx)] = "Exception fired!: " + str(e) idx += 1 return json.dumps(strReturn) return json.dumps(strReturn)
def new_dstAffProfile_build(prfDevIp, prfName, prfDplyOrChg, defaultsFrom, matchAcrossServices, matchAcrossVirtuals, matchAcrossPools, hashAlgorithm, timeout, mask, overrideConnectionLimit): #logger.info('Called get_profiles(): %s %s' % (dev_ip, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(prfDevIp), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_dstAffProfile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_dstAffProfile_build.py Parms DevIP: " + prfDevIp + " Profile name: " + prfName + " Profile Deploy or Chnage: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = { str(idx): 'Destination Address Persistence Profile Creation Report' } idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(str(prfDevIp), 'SHARED', 'PROFILE', 'DESTINATION_PERSISTENCE', prfName) logger.info( "Profile Creation process has been initiated. Destination Address Persistence Profile Name: " + prfName) prfPara1 = 'Common' if check_profileName_conflict(mr, prfName, prfPara1): logger.info("Before check_profileName_conflict() call\n") strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.persistence.dest_addrs.dest_addr.create(name=prfName, partition='Common', defaultsFrom=defaultsFrom, \ matchAcrossServices=matchAcrossServices, matchAcrossVirtuals=matchAcrossVirtuals, matchAcrossPools=matchAcrossPools, \ hashAlgorithm=hashAlgorithm, timeout=timeout, mask=mask, overrideConnectionLimit=overrideConnectionLimit) except Exception as e: logger.info( "Exception during Destination Address Persistence Profile creation" ) strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info( "Destination Address Persistence Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = { str(idx): 'Destination Address Persistence Profile Modification Report' } idx += 1 logger.info( "Profile Modification process has been initiated. Destination Address Persistence Profile Name: " + prfName) # Load Destination Affinity profile settings of a given Destination Affinity profile name try: loadedPrf = mr.tm.ltm.persistence.dest_addrs.dest_addr.load( name=prfName, partition='Common') except Exception as e: logger.info( "Exception during Destination Affinity Profile loading") strReturn[str( idx )] = "Exception fired during Destination Affinity Profile setting loading! (" + prfName + "): " + str( e) idx += 1 logger.info( "Exception fired during Destination Affinity Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update DNS profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.matchAcrossServices = matchAcrossServices loadedPrf.matchAcrossVirtuals = matchAcrossVirtuals loadedPrf.matchAcrossPools = matchAcrossPools loadedPrf.hashAlgorithm = hashAlgorithm loadedPrf.timeout = timeout loadedPrf.mask = mask loadedPrf.overrideConnectionLimit = overrideConnectionLimit ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, matchAcrossServices, matchAcrossVirtuals, matchAcrossPools, hashAlgorithm, timeout, mask, overrideConnectionLimit): strReturn[str( idx )] = "Destination Affinity Profile settings have been saved!" idx += 1 try: #loadedPrf.update()] loadedPrf.modify(**modContent) except Exception as e: strReturn[str( idx )] = "Exception fired during Destination Affinity profile update() (" + prfName + "): " + str( e) idx += 1 logger.info( "Destination Affinity Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info( "No Destination Address Persistence Profile modification is needed" ) strReturn[str( idx )] = "No No Destination Address Persistence Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str( idx )] = "Destination Address Persistence Profile(" + prfName + ") has been created" idx += 1 logger.info("Destination Address Persistence Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str( idx )] = "Destination Address Persistence Profile modification(" + prfName + ") has been completed" idx += 1 logger.info( "Destination Address Persistence Profile modification has been completed" ) for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_streamProfile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, source, tmTarget): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_streamProfile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_streamProfile_build.py Parms DevIP: " + active_ltm + " Profile name: " + prfName + " Profile Deploy or Change: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx): 'Stream Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'STREAM', prfName) logger.info( "Profile Creation process has been initiated. Stream Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.profile.streams.stream.create( name=prfName, partition='Common', defaultsFrom=defaultsFrom, source=source, tmTarget=tmTarget) except Exception as e: logger.info("Exception during Stream Profile creation") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("Stream Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx): 'Stream Profile Modification Report'} idx += 1 logger.info( "Profile Modification process has been initiated. Stream Profile Name: " + prfName) # Load Stream profile settings of a given Stream profile name # 'defaultsFrom', 'source', 'tmTarget' try: loadedPrf = mr.tm.ltm.profile.streams.stream.load( name=prfName, partition='Common') except Exception as e: logger.info("Exception during Stream Profile loading") strReturn[str( idx )] = "Exception fired during Stream Profile setting loading! (" + prfName + "): " + str( e) idx += 1 logger.info( "Exception fired during Stream Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update Stream profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.source = source loadedPrf.tmTarget = tmTarget ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, source, tmTarget): strReturn[str(idx)] = "Stream Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str( idx )] = "Exception fired during Stream profile modification (" + prfName + "): " + str( e) idx += 1 logger.info("Stream Profile modification exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No Stream Profile modification is needed") strReturn[str( idx )] = "No Stream Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str( idx)] = "Stream Profile (" + prfName + ") has been created" idx += 1 logger.info("Stream Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str( idx )] = "Stream Profile Modification(" + prfName + ") has been completed" idx += 1 logger.info("Stream Profile modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_clisslProfile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, cert, key, chain, ciphers, proxySsl, proxySslPassthrough, renegotiation, renegotiatePeriod, renegotiateSize, renegotiateMaxRecordDelay, secureRenegotiation, maxRenegotiationsPerMinute, serverName, sniDefault, sniRequire): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_clisslProfile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_clisslProfile_build.py Parms DevIP: " + active_ltm + " Profile name: " + prfName + " Profile Deploy or Change: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx): 'ClientSSL Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'CLIENTSSL', prfName) logger.info( "Profile Creation process has been initiated. ClientSSL Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.profile.client_ssls.client_ssl.create(name=prfName, partition='Common', defaultsFrom=defaultsFrom, cert=cert, key=key, \ chain=chain, ciphers=ciphers, proxySsl=proxySsl, proxySslPassthrough=proxySslPassthrough, renegotiation=renegotiation, \ renegotiatePeriod=renegotiatePeriod, renegotiateSize=renegotiateSize, renegotiateMaxRecordDelay=renegotiateMaxRecordDelay, secureRenegotiation=secureRenegotiation, \ maxRenegotiationsPerMinute=maxRenegotiationsPerMinute, serverName=serverName, sniDefault=sniDefault, sniRequire=sniRequire) except Exception as e: logger.info("Exception during ClientSSL Profile creation") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("ClientSSL Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx): 'ClientSSL Profile Modification Report'} idx += 1 logger.info( "Profile Modification process has been initiated. ClientSSL Profile Name: " + prfName) # Load Client SSL profile settings of a given Client SSL profile name # 'defaultsFrom', 'cert', 'key', 'chain', 'ciphers', 'proxySsl', 'proxySslPassthrough', # 'renegotiation', 'renegotiatePeriod', 'renegotiateSize', 'renegotiateMaxRecordDelay', # 'secureRenegotiation', 'maxRenegotiationsPerMinute', 'serverName', 'sniDefault', # 'sniRequire' try: loadedPrf = mr.tm.ltm.profile.client_ssls.client_ssl.load( name=prfName, partition='Common') except Exception as e: logger.info("Exception during Client SSL Profile loading") strReturn[str( idx )] = "Exception fired during Client SSL Profile setting loading! (" + prfName + "): " + str( e) idx += 1 logger.info( "Exception fired during Client SSL Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update Client SSL profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.cert = cert loadedPrf.key = key loadedPrf.chain = chain loadedPrf.ciphers = ciphers loadedPrf.proxySsl = proxySsl loadedPrf.proxySslPassthrough = proxySslPassthrough loadedPrf.renegotiation = renegotiation loadedPrf.renegotiatePeriod = renegotiatePeriod loadedPrf.renegotiateSize = renegotiateSize loadedPrf.renegotiateMaxRecordDelay = renegotiateMaxRecordDelay loadedPrf.secureRenegotiation = secureRenegotiation loadedPrf.maxRenegotiationsPerMinute = maxRenegotiationsPerMinute loadedPrf.serverName = serverName loadedPrf.sniDefault = sniDefault loadedPrf.sniRequire = sniRequire ''' certKeyChain = [{ "name": "default", "cert": cert, "key": key, "chain": chain }] if isNeedUpdate(loadedPrf, modContent, defaultsFrom, certKeyChain, ciphers, proxySsl, proxySslPassthrough, renegotiation, renegotiatePeriod, renegotiateSize, renegotiateMaxRecordDelay, secureRenegotiation, maxRenegotiationsPerMinute, serverName, sniDefault, sniRequire): strReturn[str( idx)] = "Client SSL Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str( idx )] = "Exception fired during Client SSL profile update() (" + prfName + "): " + str( e) idx += 1 logger.info( "Client SSL Profile Modification exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No Client SSL Profile modification is needed") strReturn[str( idx )] = "No Client SSL Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str( idx)] = "ClientSSL Profile (" + prfName + ") has been created" idx += 1 logger.info("ClientSSL Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str( idx )] = "ClientSSL Profile Modification(" + prfName + ") has been completed" idx += 1 logger.info("ClientSSL Profile Modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_uniProfile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, matchAcrossServices, matchAcrossVirtuals, matchAcrossPools, timeout, rule, overrideConnectionLimit): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_uniProfile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_uniProfile_build.py Parms \nDevIP: " + active_ltm + "\nProfile name: " + prfName + "\nProfile Deploy or Change: " + prfDplyOrChg + "\nDefaults-from: " + defaultsFrom + "\n") idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx): 'Universal Persistence Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'UNIVERSAL_PERSISTENCE', prfName) logger.info( "Profile Creation process has been initiated. Universal Persistence Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.persistence.universals.universal.create( name=prfName, partition='Common', defaultsFrom=defaultsFrom, matchAcrossServices=matchAcrossServices, matchAcrossVirtuals=matchAcrossVirtuals, matchAcrossPools=matchAcrossPools, timeout=timeout, rule=rule, overrideConnectionLimit=overrideConnectionLimit) except Exception as e: logger.info( "Exception during Universal Persistence Profile creation") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info( "Universal Persistence Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = { str(idx): 'Universal Persistence Profile Modification Report' } idx += 1 logger.info( "Profile Modification process has been initiated. Universal Persistence Profile Name: " + prfName) # Load Universal Persistence profile settings of a given Universal Persistence profile name # 'defaultsFrom', 'matchAcrossServices', 'matchAcrossVirtuals', 'matchAcrossPools','timeout', 'rule', 'overrideConnectionLimit' try: loadedPrf = mr.tm.ltm.persistence.universals.universal.load( name=prfName, partition='Common') except Exception as e: logger.info( "Exception during Universal Persistence Profile loading") strReturn[str( idx )] = "Exception fired during Universal Persistence Profile setting loading! (" + prfName + "): " + str( e) idx += 1 logger.info( "Exception fired during Universal Persistence Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # 'defaultsFrom', 'matchAcrossServices', 'matchAcrossVirtuals', 'matchAcrossPools', 'timeout', 'overrideConnectionLimit' ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.matchAcrossServices = matchAcrossServices loadedPrf.matchAcrossVirtuals = matchAcrossVirtuals loadedPrf.matchAcrossPools = matchAcrossPools loadedPrf.timeout = timeout loadedPrf.rule = rule loadedPrf.overrideConnectionLimit = overrideConnectionLimit ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, matchAcrossServices, matchAcrossVirtuals, matchAcrossPools, timeout, rule, overrideConnectionLimit): strReturn[str( idx )] = "Universal Persistence Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str( idx )] = "Exception fired during Universal Persistence profile update() (" + prfName + "): " + str( e) idx += 1 logger.info( "Universal Persistence Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info( "No Universal Persistence Profile modification is needed") strReturn[str( idx )] = "No SSLUniversalPersistence Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str( idx )] = "Universal Persistence Profile (" + prfName + ") has been created" idx += 1 logger.info("Universal Persistence Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str( idx )] = "Universal Persistence Profile Modification(" + prfName + ") has been completed" idx += 1 logger.info( "Universal Persistence Profile modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_cookieProfile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, method, cookieName, httponly, secure, alwaysSend, expiration, overrideConnectionLimit): #logger.info('Called get_profiles(): %s %s' % (dev_ip, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_cookieProfile_build()- Use Standard Global naming : " + useGlobalNaming ) logger.info("new_cookieProfile_build.py Parms DevIP: " + active_ltm + " Profile name: " + prfName + " Profile Deploy or Change: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx) : 'Cookie Persistence Profile Creation Report'} idx += 1 #logger.info("ProxyType before change: " + prfPxyType) if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'COOKIE_PERSISTENCE', prfName) logger.info("Profile Creation process has been initiated. Cookie Persistence Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx) : 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info("No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.persistence.cookies.cookie.create(name=prfName, partition='Common', defaultsFrom=defaultsFrom, method=method, cookieName=cookieName, httponly=httponly, secure=secure, alwaysSend=alwaysSend, expiration=expiration, overrideConnectionLimit=overrideConnectionLimit) except Exception as e: logger.info("Exception during Cookie Persistence Profile creation") strReturn[str(idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("Cookie Persistence Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx) : 'Cookie Persistence Profile Modification Report'} idx += 1 #logger.info("ProxyType before change: " + prfPxyType) logger.info("Profile Modification process has been initiated. Cookie Persistence Profile Name: " + prfName) # Load Cookie profile settings of a given Cookie profile name try: loadedPrf = mr.tm.ltm.persistence.cookies.cookie.load(name=prfName, partition='Common') except Exception as e: logger.info("Exception during Cookie Persistence Profile loading") strReturn[str(idx)] = "Exception fired during Cookie Profile setting loading! (" + prfName + "): " + str(e) idx += 1 logger.info("Exception fired during Cookie Persistence Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update Cookie Persistence profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.method = method loadedPrf.cookieName = cookieName loadedPrf.httponly = httponly loadedPrf.secure = secure loadedPrf.alwaysSend = alwaysSend loadedPrf.expiration = expiration loadedPrf.overrideConnectionLimit = overrideConnectionLimit ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, method, cookieName, httponly, secure, alwaysSend, expiration, overrideConnectionLimit): strReturn[str(idx)] = "Cookie Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str(idx)] = "Exception fired during Cookie profile update() (" + prfName + "): " + str(e) idx += 1 logger.info("Cookie Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No Cookie Persistence Profile modification is needed") strReturn[str(idx)] = "No Cookie Persistence Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str(idx)] = "Cookie Persistence Profile (" + prfName + ") has been created" idx += 1 logger.info("Cookie Persistence Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str(idx)] = "Cookie Persistence Profile modification(" + prfName + ") has been completed" idx += 1 logger.info("Cookie Persistence Profile modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_vs_build2(active_ltm, vs_dnsname, vs_dest, vs_port, vs_desc, vs_env, vs_tcpprofile, vs_persistence, vs_redirect, vs_type, vs_httpprofile, vs_sslclient, vs_sslserver, vs_irule, vs_snatpool, vs_policy, vs_poolname): admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_vs_build2()- Use Standard Global naming : " + useGlobalNaming ) idx = 1 strReturn = {str(idx) : 'VS Creation Report'} idx += 1 logger.info(str(active_ltm) + " VS DNS:" + str(vs_dnsname) + " VS DEST:" + str(vs_dest) + " VS PORT:" + str(vs_port) + " VS DESC:" + str(vs_desc) + " VS Env.:" + str(vs_env) + " VS TCP Prf:" + str(vs_tcpprofile) + " VS Persist:" + str(vs_persistence) + " VS Redirect:" + str(vs_redirect) + " VS Type:" + str(vs_type) + " VS HTTP Prf:" + str(vs_httpprofile) + " VS Clientssl:" + str(vs_sslclient) + " VS Serverssl:" + str(vs_sslserver) + " VS iRule: " + str(vs_irule) + " VS SNATPOOL: " + str(vs_snatpool) + " VS Policy: " + str(vs_policy) + " VS Pool Name: " + str(vs_poolname) ) logger.info("Before VS Build - Env Name: " + str(vs_env) + " DNS name: " + str(vs_dnsname) + " Port: " + str(vs_port)) if useGlobalNaming == '1': std_vsname = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'VIRTUAL_SERVER', '', vs_dnsname) else: std_vsname = str(vs_dnsname) #std_vsname = build_std_names.build_std_vs_name(str(vs_env), str(vs_dnsname), str(vs_port)) #std_poolname = build_std_names.build_std_pool_name(str(vs_env), str(vs_dnsname), str(vs_port)) logger.info("VS Creation process has been initiated. VS Name: " + std_vsname) try: fieldNames = {"name":std_vsname, "description":vs_desc, "ip":vs_dest, "port":vs_port, "ipProtocol":"tcp", "pool":vs_poolname, \ "protocolProfileClient":vs_tcpprofile, "httpProfile":vs_httpprofile, "oneConnectProfile":"none", "sslProfileClient":vs_sslclient, \ "sslProfileServer":vs_sslserver, "rules":vs_irule, "sourceAddressTranslation":vs_snatpool, "persistence":vs_persistence, "policies":vs_policy} logger.info("Protocol Profile: " + fieldNames["protocolProfileClient"] + " HTTP Profie: " + fieldNames["httpProfile"] + \ " SSL Client Profile: " + fieldNames["sslProfileClient"] + " SSL Server Profile: " + fieldNames["sslProfileServer"] + \ " iRule: " + fieldNames["rules"] + " Persistence: " + fieldNames["persistence"] + " Policy: " + fieldNames["policies"]) myvirtual = mr.tm.ltm.virtuals.virtual.create(name=fieldNames["name"], description=fieldNames["description"], \ destination="%s:%s" % (fieldNames["ip"], fieldNames["port"]), ipProtocol=fieldNames["ipProtocol"], \ pool=fieldNames["pool"]) # Create the profiles. When a virtual server is created which has a TCP # base protocol then it is automatically assigned the base "tcp" profile. # This profile cannot be removed without assigning some other TCP profile. # To do this you have to wrap the deletion of the "tcp" profile and the # creation of the of the other TCP profile in a transaction. tx = mr.tm.transactions.transaction with TransactionContextManager(tx) as api: profiles = myvirtual.profiles_s if fieldNames["protocolProfileClient"] != "none": p1 = profiles.profiles.load(partition="Common",name="tcp") p1.delete() myvirtual.profiles_s.profiles.create(partition="Common", name=fieldNames["protocolProfileClient"]) if fieldNames["httpProfile"] != "none": myvirtual.profiles_s.profiles.create(partition="Common", name=fieldNames["httpProfile"]) if fieldNames["oneConnectProfile"] != "none": myvirtual.profiles_s.profiles.create(partition="Common", name=fieldNames["oneConnectProfile"]) if fieldNames["sslProfileClient"] != "none": myvirtual.profiles_s.profiles.create(partition="Common", name=fieldNames["sslProfileClient"]) if fieldNames["sslProfileServer"] != "none": myvirtual.profiles_s.profiles.create(partition="Common", name=fieldNames["sslProfileServer"]) strReturn[str(idx)] = 'Protocol/HTTP/OneConnect/Client and Server SSL Profile has been updated' idx += 1 # Update the virtual server with the iRules. The iRules have to be a list. if fieldNames["rules"] != 'none': rules = [] for rule in fieldNames["rules"].split(): rules.append(rule) myvirtual.rules = rules myvirtual.update() # Update the virtual server with the Snatpool. The Snatpool have to be a dictionary. # When you add snatpool to a Virtual Server during Virtual Server creation, BIG-IP takes 'snatpool'. # However when you need to update snatpool with a specific virtual server, you should use 'sourceAddressTranslation' with dictionary format. if fieldNames["sourceAddressTranslation"] != 'none': vssnatpool = {'pool':'', 'type':'snat'} vssnatpool['pool'] = '/Common/' + fieldNames["sourceAddressTranslation"] myvirtual.sourceAddressTranslation = vssnatpool myvirtual.update() # Update the virtual server with the persistence profile. The iRules # have to be a list. But we will never have more than one. if fieldNames["persistence"] != 'none': persistence = [] for persistenceProfile in fieldNames["persistence"].split(): persistence.append(persistenceProfile) myvirtual.persist = persistence myvirtual.update() # Update the virtual server with the policy. policies = myvirtual.policies_s if fieldNames["policies"] != 'none': myvirtual.policies_s.policies.create(partition="Common", name=fieldNames["policies"]) strReturn[str(idx)] = 'iRule/Persistence/SnatPool/Policy Profile has been updated' idx += 1 strReturn[str(idx)] = 'Requested Virtual Server (' + std_vsname + ') has been succssfully created' idx += 1 except Exception as e: logger.info("Exception during Virtual Server creation-update") strReturn[str(idx)] = "Exception fired!: " + str(e) idx += 1 logger.info("Virtual Server creation-update exception fired: " + str(e)) return json.dumps(strReturn) return json.dumps(strReturn)
def new_DnsProfile_build(active_ltm, prfName, prfDplyOrChg, prfDftFrom, prfHwValid, prfHwRespCache, prfDnsExp, prfGtm, prfUnhandledAct, prfUseBind, prfZoneXfr, prfDnsSecurity, prfRecursion): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_DnsProfile_build()- Use Standard Global naming : " + useGlobalNaming ) logger.info("new_DnsProfile_build.py Parms \nDevIP: " + active_ltm + "\nProfile name: " + prfName + "\nProfile Deploy or Change: " + prfDplyOrChg + "\nDefaults-from: " + prfDftFrom) idx = 1 #logger.info("ProxyType before change: " + prfPxyType) if prfDplyOrChg == 'new_profile': strReturn = {str(idx) : 'DNS Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'SERVICE_DNS', prfName) logger.info("Profile Creation process has been initiated. Profile Name: " + prfName + "\n") if check_profileName_conflict(mr, prfName, prfDftFrom): strReturn.update({str(idx) : 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info("No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.profile.dns_s.dns.create(name=prfName, partition='Common', defaultsFrom=prfDftFrom, enableHardwareQueryValidation=prfHwValid, enableHardwareResponseCache=prfHwRespCache, enableDnsExpress=prfDnsExp, enableGtm=prfGtm, unhandledQueryAction=prfUnhandledAct , useLocalBind=prfUseBind, processXfr=prfZoneXfr, enableDnsFirewall=prfDnsSecurity, processRd=prfRecursion) except Exception as e: logger.info("Exception during DNS Profile creation") strReturn[str(idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("DNS Profile creation exception fired: " + str(e)) return json.dumps(strReturn) strReturn[str(idx)] = "DNS Profile (" + prfName + ") has been created" idx += 1 logger.info("DNS Profile has been created") elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx) : 'DNS Profile Modification Report'} idx += 1 logger.info("Profile Modification process has been initiated. Profile Name: " + prfName + "\n") # Load DNS profile settings of a given DNS profile name try: loadedPrf = mr.tm.ltm.profile.dns_s.dns.load(name=prfName, partition='Common') except Exception as e: logger.info("Exception during DNS Profile loading") strReturn[str(idx)] = "Exception fired during DNS Profile setting loading! (" + prfName + "): " + str(e) idx += 1 logger.info("Exception fired during DNS Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update DNS profile settings ''' loadedPrf.defaultsFrom = prfDftFrom loadedPrf.enableHardwareQueryValidation = prfHwValid loadedPrf.enableHardwareResponseCache = prfHwRespCache loadedPrf.enableDnsExpress = prfDnsExp loadedPrf.enableGtm = prfGtm loadedPrf.unhandledQueryAction = prfUnhandledAct loadedPrf.useLocalBind = prfUseBind loadedPrf.processXfr = prfZoneXfr loadedPrf.enableDnsFirewall = prfDnsSecurity loadedPrf.processRd = prfRecursion ''' if isNeedUpdate(loadedPrf, modContent, prfDftFrom, prfHwValid, prfHwRespCache, prfDnsExp, prfGtm, prfUnhandledAct, prfUseBind, prfZoneXfr, prfDnsSecurity, prfRecursion): strReturn[str(idx)] = "DNS Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str(idx)] = "Exception fired during DNS profile update() (" + prfName + "): " + str(e) idx += 1 logger.info("DNS Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No DNS Profile modification is needed") strReturn[str(idx)] = "No DNS Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str(idx)] = "DNS Profile (" + prfName + ") has been created" idx += 1 logger.info("DNS Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str(idx)] = "DNS Profile modification has been completed" idx += 1 logger.info("DNS Profile modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_httpProfile_build(active_ltm, prfName, prfDplyOrChg, prfPxyType, prfDftFrom, prfBscAuthRealm, prfFallbackHost, prfFallbackStsCode, prfHdrErase, prfHdrInsert, prfReqChunking, prfRespChunking, prfInstXFF, prfSrvAgtName): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) # Default value set if no value is given if (prfInstXFF == ''): prfInstXFF = 'disabled' admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_httpProfile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_httpProfile_build.py Parms DevIP: " + active_ltm \ + " Profile name: " + prfName \ + " Defaults-from: " + prfDftFrom \ + " Profile Proxy Type: " + prfPxyType \ + " Profile Deploy or Change: " + prfDplyOrChg \ + " Basic Auth Realm: " + prfBscAuthRealm \ + " Fallback Host: " + prfFallbackHost \ + " Fallback on Error Codes: " + prfFallbackStsCode \ + " Request Header Erase: " + prfHdrErase \ + " Request Header Insert: " + prfHdrInsert \ + " Request Chunking: " + prfReqChunking \ + " Response Chunking: " + prfRespChunking \ + " Inser X-forwared-for: " + prfInstXFF \ + " Server Agent name: " + prfSrvAgtName ) # Process to build new HTTP profile if prfDplyOrChg == 'new_profile': logger.info( "Profile Creation process has been initiated. Profile Name: " + prfName) idx = 1 strReturn = {str(idx): 'Profile Creation Report'} idx += 1 #logger.info("ProxyType before change: " + prfPxyType) #prfPxyType has 'explicit:DNS_Resolver_name' format if HTTP proxy type is 'explicit' tmp = prfPxyType.split(":") #logger.info("ProxyType after change: tmp[0]: " + tmp[0]) pxyLen = len(tmp) prfPxyType = tmp[0] # Only HTTP Explict Proxy type has the length of 2 ('explicit' and 'DNS_Resolver_name') if pxyLen == 2: dnsRzvName = tmp[1] logger.info("ProxyType: " + prfPxyType + " DNS Resolver name: " + dnsRzvName) #std_irname = build_std_names.build_std_ir_name(str(irEnv), str(irVsName), str(irVsPort), str(irType)) if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'SERVICE_HTTP', prfName) if check_profileName_conflict(mr, prfName, prfPxyType, prfDftFrom): strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: new_records = [] arrRecords = prfFallbackStsCode.split(' ') for arrRecord in arrRecords: aRecord = arrRecord.split(':') logger.info("FallbackStatus Codes: " + arrRecord) nr = [str(arrRecord)] new_records.extend(nr) if prfPxyType == 'explicit': proxyDict = {'dnsResolver': '/Common/' + dnsRzvName} #logger.info("DNS Resolver Full name: " + proxyDict['dnsResolver']) mydg = mr.tm.ltm.profile.https.http.create( name=prfName, partition='Common', proxyType=prfPxyType, defaultsFrom=prfDftFrom, basicAuthRealm=prfBscAuthRealm, fallbackHost=prfFallbackHost, fallbackStatusCodes=new_records, headerErase=prfHdrErase, headerInsert=prfHdrInsert, requestChunking=prfReqChunking, responseChunking=prfRespChunking, insertXforwardedFor=prfInstXFF, serverAgentName=prfSrvAgtName, explicitProxy=proxyDict) else: mydg = mr.tm.ltm.profile.https.http.create( name=prfName, partition='Common', proxyType=prfPxyType, defaultsFrom=prfDftFrom, basicAuthRealm=prfBscAuthRealm, fallbackHost=prfFallbackHost, fallbackStatusCodes=new_records, headerErase=prfHdrErase, headerInsert=prfHdrInsert, requestChunking=prfReqChunking, responseChunking=prfRespChunking, insertXforwardedFor=prfInstXFF, serverAgentName=prfSrvAgtName) except Exception as e: logger.info("Exception during Profile creation") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("Profile creation exception fired: " + str(e)) return json.dumps(strReturn) # Process to change an existing HTTP profile else: # modContent dictionary is used with modify(**modContent) to update only specified values # Issue Track: #1 modContent = {} logger.info( "HTTP profile modification process has been initiated. Profile Name: " + prfName) idx = 1 strReturn = {str(idx): 'Profile Modification Report'} idx += 1 logger.info("ProxyType before change: " + prfPxyType) tmp = prfPxyType.split(":") logger.info("ProxyType after change: tmp[0]: " + tmp[0]) try: # Loading profile of a given profile name loadedPrf = mr.tm.ltm.profile.https.http.load(name=prfName, partition='Common') except Exception as e: logger.info("Exception during loading HTTP Profile" + prfName) strReturn[str( idx )] = "HTTP Profile Loading Exception fired! (" + prfName + "): " + str( e) idx += 1 return json.dumps(strReturn) pxyLen = len(tmp) prfPxyType = tmp[0] if pxyLen == 2: dnsRzvName = tmp[1] logger.info("ProxyType: " + prfPxyType + " DNS Resolver name: " + dnsRzvName) if prfPxyType == 'explicit': proxyDict = {'dnsResolver': dnsRzvName} # loadedPrf.explicitProxy = proxyDict - Issue Track: #1 modContent['explicitProxy'] = proxyDict ''' # Set HTTP profile values # # Issue Track: #1 #loadedPrf.proxyType = prfPxyType #loadedPrf.defaultsFrom = prfDftFrom #loadedPrf.basicAuthRealm = prfBscAuthRealm #loadedPrf.fallbackHost = prfFallbackHost modContent['proxyType'] = prfPxyType modContent['defaultsFrom'] = prfDftFrom modContent['basicAuthRealm'] = prfBscAuthRealm modContent['fallbackHost'] = prfFallbackHost new_records = [] arrRecords = prfFallbackStsCode.split(' ') for arrRecord in arrRecords: aRecord = arrRecord.split(':') logger.info("FallbackStatus Codes: " + arrRecord) nr = [str(arrRecord)] new_records.extend(nr) # # Issue Track: #1 #loadedPrf.fallbackStatusCodes = arrRecords #loadedPrf.headerErase = prfHdrErase #loadedPrf.headerInsert = prfHdrInsert #loadedPrf.requestChunking = prfReqChunking #loadedPrf.responseChunking = prfRespChunking #loadedPrf.insertXforwardedFor = prfInstXFF #loadedPrf.serverAgentName = prfSrvAgtName modContent['fallbackStatusCodes'] = arrRecords modContent['headerErase'] = prfHdrErase modContent['headerInsert'] = prfHdrInsert modContent['requestChunking'] = prfReqChunking modContent['responseChunking'] = prfRespChunking modContent['insertXforwardedFor'] = prfInstXFF modContent['serverAgentName'] = prfSrvAgtName ''' # Issue Track: #1 # Found which values have been modified if isNeedUpdate(loadedPrf, modContent, prfPxyType, prfDftFrom, prfBscAuthRealm, prfFallbackHost, prfFallbackStsCode, prfHdrErase, prfHdrInsert, prfReqChunking, prfRespChunking, prfInstXFF, prfSrvAgtName): # Update HTTP profile try: # # Issue Track: #1 #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: logger.info( "Exception during updating HTTP Profile modification") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info( "HTTP Profile modificaiton creation Exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No HTTP Profile modification is needed") strReturn[str( idx )] = "No HTTP Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str(idx)] = "HTTP Profile (" + prfName + ") has been created" logger.info("HTTP Profile has been created") else: strReturn[str( idx )] = "Modifying HTTP Profile (" + prfName + ") has been completed" logger.info("HTTP Profile modification has been completed") idx += 1 for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_irule_build(active_ltm, irDgName, irEnv, irType, irCode, irDgType, irDgData): logger.info("new_irule_build.py parms\n DevIP: " + active_ltm + "\niRule/Data Group Name: " + irDgName + "\nEnv: " + irEnv + "\nConfig Type: " + irType + "\niRule Code: " + irCode + "\nDG Type: " + irDgType + "\nDG Data: " + irDgData + "\n") admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_irule_build()- Use Standard Global naming : " + useGlobalNaming) idx = 1 strReturn = {str(idx): 'iRule/Data Group Creation Report'} idx += 1 if useGlobalNaming == '1': logger.info( "new_irule_build()- Standard Global naming process starts!") if irType == 'iRule': std_irname = loadStdNames.get_std_name(active_ltm, 'SHARED', 'IRULE', '', irDgName) elif irType == 'Data Group': std_irname = loadStdNames.get_std_name(active_ltm, 'SHARED', 'DATA_GROUP', '', irDgName) #std_irname = build_std_names.build_std_ir_name(str(irEnv), str(irDgName), str(irType)) logger.info( "iRule/Data Group Creation process has been initiated. iRule/Data Group Name: " + std_irname) if check_irname_conflict(mr, std_irname, irType, irDgType): strReturn.update({str(idx): 'iRule/Data Group Name conflict'}) logger.info("iRule/Data Group name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No iRule/Data Group name conflict. Now creating a iRule/Data Group") #Create a iRule/Data Group try: if irType == "iRule": myir = mr.tm.ltm.rules.rule.create(name=std_irname, partition='Common', apiAnonymous=irCode) elif irType == "Data Group": new_records = [] arrRecords = irDgData.split(',') for arrRecord in arrRecords: aRecord = arrRecord.split(':=') logger.info("name: " + aRecord[0] + " Value: " + aRecord[1]) nr = [{'name': str(aRecord[0]), 'data': str(aRecord[1])}] new_records.extend(nr) if irDgType == "ip": mydg = mr.tm.ltm.data_group.internals.internal.create( name=std_irname, partition='Common', type='ip', records=new_records) elif irDgType == "string": mydg = mr.tm.ltm.data_group.internals.internal.create( name=std_irname, partition='Common', type='string', records=new_records) elif irDgType == "integer": mydg = mr.tm.ltm.data_group.internals.internal.create( name=std_irname, partition='Common', type='integer', records=new_records) except Exception as e: logger.info("iRule/Data Group Exception printing") strReturn[str( idx)] = "Exception fired! (" + std_irname + "): " + str(e) idx += 1 logger.info( "Exception during iRule/Data Group creation has been fired: " + str(e)) return json.dumps(strReturn) strReturn[str( idx )] = irType + " iRule/Data Group (" + std_irname + ") has been created" idx += 1 logger.info("iRule/Data Group has been created") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_f4Profile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, resetOnTimeout, reassembleFragments, idleTimeout, tcpHandshakeTimeout, tcpTimestampMode, tcpWscaleMode, looseInitialization, looseClose, tcpCloseTimeout, keepAliveInterval): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_f4Profile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_f4Profile_build.py Parms DevIP: " + active_ltm + " Profile name: " + prfName + " Profile Deploy or Change: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx): 'FastL4 Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'FASTL4_PROTOCOL', prfName) logger.info( "Profile Creation process has been initiated. FastL4 Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.profile.fastl4s.fastl4.create(name=prfName, partition='Common', defaultsFrom=defaultsFrom, resetOnTimeout=resetOnTimeout,\ reassembleFragments=reassembleFragments, idleTimeout=idleTimeout, tcpHandshakeTimeout=tcpHandshakeTimeout, \ tcpTimestampMode=tcpTimestampMode, tcpWscaleMode=tcpWscaleMode, looseInitialization=looseInitialization, looseClose=looseClose, \ tcpCloseTimeout=tcpCloseTimeout, keepAliveInterval=keepAliveInterval) except Exception as e: logger.info("Exception during FastL4 Profile creation") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("FastL4 Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx): 'FastL4 Profile Modification Report'} idx += 1 logger.info( "Profile Modification process has been initiated. FastL4 Profile Name: " + prfName) # Load FastL4 profile settings of a given FastL4 profile name # 'defaultsFrom', 'resetOnTimeout', 'reassembleFragments', 'idleTimeout', # 'tcpHandshakeTimeout', 'tcpTimestampMode', 'tcpWscaleMode', 'looseInitialization', # 'looseClose', 'tcpCloseTimeout', 'keepAliveInterval' try: loadedPrf = mr.tm.ltm.profile.fastl4s.fastl4.load( name=prfName, partition='Common') except Exception as e: logger.info("Exception during FastL4 Profile loading") strReturn[str( idx )] = "Exception fired during FastL4 Profile setting loading! (" + prfName + "): " + str( e) idx += 1 logger.info( "Exception fired during FastL4 Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update FastL4 profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.resetOnTimeout = resetOnTimeout loadedPrf.reassembleFragments = reassembleFragments loadedPrf.idleTimeout = idleTimeout loadedPrf.tcpHandshakeTimeout = tcpHandshakeTimeout loadedPrf.tcpTimestampMode = tcpTimestampMode loadedPrf.tcpWscaleMode = tcpWscaleMode loadedPrf.looseInitialization = looseInitialization loadedPrf.looseClose = looseClose loadedPrf.tcpCloseTimeout = tcpCloseTimeout loadedPrf.keepAliveInterval = keepAliveInterval ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, resetOnTimeout, reassembleFragments, idleTimeout, tcpHandshakeTimeout, tcpTimestampMode, tcpWscaleMode, looseInitialization, looseClose, tcpCloseTimeout, keepAliveInterval): strReturn[str(idx)] = "FastL4 Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str( idx )] = "Exception fired during FastL4 profile update() (" + prfName + "): " + str( e) idx += 1 logger.info("FastL4 Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No FastL4 Profile modification is needed") strReturn[str( idx )] = "No FastL4 Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str( idx)] = "FastL4 Profile(" + prfName + ") has been created" idx += 1 logger.info("FastL4 Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str( idx )] = "FastL4 Profile Modification(" + prfName + ") has been completed" idx += 1 logger.info("FastL4 Profile Modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_pool_build(active_ltm, vs_dnsname, vs_port, vs_env, vs_poolmon, pLBMethod, pPriGroup, pPriGroupLessThan, pool_membername, pool_memberip, pool_memberport, pool_memberratio, pmMon, pmPriGroup): logger.info("new_pool_build.py parms DevIP: " + active_ltm + " Pool Name: " + vs_dnsname + " VS Port: " + vs_port + " Env: " + vs_env + " Pool Mon: " + vs_poolmon + " LB Method: " + pLBMethod + " Pri Group: " + pPriGroup + " Lessthan: " + pPriGroupLessThan + " PM Names: " + pool_membername + " PM IPs: " + pool_memberip + " PM Ports: " + pool_memberport + "PM Ration: " + pool_memberratio + " PM Mons:" + pmMon + " PM Pri:" + pmPriGroup) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_pool_build()- Use Standard Global naming : " + useGlobalNaming) # Passed Parameter format change from string to array = "srv1.xyz.com:srv2.xyz.com:" ==> [srv1.xyz.com, srv2.xyz.com] membernames = pool_membername.split(":") memberips = pool_memberip.split(":") memberports = pool_memberport.split(":") memberratios = pool_memberratio.split(":") membermons = pmMon.split(":") memberPriGroups = pmPriGroup.split(":") logger.info(" Pool Member1: " + membernames[0] + " Pool Member2: " + membernames[1]) idx = 1 strReturn = {str(idx): 'Pool Creation Report'} idx += 1 if useGlobalNaming == '1': std_poolname = loadStdNames.get_std_name(active_ltm, 'LOCAL', 'POOL', '', vs_dnsname) else: #std_poolname = build_std_names.build_std_pool_name(str(vs_env), str(vs_dnsname), str(vs_port)) std_poolname = str(vs_dnsname) logger.info("Pool Creation process has been initiated. Pool Name: " + std_poolname) if check_poolname_conflict(mr, std_poolname): strReturn.update({str(idx): 'Pool Name conflict'}) idx += 1 return json.dumps(strReturn) logger.info("No Pool name conflict. Now creating a pool") #Create a pool try: if pPriGroup != 'Lessthan': mypool = mr.tm.ltm.pools.pool.create(name=std_poolname, partition='Common', loadBalancingMode=pLBMethod, monitor='/Common/' + vs_poolmon) else: mypool = mr.tm.ltm.pools.pool.create( name=std_poolname, partition='Common', loadBalancingMode=pLBMethod, monitor='/Common/' + vs_poolmon, minActiveMembers=pPriGroupLessThan) mypool_1 = mr.tm.ltm.pools.pool.load(name=std_poolname, partition='Common') except Exception as e: logger.info("Exception during building base Pool creation") strReturn[str(idx)] = "Exception fired!: " + str(e) idx += 1 logger.info("Base Pool Creation has failed with the excpetion of " + str(e)) return json.dumps(strReturn) strReturn[str( idx )] = "Base Pool has been created (Without pool members and Priority Group)" idx += 1 #for membername, memberip, memberport, membermon in map(None, membernames, memberips, memberports, membermons): try: count = 1 if pPriGroup != 'Lessthan': for membername, memberip, memberport, membermon, memberratio in zip( membernames, memberips, memberports, membermons, memberratios): if (membername == ''): break if useGlobalNaming == '1': membername = loadStdNames.get_std_name( active_ltm, 'LOCAL', 'NODE', '', membername) logger.info("Count: " + str(count) + " Member Name: " + membername + " IP: " + memberip + " port: " + memberport + " Ratio: " + memberratio + " mon: " + membermon) # Pool member creation issue - Calling Pool creation method too fast?? if (str(membermon) == 'inherit'): poolm = mypool_1.members_s.members.create( name=membername + ':' + memberport, partition='Common', address=memberip, ratio=memberratio, monitor=vs_poolmon) logger.info("inherit") else: poolm = mypool_1.members_s.members.create( name=membername + ':' + memberport, partition='Common', address=memberip, ratio=memberratio, monitor=membermon) logger.info("Custom Pool monitor") logger.info("Count: " + str(count) + " Member Name: " + membername + " IP: " + memberip + " Port: " + memberport + " Ratio: " + memberratio + " Monitor: " + membermon + " Pool Monitor: " + vs_poolmon) strReturn[str( idx )] = 'Member(' + membername + ' IP:' + memberip + ':' + memberport + ' Monitor: ' + membermon + ') has been updated with the built pool' idx += 1 count = count + 1 else: for membername, memberip, memberport, memberratio, membermon, memberPriGroup in zip( membernames, memberips, memberports, memberratios, membermons, memberPriGroups): if (membername == ''): break if useGlobalNaming == '1': membername = loadStdNames.get_std_name( active_ltm, 'LOCAL', 'NODE', '', membername) logger.info("Count: " + str(count) + " Member Name: " + membername + " IP: " + memberip + " port: " + memberport + "Ratio: " + memberratio + " mon: " + membermon + " PoolMember Priority: " + memberPriGroup) # Pool member creation issue - Calling Pool creation method too fast?? if (str(membermon) == 'Inherit'): poolm = mypool_1.members_s.members.create( name=membername + ':' + memberport, partition='Common', address=memberip, ratio=memberratio, monitor=vs_poolmon, priorityGroup=memberPriGroup) logger.info("Inherit") else: poolm = mypool_1.members_s.members.create( name=membername + ':' + memberport, partition='Common', address=memberip, ratio=memberratio, monitor=membermon, priorityGroup=memberPriGroup) logger.info("Custom Pool Monitor") logger.info("Count: " + str(count) + " Member Name: " + membername + " IP: " + memberip + " Port: " + memberport + " Ratio: " + memberratio + " Monitor: " + membermon + " Pool Monitor: " + vs_poolmon) strReturn[str( idx )] = 'Member(' + membername + ' IP:' + memberip + ':' + memberport + 'Ratio: ' + memberratio + ' Monitor: ' + membermon + ') has been updated with the built pool' idx += 1 count = count + 1 except Exception as e: logger.info( "Exception occurred during updating base Pool with pool properties" ) strReturn[str(idx)] = "Exception fired!: " + str(e) idx += 1 logger.info("Base Pool update has failed with the exception of " + str(e)) return json.dumps(strReturn) strReturn[str( idx)] = 'Pool creation process has been completed successfully' idx += 1 logger.info("Final strReturn: Started") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_monitor_build(active_ltm, monName, mDesc, mEnv, mMonType, mMonCode, mParMonType, mInterval, mTimeout, mSend, mRecv, mUsername, mPassword, mReverse, mAliasPort, mCipherlist): logger.info("new_monitor_build.py parms DevIP: " + active_ltm + " VS Name: " + monName + " Env: " + mEnv + " Mon Code: " + mMonCode + " Interval: " + mInterval + " Send: " + mSend + " Reverse: " + mReverse + " Alias Port: " + mAliasPort + " CipherList: " + mCipherlist) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_monitor_build()- Use Standard Global naming : " + useGlobalNaming) idx = 1 strReturn = {str(idx): 'Monitor Creation Report'} idx += 1 if useGlobalNaming == '1': if mMonType == "TCP Half Open": std_monname = loadStdNames.get_std_name(active_ltm, 'SHARED', 'MONITOR', 'TCP_HALF_OPEN', monName) elif mMonType == 'External': std_monname = loadStdNames.get_std_name(active_ltm, 'SHARED', 'MONITOR', 'EXTERNAL', monName) else: std_monname = loadStdNames.get_std_name(active_ltm, 'SHARED', 'MONITOR', mMonType, monName) else: std_monname = monName #std_monname = build_std_names.build_std_mon_name(str(mEnv), str(monName)) logger.info("Monitor Creation process has been initiated. Pool Name: " + std_monname) if check_monname_conflict(mr, std_monname, mMonType): strReturn.update({str(idx): 'Monitor Name conflict'}) logger.info("Monitor name conflict.") idx += 1 return json.dumps(strReturn) logger.info("No Monitor name conflict. Now creating a monitor") #Create a monitor if mMonType == "HTTP": mymon = mr.tm.ltm.monitor.https.http.create(name=std_monname, partition='Common', description=mDesc, interval=int(mInterval), timeout=int(mTimeout), reverse=mReverse, send=mSend, recv=mRecv, username=mUsername, password=mPassword, destination="*:" + mAliasPort) elif mMonType == "HTTPS": mymon = mr.tm.ltm.monitor.https_s.https.create(name=std_monname, partition='Common', description=mDesc, interval=int(mInterval), timeout=int(mTimeout), reverse=mReverse, send=mSend, recv=mRecv, username=mUsername, password=mPassword, destination="*:" + mAliasPort, cipherlist=mCipherlist) elif mMonType == "TCP": mymon = mr.tm.ltm.monitor.tcps.tcp.create(name=std_monname, partition='Common', description=mDesc, interval=int(mInterval), timeout=int(mTimeout), reverse=mReverse, send=mSend, recv=mRecv, destination="*:" + mAliasPort) elif mMonType == "UDP": mymon = mr.tm.ltm.monitor.udps.udp.create(name=std_monname, partition='Common', description=mDesc, interval=int(mInterval), timeout=int(mTimeout), reverse=mReverse, send=mSend, recv=mRecv, destination="*:" + mAliasPort) elif mMonType == "TCP Half Open": mymon = mr.tm.ltm.monitor.tcp_half_opens.tcp_half_open.create( name=std_monname, partition='Common', description=mDesc, interval=int(mInterval), timeout=int(mTimeout), destination="*:" + mAliasPort) elif mMonType == "External": pass strReturn[str( idx)] = mMonType + " Monitor (" + std_monname + ") has been created" idx += 1 logger.info("Monitor created") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_tcpProfile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, resetOnTimeout, proxyBufferHigh, proxyBufferLow, receiveWindowSize, sendBufferSize, ackOnPush, nagle, initCwnd, slowStart, selectiveAcks): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_tcpProfile_build()- Use Standard Global naming : " + useGlobalNaming) logger.info("new_tcpProfile_build.py Parms DevIP: " + active_ltm + " Profile name: " + prfName + " Profile Deploy or Change: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx): 'TCP Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'TCP_PROTOCOL', prfName) logger.info( "Profile Creation process has been initiated. TCP Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx): 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info( "No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.profile.tcps.tcp.create(name=prfName, partition='Common', defaultsFrom=defaultsFrom, resetOnTimeout=resetOnTimeout,\ proxyBufferHigh=proxyBufferHigh, proxyBufferLow=proxyBufferLow, receiveWindowSize=receiveWindowSize, sendBufferSize=sendBufferSize,\ ackOnPush=ackOnPush, nagle=nagle, initCwnd=initCwnd, slowStart=slowStart, selectiveAcks=selectiveAcks) except Exception as e: logger.info("Exception during TCP Profile creation") strReturn[str( idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("TCP Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx): 'TCP Profile Modification Report'} idx += 1 logger.info( "Profile Modification process has been initiated. TCP Profile Name: " + prfName) # Load TCP profile settings of a given TCP profile name # 'defaultsFrom', 'resetOnTimeout', 'proxyBufferHigh', 'proxyBufferLow', # 'receiveWindowSize', 'sendBufferSize', 'ackOnPush', 'nagle', 'initCwnd', # 'slowStart', 'selectiveAcks' try: loadedPrf = mr.tm.ltm.profile.tcps.tcp.load(name=prfName, partition='Common') except Exception as e: logger.info("Exception during TCP Profile loading") strReturn[str( idx )] = "Exception fired during TCP Profile setting loading! (" + prfName + "): " + str( e) idx += 1 logger.info( "Exception fired during TCP Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update TCP profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.resetOnTimeout = resetOnTimeout loadedPrf.proxyBufferHigh = proxyBufferHigh loadedPrf.proxyBufferLow = proxyBufferLow loadedPrf.receiveWindowSize = receiveWindowSize loadedPrf.sendBufferSize = sendBufferSize loadedPrf.ackOnPush = ackOnPush loadedPrf.nagle = nagle loadedPrf.initCwnd = initCwnd loadedPrf.slowStart = slowStart ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, resetOnTimeout, proxyBufferHigh, proxyBufferLow, receiveWindowSize, sendBufferSize, ackOnPush, nagle, initCwnd, slowStart, selectiveAcks): strReturn[str(idx)] = "TCP Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str( idx )] = "Exception fired during TCP profile update() (" + prfName + "): " + str( e) idx += 1 logger.info("TCP Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No TCP Profile modification is needed") strReturn[str( idx )] = "No TCP Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str(idx)] = "TCP Profile (" + prfName + ") has been created" idx += 1 logger.info("TCP Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str( idx )] = "TCP Profile Modification(" + prfName + ") has been completed" idx += 1 logger.info("TCP Profile modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)
def new_udpProfile_build(active_ltm, prfName, prfDplyOrChg, defaultsFrom, proxyMss, idleTimeout, ipTosToClient, linkQosToClient, datagramLoadBalancing, allowNoPayload, ipTtlMode, ipTtlV4, ipTtlV6, ipDfMode): #logger.info('Called get_profiles(): %s %s' % (active_ltm, pf_type)) admpass = getpass.getpass('LTM', 'admin') mr = ManagementRoot(str(active_ltm), 'admin', admpass) output = '' # Check if Standard naming is used useGlobalNaming = loadStdNames.useStdNaming() logger.info("new_udpProfile_build()- Use Standard Global naming : " + useGlobalNaming ) logger.info("new_udpProfile_build.py Parms DevIP: " + active_ltm + " Profile name: " + prfName + " Profile Deploy or Change: " + prfDplyOrChg + " Defaults-from: " + defaultsFrom) idx = 1 if prfDplyOrChg == 'new_profile': strReturn = {str(idx) : 'UDP Profile Creation Report'} idx += 1 if useGlobalNaming == '1': prfName = loadStdNames.get_std_name(active_ltm, 'SHARED', 'PROFILE', 'UDP_PROTOCOL', prfName) logger.info("Profile Creation process has been initiated. UDP Profile Name: " + prfName) if check_profileName_conflict(mr, prfName, defaultsFrom): strReturn.update({str(idx) : 'Profile Name conflict'}) logger.info("Profile name conflict.") idx += 1 return json.dumps(strReturn) logger.info("No profile name conflict. Now creating the requested profile") try: mydg = mr.tm.ltm.profile.udps.udp.create(name=prfName, partition='Common', defaultsFrom=defaultsFrom, proxyMss=proxyMss, idleTimeout=idleTimeout, ipTosToClient=ipTosToClient, linkQosToClient=linkQosToClient, datagramLoadBalancing=datagramLoadBalancing, allowNoPayload=allowNoPayload, ipTtlMode=ipTtlMode, ipTtlV4=ipTtlV4, ipTtlV6=ipTtlV6, ipDfMode=ipDfMode) except Exception as e: logger.info("Exception during UDP Profile creation") strReturn[str(idx)] = "Exception fired! (" + prfName + "): " + str(e) idx += 1 logger.info("UDP Profile creation exception fired: " + str(e)) return json.dumps(strReturn) elif prfDplyOrChg == 'chg_profile': modContent = {} strReturn = {str(idx) : 'UDP Profile Creation Report'} idx += 1 logger.info("Profile Modification process has been initiated. UDP Profile Name: " + prfName) # Load UDP profile settings of a given UDP profile name # 'defaultsFrom', 'proxyMss', 'idleTimeout', 'ipTosToClient', 'linkQosToClient', # 'datagramLoadBalancing', 'allowNoPayload', 'ipDfMode', 'ipTtlV4', 'ipTtlV6', # 'ipDfMode' try: loadedPrf = mr.tm.ltm.profile.udps.udp.load(name=prfName, partition='Common') except Exception as e: logger.info("Exception during UDP Profile loading") strReturn[str(idx)] = "Exception fired during UDP Profile setting loading! (" + prfName + "): " + str(e) idx += 1 logger.info("Exception fired during UDP Profile setting loading! ( " + str(e) + ")") return json.dumps(strReturn) # Save the update UDP profile settings ''' loadedPrf.defaultsFrom = defaultsFrom loadedPrf.proxyMss = proxyMss loadedPrf.idleTimeout = idleTimeout loadedPrf.ipTosToClient = ipTosToClient loadedPrf.linkQosToClient = linkQosToClient loadedPrf.datagramLoadBalancing = datagramLoadBalancing loadedPrf.allowNoPayload = allowNoPayload loadedPrf.ipDfMode = ipDfMode loadedPrf.ipTtlV4 = ipTtlV4 loadedPrf.ipTtlV6 = ipTtlV6 loadedPrf.ipDfMode = ipDfMode ''' if isNeedUpdate(loadedPrf, modContent, defaultsFrom, proxyMss, idleTimeout, ipTosToClient, linkQosToClient, datagramLoadBalancing, allowNoPayload, ipTtlMode, ipTtlV4, ipTtlV6, ipDfMode): strReturn[str(idx)] = "UDP Profile settings have been saved!" idx += 1 try: #loadedPrf.update() loadedPrf.modify(**modContent) except Exception as e: strReturn[str(idx)] = "Exception fired during UDP profile update() (" + prfName + "): " + str(e) idx += 1 logger.info("UDP Profile creation exception fired: " + str(e)) return json.dumps(strReturn) else: logger.info("No UDP Profile modification is needed") strReturn[str(idx)] = "No UDP Profile modification is needed (" + prfName + "): " idx += 1 if prfDplyOrChg == 'new_profile': strReturn[str(idx)] = "UDP Profile (" + prfName + ") has been created" idx += 1 logger.info("UDP Profile has been created") elif prfDplyOrChg == 'chg_profile': strReturn[str(idx)] = "UDP Profile Modification(" + prfName + ") has been completed" idx += 1 logger.info("UDP Profile Modification has been completed") for keys, values in strReturn.items(): logger.info("Key: " + keys + " Value: " + values) return json.dumps(strReturn)