def do_project_branches_list(self, options):
h2 = httplib2.Http("~/.rpathcmd/.cache")
h2.disable_ssl_certificate_validation = True
h2.add_credentials(self.options.username, self.options.password)
branchesdatapages = []
tmpxml = h2.request('http://' + self.options.server + '/api/v1/project_branches')
branchesdatapages.append(tmpxml[1])
tmpdata = xobj.parse(tmpxml[1])
#epdb.st()
if int(tmpdata.project_branches.num_pages) == 1:
print "#one page"
else:
print "pagination not yet supported"
sys.exit(1)
for branchesdatapage in branchesdatapages:
branchesdata = xobj.parse(branchesdatapage)
for project_branch in branchesdata.project_branches.project_branch:
#epdb.st()
print "%s: %s %s" % (project_branch.branch_id,
project_branch.project.short_name,
project_branch.name)
def testQuerySetWithMissingFilter(self):
# RCE-1879
# Create queryset
response = self._post('query_sets/',
data=testsxml.queryset_post_xml,
username="******", password="******")
self.assertEquals(response.status_code, 200)
xobjModel = xobj.parse(response.content)
qs1 = models.QuerySet.objects.get(
query_set_id=str(xobjModel.query_set.query_set_id))
xml = """\
<query_set>
<filter_entries>
<filter_entry>
<operator>LIKE</operator>
<field>name</field>
<value>jdl</value>
</filter_entry>
<filter_entry>
<field/>
<operator>EQUAL</operator>
<value/>
</filter_entry>
</filter_entries>
</query_set>
"""
response = self._put("query_sets/%s" % qs1.pk,
username="******", password="******",
data=xml)
self.assertEquals(response.status_code, 400)
xobjModel = xobj.parse(response.content)
self.assertEquals(xobjModel.fault.message,
'null value in column "field" violates not-null constraint\nDETAIL: Failing row contains (21, null, EQUAL, null).\n')
def testImageOrdering(self):
user = usermodels.User.objects.get(user_name='ExampleDeveloper')
stage = projectsmodels.Stage.objects.filter(
project__short_name='chater-foo',
project_branch__name='1',
name='Development')[0]
for name in [ 'a', 'b', 'c', 'A', 'B', 'C' ]:
img = models.Image(name=name,
project_branch_stage=stage,
created_by=user,
status=300)
self.mgr.createImageBuild(img, for_user=user)
self.mgr.commit()
response = self._get('query_sets/%s/all;order_by=name' % self.all_images.query_set_id,
username='******', password='******')
self.assertEquals(response.status_code, 200)
doc = xobj.parse(response.content)
self.assertEquals(
[ x.name for x in doc.images.image ],
['A', 'B', 'C', 'a', 'b', 'c'])
# Same deal, reverse order
response = self._get('query_sets/%s/all;order_by=-name' % self.all_images.query_set_id,
username='******', password='******')
self.assertEquals(response.status_code, 200)
doc = xobj.parse(response.content)
self.assertEquals(
[ x.name for x in doc.images.image ],
['c', 'b', 'a', 'C', 'B', 'A'])
def testPOST(self):
# Test POST of an XObj object tree.
xml = self.getArchiveContents('employee1.xml')
doc = xobj.parse(xml)
model = doc.employee
robj = self._client.do_POST('/employees', model)
employee = robj._root
# Make sure the model that is returned matches the one that was sent.
self.failUnlessEqual(model.name, employee.name)
self.failUnlessEqual(model.address.street, employee.address.street)
self.failUnlessEqual(model.address.city, employee.address.city)
self.failUnlessEqual(model.address.state, employee.address.state)
self.failUnlessEqual(model.address.zipcode, employee.address.zipcode)
self.failUnlessEqual(model.phone, employee.phone)
self.failUnlessEqual(employee.employeeid, '0')
self.failUnlessEqual(employee.id, '/api/employees/0')
# Make sure there is an error raised when no document is provided.
self.failUnlessRaises(TypeError, self._client.do_POST, '/employees')
# Make sure POST of an XObj document works.
xml2 = self.getArchiveContents('employee2.xml')
doc2 = xobj.parse(xml2)
robj = self._client.do_POST('/employees', doc2)
employee2 = robj._root
self.failUnlessEqual(doc2.employee.name, employee2.name)
self.failUnlessEqual(employee2.employeeid, '1')
def testGetQuerySetAll(self):
# show that we can get results from a query set
qsid = self._getQs("All Systems")
response = self._get("query_sets/%s/all;start_index=0;limit=9999" % qsid,
username="******", password="******")
self.assertEquals(response.status_code, 200)
systems = xobj.parse(response.content)
count = len(systems.systems.system)
self.failUnlessEqual(count, 201)
# we will have tagged it by visiting the last pass
# now hit it again and run down the "tagged" path
# for code coverage purposes & make sure we get
# the same result
response = self._get("query_sets/%s/all;start_index=0;limit=9999" % qsid,
username="******", password="******")
self.assertEquals(response.status_code, 200)
systems = xobj.parse(response.content)
count = len(systems.systems.system)
self.failUnlessEqual(count, 201)
# since we just fetched the queryset, the queryset entry itself
# should now have an invalidation job on it which we can use
# have it re-tag on the next pass
response = self._get("query_sets/%s" % qsid,
username="******", password="******")
self.assertEquals(response.status_code, 200)
self.assertXMLEquals(response.content, testsxml.queryset_with_actions,
ignoreNodes=[
'filter_entry_id', 'created_date',
'last_login_date', 'created_by', 'modified_by',
'tagged_date', 'modified_date', 'is_public', 'is_static',
])
# every queryset should have a "universe" URL that points to the all
# collection for the given queryset type
response = self._get("query_sets/%s/universe" % qsid,
username="******", password="******")
self.assertEquals(response.status_code, 200)
# the tagged date should be set because we ran the queryset
# at least once.
# post the invalidation job to the queryset and verify the tagged
# date goes back to null
queryset = models.QuerySet.objects.get(pk=qsid)
self.assertTrue(queryset.tagged_date is not None)
response = self._post("query_sets/%s/jobs" % qsid,
data=testsxml.queryset_invalidate_post_xml,
username="******", password="******")
self.assertEquals(response.status_code, 200)
queryset = models.QuerySet.objects.get(pk=qsid)
self.assertEquals(queryset.tagged_date, None)
# verify that asking for 0 results returns 0 results
# (not this should happen)
response = self._get("query_sets/%s/all;start_index=0;limit=0" % qsid,
username="******", password="******")
self.assertEquals(response.status_code, 200)
def _testUpdateImageBuildFile(self, username, expected_code):
response = self._post('images/1/build_files/',
username=username, password='******', data=testsxml.build_file_post_xml)
self.assertEqual(response.status_code, expected_code)
if expected_code != 200:
return
buildFile = xobj.parse(response.content)
file_id = buildFile.file.file_id
response = self._put('images/1/build_files/%s' % file_id,
username=username, password='******', data=testsxml.build_file_put_xml)
self.assertEquals(response.status_code, expected_code)
buildFileUpdated = xobj.parse(response.content)
self.assertEquals(buildFileUpdated.file.title, 'newtitle')
def testGetAggregateProjectBranchStages(self):
self._initProject()
response = self._get('project_branch_stages/',
username="******", password="******", pagination=';start_index=0;limit=9999')
self.assertEquals(response.status_code, 200)
stages = xobj.parse(response.content).project_branch_stages.project_branch_stage
oldMaxDiff = self.maxDiff
self.maxDiff = None
self.failUnlessEqual([ x.label for x in stages ],
[
'label',
'postgres.rpath.com@rpath:postgres-1-qa',
'postgres.rpath.com@rpath:postgres-1',
'postgres.rpath.com@rpath:postgres-2-devel',
'postgres.rpath.com@rpath:postgres-2-qa',
'postgres.rpath.com@rpath:postgres-2',
'postgres-private.rpath.com@rpath:postgres-1-devel',
'postgres-private.rpath.com@rpath:postgres-1-qa',
'postgres-private.rpath.com@rpath:postgres-1',
'foo@ns:trunk-devel',
'foo@ns:trunk-qa',
'foo@ns:trunk-stage',
'foo@ns:trunk'
])
self.maxDiff = oldMaxDiff
# developer can still fetch all stages collection since it's a queryset,
# though it should return only what he can see. FIXME: determine
# if what we get is actually correct before adding XML test.
response = self._get('project_branch_stages/',
username='******', password="******")
self.assertEquals(response.status_code, 200)
def testAddProject(self):
response = self._post('projects',
data=testsxml.project_post_xml,
username="******", password="******")
self.assertEquals(response.status_code, 200)
project = xobj.parse(response.content).project
projectId = project.project_id
project = models.Project.objects.get(pk=projectId)
self.assertEquals("test-project", project.name)
self.assertEquals(1, project.created_by.user_id)
self.assertEquals(1, project.modified_by.user_id)
self.assertTrue(project.created_date is not None)
self.assertTrue(project.modified_date is not None)
# adding project again should give a 400 error
response = self._post('projects',
data=testsxml.project_post_xml,
username="******", password="******")
self.assertEquals(response.status_code, 409)
# same short name, different name (APPENG-2999)
xml = testsxml.project_post_xml.replace("<name>test-project</name>",
"<name>another test project</name>")
response = self._post('projects',
data=xml,
username="******", password="******")
self.assertEquals(response.status_code, 409)
def configureTargetCredentials(self, target, ddata):
'''
Configure credentials for a target
@param ddata: descriptor for target
@type ddata: DescriptorData
@param target: target to configure
@type target: rObj(target)
@return: the configured target
@rtype: rObj(target)
'''
# make sure our target object is up to date
target.refresh()
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = target.actions[1]._root.job_type
job.descriptor = target.actions[1]._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
jobObj = target.jobs.append(doc)
while jobObj.job_state.name in ['Queued', 'Running']:
jobObj.refresh()
if jobObj.job_state.name == 'Failed':
raise errors.RbuildError('Unable to set credentials')
return target
def testCreateJob(self):
jobXml = """
<job>
<job_type id="http://localhost/api/v1/inventory/event_types/19"/>
<descriptor id="http://testserver/api/v1/target_types/6/descriptor_create_target"/>
<descriptor_data>
<alias>newbie</alias>
<description>Brand new cloud</description>
<name>newbie.eng.rpath.com</name>
<zone>Local rBuilder</zone>
</descriptor_data>
</job>
"""
response = self._post('jobs', jobXml,
username='******', password='******')
self.assertEquals(response.status_code, 200)
obj = xobj.parse(response.content)
job = obj.job
self.failUnlessEqual(job.descriptor.id, "http://testserver/api/v1/target_types/6/descriptor_create_target")
dbjob = models.Job.objects.get(job_uuid=unicode(job.job_uuid))
# Make sure the job is related to the target type
self.failUnlessEqual(
[ x.target_type.name for x in dbjob.jobtargettype_set.all() ],
[ 'xen-enterprise' ],
)
def testUpdateJob(self):
jobUuid = 'jobUuid1'
jobToken = 'jobToken1'
job = self._newJob(jobUuid, jobToken=jobToken,
jobType=models.EventType.TARGET_REFRESH_IMAGES)
jobXml = """
<job>
<job_status>Completed</job_status>
<status_code>200</status_code>
<status_text>Some status here</status_text>
<results encoding="identity">
<images>
<image id="id1">
<imageId>id1</imageId>
</image>
<image id="id2">
<imageId>id2</imageId>
</image>
</images>
</results>
</job>
"""
response = self._put('jobs/%s' % jobUuid, jobXml,
jobToken=jobToken)
self.assertEquals(response.status_code, 200)
obj = xobj.parse(response.content)
self.failUnlessEqual(obj.job.id, "http://testserver/api/v1/jobs/%s" % job.job_uuid)
def testCreateTarget(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
_targets = []
def _append(x, tag=None):
_targets.append(x)
return x
client._api.targets._mock.set(append=_append)
_ddata = {
'name': 'foo',
'zone': 'local',
'description': 'Foo',
}
ddata = mock.MockObject()
ddata._mock.set(getField=lambda x: _ddata[x])
expected_results = xobj.parse(TARGET_XML)
results = client.createTarget(ddata, 'vmware')
self.assertEqual(results.toxml(), expected_results.toxml())
self.assertTrue(len(_targets) == 1)
def _append_error(x, tag=None):
raise robj.errors.HTTPConflictError(uri=None,
status=None,
reason=None,
response=None)
client._api.targets._mock.set(append=_append_error)
self.assertRaises(errors.RbuildError, client.createTarget, ddata,
'vmware')
self.assertTrue(len(_targets) == 1)
def cancel(self, image):
'''
Cancel a currently running image build
:param image: image obj
:type image: rObj(image)
'''
if image.status != '100':
raise CancelImageError(msg="Image '%s' is not currently building" %
image.image_id)
cancelAction = [a for a in image.actions if a.key == self.CANCEL]
if not cancelAction:
raise CancelImageError(msg="Unable to find cancel action for"
" image '%s'" % image.image_id)
cancelAction = cancelAction[0]
ddata = self.handle.DescriptorConfig.createDescriptorData(
fromStream=cancelAction.descriptor)
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = cancelAction._root.job_type
job.descriptor = cancelAction._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
return image.jobs.append(doc)
def _createJob(self, action_type, image_name, target_name, doLaunch):
rb = self.handle.facade.rbuilder
images = self.getImages(image_name)
target = rb.getTargets(name=target_name)
if not target:
raise errors.PluginError("No target matching '%s'" % target_name)
target = target[0]
if target.is_configured == 'false':
raise errors.PluginError(("Target '{0}' is not configured. Try"
" running \"rbuild edit target '{0}'\" or contacting"
" your rbuilder administrator.").format(target.name))
if target.credentials_valid == 'false':
raise errors.PluginError(("Target '{0}' does not have valid"
" credentials. Try running \"rbuild edit target '{0}'\""
" and updating your credentials.").format(target.name))
image, action = self._getAction(images, target, action_type)
ddata = self.handle.DescriptorConfig.createDescriptorData(
fromStream=action.descriptor)
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = action._root.job_type
job.descriptor = action._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
if doLaunch:
return image.jobs.append(doc)
def testCanGetImageTypeDefinitionDescriptor(self):
# make sure we can load all the valid types
for image_type in mint.buildtypes.xmlTagNameImageTypeMap.keys():
# we do not have XML for netboot/live because they're deprecated
# and deferred is special so we want to test differently
if image_type in ['netbootImage', 'liveIsoImage', 'deferredImage']:
continue
# verify we can get the descriptor
url = "platforms/image_type_definition_descriptors/%s" % image_type
response = self._get(url) #, username='******', password='******')
self.assertEquals(response.status_code, 200)
model = xobj.parse(response.content)
self.failUnlessEqual(model.descriptor._xobj.tag, 'descriptor')
# Check for constraints
fields = dict((x.name, x) for x in model.descriptor.dataFields.field)
field = fields.get('options.freespace')
if field is not None:
self.assertEquals(field.constraints.range.min, '16')
field = fields.get('options.swapSize')
if field is not None:
self.assertEquals(field.constraints.range.min, '16')
field = fields.get('options.vmMemory')
if field is not None:
self.assertEquals(field.constraints.range.min, '256')
field = fields.get('options.vmCPUs')
if field is not None:
self.assertEquals(field.constraints.range.min, '1')
self.assertEquals(field.constraints.range.max, '32')
# an invalid one should 404
response = self._get('platforms/image_type_definition_descriptors/doesNotExist')
# username='******', password='******')
self.assertEquals(response.status_code, 404)
def configureTargetCredentials(self, target, ddata):
'''
Configure credentials for a target
@param ddata: descriptor for target
@type ddata: DescriptorData
@param target: target to configure
@type target: rObj(target)
@return: the configured target
@rtype: rObj(target)
'''
# make sure our target object is up to date
target.refresh()
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = target.actions[1]._root.job_type
job.descriptor = target.actions[1]._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
jobObj = target.jobs.append(doc)
while jobObj.job_state.name in ['Queued', 'Running']:
jobObj.refresh()
if jobObj.job_state.name == 'Failed':
raise errors.RbuildError('Unable to set credentials')
return target
def do_image_info(self, options):
# input validation ... TBD :(
image_id = options
#epdb.st()
h2 = httplib2.Http("~/.rpathcmd/.cache")
h2.disable_ssl_certificate_validation = True
h2.add_credentials(self.options.username, self.options.password)
# fetch the imageid
tmpxml = h2.request('http://' + self.options.server + '/api/v1/images/' + image_id)
tmpdata = xobj.parse(tmpxml[1])
#epdb.st()
print "id: " + tmpdata.image.image_id
print "name: " + tmpdata.image.name
print "type: " + tmpdata.image.image_type.key
print "timecreated: " + tmpdata.image.time_created
print "trovename: " + tmpdata.image.trove_name
print "trailingversion: " + tmpdata.image.trailing_version
print "troveversion: " + tmpdata.image.trove_version
print "troveflavor: " + tmpdata.image.trove_flavor
print "fileid: " + tmpdata.image.files.file.file_id
print "filetitle: " + tmpdata.image.files.file.title
print "fileurl: " + tmpdata.image.files.file.url
def testLocalCacheOfCollections(self):
xml = """\
<?xml version='1.0' encoding='UTF-8'?>
<results>
<package>
<components>
<component>
<uuid>DA94B959-D786-4D58-8428-2991DE6A4FE5</uuid>
<path>Program Files\WindowsAppTest</path>
</component>
<component>
<uuid>DA94B959-D786-4D58-8428-2991DE6A4FE6</uuid>
<path>Program Files\WindowsAppTest2</path>
</component>
</components>
</package>
</results>
"""
doc = xobj.parse(xml)
root = doc.results
results = rObjProxy('/results', None, root, parent=None)
self.failUnlessEqual(results.package.components[0].uuid,
'DA94B959-D786-4D58-8428-2991DE6A4FE5')
self.failUnlessEqual(results.package.components[1].uuid,
'DA94B959-D786-4D58-8428-2991DE6A4FE6')
def _createJob(self, action_type, image_name, target_name, doLaunch):
rb = self.handle.facade.rbuilder
project, branch, stage = self._getProductStage()
image_name, _, version = image_name.partition('=')
images = rb.getImages(
image_name,
project=project,
branch=branch,
stage=stage,
trailingVersion=version,
)
image, action = self._getAction(images, target_name, action_type)
ddata = self.handle.DescriptorConfig.createDescriptorData(
fromStream=action.descriptor)
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = action._root.job_type
job.descriptor = action._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
if doLaunch:
return image.jobs.append(doc)
def cancel(self, image):
'''
Cancel a currently running image build
:param image: image obj
:type image: rObj(image)
'''
if image.status != '100':
raise CancelImageError(msg="Image '%s' is not currently building" %
image.image_id)
cancelAction = [a for a in image.actions if a.key == self.CANCEL]
if not cancelAction:
raise CancelImageError(msg="Unable to find cancel action for"
" image '%s'" % image.image_id)
cancelAction = cancelAction[0]
ddata = self.handle.DescriptorConfig.createDescriptorData(
fromStream=cancelAction.descriptor)
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = cancelAction._root.job_type
job.descriptor = cancelAction._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
return image.jobs.append(doc)
def testCanListPermissions(self):
url = 'rbac/grants'
content = self.req(url, method='GET', expect=403, is_authenticated=True)
content = self.req(url, method='GET', expect=200, is_admin=True)
obj = xobj.parse(content)
found_items = self._xobj_list_hack(obj.grants.grant)
self.assertEqual(len(found_items), 10, 'right number of items')
# no need to test full list dump, have test of single
# self.assertXMLEquals(content, testsxml.permission_list_xml)
# verify that grants also show up on roles objects
# via associations
url = 'rbac/roles'
content = self.req(url, method='GET', expect=200, is_admin=True)
self.assertXMLEquals(content, testsxml.role_list_xml_with_grants)
# verify that we can also retrieve permissions (grants) via
# queryset and the result is the same as from the collection
queryset = querymodels.QuerySet.objects.get(name='All Grants')
url = "query_sets/%s/all" % queryset.pk
content = self.req(url, method='GET', expect=200, is_admin=True)
# listing test no longer needed
# self.assertXMLEquals(content, testsxml.permission_queryset_xml)
# verify we can list permissions off the role itself
sysadmin = models.RbacRole.objects.get(name='sysadmin')
url = "rbac/roles/%s/grants/" % sysadmin.pk
content = self.req(url, method='GET', expect=200, is_admin=True)
self.assertXMLEquals(content, testsxml.permission_list_xml_for_role)
def _createJob(self, action_type, image_name, target_name, doLaunch):
rb = self.handle.facade.rbuilder
images = self.getImages(image_name)
target = rb.getTargets(name=target_name)
if not target:
raise errors.PluginError("No target matching '%s'" % target_name)
target = target[0]
if target.is_configured == 'false':
raise errors.PluginError(
("Target '{0}' is not configured. Try"
" running \"rbuild edit target '{0}'\" or contacting"
" your rbuilder administrator.").format(target.name))
if target.credentials_valid == 'false':
raise errors.PluginError(
("Target '{0}' does not have valid"
" credentials. Try running \"rbuild edit target '{0}'\""
" and updating your credentials.").format(target.name))
image, action = self._getAction(images, target, action_type)
ddata = self.handle.DescriptorConfig.createDescriptorData(
fromStream=action.descriptor)
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = action._root.job_type
job.descriptor = action._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
if doLaunch:
return image.jobs.append(doc)
def testGetQuerySet(self):
# show that we can get the definition of a queryset
qsid = self._getQs("All Systems")
response = self._get("query_sets/%s" % qsid,
username="******", password="******")
self.assertEquals(response.status_code, 200)
querySet = xobj.parse(response.content)
self.failUnlessEqual(querySet.query_set.name, 'All Systems')
def testCanGetSingleRole(self):
url = 'rbac/roles/3'
content = self.req(url, method='GET', expect=403, is_authenticated=True)
content = self.req(url, method='GET', expect=200, is_admin=True)
obj = xobj.parse(content)
self.assertEqual(obj.role.name, 'developer')
self.assertXMLEquals(content, testsxml.role_get_xml)
def testAddProjectNoHostname(self):
response = self._post('projects',
data=testsxml.project_post_no_hostname_xml,
username="******", password="******")
self.assertEquals(response.status_code, 200)
project = xobj.parse(response.content).project
projectId = project.project_id
project = models.Project.objects.get(pk=projectId)
self.assertEquals("test-project", project.hostname)
def _testCreateImage(self, username, expected_code):
url = 'images/'
response = self._post(url, username=username, password='******', data=testsxml.image_post_xml)
self.assertEquals(response.status_code, expected_code)
if expected_code == 200:
image = xobj.parse(response.content)
self.assertEquals(image.image.name, 'image-20')
self.assertEquals(image.image.trove_name, 'troveName20')
self.assertEquals(image.image.image_id, u'4')
def testCanListUserRoles(self):
user_id = self.admin_user.pk
url = "users/%s/roles/" % user_id
content = self.req(url, method='GET', expect=403, is_authenticated=True)
content = self.req(url, method='GET', expect=200, is_admin=True)
obj = xobj.parse(content)
found_items = self._xobj_list_hack(obj.roles.role)
self.assertEqual(len(found_items), 3, 'right number of items')
self.assertXMLEquals(content, testsxml.user_role_list_xml)
def do_project_branch_imagedef_create(self, args):
# https://$RBA/api/products/$PROJECT_SHORTNAME/versions/1.0/imageTypeDefinitions
# PUT XML ... imagedef-esx-x86.template
# $RBA
# $PROJECT_SHORTNAME
# $FREESPACE == 1024 (MB)
moduledir = os.path.dirname(self.sys.modules['rpathcmd.systems'].__file__)
xmldir = moduledir + '/xml/'
templatefile = xmldir + 'imagedef-esx-x8664.template'
templatedata = open(templatefile, 'r')
(args, options) = parse_arguments(args)
projectshortname = args[0]
branch_name = args[1]
freespace = args[2]
values = { 'RBA': self.options.server,
'PROJECT_SHORTNAME': projectshortname,
'BRANCH_NAME': branch_name,
'FREESPACE': freespace}
template = TextTemplate(templatedata, lookup='lenient')
stream = template.generate(**values)
postxml = stream.render('text')
print "-----------<POSTDATA>-----------"
print postxml
print "-----------<POSTDATA>-----------"
# initialize httlib2 and add credentials
h2 = httplib2.Http("~/.rpathcmd/.cache")
h2.disable_ssl_certificate_validation = True
h2.add_credentials(self.options.username, self.options.password)
# make POST request
returndata = h2.request('http://' + self.options.server +
'/api/products/' + str(projectshortname) +
'/versions/' + branch_name + '/imageDefinitions',
headers={'Content-Type': 'application/xml'},
method="PUT",
body=postxml)
#epdb.st()
#pprint(returndata)
if returndata[0]['status'] != '200':
print "creation failed: %s" % returndata[0]['status']
sys.exit(1)
else:
print "creation completed: %s" % returndata[0]['status']
returnxml = xobj.parse(returndata[1])
print returnxml
def testListQuerySet(self):
# show that we can list all query sets
response = self._get('query_sets/',
username="******", password="******")
self.assertEquals(response.status_code, 200)
querySets = xobj.parse(response.content)
length = len(querySets.query_sets.query_set)
# ok to bump this if we add more QS in the db
self.assertEqual(length, 10)
# favorite queryset view returns what to show in
# the UI navigation
response = self._get('favorites/query_sets/',
username="******", password="******")
self.assertEquals(response.status_code, 200)
querySets = xobj.parse(response.content)
length = len(querySets.favorite_query_sets.query_set)
self.assertEqual(length, 10)
def testGetImageJobs(self):
# TODO: rbac tests somewhat missing -- need to isolate some errors
# with rmake mocking not working in my environment -- MPD
imageId = 3
for i in range(3):
jobTypes = [ jobsmodels.EventType.TARGET_DEPLOY_IMAGE,
jobsmodels.EventType.TARGET_LAUNCH_SYSTEM ]
for j, jobType in enumerate(jobTypes):
jobUuid = "job-uuid-%02d-%02d" % (i, j)
job = self._newJob(jobUuid, jobType=jobType)
models.JobImage.objects.create(job=job, image_id=imageId)
# TODO: add tests for non-admon access w/ rights
self.mgr.retagQuerySetsByType('image')
response = self._get('images/%s/jobs' % imageId,
username='******', password='******')
if response.status_code != 200:
print response.content
self.failUnlessEqual(response.status_code, 200)
doc = xobj.parse(response.content)
self.failUnlessEqual([ x.job_uuid for x in doc.jobs.job ],
[
'job-uuid-02-01',
'job-uuid-02-00',
'job-uuid-01-01',
'job-uuid-01-00',
'job-uuid-00-01',
'job-uuid-00-00',
])
# Test sorting by job description
response = self._get('images/%s/jobs?order_by=non_existent_field' % imageId,
username='******', password='******')
self.unmock()
self.assertEquals(response.status_code, 400)
doc = xobj.parse(response.content)
self.assertEquals(doc.fault.code, '400')
self.assertTrue(doc.fault.message.startswith(
"Cannot resolve keyword u'non_existent_field' into field."),
doc.fault.message)
def testAddProjectNoRepoHostname(self):
response = self._post('projects',
data=testsxml.project_post_no_repo_hostname_xml,
username="******", password="******")
self.assertEquals(response.status_code, 200)
project = xobj.parse(response.content).project
projectId = project.project_id
project = models.Project.objects.get(pk=projectId)
self.assertEquals("test-project.eng.rpath.com", project.repository_hostname)
self.assertEquals(1, project.created_by.user_id)
def testAddProjectNoNamespace(self):
response = self._post('projects',
data=testsxml.project_post_no_namespace_xml,
username="******", password="******")
self.assertEquals(response.status_code, 200)
project = xobj.parse(response.content).project
projectId = project.project_id
project = models.Project.objects.get(pk=projectId)
self.assertEquals(project.namespace, 'ns')
self.assertEquals(1, project.created_by.user_id)
def do_project_create(self, args):
# https://qa3.eng.rpath.com/api/v1/projects
# POST XML ... project_template.xml
# $NAME
# $SHORT_NAME
print "not done"
moduledir = os.path.dirname(self.sys.modules['rpathcmd.systems'].__file__)
xmldir = moduledir + '/xml/'
templatefile = xmldir + 'project_template.xml'
templatedata = open(templatefile, 'r')
(args, options) = parse_arguments(args)
projectname = args[0]
projectshortname = args[1]
values = { 'NAME': projectname,
'SHORT_NAME': projectshortname}
template = TextTemplate(templatedata, lookup='lenient')
stream = template.generate(**values)
postxml = stream.render('text')
print "########## <POSTDATA> ##########"
print postxml
print "########## ^POSTDATA^ ##########"
# initialize httlib2 and add credentials
h2 = httplib2.Http("~/.rpathcmd/.cache")
h2.disable_ssl_certificate_validation = True
h2.add_credentials(self.options.username, self.options.password)
# make POST request
returndata = h2.request('http://' + self.options.server +
'/api/v1/projects',
headers={'Content-Type': 'application/xml'},
method="POST",
body=postxml)
#pprint(returndata)
if returndata[0]['status'] != '200':
print "creation failed: %s" % returndata[0]['status']
sys.exit(1)
else:
print "creation completed: %s" % returndata[0]['status']
returnxml = xobj.parse(returndata[1])
#epdb.st()
print "projectid: %s" % returnxml.project.project_id
print "name: %s" % returnxml.project.name
print "shortname: %s" % returnxml.project.short_name
print "hostname: %s" % returnxml.project.hostname
def do_images_list(self, options):
h2 = httplib2.Http("~/.rpathcmd/.cache")
h2.disable_ssl_certificate_validation = True
h2.add_credentials(self.options.username, self.options.password)
#a list of each page's xml
images_data_pages = []
# fetch first page, save and parse
tmpxml = h2.request('http://' + self.options.server + '/api/v1/images')
images_data_pages.append(tmpxml[1])
tmpdata = xobj.parse(tmpxml[1])
#epdb.st()
# to paginate or not to paginate, that is the question.
if int(tmpdata.images.num_pages) == 1:
print "#one page"
else:
print "%s pages" % tmpdata.images.num_pages
next_page_url = tmpdata.images.next_page
while next_page_url != '':
# fetch next page
print "fetching %s" % next_page_url
nextxml = h2.request(tmpdata.images.next_page)
# save data
images_data_pages.append(nextxml[1])
# parse xml
nextdata = xobj.parse(nextxml[1])
# check next page
next_page_url = nextdata.images.next_page
#epdb.st()
#epdb.st()
for images_data_page in images_data_pages:
images_data = xobj.parse(images_data_page)
#epdb.st()
for image in images_data.images.image:
#epdb.st()
#print "%s: %s %s=%s" %(image.image_id, image.name, image.trove_name, image.trove_version)
print "%s: %s %s=%s" %(image.image_id, image.name, image.trove_name, image.trailing_version )
def _getCancelBuildJob(self, image):
cancelAction = image.actions[0]
ddata = self.handle.DescriptorConfig.createDescriptorData(
fromStream=cancelAction.descriptor)
doc = xobj.Document()
doc.job = job = xobj.XObj()
job.job_type = cancelAction._root.job_type
job.descriptor = cancelAction._root.descriptor
job.descriptor_data = xobj.parse(ddata.toxml()).descriptor_data
return image.jobs.append(doc)
def xobjSystems(self, url):
url = url + ";start_index=0;limit=9999"
response = self._get(url,
username="******", password="******")
xobjModel = xobj.parse(response.content)
systems = None
try:
systems = xobjModel.systems.system
except AttributeError:
return []
return self.xobjHack(systems)
def c(self, url, raw = False, auth = ('test', 'foo'),
entitlements = [], checkHeaders = {}):
if not url.startswith('http:'):
url = 'http://localhost' + url
(scheme, netloc, path, query, fragment) = \
urlparse.urlsplit(url)
mappedLoc = self.map[netloc]
finalUrl = "%sapi%s" % (mappedLoc, path)
if query:
finalUrl += '?' + query
else:
finalUrl = url
req = urllib2.Request(finalUrl)
if auth:
req.add_header('Authorization',
'Basic ' + base64.encodestring('%s:%s' % auth))
if entitlements:
l = [ "* %s" % base64.b64encode(x) for x in entitlements ]
req.add_header('X-Conary-Entitlement', " ".join(l))
f = urllib2.urlopen(req)
for key, val in checkHeaders.iteritems():
assert(f.headers[key] == val)
s = f.read()
f.close()
if raw:
return s
return xobj.parse(s)
def thaw(cls, xml):
"""
Deserialize an xml string into a DocManager instance.
"""
return xobj.parse(xml, documentClass=cls)
