def poweron_server(server_name):
handle = capi.BootAPI()
msystem = handle.find_system(name=server_name)
# msystem = handle.systems().find(name=server_name)
# print "system {0} status: netboot_enabled {1}".format(msystem.name, msystem.netboot_enabled)
# print "*"*50
# pprint(msystem.to_datastruct())
# disable Netboot
if msystem.netboot_enabled:
msystem.netboot_enabled = False
# save modified system
handle.add_system(msystem)
# msystem = handle.find_system(name=server_name)
# print "system {0} status: netboot_enabled {1}".format(msystem.name,
# msystem.netboot_enabled)
server_ip = get_interface_ip(msystem)
if is_server_on(server_ip, 1):
print("INFO: server {0} is already ON.".format(server_name))
else:
print("Power on server {0}, please wait ...".format(server_name))
print(" the status of server {0} is monitored on IP : {1}".format(
server_name, server_ip))
handle.power_on(msystem)
if is_server_on(server_ip):
print(
"\nCongradulation, server {0} is now ON.".format(server_name))
print(" Login to {0} with command ssh root@{1}".format(
server_name, server_ip))
else:
print(
"\nError. Server {0} cannot power on, please contact your administrator."
.format(server_name))
def _wrap_process_list_item_names(self, q, objects):
"""Call cobbler API **distros**, **profiles**, **systems** to get the corresponding objects
:return: a list of name of objects
"""
cobbler_handler = capi.BootAPI()
func = getattr(cobbler_handler, objects)
q.put([x.name for x in func()])
def _wrap_process_get_item_report(self, q, object_type, name):
"""get the detail report of *name* of cobbler object **object_type**.
:param string object_type: a type in ['distro', 'profile', 'system', 'kickstart',]
:param string name: the name that user specified, it supports UNIX wildcard
:return: a list of report that has the formation [{"name": name, data": data,}, {}]
"""
result_list = []
if object_type == "kickstart":
allfiles = self.list_kickstart_filenames(self.KICKSTART_LOCATION)
for filename in allfiles:
if fnmatch.fnmatch(filename, name):
result_list.append({
"type": "kickstart",
"name": filename,
"data": {"name": filename,
"contents": self.read_file_to_list("{0}/{1}".format(self.KICKSTART_LOCATION, filename)),
},
})
else:
cobbler_handler = capi.BootAPI()
func = getattr(cobbler_handler, "find_{0}".format(object_type))
for item in func(name=name, return_list=True):
data = item.to_datastruct()
if object_type == "system":
data["child_count"] = len(data["interfaces"])
else:
data["child_count"] = self.get_object_child_count(
object_type, data["name"], cobbler_handler)
result_list.append({"type": object_type,
"name": data["name"],
"data": data,
})
q.put(result_list)
def __init__(self, hostname):
"""Constructor. Requires a Cobbler API handle."""
self.hostname = hostname
self.handle = capi.BootAPI()
self.system = self.handle.find_system(hostname=self.hostname)
self.host_vars = self.get_cobbler_resource('ks_meta')
self.logger = clogger.Logger("/var/log/cobbler/cobbler.log")
self.mgmtclasses = self.get_cobbler_resource('mgmt_classes')
def serialize_item(obj, item):
if item.name is None or item.name == "":
raise exceptions.RuntimeError("name unset for object!")
# FIXME: Need a better way to support collections/items
# appending an 's' does not work in all cases
if obj.collection_type() in ['mgmtclass']:
filename = "/var/lib/cobbler/config/%ses.d/%s" % (
obj.collection_type(), item.name)
else:
filename = "/var/lib/cobbler/config/%ss.d/%s" % (obj.collection_type(),
item.name)
datastruct = item.to_datastruct()
jsonable = can_use_json()
if jsonable:
if capi.BootAPI().settings().serializer_pretty_json:
sort_keys = True
indent = 4
else:
sort_keys = False
indent = None
# avoid using JSON on python 2.3 where we can encounter
# unicode problems with simplejson pre 2.0
if os.path.exists(filename):
print "upgrading yaml file to json: %s" % filename
os.remove(filename)
filename = filename + ".json"
datastruct = item.to_datastruct()
fd = open(filename, "w+")
data = simplejson.dumps(datastruct,
encoding="utf-8",
sort_keys=sort_keys,
indent=indent)
#data = data.encode('utf-8')
fd.write(data)
else:
if os.path.exists(filename + ".json"):
print "downgrading json file back to yaml: %s" % filename
os.remove(filename + ".json")
datastruct = item.to_datastruct()
fd = open(filename, "w+")
data = yaml.dump(datastruct)
fd.write(data)
fd.close()
return True
def __init__(self):
self.running = True
self.capi = cobbler_api.BootAPI()
self.xmliface = CobblerTestXMLRPCInterface(self.capi)
self.server = CobblerTestXMLRPCServer(('127.0.0.1', 55555))
self.server.logRequests = 0
self.server.register_instance(self.xmliface)
threading.Thread.__init__(self)
def main():
"""main entry"""
cobbler_api = api.BootAPI()
for system in cobbler_api.systems():
cobbler_api.kickgen.generate_kickstart_for_system(system.name)
try:
with open('/var/www/cblr_ks/%s' % system.name,
'w') as kickstart_file:
logging.info("Migrating kickstart for %s", system.name)
data = cobbler_api.kickgen.generate_kickstart_for_system(
system.name)
kickstart_file.write(data)
except Exception as error:
logging.error("Directory /var/www/cblr_ks/ does not exist.")
logging.exception(error)
raise error
def _wrap_cobbler_power_system(self, q, name, flag_netboot, power_status):
"""wrap cobbler power action
"""
options = {
"on": "power_on",
"off": "power_off",
"reboot": "reboot",
}
cobbler_handler = capi.BootAPI()
func = getattr(cobbler_handler, "find_system")
system = func(name)
system.netboot_enabled = flag_netboot
cobbler_handler.add_system(system)
# default action is power_on
power_action = options.get(power_status.lower(), "power_on")
func = getattr(cobbler_handler, power_action)
try:
func(system)
except:
power_action = "failed"
q.put(power_action)
def _get_object_child_list(self, object_type, name, handler=None):
"""get the child list of a cobbler object **distro** and **profile**
:param string object_type: a type in ['distro', 'profile']
:param string name: the specific name in an object_type
:param BootAPI handler: the Cobbler API handler
:returns: None if object_type is NOT in ['distro', 'profile'], empty list if there is no child, otherwise return ['child', 'child',]
:rtype: list
"""
pobjects = {"distro": "profile",
"profile": "system",
}
result = None
if object_type in pobjects:
if not handler:
handler = capi.BootAPI()
func = getattr(handler, "find_{0}".format(pobjects[object_type]))
kwargs = {}
kwargs[object_type] = name
# find_profile(distro=distro_name)
child_list = func(return_list=True, **kwargs)
result = [v.name for v in child_list]
return result
def deploy_server(server_name):
handle = capi.BootAPI()
msystem = handle.find_system(name=server_name)
# msystem = handle.systems().find(name=server_name)
# print "system {0} status: netboot_enabled {1}".format(msystem.name, msystem.netboot_enabled)
# print "*"*50
# pprint(msystem.to_datastruct())
# enable Netboot
if not msystem.netboot_enabled:
msystem.netboot_enabled = True
# save modified system
handle.add_system(msystem)
server_ip = get_interface_ip(msystem)
print("Depoly new OS on server {0}, please wait ...".format(server_name))
print(" the status of server {0} is monitored on IP : {1}".format(
server_name, server_ip))
handle.reboot(msystem)
if is_server_deployed(server_ip):
print("\nDeploy server {0} successfully, now you can power on it.".
format(server_name))
else:
print("\nDeploy server {0} failed, please contact your administrator.".
format(server_name))
import cobbler.api as capi handle = capi.BootAPI() systems = handle.find_system(name="*", return_list=True)
def _wrap_cobbler_find_system(self, q, name):
cobbler_handler = capi.BootAPI()
func = getattr(cobbler_handler, "find_system")
system = func(name)
q.put(system.to_datastruct())
#from xmlrpclib import *
import cobbler.api as capi
import re
import time
system_phy_profiles = Blueprint('system_phy_profiles', __name__)
### LOCAL CONFIG ###
# Custom filter method
#def regex_replace(s, find, replace):
# """A non-optimal implementation of a regex filter"""
# return re.sub(find, replace, s)
#
#jinja_environment.filters['regex_replace'] = regex_replace
cobbler_server = capi.BootAPI(is_cobblerd=True)
#cobbler_server = xmlrpclib.Server("http://192.168.1.83/cobbler_api")
#token = cobbler_server.login("cobbler", "cobbler")
### NAPALM ###
import napalm
from napalm import get_network_driver
def napalm_switch_mac_audit(customer_sw_id):
driver = get_network_driver('ios')
optional_args = {'secret': ''}
## query customer_sw1 for ip_address and nr of switch ports, and port type
customer_sw = Customer_sw.query.filter_by(id=customer_sw_id).one()
customer_sw_number_of_ports = customer_sw.customerswbackref.portnr
customer_sw_port_type = customer_sw.customerswbackref.porttype
# test script to evaluate Cobbler API performance
#
# Michael DeHaan <*****@*****.**>
import os
import cobbler.api as capi
import time
import sys
import random
N = 500
print "sample size is %s" % N
api = capi.BootAPI()
# part one ... create our test systems for benchmarking purposes if
# they do not seem to exist.
#if not api.find_profile("foo"):
# print "CREATE A PROFILE NAMED 'foo' to be able to run this test"
# sys.exit(0)
def random_mac():
mac = [
0x00, 0x16, 0x3e,
random.randint(0x00, 0x7f),
random.randint(0x00, 0xff),
random.randint(0x00, 0xff)
]
return ':'.join(map(lambda x: "%02x" % x, mac))
import os
import cobbler.api as capi
import sys
cobbler_api = capi.BootAPI()
listimages = cobbler_api.images()
listprofiles = cobbler_api.profiles()
listsystems = cobbler_api.systems()
for p in listprofiles:
print p.name
box = listprofiles.find(name="*",return_list=True)
for d in box:
print d.name
#!/usr/bin/python
#import re
#import sys
#import xmlrpclib
#from xmlrpclib import *
#system_name="ht-esxi-test"
#new_name="ht-esxi-api"
#conn = ServerProxy("http://192.168.1.163/cobbler_api")
#cobbler_server = xmlrpclib.Server("http://192.168.1.163/cobbler_api")
#token = conn.login("cobbler","cobbler")
#coding:utf8
_author__ = 'eric'
from flask.ext.login import current_user
from flask.ext.wtf import Form
from wtforms import StringField, PasswordField, SubmitField, TextAreaField, BooleanField, SelectField, IntegerField, DateTimeField, FileField, SelectMultipleField
from wtforms.validators import Email, Length, Regexp, EqualTo, InputRequired, IPAddress, HostnameValidation, MacAddress, NumberRange
from ..models import *
from .. import db
from wtforms import ValidationError
try:
import cobbler.api as capi
cobbler_handle = capi.BootAPI()
except ImportError:
pass
class EditProfileForm(Form):
username = StringField(
'Username',
validators=[
InputRequired(),
Length(0, 64),
Regexp(
'^[A-Za-z][A-Za-z0-9_.]*$', 0,
'Username must have only letters, number, dots or underscores')
])
name = StringField(u'真实姓名')
position = StringField(u'工作职位')
