def test_user_authenticated(request):
global remote
global username
global url_cobbler_api
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
# if we have a token, get the associated username from
# the remote server via XMLRPC. We then compare that to
# the value stored in the session. If everything matches up,
# the user is considered successfully authenticated
if request.session.has_key('token') and request.session['token'] != '':
try:
if remote.token_check(request.session['token']):
token_user = remote.get_user_from_token(request.session['token'])
if request.session.has_key('username') and request.session['username'] == token_user:
username = request.session['username']
return True
except:
# just let it fall through to the 'return False' below
pass
return False
def test_user_authenticated(request):
global remote
global username
global url_cobbler_api
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
# if we have a token, get the associated username from
# the remote server via XMLRPC. We then compare that to
# the value stored in the session. If everything matches up,
# the user is considered successfully authenticated
if 'token' in request.session and request.session['token'] != '':
try:
if remote.token_check(request.session['token']):
token_user = remote.get_user_from_token(request.session['token'])
if 'username' in request.session and request.session['username'] == token_user:
username = request.session['username']
return True
except:
# just let it fall through to the 'return False' below
pass
return False
def setUp(self):
"""
Sets up Cobbler API connection and logs in
"""
self.url_api = utils.local_get_cobbler_api_url()
self.url_xmlrpc = utils.local_get_cobbler_xmlrpc_url()
self.remote = xmlrpclib.Server(self.url_api)
self.shared_secret = utils.get_shared_secret()
self.token = self.remote.login("", self.shared_secret)
if not self.token:
self.server.stop()
sys.exit(1)
# Create temp dir
self.topdir = "/tmp/cobbler_test"
try:
os.makedirs(self.topdir)
except:
pass
self.fk_initrd = os.path.join(self.topdir, FAKE_INITRD)
self.fk_initrd2 = os.path.join(self.topdir, FAKE_INITRD2)
self.fk_initrd3 = os.path.join(self.topdir, FAKE_INITRD3)
self.fk_kernel = os.path.join(self.topdir, FAKE_KERNEL)
self.fk_kernel2 = os.path.join(self.topdir, FAKE_KERNEL2)
self.fk_kernel3 = os.path.join(self.topdir, FAKE_KERNEL3)
create = [self.fk_initrd, self.fk_initrd2, self.fk_initrd3, self.fk_kernel, self.fk_kernel2, self.fk_kernel3]
for fn in create:
f = open(fn, "w+")
f.close()
def check_auth(request):
"""
A method to enable authentication by authn_passthru. Checks the
proper headers and ensures that the environment is setup.
"""
global remote
global token
global username
global url_cobbler_api
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
if token is not None:
try:
token_user = remote.get_user_from_token(token)
except:
token_user = None
else:
token_user = None
if request.META.has_key('REMOTE_USER'):
if token_user == request.META['REMOTE_USER']:
return
username = request.META['REMOTE_USER']
#REMOTE_USER is set, so no credentials are going to be available
#So we get the shared secret and let authn_passthru authenticate us
password = utils.get_shared_secret()
# Load server ip and port from local config
token = remote.login(username, password)
remote.update(token)
def do_login(request):
global remote
global username
global url_cobbler_api
username = request.POST.get('username', '').strip()
password = request.POST.get('password', '')
nextsite = request.POST.get('next',None)
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
try:
token = remote.login(username, password)
except:
token = None
if token:
request.session['username'] = username
request.session['token'] = token
if nextsite:
return HttpResponseRedirect(nextsite)
else:
return HttpResponseRedirect("/cobbler_web")
else:
return login(request,nextsite,message="Login failed, please try again")
def do_login(request):
global remote
global username
global url_cobbler_api
username = request.POST.get('username', '').strip()
password = request.POST.get('password', '')
nextsite = request.POST.get('next', None)
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
try:
token = remote.login(username, password)
except:
token = None
if token:
request.session['username'] = username
request.session['token'] = token
if nextsite:
return HttpResponseRedirect(nextsite)
else:
return HttpResponseRedirect("/cobbler_web")
else:
return login(request, nextsite, message="Login failed, please try again")
def check_auth(request):
"""
A method to enable authentication by authn_passthru. Checks the
proper headers and ensures that the environment is setup.
"""
global remote
global token
global username
global url_cobbler_api
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
if token is not None:
try:
token_user = remote.get_user_from_token(token)
except:
token_user = None
else:
token_user = None
if request.META.has_key('REMOTE_USER'):
if token_user == request.META['REMOTE_USER']:
return
username = request.META['REMOTE_USER']
#REMOTE_USER is set, so no credentials are going to be available
#So we get the shared secret and let authn_passthru authenticate us
password = utils.get_shared_secret()
# Load server ip and port from local config
token = remote.login(username, password)
remote.update(token)
def test_local_get_cobbler_api_url():
# Arrange
# Act
result = utils.local_get_cobbler_api_url()
# Assert
assert result == "http://127.0.0.1:80/cobbler_api"
def __init__(self):
# Load server ip and ports from local config
self.url_cobbler_api = utils.local_get_cobbler_api_url()
self.url_cobbler_xmlrpc = utils.local_get_cobbler_xmlrpc_url()
# FIXME: allow specifying other endpoints, and user+pass
self.parser = optparse.OptionParser()
self.remote = xmlrpc.client.Server(self.url_cobbler_api)
self.shared_secret = utils.get_shared_secret()
def __init__(self):
# Load server ip and ports from local config
self.url_cobbler_api = utils.local_get_cobbler_api_url()
self.url_cobbler_xmlrpc = utils.local_get_cobbler_xmlrpc_url()
# FIXME: allow specifying other endpoints, and user+pass
self.parser = optparse.OptionParser()
self.remote = xmlrpc.client.Server(self.url_cobbler_api)
self.shared_secret = utils.get_shared_secret()
def cobbler_xmlrpc_base():
"""
Initialises the api object and makes it available to the test.
"""
# create logger
logging.basicConfig(stream=sys.stderr)
logger = logging.getLogger("xobbler_xmlrpc_base")
logger.setLevel(logging.DEBUG)
# create XML-RPC client and connect to server
api_url = local_get_cobbler_api_url()
remote = xmlrpcclient.Server(api_url, allow_none=True)
shared_secret = get_shared_secret()
token = remote.login("", shared_secret)
if not token:
sys.exit(1)
yield (remote, token)
def setUp(self):
"""
Setup Cobbler XML-RPC connection and login
"""
# create logger
logging.basicConfig(stream=sys.stderr)
self.logger = logging.getLogger(self.__class__.__name__)
self.logger.setLevel(logging.DEBUG)
# create XML-RPC client and connect to server
api_url = local_get_cobbler_api_url()
self.remote = xmlrpcclient.Server(api_url, allow_none=True)
shared_secret = get_shared_secret()
self.token = self.remote.login("", shared_secret)
if not self.token:
sys.exit(1)
def cobbler_xmlrpc_base():
"""
Initialises the api object and makes it available to the test.
"""
# create logger
logging.basicConfig(stream=sys.stderr)
logger = logging.getLogger("xobbler_xmlrpc_base")
logger.setLevel(logging.DEBUG)
# create XML-RPC client and connect to server
api_url = local_get_cobbler_api_url()
remote = xmlrpcclient.Server(api_url, allow_none=True)
shared_secret = get_shared_secret()
token = remote.login("", shared_secret)
if not token:
sys.exit(1)
yield (remote, token)
def setUp(self):
"""
Setup Cobbler XML-RPC connection and login
"""
# create logger
logging.basicConfig( stream=sys.stderr )
self.logger = logging.getLogger( self.__class__.__name__ )
self.logger.setLevel( logging.DEBUG )
# create XML-RPC client and connect to server
api_url = local_get_cobbler_api_url()
self.remote = xmlrpclib.Server(api_url, allow_none=True)
shared_secret = get_shared_secret()
self.token = self.remote.login("", shared_secret)
if not self.token:
sys.exit(1)
def setUp(self):
"""
Sets up Cobbler API connection and logs in
"""
self.url_api = utils.local_get_cobbler_api_url()
self.url_xmlrpc = utils.local_get_cobbler_xmlrpc_url()
self.remote = xmlrpclib.Server(self.url_api)
self.shared_secret = utils.get_shared_secret()
self.token = self.remote.login("", self.shared_secret)
if not self.token:
self.server.stop()
sys.exit(1)
# Create temp dir
self.topdir = "/tmp/cobbler_test"
try:
os.makedirs(self.topdir)
except:
pass
self.fk_initrd = os.path.join(self.topdir, FAKE_INITRD)
self.fk_initrd2 = os.path.join(self.topdir, FAKE_INITRD2)
self.fk_initrd3 = os.path.join(self.topdir, FAKE_INITRD3)
self.fk_kernel = os.path.join(self.topdir, FAKE_KERNEL)
self.fk_kernel2 = os.path.join(self.topdir, FAKE_KERNEL2)
self.fk_kernel3 = os.path.join(self.topdir, FAKE_KERNEL3)
create = [
self.fk_initrd,
self.fk_initrd2,
self.fk_initrd3,
self.fk_kernel,
self.fk_kernel2,
self.fk_kernel3,
]
for fn in create:
f = open(fn, "w+")
f.close()
def test_user_authenticated(request):
global remote
global username
global url_cobbler_api
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
token = remote.login("", utils.get_shared_secret())
if ( (remote.get_authn_module_name(token) == 'authn_passthru' and
request.META.has_key('REMOTE_USER')) and
( (request.session.has_key('username') and
request.META['REMOTE_USER'] != request.session['username']) or
(not request.session.has_key('username')))):
try:
username = request.META['REMOTE_USER']
password = utils.get_shared_secret()
token = remote.login(username, password)
except:
token = None
if token:
request.session['username'] = username
request.session['token'] = token
# if we have a token, get the associated username from
# the remote server via XMLRPC. We then compare that to
# the value stored in the session. If everything matches up,
# the user is considered successfully authenticated
if request.session.has_key('token') and request.session['token'] != '':
try:
if remote.token_check(request.session['token']):
token_user = remote.get_user_from_token(request.session['token'])
if request.session.has_key('username') and request.session['username'] == token_user:
username = request.session['username']
return True
except:
# just let it fall through to the 'return False' below
pass
return False
def authenhandler(req):
"""
Mod python security handler. Logs into XMLRPC and saves the token
for later use.
"""
global remote
global token
global username
global url_cobbler_api
password = req.get_basic_auth_pw()
username = req.user
try:
# Load server ip and port from local config
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
token = remote.login(username, password)
remote.update(token)
return apache.OK
except:
return apache.HTTP_UNAUTHORIZED
def authenhandler(req):
"""
Mod python security handler. Logs into XMLRPC and saves the token
for later use.
"""
global remote
global token
global username
global url_cobbler_api
password = req.get_basic_auth_pw()
username = req.user
try:
# Load server ip and port from local config
if url_cobbler_api is None:
url_cobbler_api = utils.local_get_cobbler_api_url()
remote = xmlrpclib.Server(url_cobbler_api, allow_none=True)
token = remote.login(username, password)
remote.update(token)
return apache.OK
except:
return apache.HTTP_UNAUTHORIZED
def setUp(self):
"""
Sets up Cobbler API connection and logs in
"""
logging.basicConfig( stream=sys.stderr )
self.logger = logging.getLogger( self.__class__.__name__ )
self.logger.setLevel( logging.DEBUG )
self.url_api = utils.local_get_cobbler_api_url()
self.url_xmlrpc = utils.local_get_cobbler_xmlrpc_url()
self.remote = xmlrpclib.Server(self.url_api)
self.shared_secret = utils.get_shared_secret()
self.token = self.remote.login("", self.shared_secret)
if not self.token:
self.server.stop()
sys.exit(1)
# Create temp dir
self.topdir = "/tmp/cobbler_test"
try:
os.makedirs(self.topdir)
except:
pass
self.fk_initrd = os.path.join(self.topdir, FAKE_INITRD)
self.fk_initrd2 = os.path.join(self.topdir, FAKE_INITRD2)
self.fk_initrd3 = os.path.join(self.topdir, FAKE_INITRD3)
self.fk_kernel = os.path.join(self.topdir, FAKE_KERNEL)
self.fk_kernel2 = os.path.join(self.topdir, FAKE_KERNEL2)
self.fk_kernel3 = os.path.join(self.topdir, FAKE_KERNEL3)
self.redhat_kickstart = os.path.join(self.topdir, "test.ks")
self.ubuntu_preseed = os.path.join(self.topdir, "test.seed")
create = [
self.fk_initrd, self.fk_initrd2, self.fk_initrd3,
self.fk_kernel, self.fk_kernel2, self.fk_kernel3,
self.redhat_kickstart, self.ubuntu_preseed,
]
for fn in create:
f = open(fn,"w+")
f.close()
self.distro_fields = [
# TODO: fetchable files, boot files, etc.
# field_name, good value(s), bad value(s)
# ["",["",],["",]],
["name",["testdistro0",],[]],
["kernel",[self.fk_kernel,],["",]],
["initrd",[self.fk_initrd,],["",]],
["breed",["generic",],["badversion",]],
["os_version",["generic26",],["bados",]],
["arch",["i386","x86_64","ppc","ppc64"],["badarch",]],
["comment",["test comment",],[]],
["owners",["user1 user2 user3",],[]],
["kernel_options",["a=1 b=2 c=3 c=4 c=5 d e",],[]],
["kernel_options_post",["a=1 b=2 c=3 c=4 c=5 d e",],[]],
["ks_meta",["a=1 b=2 c=3 c=4 c=5 d e",],[]],
["mgmt_classes",["one two three",],[]],
["redhat_management_key",["abcd1234",],[]],
["redhat_management_server",["1.1.1.1",],[]],
]
self.profile_fields = [
# TODO: fetchable files, boot files, etc.
# repos, which have to exist
# field_name, good value(s), bad value(s)
# ["",["",],["",]],
["name",["testprofile0",],[]],
["distro",["testdistro0",],["baddistro",]],
["enable_gpxe",["yes","YES","1","0","no"],[]],
["enable_menu",["yes","YES","1","0","no"],[]],
["comment",["test comment",],[]],
["owners",["user1 user2 user3",],[]],
["kernel_options",["a=1 b=2 c=3 c=4 c=5 d e",],[]],
["kernel_options_post",["a=1 b=2 c=3 c=4 c=5 d e",],[]],
["ks_meta",["a=1 b=2 c=3 c=4 c=5 d e",],[]],
["kickstart",[self.redhat_kickstart,self.ubuntu_preseed],["/path/to/bad/kickstart",]],
["proxy",["testproxy",],[]],
["virt_auto_boot",["1","0"],["yes","no"]],
["virt_cpus",["<<inherit>>","1","2"],["a",]],
["virt_file_size",["<<inherit>>","5","10"],["a",]],
["virt_disk_driver",["<<inherit>>","raw","qcow2","vmdk"],[]],
["virt_ram",["<<inherit>>","256","1024"],["a",]],
["virt_type",["<<inherit>>","xenpv","xenfv","qemu","kvm","vmware","openvz"],["bad",]],
["virt_bridge",["<<inherit>>","br0","virbr0","xenbr0"],[]],
["virt_path",["<<inherit>>","/path/to/test",],[]],
["dhcp_tag",["","foo"],[]],
["server",["1.1.1.1",],[]],
["name_servers",["1.1.1.1 1.1.1.2 1.1.1.3",],[]],
["name_servers_search",["example.com foo.bar.com",],[]],
["mgmt_classes",["one two three",],[]],
["mgmt_parameters",["<<inherit>>",],["badyaml",]], # needs more test cases that are valid yaml
["redhat_management_key",["abcd1234",],[]],
["redhat_management_server",["1.1.1.1",],[]],
["template_remote_kickstarts",["yes","YES","1","0","no"],[]],
]
import tornado.ioloop as ioloop
import cobbler.templar
import Cheetah # need exception types
from struct import pack, unpack
from subprocess import Popen, PIPE, STDOUT
# Data/Defines
TFTP_OPCODE_RRQ = 1
TFTP_OPCODE_DATA = 3
TFTP_OPCODE_ACK = 4
TFTP_OPCODE_ERROR = 5
TFTP_OPCODE_OACK = 6
COBBLER_HANDLE = xmlrpc.client.Server(local_get_cobbler_api_url())
OPTIONS = {
"port": "69",
"timeout": 10,
"min_timeout": 1,
"max_timeout": 255,
"blksize": 512, # that's the default, required
"max_blksize": 1428, # MTU - overhead
"min_blksize": 512, # the default is small enough already
"retries": 4,
"verbose": False,
"debug": False,
"idle": 0, # how long to stick around: 0: unlimited
"idle_timer": None,
"cache": True, # 'cache-time' = 300
