def main():
handle = UcsHandle("10.0.0.201", "ucspe", "ucspe", secure=False)
handle.login()
## Query Based on Class Name
print("\n\n=== Query Based on Class Name")
blades = handle.query_classid("computeBlade")
for blade in blades:
print(blade.dn, blade.name, blade.model)
## Query Class Name with filter
print("\n\n=== Query Based on Class Name with Filter equal to")
filter = "(model, 'UCSB-EX-M4-1', type='eq')"
blades = handle.query_classid("computeBlade", filter_str=filter)
for blade in blades:
print(blade.dn, blade.name, blade.model)
print("\n\n=== Query Based on Class Name with Filter not-equal to")
filter = "(model,'UCSB-EX-M4-1',type='ne')"
blades = handle.query_classid("computeBlade", filter_str=filter)
for blade in blades:
print(blade.dn, blade.name, blade.model)
## Query Directly the DN of an Object
print("\n\n=== Query Based on Distinguished Name")
blade = handle.query_dn(blades[0].dn)
print(blade)
handle.logout()
def login(username, password, server):
# first see if reachable
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(2)
try:
result = s.connect_ex((server, 80))
if result != 0:
return "", "%s is not reachable" % server
s.close()
except socket.error as err:
return "", "UCS Login Error: %s %s" % (server, err.strerror)
handle = UcsHandle(server, username, password)
try:
handle.login()
except UcsException as err:
print "Login Error: " + err.error_descr
return "", err.error_descr
except HTTPError as err:
print "Connection Error: Bad UCSM? " + err.reason
return "", err.reason
except:
print "Issue logging in. Please check that all parameters are correct"
return "", "Issue logging in. Please check that all parameters are correct."
return handle, ""
def login(self):
from ucsmsdk.ucshandle import UcsHandle
# use_proxy=yes (default) and proxy=None (default) should be using the system defined proxy
# use_proxy=yes (default) and proxy=value should use the provided proxy
# use_proxy=no (user) should not be using a proxy
if self.module.params['use_proxy']:
proxy = self.module.params['proxy']
else:
# force no proxy to be used. Note that proxy=None in UcsHandle will
# use the system proxy so we must set to something else
proxy = {}
try:
handle = UcsHandle(ip=self.module.params['hostname'],
username=self.module.params['username'],
password=self.module.params['password'],
port=self.module.params['port'],
secure=self.module.params['use_ssl'],
proxy=proxy)
handle.login()
except Exception as e:
self.result['msg'] = str(e)
self.module.fail_json(**self.result)
self.login_handle = handle
def login(self, username, password, server):
# Test if the server reachable
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(2)
try:
result = s.connect_ex((server, 80))
if result != 0:
return None, "{0} is not reachable".format(server)
s.close()
except socket.error as err:
return None, "UCS Login Error: {0} {1}".format(
server, err.strerror)
handle = UcsHandle(server, username, password)
try:
handle.login()
except UcsException as err:
print "Login Error: " + err.error_descr
return None, err.error_descr
except HTTPError as err:
print "Connection Error: Bad UCSM? " + err.reason
return None, err.reason
except Exception as e:
print "Issue logging in. Please check that all parameters are correct"
print e
return None, "Issue logging in. Please check that all parameters are correct."
msg = self.ensure_version(handle)
return handle, msg
def run_module():
""" Run the module """
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=True),
username=dict(type='str', default='admin'),
password=dict(type='str', required=True, no_log=True),
name=dict(type='str'),
descr=dict(type='str'),
state=dict(
type='str', default='present', choices=['present', 'absent'])))
from ucsmsdk.ucshandle import UcsHandle
from ucsmsdk.mometa.org.OrgOrg import OrgOrg
handle = UcsHandle(module.params['hostname'], module.params['username'],
module.params['password'])
handle.login()
ucs_mo = OrgOrg(parent_mo_or_dn='org-root',
name=module.params['name'],
descr=module.params['descr'])
handle.add_mo(ucs_mo, modify_present=True)
handle.commit()
handle.logout()
# TODO: Add delete object code
result = dict(changed=True)
module.exit_json(**result)
class UCSMController:
def __init__(self):
self.handle = UcsHandle(ip=IP, username=USERNAME, password=PASSWORD)
if not self.handle.login():
raise Exception("No valid UCS Manager credentials")
def GetHandle(self):
return self.handle
def GetInterfaceProfiles(self):
handle = self.GetHandle()
return handle.query_classid("vnicLanConnTempl")
def GetBIOSProfiles(self):
handle = self.GetHandle()
return handle.query_classid("biosVProfile")
def GetSvcProfiles(self):
handle = self.GetHandle()
return handle.query_classid("lsServer")
def GetByDN(self, dn, hierarchy=True):
handle = self.GetHandle()
return handle.query_dn(dn, hierarchy=hierarchy)
def Logout(self):
self.handle.logout()
def login(self):
from ucsmsdk.ucshandle import UcsHandle
# use_proxy=yes (default) and proxy=None (default) should be using the system defined proxy
# use_proxy=yes (default) and proxy=value should use the provided proxy
# use_proxy=no (user) should not be using a proxy
if self.module.params['use_proxy']:
proxy = self.module.params['proxy']
else:
# force no proxy to be used. Note that proxy=None in UcsHandle will
# use the system proxy so we must set to something else
proxy = {}
try:
handle = UcsHandle(ip=self.module.params['hostname'],
username=self.module.params['username'],
password=self.module.params['password'],
port=self.module.params['port'],
secure=self.module.params['use_ssl'],
proxy=proxy)
handle.login()
except Exception as e:
self.result['msg'] = str(e)
self.module.fail_json(**self.result)
self.login_handle = handle
def _getHandler(headers, handlers):
authInfo = Ucs._getUcsAuthInfo(headers)
host, user, password = authInfo
timestamp = time.time()
handle_obj = handlers.get(host, None)
ucs_handle = handle_obj and handle_obj.get('ucs-handle', None)
is_auth_valid = ucs_handle \
and handle_obj.get('ucs-user') == user \
and handle_obj.get('ucs-password') == password \
and (timestamp - handle_obj['timestamp']) < SESSION_DURATION
if is_auth_valid:
handle_obj['timestamp'] = timestamp
else:
if ucs_handle:
# logout existing handler if it is invalid
ucs_handle.logout()
ucs_handle = UcsHandle(*authInfo, secure=False)
if ucs_handle.login():
ucs_handle_obj = {
'ucs-user': user,
'ucs-password': password,
'ucs-host': host,
'ucs-handle': ucs_handle,
'timestamp': timestamp
}
handlers[host] = ucs_handle_obj
else:
ucs_handle.logout()
return None
return ucs_handle
def main():
handle = UcsHandle("192.168.254.200","ucspe","ucspe", secure=False)
handle.login()
# Query Blades that are unassociated
print("\n\n=== Query Based on Class Name with Filter equal to")
filter = "(oper_state,'unassociated',type='eq')".format(BLADE_MODEL)
blades = handle.query_classid("computeBlade",filter_str=filter)
print("***Found {} Blades".format(len(blades)))
# Error Check for available blades
if len(blades) < NUM_SP:
error = "There are only {} blades left to associate, and you asked for {} Servers to be generated".format(len(blades),NUM_SP)
raise NameError(error)
# Setup Variable for SP Templates to be deployed
dn_set = DnSet()
for i in range(1, NUM_SP+1):
dn = Dn()
sp_name = "SP{}".format(str(i))
dn.attr_set("value", sp_name)
dn_set.child_add(dn)
# Build XML Object to submit to the API
templates = ls_instantiate_n_named_template(
cookie=handle.cookie,
dn="org-root/ls-globotemplate",
in_target_org="org-root",
in_error_on_existing="false",
in_name_set=dn_set
)
# Send XML Object to xml process handler
sp_list = handle.process_xml_elem(templates)
# Loop through each created sp, and associate them to blades
i = 0
while i < len(sp_list):
sp = sp_list[i]
blade = blades[i]
# Print SP and Blade Combination
print(sp.dn,blade.dn)
# Get Binding Object
mo = LsBinding(
parent_mo_or_dn=sp.dn,
pn_dn=blade.dn,
restrict_migration="no"
)
# Add MO Binding Object to handler
handle.add_mo(mo,modify_present=True)
i=i+1
# Bundle the SP Associates
handle.commit()
def update_usrlbl(usrlbl):
""" Update object usrlbl, ComputeBlade,ComputeRackUnit, LsServer"""
handle = UcsHandle(UCS_HOST, UCS_USER, UCS_PASS)
handle.login()
usrlbl_classes = ['computeblade', 'computerackunit', 'lsserver']
for usrlbl_class in usrlbl_classes:
compute_mos = handle.query_classid(usrlbl_class)
for compute_mo in compute_mos:
if '/blade-' in compute_mo.dn:
print('blade', compute_mo.dn, 'usrlbl', compute_mo.usr_lbl)
compute_mo.usr_lbl = usrlbl
elif '/rackunit-' in compute_mo.dn:
print('rack', compute_mo.dn, 'usrlbl', compute_mo.usr_lbl)
compute_mo.usr_lbl = usrlbl
elif '/ls-' in compute_mo.dn:
print('service profile', compute_mo.dn, 'usrlbl',
compute_mo.usr_lbl)
compute_mo.usr_lbl = usrlbl
handle.add_mo(compute_mo, modify_present=True)
handle.commit()
def ucs_login(self,ip,username,password):
results = {}
handle = UcsHandle(ip, username, password)
try:
handle.login()
#mo = handle.query_dn("org-root/boot-policy-ciscotest")
#print(mo)
results['logged_in'] = True
#print("Logged In !!!!")
except:
results['logged_in'] = False
return handle
def static_setup():
from ucsmsdk.ucshandle import UcsHandle
from ucsmsdk.ucscoremeta import UcsVersion
global ref_handle
global diff_handle
ref_handle = UcsHandle("192.168.1.1", "admin", "password")
diff_handle = UcsHandle("192.168.1.2", "admin", "password")
ref_handle.__dict__['_UcsSession__version'] = UcsVersion("2.2(5a)")
diff_handle.__dict__['_UcsSession__version'] = UcsVersion("2.2(2c)")
class UCS(object):
def __init__(self, ucsm_ip="", ucsm_login="", ucsm_pw=""):
self.handle = UcsHandle(ucsm_ip, ucsm_login ,ucsm_pw)
self.ucsm_ip = ucsm_ip
self.ucsm_pw = ucsm_pw
self.ucsm_login = ucsm_login
def login(self):
self.handle.login()
def logout(self):
self.handle.logout()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--ip", help="IP Address")
parser.add_argument("-u", "--username", help="Username")
parser.add_argument("-p", "--password", help="Password")
args = parser.parse_args()
#Log into UCS using UcsHandle
handle = UcsHandle(ip=args.ip,
username=args.username,
password=args.password)
handle.login()
def authenticate_to_ucs_domain():
global handle
handle = UcsHandle(ucs_name, login_name, password)
try:
print('\n*** Logging in')
handle.login()
print('*** Successfully Logged in \n')
except:
print(
'*** ERROR - UNABLE TO LOGIN. CHECK CREDENTIALS AND TRY AGAIN.\n\n\n'
)
exit()
def login(username, password, server):
handle = UcsHandle(server, username, password)
try:
handle.login()
except UcsException as err:
print "Login Error: " + err.error_descr
return ""
except HTTPError as err:
print "Connection Error: Bad UCSM? " + err.reason
return ""
except:
print "Issue logging in. Please check that all parameters are correct"
return ""
return handle
def add_vlan_to_vnic_template():
""" Add VLAN to VNIC Template """
handle = UcsHandle(UCS_HOST, UCS_USER, UCS_PASS)
handle.login()
my_vlan = handle.query_classid("fabricVlan", filter_str='(id,"301")')
my_templ = handle.query_classid("vnicLanConnTempl",
filter_str='(name,"Trunk_B")')
VnicEtherIf(parent_mo_or_dn=my_templ[0],
default_net=my_vlan[0].default_net,
name=my_vlan[0].name)
handle.add_mo(my_templ[0], True)
handle.commit()
def ucsm_login():
try:
print "Testing for ping response...."
response = subprocess.check_output(
['ping', '-c', '3', ucsm_ip],
stderr=subprocess.STDOUT, # get all output
universal_newlines=True # return string not bytes
)
handle = UcsHandle(ucsm_ip, ucsm_username, ucsm_password)
handle.login()
return handle
except:
response = None
print "Unable to ping IP address provided. Exiting...."
exit()
def custom_setup():
import ConfigParser
import os
from ucsmsdk.ucshandle import UcsHandle
config = ConfigParser.RawConfigParser()
config.read(os.path.join(os.path.dirname(__file__), '..', 'connection',
'connection.cfg'))
hostname = config.get(host, "hostname")
username = config.get(host, "username")
password = config.get(host, "password")
handle = UcsHandle(hostname, username, password, port=80)
handle.login()
return handle
def get_ucs_ntp_settings(ucs_list, ucs_username, user_passwd):
timestamps_all=[]
for ucs in ucs_list:
handle = UcsHandle(ip=ucs, username=ucs_username, password=user_passwd)
handle.login()
mo_dn = handle.query_dn("sys")
ucs_current_time=mo_dn.current_time
utc_current_time=datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%f1')
utc_current_time = utc_current_time[:-4]
t1 = datetime.strptime(ucs_current_time, "%Y-%m-%dT%H:%M:%S.%f")
t2 = datetime.strptime(utc_current_time, "%Y-%m-%dT%H:%M:%S.%f")
diff = t1 - t2
ntp_dn = handle.query_classid("commNtpProvider")
mgmt_ip_a = handle.query_dn("sys/switch-A")
fi_ip = mgmt_ip_a.oob_if_ip
netmask = mgmt_ip_a.oob_if_mask
if len(ntp_dn) > 0:
ntp_servers = [ n.name for n in ntp_dn ]
network=ipaddress.ip_network('{}/{}'.format(fi_ip,netmask),strict=False)
correct_ntp=ipaddress.ip_address(ntp_servers[0]) in ipaddress.ip_network(network)
else:
ntp_servers = ['no ntp']
# create temp list to add to a list of lists
timestamp_per_site = []
timestamp_per_site.extend([handle.ip,
utc_current_time,
ucs_current_time,
abs(diff.total_seconds()),
ntp_servers[0],
correct_ntp])
timestamps_all.append(timestamp_per_site)
print("=> logged out of {}".format(handle.ip))
handle.logout()
if platform.system() != ('Windows'):
os.system('clear')
else:
os.system( 'cls' )
headers=['site', 'utc timestamp', 'ucs timestamp', 'offset', 'ntp server', 'correct']
print(tabulate(timestamps_all, headers=headers, tablefmt=table_output))
def remove_ucs_bios_policy():
""" Remove UCS BIOS Policy """
handle = UcsHandle(UCS_HOST, UCS_USER, UCS_PASS)
handle.login()
mo_bios_policies = handle.query_classid("BiosVProfile")
for mo_bios_policy in mo_bios_policies:
if mo_bios_policy.name == "test-bios-prof":
handle.remove_mo(mo_bios_policy)
handle.commit()
def main():
handle = UcsHandle("192.168.254.200", "ucspe", "ucspe", secure=False)
handle.login()
# Create XML Object to create template clone
templates = ls_instantiate_n_template(cookie=handle.cookie,
dn="org-root/ls-globotemplate",
in_target_org="org-root",
in_server_name_prefix_or_empty="SP",
in_number_of=str(NUM_SP),
in_hierarchical="no")
# Send XML Object to xml process handler
mo_list = handle.process_xml_elem(templates)
for mo in mo_list:
print(mo.dn)
def test_invalid_disk_state(add_mo_mock, commit_mock):
add_mo_mock.return_value = True
commit_mock.return_value = True
handle = UcsHandle('169.254.1.1', 'admin', 'password')
# Scenario invalid state
assert_raises(ValueError, disk_state_set, handle, 16, 1, "blah")
def test_invalid_server_pool_add_rack_unit(query_mock, add_mo_mock,
commit_mock):
add_mo_mock.return_value = True
commit_mock.return_value = True
handle = UcsHandle('169.254.1.1', 'admin', 'password')
# Scenario: Invalid Org
query_mock.return_value = None
# Verify exception was raised for invalid org
assert_raises(
ValueError,
server_pool_add_rack_unit,
handle,
16,
)
# Scenario: Org is not a ComputePool
query_mock.return_value = OrgOrg(parent_mo_or_dn="org-root", name="root")
# Verify exception was raised for invalid type
assert_raises(
TypeError,
server_pool_add_rack_unit,
handle,
16,
)
def test_valid_server_port_create(add_mo_mock, commit_mock):
# Patch UcsHandle.add_mo to simulate CIMC interaction w/o real CIMC
# Patch UcsHandle.commit to simulate CIMC interaction w/o real CIMC
add_mo_mock.return_value = True
commit_mock.return_value = True
handle = UcsHandle('169.254.1.1', 'admin', 'password')
# Scenario: Set Fabric-A port Eth1/10 to server port
fabric_dn = 'fabric/lan/A'
port_id = '10'
slot_id = '1'
server_port_create(handle, fabric_dn, port_id, slot_id)
# Assert values of the object passed to add_mo()
test_server_mo = add_mo_mock.call_args[0][0]
assert test_server_mo.port_id == "10"
assert test_server_mo.slot_id == "1"
assert test_server_mo.dn == '{0}/slot-{1}-port-{2}'.format(
fabric_dn, slot_id, port_id)
# Scenario: Set Fabric-B port Eth2/6 to server port
fabric_dn = 'fabric/lan/B'
port_id = '6'
slot_id = '2'
server_port_create(handle, fabric_dn, port_id, slot_id)
# Assert values of the object passed to add_mo()
test_server_mo = add_mo_mock.call_args[0][0]
assert test_server_mo.port_id == "6"
assert test_server_mo.slot_id == "2"
assert test_server_mo.dn == '{0}/slot-{1}-port-{2}'.format(
fabric_dn, slot_id, port_id)
def loginTest():
global handle
handle = UcsHandle(ip_address, user_name, pass_word)
try:
if handle.login() == True:
puts(
colored.cyan(
'#####################################################\nUCS Manager Login Successful to '
+ ip_address +
'\n#####################################################\n\n\n\n'
))
launchQuery()
except urllib2.URLError:
puts(
colored.red('LOGIN FAILED: Bad IP Address. Please Try Again.'))
print('\n\n\n')
ipAddress()
def modify_UCS_VNIC(vl_range):
handle = UcsHandle(credentials.UCS_login['ipaddr'],
credentials.UCS_login['username'],
credentials.UCS_login['password'])
handle.login()
for vlan_id in vl_range:
mo = VnicLanConnTempl(parent_mo_or_dn="org-root", name="ACI-A")
mo_vnic_a = VnicEtherIf(parent_mo_or_dn=mo,
default_net="no",
name="ACI-" + vlan_id)
handle.set_mo(mo)
mo = VnicLanConnTempl(parent_mo_or_dn="org-root", name="ACI-B")
mo_vnic_b = VnicEtherIf(parent_mo_or_dn=mo,
default_net="no",
name="ACI-" + vlan_id)
handle.set_mo(mo)
handle.commit()
def ucs_login():
import ConfigParser
import os
from ucsmsdk.ucshandle import UcsHandle
config = ConfigParser.RawConfigParser()
config.read(
os.path.join(os.path.dirname(__file__), '..', 'connection',
'connection.cfg'))
hostname = config.get(host, "hostname")
username = config.get(host, "username")
password = config.get(host, "password")
port = config.get(host, "port")
handle = UcsHandle(hostname, username, password, port)
handle.login()
return handle
def custom_setup():
import os
from ucsmsdk.ucshandle import UcsHandle
config = configparser.RawConfigParser()
config.read(
os.path.join(os.path.dirname(__file__), '..', 'connection',
'connection.cfg'))
try:
hostname = config.get(host, "hostname")
username = config.get(host, "username")
password = config.get(host, "password")
except:
return None
handle = UcsHandle(hostname, username, password)
handle.login(auto_refresh=True, force=True)
return handle
def set_up(self):
# get arguments
self.args = self.get_args()
# set log level
self.set_log_level(self.args.log_level)
self.host = self.args.ucs
if self.args.secure == True:
self.url = 'https://%s/nuova' % self.args.ucs
else:
self.url = 'http://%s/nuova' % self.args.ucs
self.user = self.args.user
self.passwd = self.args.password
self.token = self.args.token
self.zeus_server = self.args.zeus
# set up a Zeus client to submit log to Zeus.
self.logger.info("Initiating Zeus connection...")
self.zeus_client = client.ZeusClient(self.token, self.zeus_server)
# set up a http client to UCS server.
self.logger.info("Initiating UCSM connection...")
self.handler = UcsHandle(self.host,
self.user,
self.passwd,
port=self.args.port,
secure=self.args.secure)
# login to ucs
self.handler.login(auto_refresh=True)
self.add_log("DEBUG",
"ucs",
msg={
"User": self.user,
"Password": self.passwd,
"cookie": self.handler.cookie
})
self.logger.info("Login UCSM completed.")
self.logger.info("Getting configuration data...")
self.get_dn_conf()
self.logger.info("Listening to UCSM events...")
self.event_loop()
def vKVM_launcher_blade(ucsm_ip, user, password, chassis, blade):
handle = UcsHandle(ucsm_ip, user, password)
handle.login()
mo = handle.query_dn("sys/chassis-{0}/blade-{1}".format(chassis, blade))
print mo
ucs_kvm_launch(handle, blade=mo)
handle.logout()
def test_invalid_ipmi_policy_create(query_mock, add_mo_mock, commit_mock):
add_mo_mock.return_value = True
commit_mock.return_value = True
handle = UcsHandle('169.254.1.1', 'admin', 'password')
# Scenario: Invalid Org
query_mock.return_value = None
# Verify exception was raised for invalid org
assert_raises(ValueError, ipmi_policy_create, handle, 'invalid')
def test_serialize_handle():
handle1 = custom_setup()
if not handle1:
msg = get_skip_msg()
raise SkipTest(msg)
frozen_handle = handle1.freeze()
handle2 = UcsHandle.unfreeze(frozen_handle)
custom_teardown(handle2)
def custom_setup():
try:
import ConfigParser
except:
import configparser as ConfigParser
import os
from ucsmsdk.ucshandle import UcsHandle
config = ConfigParser.RawConfigParser()
config.read(os.path.join(os.path.dirname(__file__), '..', 'connection',
'connection.cfg'))
hostname = config.get(host, "hostname")
username = config.get(host, "username")
password = config.get(host, "password")
handle = UcsHandle(hostname, username, password)
handle.login(auto_refresh=True, force=True)
return handle
def test_001_create_uri():
# Create an object of type LsServer with parent dn specified
# check if the object has the right values populated
handle = UcsHandle("192.168.1.1", "admin", "password")
assert_equal(
handle._UcsSession__create_uri(
port=None,
secure=None),
'https://192.168.1.1:443')
assert_equal(
handle._UcsSession__create_uri(
port=8080,
secure=None),
'https://192.168.1.1:8080')
assert_equal(
handle._UcsSession__create_uri(
port=None,
secure=True),
'https://192.168.1.1:443')
assert_equal(
handle._UcsSession__create_uri(
port=None,
secure=False),
'http://192.168.1.1:80')
assert_equal(
handle._UcsSession__create_uri(
port=444,
secure=False),
'http://192.168.1.1:444')
def test_ucs_backup_after_freeze_unfreeze():
# for this test to be more meaningful there needs to be proxy server
# configured
h1 = custom_setup()
frozen_handle = h1.freeze()
h2 = UcsHandle.unfreeze(frozen_handle)
# Try a download operation using new handle
_test_ucs_backup(file_dir="/tmp/backup",
file_name="config2.xml",
backup_type="config-logical")
custom_teardown(h2)
from ucsmsdk.mometa.org.OrgOrg import OrgOrg
from ucsmsdk.mometa.uuidpool.UuidpoolPool import UuidpoolPool
from ucsmsdk.mometa.uuidpool.UuidpoolBlock import UuidpoolBlock
from ucsmsdk.mometa.fabric.FabricVlan import FabricVlan
from ucsmsdk.mometa.compute.ComputePool import ComputePool
from ucsmsdk.mometa.compute.ComputePooledSlot import ComputePooledSlot
from ucsmsdk.mometa.lsmaint.LsmaintMaintPolicy import LsmaintMaintPolicy
my_Org = "Test_Org"
my_Full_Path_Org = "org-root/org-%s" % my_Org
my_UUID_Pool = "%s/uuid-pool-UUID_POOL" % my_Full_Path_Org
my_Server_Pool = "%s/compute-pool-Server_Pool" % my_Full_Path_Org
my_Maint_Pol = "%s/maint-Usr_Ack" % my_Full_Path_Org
my_Power_Pol = "%s/power-policy-No_Cap" % my_Full_Path_Org
#create the handle
handle = UcsHandle("192.168.67.148","admin","password",secure=False)
#login into UCS manager
handle.login()
#Remove Sub Organization
mo = handle.query_dn(my_Full_Path_Org)
handle.remove_mo(mo)
handle.commit()
#Unconfigure Ports
#PC-50
mo = handle.query_dn("fabric/lan/A/pc-50")
handle.remove_mo(mo)
handle.commit()
#PC-51
mo = handle.query_dn("fabric/lan/B/pc-51")
from ucsmsdk.mometa.ls.LsVConAssign import LsVConAssign
from ucsmsdk.mometa.vnic.VnicEther import VnicEther
from ucsmsdk.mometa.vnic.VnicFc import VnicFc
from ucsmsdk.mometa.vnic.VnicFcIf import VnicFcIf
from ucsmsdk.mometa.vnic.VnicFcNode import VnicFcNode
from ucsmsdk.mometa.ls.LsRequirement import LsRequirement
from ucsmsdk.mometa.ls.LsPower import LsPower
from ucsmsdk.mometa.fabric.FabricVCon import FabricVCon
#Are we having iSCSI to the Hosts?
iSCSI = True
#Are we having FC to the hosts?
FC = False
#Create the handle
handle = UcsHandle("10.242.100.90","admin","password",secure=False)
#login into UCS manager
handle.login()
#reading variables from the ucs workbook
my_file=open("/Users/javirodz/Documents/ucs-book.csv", "r")
my_csv_file = csv.reader(my_file)
for row in my_csv_file:
if row[0] == "Organization Name":
my_Org = row[1]
my_Full_Path_Org = "org-root/org-%s" % my_Org
elif row[0] == "KVM Starting IP Address":
my_kvm_pool_first = row[1]
elif row[0] == "KVM Primary DNS IP Address":
my_Primary_DNS = row[1]
elif row[0] == "KVM Secondary DNS IP Address":
#!/usr/bin/env python
from ucsmsdk.ucshandle import UcsHandle
# Create a connection handle
handle = UcsHandle("172.xx.xx.xx", "admin", "cisco!098")
# Put in the VLANs you want to remove first one, and then the last one.
vlan_start = 400
vlan_end = 499
vlan_name_prefix = "vmware_client_"
# Login to the server
handle.login()
for a in range(vlan_start, vlan_end + 1):
mydn = vlan_name_prefix + str(a)
print "Removing " + (mydn)
myfulldn = "fabric/lan/net-" + mydn
# Query for an existing Mo
sp = handle.query_dn(myfulldn)
# Remove the object
handle.remove_mo(sp)
# and commit the changes (actually happens now)
handle.commit()
# Logout from the server
'--hostname',
help="hostname/ip of the server",
required=True)
parser.add_argument('--username', help="username", required=True)
parser.add_argument('--password', help="password", required=True)
args = parser.parse_args()
host, user, password = args.hostname, args.username, args.password
try:
input = raw_input
except NameError:
pass
try:
handle = UcsHandle(host, user, password)
handle.login()
ucs_gui_launch(handle)
time.sleep(5)
print("================================================")
print("Hit an Enter here AFTER the Java UI is up and running...")
print("================================================")
wait = input()
convert_to_ucs_python()
except:
handle.logout()
raise
# This is the file that I use to connect to UCS and then run the converttopython part of the UCSMSDK import xlrd file_location = "./UCS.xlsx" workbook = xlrd.open_workbook(file_location) sheet = workbook.sheet_by_index(1) from ucsmsdk.utils.ucsguilaunch import ucs_gui_launch from ucsmsdk.ucshandle import UcsHandle #login to the server handle = UcsHandle( (sheet.cell_value(3,1)),(sheet.cell_value(4,1)),(sheet.cell_value(5,1))) handle.login() #launch the UCSM GUI ucs_gui_launch(handle) #convert_to_ucs portion from ucsmsdk.utils.converttopython import convert_to_ucs_python convert_to_ucs_python()
import xlrd
import ucsmsdk
file_location = "./UCS.xlsx"
workbook = xlrd.open_workbook(file_location)
sheet = workbook.sheet_by_index(1)
# Create Session
#
from ucsmsdk.ucshandle import UcsHandle
handle = UcsHandle( (sheet.cell_value(3,1)),(sheet.cell_value(4,1)),(sheet.cell_value(5,1)))
handle.login()
mo = handle.query_dn("org-root")
print (mo)
# Compute Chassis Link Aggregation Policy
from ucsmsdk.mometa.compute.ComputeChassisDiscPolicy import ComputeChassisDiscPolicy
mo = ComputeChassisDiscPolicy(parent_mo_or_dn="org-root", rebalance="user-acknowledged", descr="",
action=(sheet.cell.value(8.1)), name="", policy_owner="local", link_aggregation_pref="none")
handle.add_mo(mo, True)
handle.commit()
def test_serialize_handle():
handle1 = custom_setup()
frozen_handle = handle1.freeze()
handle2 = UcsHandle.unfreeze(frozen_handle)
custom_teardown(handle2)
def ucs_login(hostname, username, password):
from ucsmsdk.ucshandle import UcsHandle
handle = UcsHandle(hostname, username, password)
handle.login()
return handle
