def add_lbr_to_nsx_edge(nsx_edges_dir, nsx_edge):

    template_dir = '.'

    iso_zones = nsx_edge['iso_zones']
    app_profiles = nsx_edge['app_profiles']
    ert_certId = nsx_edge['cert_id']

    # Link the iso cert id against the corresponding app profiles,
    # if they are using any ssl/secure protocol and are associated
    # with Ert or IsoZone switches
    for app_profile in app_profiles:
        switch_name = app_profile.get('switch')
        app_profile_name = app_profile['name']

        if app_profile['requires_cert']:
            if switch_name and 'ISOZONE' in switch_name.upper():
                for iso_zone in iso_zones:
                    if switch_name == iso_zone['name']:
                        app_profile['cert_id'] = iso_zone['cert_id']
                        continue
            # Use the same ert cert id for those not associated with any switches too
            else:  #if not switch_name or (switch_name and 'ERT' in switch_name.upper()):
                app_profile['cert_id'] = ert_certId
                continue

    nsx_edges_context = {
        'nsx_edge': nsx_edge,
        'app_profiles': app_profiles,
        'app_rules': nsx_edge['app_rules'],
        'monitor_list': nsx_edge['monitor_list'],
        'routed_components': nsx_edge['routed_components'],
        'files': []
    }

    template.render(
        os.path.join(nsx_edges_dir,
                     nsx_edge['name'] + '_lbr_config_put_payload.xml'),
        os.path.join(template_dir, 'edge_lbr_config_put_payload.xml'),
        nsx_edges_context)

    put_response = client.put_xml(
        NSX_URLS['esg']['all'] + '/' + nsx_edge['id'] +
        NSX_URLS['lbrConfig']['all'],
        os.path.join(nsx_edges_dir,
                     nsx_edge['name'] + '_lbr_config_put_payload.xml'),
        check=False)
    data = put_response.text

    if DEBUG:
        print('NSX Edge LBR Config Update response:{}\n'.format(data))

    if put_response.status_code < 400:
        print('Updated NSX Edge LBR Config for : {}\n'.format(
            nsx_edge['name']))
    else:
        print(
            'Update of NSX Edge LBR Config failed, details:{}\n'.format(data))
        raise Exception(
            'Update of NSX Edge LBR Config failed, details:\n {}'.format(data))
Beispiel #2
0
def vote_get():
	page = Page('/vote', 'Vote')
	if page not in pages:
		abort(404)
	current_user = process_cookie(request.get_cookie("login"))

	if current_user is None:
		redirect('/login?message=3')
	if current_user.has_voted:
		return template.render("home_redirect.html",
							   {'message': "<h1>You have already voted.</h1>"})
	
	nominees = user.get_nominees()
	random.shuffle(nominees)
	col_size = len(nominees)/3
	if len(nominees) % 3 > 0:
		col_size += 1
	
	nominees = [nominees[:col_size],
				nominees[col_size:2*col_size],
				nominees[2*col_size:]]
	
	return template.render("voting.html",
						   {'config': config,
							'pages': pages, 'page': page,
							'nominees': nominees,
							'csrf': csrf.get_csrf_key(current_user.userid),
							'user': current_user})
Beispiel #3
0
def login_post():
	page = Page('/login', 'Login')
	current_user = process_cookie(request.get_cookie("login"))
	
	if current_user is not None:
		return template.render("home_redirect.html",
							   {'message': "<h1>You are already logged in</h1>"})

	if request.forms.get('username') == 'admin' and\
			user.hash_password(request.forms.get('password')) == config["admin_hash"]:
		response.set_cookie("login",
							cookies.give_cookie("admin"),
							max_age=cookies.expire_time)
		
		return template.render("vote_count_redirect.html",
							   {'message': "<h1>Admin Login Successful</h1>"})
	
	validity = user.is_valid_login(request.forms.get('username'),
								   request.forms.get('password'))
	
	if validity == 0: # Success		
		cookie = cookies.give_cookie(request.forms.get('username'))
		print cookie
		response.set_cookie("login", cookie, max_age=cookies.expire_time)
		return template.render("home_redirect.html",
							   {'message': "<h1>Login Successful</h1>"})
	else:
		return template.render("login.html", {'config': config,
											  'pages': pages, 'page': page,
											  'valid': validity,
											  'user': current_user})
Beispiel #4
0
def nominate_get():
	page = Page('/nominate', 'Nominate')
	if page not in pages:
		abort(404)
	current_user = process_cookie(request.get_cookie("login"))
	nominee_fields = config['nominee_fields']
	
	if current_user is None:
		redirect('/login?message=3')
	
	if current_user.student_info is None:
		return template.render("home_redirect.html",
							   {'message': "<h1>Staff cannot nominate</h1>"})
	if not current_user.student_info.is_nominee and config['prenominate']:
		return template.render("home_redirect.html",
							   {'message': "<h1>You are not a candidate.</h1>"})
	
	nominee_fields = filter(
		lambda x: x['name'] not in current_user.student_info.nominee_fields,
		nominee_fields)

	if len(nominee_fields) == 0:
		return template.render("home_redirect.html",
							   {'message': """<h1>You have already
 submitted your nomination</h1>"""})
	
	return template.render("nominate.html",
						   {'config': config,
							'nominee_fields': nominee_fields,
							'csrf': csrf.get_csrf_key(current_user.userid),
							'pages': pages, 'page': page,
							'user': current_user})
Beispiel #5
0
def create_tile(context):
    release = context['release']
    release['file'] = os.path.basename(release['tarball'])
    with cd('releases'):
        print 'tile import release', release['name']
        shutil.copy(release['tarball'], release['file'])
        if context.get('requires_docker_bosh', False):
            print 'tile import release docker'
            docker_release = download_docker_release()
            context['docker_release'] = docker_release
    print 'tile generate metadata'
    template.render('metadata/' + release['name'] + '.yml',
                    'tile/metadata.yml', context)
    print 'tile generate content-migrations'
    template.render('content_migrations/' + release['name'] + '.yml',
                    'tile/content-migrations.yml', context)
    print 'tile generate package'
    pivotal_file = release['name'] + '-' + release['version'] + '.pivotal'
    with zipfile.ZipFile(pivotal_file, 'w') as f:
        f.write(os.path.join('releases', release['file']))
        if context.get('requires_docker_bosh', False):
            docker_release = context['docker_release']
            f.write(os.path.join('releases', docker_release['file']))
        f.write(os.path.join('metadata', release['name'] + '.yml'))
        f.write(os.path.join('content_migrations', release['name'] + '.yml'))
    print
    print 'created tile', pivotal_file
Beispiel #6
0
def add_package(dir, context, package, alternate_template=None):
	name = package['name'].lower().replace('-','_')
	package['name'] = name
	bosh('generate', 'package', name)
	target_dir = os.path.realpath(os.path.join(dir, name))
	package_dir = os.path.realpath(os.path.join('packages', name))
	mkdir_p(target_dir)
	template_dir = 'packages'
	if alternate_template is not None:
		template_dir = os.path.join(template_dir, alternate_template)
	package_context = {
		'context': context,
		'package': package,
		'files': []
	}
	with cd('..'):
		for file in package.get('files', []):
			filename = file.get('name', os.path.basename(file['path']))
			try:
				urllib.urlretrieve(file['path'], os.path.join(target_dir, filename))
			except ValueError: # Invalid URL, assume filename
				shutil.copy(os.path.join('..', file['path']), target_dir)
			package_context['files'] += [ filename ]
			file['name'] = filename
	template.render(
		os.path.join(package_dir, 'spec'),
		os.path.join(template_dir, 'spec'),
		package_context
	)
	template.render(
		os.path.join(package_dir, 'packaging'),
		os.path.join(template_dir, 'packaging'),
		package_context
	)
Beispiel #7
0
def gen_scripts(dir, context, alternate_template=None):
    scripts_dir = os.path.realpath(os.path.join(dir))
    context['product']['tile']['version'] = context['version']

    mkdir_p(scripts_dir)
    template_dir = dir
    if alternate_template is not None:
        template_dir = os.path.join(template_dir, alternate_template)

    tile_context = {
        'context': context,
        'root_dir': context['root_dir'],
        'product': context['product'],
        'history': context['history'],
        'version': context['version'],
        'tile': context['product']['tile'],
        'files': []
    }

    template.render(os.path.join(scripts_dir, 'createRelease.sh'),
                    os.path.join(template_dir, 'createRelease.sh'),
                    tile_context)
    template.render(os.path.join(scripts_dir, 'createTile.sh'),
                    os.path.join(template_dir, 'createTile.sh'), tile_context)

    tileScript = os.stat(scripts_dir + '/createTile.sh')
    os.chmod(scripts_dir + '/createTile.sh', tileScript.st_mode | stat.S_IEXEC)
    releaseScript = os.stat(scripts_dir + '/createRelease.sh')
    os.chmod(scripts_dir + '/createRelease.sh',
             releaseScript.st_mode | stat.S_IEXEC)
Beispiel #8
0
def create_tile(context):
	release = context['release']
	release['file'] = os.path.basename(release['tarball'])
	with cd('releases'):
		print 'tile import release', release['name']
		shutil.copy(release['tarball'], release['file'])
		if context.get('requires_docker_bosh', False):
			print 'tile import release docker'
			docker_release = download_docker_release()
			context['docker_release'] = docker_release
	print 'tile generate metadata'
	template.render('metadata/' + release['name'] + '.yml', 'tile/metadata.yml', context)
	print 'tile generate content-migrations'
	template.render('content_migrations/' + release['name'] + '.yml', 'tile/content-migrations.yml', context)
	print 'tile generate package'
	pivotal_file = release['name'] + '-' + release['version'] + '.pivotal'
	with zipfile.ZipFile(pivotal_file, 'w') as f:
		f.write(os.path.join('releases', release['file']))
		if context.get('requires_docker_bosh', False):
			docker_release = context['docker_release']
			f.write(os.path.join('releases', docker_release['file']))
		f.write(os.path.join('metadata', release['name'] + '.yml'))
		f.write(os.path.join('content_migrations', release['name'] + '.yml'))
	print
	print 'created tile', pivotal_file
Beispiel #9
0
def add_bosh_job(context, package, job_type, post_deploy=False, pre_delete=False):
	job_name = job_type + '-' + package['name']
	bosh('generate', 'job', job_name)
	job_context = {
		'job_name': job_name,
		'job_type': job_type,
		'context': context,
		'package': package,
	}
	template.render(
		os.path.join('jobs', job_name, 'spec'),
		os.path.join('jobs', 'spec'),
		job_context
	)
	template.render(
		os.path.join('jobs', job_name, 'templates', job_name + '.sh.erb'),
		os.path.join('jobs', job_type + '.sh.erb'),
		job_context
	)
	context['jobs'] = context.get('jobs', []) + [{
		'name': job_name,
		'type': job_type,
		'package': package,
	}]
	if post_deploy:
		context['post_deploy_errands'] = context.get('post_deploy_errands', []) + [{ 'name': job_name }]
	if pre_delete:
		context['pre_delete_errands'] = context.get('pre_delete_errands', []) + [{ 'name': job_name }]
Beispiel #10
0
def gen_manifest(dir, context, alternate_template=None):
    manifest_dir = os.path.realpath(os.path.join(dir))

    mkdir_p(manifest_dir)
    template_dir = 'manifests'
    if alternate_template is not None:
        template_dir = os.path.join(template_dir, alternate_template)
    manifest_context = {
        'context': context,
        'vmInstances': context['vms'],
        'product': context['product'],
        'service': context['service'],
        'job2release_lookup_map': context['job2release_lookup_map'],
        'managed_service_releases': context['managed_service_releases'],
        #'managed_service_release_jobs': context['managed_service_release_jobs'],
        'files': []
    }

    shutil.copy(
        context['root_dir'] +
        '/templates/manifests/bosh-lite-cloud-config.yml', manifest_dir)

    template.render(
        os.path.join(
            manifest_dir,
            context['product']['short_name'] + '-odb-warden-manifest.yml'),
        os.path.join(template_dir, 'on-demand-broker-warden-manifest.yml'),
        manifest_context)
Beispiel #11
0
def vote_post():
	page = Page('/vote', 'Vote')
	if page not in pages:
		abort(404)
	current_user = process_cookie(request.get_cookie("login"))
	given_csrf_key = request.forms.get('csrf')

	if not csrf.check_csrf_key(current_user.userid, given_csrf_key):
		abort(403, "A potential CSRF attack was detected. "
			  "Please try again later.")
	
	if current_user is None:
		redirect('/login?message=3')
	if current_user.has_voted:
		return template.render("home_redirect.html",
							   {'message': "<h1>You have already voted.</h1>"})
	
	nominees = user.get_nominees()
	votes = []
	for n in nominees:
		if request.forms.get(str(n.userid)):
			votes.append(n.userid)
	
	if len(votes) > config['num_votes']:
		redirect('/vote')

	submissions.submit_votes(current_user.userid, votes)
		
	return template.render("home_redirect.html",
						   {'message': "<h1>Vote successful.</h1>"})
Beispiel #12
0
def build_transport_zone(dir, context, type='transport_zone', alternate_template=None):

    # if found the matching transport zone (either given or default), return
    if check_transport_zone(context):
        return

    # Transport zone does not exist, lets create
    transport_zone_name = context['nsxmanager'].get('transport_zone')
    if not transport_zone_name:
        transport_zone_name = context['name'] + '-tz'

    transport_zone = {}
    transport_zone['name'] = transport_zone_name
    transport_zone['cluster_names'] = context['nsxmanager'].get('transport_zone_clusters').strip()
    if transport_zone['cluster_names'] == '':
        raise Exception('Error! No cluster members specified to create the Transport Zone...!!')
    
    cluster_ids = ''
    for cluster_name in transport_zone['cluster_names'].split(','):
        cluster_id = mobclient.lookup_moid(cluster_name.strip())
        if 'domain' in cluster_id:
            cluster_ids += cluster_id + ','

    cluster_ids = cluster_ids.strip(',')
    if cluster_ids == '':
        raise Exception('Error! No matching cluster members found to create the Transport Zone...!!')
    
    transport_zone['cluster_ids'] = cluster_ids
    tz_context = {
        'context': context,
        'transport_zone': transport_zone,
        'files': []
    }    

    transport_zones_dir = os.path.realpath(os.path.join(dir ))
    if os.path.isdir(transport_zones_dir):
        shutil.rmtree(transport_zones_dir)
    mkdir_p(transport_zones_dir)

    template_dir = '.'
    if alternate_template is not None:
        template_dir = os.path.join(template_dir, alternate_template)

    template.render(
        os.path.join(transport_zones_dir, transport_zone['name'] + '_payload.xml'),
        os.path.join(template_dir, 'vdn_scope_post_payload.xml' ),
        tz_context
    )

    post_response = client.post_xml(NSX_URLS['scope']['all'], 
            os.path.join(transport_zones_dir, transport_zone['name'] + '_payload.xml'))
    data = post_response.text
    if DEBUG:
        print('Transport Zone creation response:{}\n'.format(data))

    if post_response.status_code < 400: 
        print('Created Transport Zone : {}\n'.format(transport_zone['name']))
        context['nsxmanager']['transport_zone'] = transport_zone['name']
        context['nsxmanager']['transport_zone_id'] = data
Beispiel #13
0
 def add_package_to_bosh(self, dir, package, alternate_template=None):
     # Hmm...this possible renaming might break stuff...can we do it earlier?
     name = package['name'].lower().replace('-', '_')
     package['name'] = name
     self.__bosh('generate', 'package', name)
     target_dir = os.path.realpath(os.path.join(dir, name))
     package_dir = os.path.realpath(os.path.join('packages', name))
     mkdir_p(target_dir)
     template_dir = 'packages'
     if alternate_template is not None:
         template_dir = os.path.join(template_dir, alternate_template)
     package_context = {
         'context': self.context,
         'package': package,
         'files': []
     }
     with cd('..'):
         files = package.get('files', [])
         path = package.get('path', None)
         if path is not None:
             files += [{'path': path}]
             package['path'] = os.path.basename(path)
         manifest = package.get('manifest', None)
         manifest_path = None
         if type(manifest) is dict:
             manifest_path = manifest.get('path', None)
         if manifest_path is not None:
             files += [{'path': manifest_path}]
             package['manifest']['path'] = os.path.basename(manifest_path)
         for file in files:
             filename = file.get('name', os.path.basename(file['path']))
             file['name'] = filename
             urllib.urlretrieve(file['path'],
                                os.path.join(target_dir, filename))
             package_context['files'] += [filename]
         for docker_image in package.get('docker_images', []):
             filename = docker_image.lower().replace('/', '-').replace(
                 ':', '-') + '.tgz'
             download_docker_image(docker_image,
                                   os.path.join(target_dir, filename),
                                   cache=self.context.get(
                                       'docker_cache', None))
             package_context['files'] += [filename]
     if package.get('is_app', False):
         manifest = package.get('manifest', {'name': name})
         if manifest.get('random-route', False):
             print >> sys.stderr, 'Illegal manifest option in package', name + ': random-route is not supported'
             sys.exit(1)
         manifest_file = os.path.join(target_dir, 'manifest.yml')
         with open(manifest_file, 'wb') as f:
             f.write('---\n')
             f.write(yaml.safe_dump(manifest, default_flow_style=False))
         package_context['files'] += ['manifest.yml']
         update_memory(self.context, manifest)
     template.render(os.path.join(package_dir, 'spec'),
                     os.path.join(template_dir, 'spec'), package_context)
     template.render(os.path.join(package_dir, 'packaging'),
                     os.path.join(template_dir, 'packaging'),
                     package_context)
Beispiel #14
0
def add_package(dir, context, package, alternate_template=None):
	name = package['name'].lower().replace('-','_')
	package['name'] = name
	bosh('generate', 'package', name)
	target_dir = os.path.realpath(os.path.join(dir, name))
	package_dir = os.path.realpath(os.path.join('packages', name))
	mkdir_p(target_dir)
	template_dir = 'packages'
	if alternate_template is not None:
		template_dir = os.path.join(template_dir, alternate_template)
	package_context = {
		'context': context,
		'package': package,
		'files': []
	}
	with cd('..'):
		files = package.get('files', [])
		path = package.get('path', None)
		if path is not None:
			files += [ { 'path': path } ]
			package['path'] = os.path.basename(path)
		manifest = package.get('manifest', None)
		manifest_path = None
		if type(manifest) is dict:
			manifest_path = manifest.get('path', None)
		if manifest_path is not None:
			files += [ { 'path': manifest_path } ]
			package['manifest']['path'] = os.path.basename(manifest_path)
		for file in files:
			filename = file.get('name', os.path.basename(file['path']))
			file['name'] = filename
			urllib.urlretrieve(file['path'], os.path.join(target_dir, filename))
			package_context['files'] += [ filename ]
		for docker_image in package.get('docker_images', []):
			filename = docker_image.lower().replace('/','-').replace(':','-') + '.tgz'
			download_docker_image(docker_image, os.path.join(target_dir, filename), cache=context.get('docker_cache', None))
			package_context['files'] += [ filename ]
	if package.get('is_app', False):
		manifest = package.get('manifest', { 'name': name })
		if manifest.get('random-route', False):
			print >> sys.stderr, 'Illegal manifest option in package', name + ': random-route is not supported'
			sys.exit(1)
		manifest_file = os.path.join(target_dir, 'manifest.yml')
		with open(manifest_file, 'wb') as f:
			f.write('---\n')
			f.write(yaml.safe_dump(manifest, default_flow_style=False))
		package_context['files'] += [ 'manifest.yml' ]
		update_memory(context, manifest)
	template.render(
		os.path.join(package_dir, 'spec'),
		os.path.join(template_dir, 'spec'),
		package_context
	)
	template.render(
		os.path.join(package_dir, 'packaging'),
		os.path.join(template_dir, 'packaging'),
		package_context
	)
Beispiel #15
0
def index(request, *args):
    context = {}
    context['data_list'] = ''
    for i in range(10):
        context['data_list'] += render("panel", False)
    context['title'] = '~~~~~~~'
    context['site_name'] = "Python的博客"
    context['css'] = Config.CSS
    context['js'] = Config.JS
    return render(context=context)
Beispiel #16
0
def vote_count_get():
	user = process_cookie(request.get_cookie("login"))
	if user is None or user.username != "admin":
		return template.render("home_redirect.html",
						{'message': """<h1>You can't view the vote count if you are not admin</h1>"""})
	votes_dict = vote.vote_count()
	votes_list = map(lambda x: (x, votes_dict[x][0], votes_dict[x][1]), votes_dict)
	votes_list.sort(key = lambda x: x[1], reverse=True)

	return template.render("vote_count.html", 
					{'config': config, 'vote_count': votes_list})
Beispiel #17
0
    def get_render(self,template_file,values):
        template_file=template_file+".html"
        self.template_vals.update(values)
        logging.info("-----------------")
        try:
            #sfile=getattr(self.blog.theme, template_file)
            logging.debug("get_render:"+template_file)
            html = micolog_template.render(self.blog.theme, template_file, self.template_vals)
        except TemplateDoesNotExist:
            #sfile=getattr(self.blog.default_theme, template_file)
            html = micolog_template.render(self.blog.default_theme, template_file, self.template_vals)

        return html
Beispiel #18
0
 def testRun(self):
     self.assertEqual(render(content="{{for i in range(n):}}{{=i}}{{pass}}", context=dict(n=3)), "012")
     self.assertEqual(render(content="{{if n>2:}}ok{{pass}}", context=dict(n=3)), "ok")
     self.assertEqual(render(content="{{try:}}{{n/0}}{{except:}}fail{{pass}}", context=dict(n=3)), "fail")
     self.assertEqual(render(content='{{="<&>"}}'), "&lt;&amp;&gt;")
     self.assertEqual(render(content='"abc"'), '"abc"')
     self.assertEqual(render(content='"a\'bc"'), '"a\'bc"')
     self.assertEqual(render(content='"a"bc"'), '"a"bc"')
     self.assertEqual(render(content=r'''"a\"bc"'''), r'"a\"bc"')
     self.assertEqual(render(content=r'''"""abc\""""'''), r'"""abc\""""')
def add_ospf_to_nsx_dlr(nsx_dlrs_dir, context, nsx_dlr):

    map_nsx_esg_id([nsx_dlr])

    template_dir = '.'
    logical_switches = context['logical_switches']

    for lswitch in logical_switches:
        switch_name_upper = lswitch['name'].upper()
        if 'OSPF' in switch_name_upper:
            ospfLogicalSwitch = lswitch

    disable_ospf = False
    static_routes = nsxmanager['static_routes']
    disable_ospf = (static_routes is not None and len(static_routes) > 0)

    nsx_dlrs_context = {
        'context': context,
        'defaults': context['defaults'],
        'nsxmanager': context['nsxmanager'],
        'dlr': nsx_dlr,
        'logical_switches': logical_switches,
        'ospfLogicalSwitch': ospfLogicalSwitch,
        'disable_ospf': disable_ospf,
        'gateway_address': nsx_dlr['gateway_ip'],
        'files': []
    }

    template.render(
        os.path.join(nsx_dlrs_dir,
                     nsx_dlr['name'] + '_dlr_config_put_payload.xml'),
        os.path.join(template_dir, 'dlr_config_put_payload.xml'),
        nsx_dlrs_context)

    put_response = client.put_xml(
        NSX_URLS['esg']['all'] + '/' + nsx_dlr['id'],
        os.path.join(nsx_dlrs_dir,
                     nsx_dlr['name'] + '_dlr_config_put_payload.xml'),
        check=False)
    data = put_response.text

    if DEBUG:
        print('NSX DLR Config Update response:{}\n'.format(data))

    if put_response.status_code < 400:
        print('Updated NSX DLR Config for : {}\n'.format(nsx_dlr['name']))
    else:
        print('Update of NSX DLR Config failed, details:{}\n'.format(data))
        raise Exception(
            'Update of NSX DLR Config failed, details:\n {}'.format(data))
Beispiel #20
0
def gen_release_dir(dir, context, alternate_template=None):
    release_dir = os.path.realpath(os.path.join(dir))

    template_dir = dir
    release_context = {
        'context': context,
        'product': context['product'],
        #'managed_service_release_jobs': context['managed_service_release_jobs'],
        'files': []
    }
    template.render(os.path.join(release_dir, 'blobs.yml'),
                    os.path.join(template_dir, 'blobs.yml'), release_context)
    template.render(os.path.join(release_dir, 'final.yml'),
                    os.path.join(template_dir, 'final.yml'), release_context)
Beispiel #21
0
def nominate_post():
	page = Page('/nominate', 'Nominate')
	if page not in pages:
		abort(404)
	current_user = process_cookie(request.get_cookie("login"))
	nominee_fields = config['nominee_fields']
	given_csrf_key = request.forms.get('csrf')
	
	if current_user is None:
		redirect('/login?message=3')

	if not csrf.check_csrf_key(current_user.userid, given_csrf_key):
		abort(403, "A potential CSRF attack was detected. "
			  "Please try again later.")
	
	if current_user.student_info is None:
		return template.render("home_redirect.html",
							   {'message': "<h1>Staff cannot nominate</h1>"})
	
	if not current_user.student_info.is_nominee and config['prenominate']:
		return template.render("home_redirect.html",
							   {'message': "<h1>You are not a candidate.</h1>"})
	
	nominee_fields = filter(
		lambda x: x['name'] not in current_user.student_info.nominee_fields,
		nominee_fields)

	if len(nominee_fields) == 0:
		return template.render("home_redirect.html",
							   {'message': """<h1>You have already
 submitted your nomination</h1>"""})

	truncated = False
	
	for field in nominee_fields:
		submission = request.forms.getunicode(field['name'])
		if len(submission) > field['character_limit']:
			truncated = True
			submission = submission[:650] + "...[truncated]"
		print "sub:", repr(submission)
		submissions.add_nominee_field(current_user.userid,
									  field['name'], submission)

	if not config['prenominate']:
		submissions.add_nominee(current_user.userid)
	
	return template.render("home_redirect.html",
						   {'message': "<h1>Submitted" +
							" (truncated)" if truncated else "" +
							"</h1>"})
Beispiel #22
0
def gen_packages(dir, context, alternate_template=None):
    packages_dir = os.path.realpath(os.path.join(dir))

    mkdir_p(packages_dir)
    template_dir = dir
    if alternate_template is not None:
        template_dir = os.path.join(template_dir, alternate_template)
    packages_context = {
        'context': context,
        'product': context['product'],
        #'managed_service_release_jobs': context['managed_service_release_jobs'],
        'files': []
    }

    template.render(os.path.join(packages_dir, 'apigee-mirror/packaging'),
                    os.path.join(template_dir, 'apigee-mirror/packaging'),
                    packages_context)
    template.render(os.path.join(packages_dir, 'apigee-mirror/spec'),
                    os.path.join(template_dir, 'apigee-mirror/spec'),
                    packages_context)
    template.render(os.path.join(packages_dir, 'component/spec'),
                    os.path.join(template_dir, 'component/spec'),
                    packages_context)
    template.render(os.path.join(packages_dir, 'component/packaging'),
                    os.path.join(template_dir, 'component/packaging'),
                    packages_context)
def add_lbr_to_nsx_edge_with_no_certs(nsx_edges_dir, nsx_edge):

    template_dir = '.'
    map_nsx_esg_id([nsx_edge])

    iso_zones = nsx_edge['iso_zones']
    app_profiles = nsx_edge['app_profiles']

    # Link the iso cert id against the corresponding app profiles,
    # if they are using any ssl/secure protocol and are associated
    # with Ert or IsoZone switches
    for app_profile in app_profiles:
        switch_name = app_profile.get('switch')
        app_profile_name = app_profile['name']

    nsx_edges_context = {
        'nsx_edge': nsx_edge,
        'app_profiles': app_profiles,
        'app_rules': nsx_edge['app_rules'],
        'monitor_list': nsx_edge['monitor_list'],
        'routed_components': nsx_edge['routed_components'],
        'files': []
    }

    template.render(
        os.path.join(nsx_edges_dir,
                     nsx_edge['name'] + '_lbr_config_put_payload.xml'),
        os.path.join(template_dir, 'edge_lbr_config_put_payload.xml'),
        nsx_edges_context)

    put_response = client.put_xml(
        NSX_URLS['esg']['all'] + '/' + nsx_edge['id'] +
        NSX_URLS['lbrConfig']['all'],
        os.path.join(nsx_edges_dir,
                     nsx_edge['name'] + '_lbr_config_put_payload.xml'),
        check=False)
    data = put_response.text

    if DEBUG:
        print('NSX Edge LBR Config Update response:{}\n'.format(data))

    if put_response.status_code < 400:
        print('Updated NSX Edge LBR Config for : {}\n'.format(
            nsx_edge['name']))
    else:
        print(
            'Update of NSX Edge LBR Config failed, details:{}\n'.format(data))
        raise Exception(
            'Update of NSX Edge LBR Config failed, details:\n {}'.format(data))
Beispiel #24
0
def add_package(dir, context, package, alternate_template=None):
    name = package['name'].lower().replace('-', '_')
    package['name'] = name
    bosh('generate', 'package', name)
    target_dir = os.path.realpath(os.path.join(dir, name))
    package_dir = os.path.realpath(os.path.join('packages', name))
    mkdir_p(target_dir)
    template_dir = 'packages'
    if alternate_template is not None:
        template_dir = os.path.join(template_dir, alternate_template)
    package_context = {'context': context, 'package': package, 'files': []}
    with cd('..'):
        files = package.get('files', [])
        path = package.get('path', None)
        if path is not None:
            files += [{'path': path}]
            package['path'] = os.path.basename(path)
        manifest = package.get('manifest', None)
        manifest_path = None
        if type(manifest) is dict:
            manifest_path = manifest.get('path', None)
        if manifest_path is not None:
            files += [{'path': manifest_path}]
            package['manifest']['path'] = os.path.basename(manifest_path)
        for file in files:
            filename = file.get('name', os.path.basename(file['path']))
            file['name'] = filename
            urllib.urlretrieve(file['path'],
                               os.path.join(target_dir, filename))
            package_context['files'] += [filename]
        for docker_image in package.get('docker_images', []):
            filename = docker_image.lower().replace('/', '-').replace(
                ':', '-') + '.tgz'
            download_docker_image(docker_image,
                                  os.path.join(target_dir, filename))
            package_context['files'] += [filename]
    if package.get('is_app', False):
        manifest = os.path.join(target_dir, 'manifest.yml')
        with open(manifest, 'wb') as f:
            f.write('---\n')
            f.write(
                yaml.safe_dump(package.get('manifest', {'name': name}),
                               default_flow_style=False))
        package_context['files'] += ['manifest.yml']
    template.render(os.path.join(package_dir, 'spec'),
                    os.path.join(template_dir, 'spec'), package_context)
    template.render(os.path.join(package_dir, 'packaging'),
                    os.path.join(template_dir, 'packaging'), package_context)
Beispiel #25
0
    def results(self, search_id):
        print "results"
        search_id = int(search_id)
        #TODO: this should be closed with the session timeout
        json_data = self.server_rpc.open_search_pager(search_id=search_id)
        pager_uuid = json_data["pager_uuid"]

        session = self.Session()

        try:
            user = cherrypy.session["user"]
            session.add(user)
            # note that we add in the customer id to verify the user is allowed
            # to edit the object
            search = session.query(Search)\
                    .filter(Search.id==search_id)\
                    .filter(Search.customer_id==user.customer_id).one()

            #            collectors = session.query(Collector)\
            #                    .filter(Collector.customer_id==user.customer_id)
            #            devices = session.query(Device)\
            #                    .filter(Device.customer_id==user.customer_id)

            return template.render(errors={}, search=search, \
                    search_type=search.query_type, \
                    query_types=self.QUERY_TYPES, \
                    pager_uuid=pager_uuid)

        finally:
            session.close()
Beispiel #26
0
    def get_render(self,template_file,values):
        if self.isPhone():
            template_file=os.path.join('m',template_file+".html")
        else:
            template_file=template_file+".html"
        self.template_vals.update(values)
        logging.info("-----------------")
        try:
            #sfile=getattr(self.blog.theme, template_file)
            logging.debug("get_render:"+template_file)
            html = micolog_template.render(self.blog.theme, template_file, self.template_vals,debug=settings.DEBUG)
        except TemplateDoesNotExist:
            #sfile=getattr(self.blog.default_theme, template_file)
            html = micolog_template.render(self.blog.default_theme, template_file, self.template_vals,debug=settings.DEBUG)

        return html
Beispiel #27
0
    def paginate(self, filename, page_meta):
        """Paginate the content in the file
        """
        log.info('Paginating page %s' % filename)
        for pgr in self.paginator:
            log.debug('Paginating: %s' % pgr)
            html = template.render(
                page_meta['raw'], 
                {'page': page_meta, 'paginator': pgr})
            if pgr.current_page == 1:
                paginator_path = os.path.join(self.config.site_dir,
                    filename.split(self.work_dir)[1][1:])
                log.debug('Generating page %s' % paginator_path)
                self.write_html(paginator_path, html)

            current_page = 'page%s' %pgr.current_page
            site_path, ext = os.path.splitext(
                filename.split(self.work_dir)[1][1:])
            if site_path == 'index': site_path = '';
            paginator_path = os.path.join(
                self.config.site_dir,
                site_path,
                current_page,
                'index.html')

            log.debug('Generating page %s' % paginator_path)
            # write the rendered page
            self.write_html(paginator_path, html)
Beispiel #28
0
	def responseClub(self, clubmodel, nickname):
		templateValues = dict(action=self.request.path, username=nickname, model=clubmodel)
		if (hasClubPrivilige(users.get_current_user(), clubmodel, "finance" )):
			templateValues['enableFinance'] = True
		if (clubmodel.is_saved()):
			templateValues['oldslug'] = clubmodel.slug
		self.response.out.write (render(self.template, templateValues, self.request.url) )
Beispiel #29
0
 def generate_sitemap(self, filename='sitemap.xml'):
     map_path = os.path.join(self.config.site_dir, filename)
     log.info('Generating sitemap at %s' % map_path)
     sitemap = template.render(
         SITE_MAP, 
         {'posts' : self.posts, 'pages' : self.pages})
     self.write_html(map_path, sitemap)
Beispiel #30
0
    def get(self):
        files = template.variable()
        tagQuery = self.request.get('tag')

        if (tagQuery):
            for f in File.all().ancestor(FILE_LIST).filter("tag =", tagQuery).order('-uploaded_at'):
                fileString =  '<li><a href="/download/%s">%s</a> Tags:' \
                                % (f.name, f.name)
                for t in f.tag:
                    fileString += '<a href="/list?tag=%s">%s</a>, ' \
                            % (t, t)
                print >>files, fileString
        else:               
            for f in File.all().ancestor(FILE_LIST).order('-uploaded_at'):
                fileString =  '<li><a href="/download/%s">%s</a> Tags:' \
                                % (f.name, f.name)
                for t in f.tag:
                    fileString += '<a href="/list?tag=%s">%s</a>, ' \
                                % (t, t)
                print >>files, fileString
                
        html = template.render(
            'list.html',
            {'file_list': files},
            escaped=False
        )
        self.response.write(html)
async def get_form(server, reader, writer, querystring, body):
    from times_utils import restore_timers, pformat_timers, get_active_days
    timers = pformat_timers(restore_timers())
    active_days = get_active_days()
    del restore_timers
    del pformat_timers
    del get_active_days
    del sys.modules['times_utils']
    gc.collect()

    context = {
        'timers': timers,
        'on_selected': 'selected' if server.context.power_timer_active else '',
        'off_selected':
        '' if server.context.power_timer_active else 'selected',
    }
    for day_no in range(7):
        context['d%i' % day_no] = 'checked' if day_no in active_days else ''

    from template import render
    await server.send_html_page(
        writer,
        filename='webswitch.html',
        content_iterator=render(filename='http_set_timer.html',
                                context=context,
                                content_iterator=None),
    )
Beispiel #32
0
def infoPage(response, title='', message='', redirect=''):
    vars = dict(title=title,
                pageTitle=title,
                message=message,
                redirect=redirect)
    response.out.write(render(InfoPageTempl, vars))
    return True
Beispiel #33
0
def error_development_handler(status, message, traceback, version):
    data = {
        'code': status,
        'reason': message,
        'call_stack': cherrypy._cperror.format_exc()
    }
    return template.render('error.html', data)
Beispiel #34
0
    def get(self):
        """Presents nice recent statistics.

    It fetches data from the 'JSON' API.
    """
        # Preloads the data to save a complete request.
        resolution = self.request.params.get('resolution', 'hours')
        if resolution not in ('days', 'hours', 'minutes'):
            resolution = 'hours'
        duration = utils.get_request_as_int(self.request, 'duration', 120, 1,
                                            1000)

        description = _GVIZ_DESCRIPTION.copy()
        description.update(
            stats_framework_gviz.get_description_key(resolution))
        table = stats_framework.get_stats(stats.STATS_HANDLER, resolution,
                                          None, duration, True)
        params = {
            'duration':
            duration,
            'initial_data':
            gviz_api.DataTable(
                description, table).ToJSon(columns_order=_GVIZ_COLUMNS_ORDER),
            'now':
            datetime.datetime.utcnow(),
            'resolution':
            resolution,
        }
        self.response.write(template.render('isolate/stats.html', params))
Beispiel #35
0
    def get(self):
        files = File.all().ancestor(FILE_LIST).order('-uploaded_at')

        tag = self.request.GET.get('tag')
        if tag:
            files = files.filter('tags =', tag)

        file_list = template.variable()
        for f in files:
            print >>file_list, '<tr>'
            print >>file_list, '<td><a href="/download/%s">%s</a></td>' \
                            % (f.name, f.name)
            print >>file_list, '<td>'
            for tag in f.tags:
                print >>file_list, '<a href="/list?tag=%s">%s</a>' \
                                % (tag, tag)
            print >>file_list, '</td>'
            print >>file_list, '</tr>'

        html = template.render(
            'list.html',
            {'file_list': file_list},
            escaped=False
        )
        self.response.write(html)
Beispiel #36
0
    def get(self, *path):
        root = cherrypy.request.app.config['video']['path']
        fullpath = os.path.join(root, *path)

        f = Item.create(root, path, path[-1])
        url = urllib.quote(os.path.join(*path).encode('utf-8'))

        refs = []
        for x in cherrypy.request.app.config['refs']:
            ref = x
            href = '#'
            try:
                href = cherrypy.request.app.config['refs'][x].format(id=f[x])
            except KeyError:
                pass
            refs.append((x, href))

        # meta data which is always visible
        meta = {
            'Genre': None,
            'Tags': None,
            'Year': None
        }

        return template.render(url=url, file=f, refs=refs, meta=meta)
Beispiel #37
0
def send_diff_by_email(cfg, module, revision, log, diff):
    logger = logging.getLogger(module)

    subscribers = cfg.get(MAIN_CONFIG_SECTION, OPT_SUBSCRIBERS)
    if cfg.has_option(module, OPT_SUBSCRIBERS):
        subscribers = cfg.get(module, OPT_SUBSCRIBERS)

    # create message
    context = {
        "revision": revision,
        "author": log.author_name,
        "timestamp": log.timestamp,
        "message": escape_html(log.message),
        "diff": escape_html(diff),
        "files": diffparser.get_files(diff, cfg.get(module, OPT_REPO))
    }
    
    msg_str = template.render(open(TEMPLATE_FILE, 'r').read(), context)
    
    # create email message
    from_domain = cfg.get(MAIN_CONFIG_SECTION, OPT_FROM_DOMAIN)
    from_addr = "%s@%s" % (log.author, from_domain)
    msg = MIMEText(msg_str, "html")
    msg['Subject'] = "[svn-diff for %s, r%d] %s" % (module, revision, log.message)
    msg['From'] = from_addr 
    msg['To'] = subscribers
    
    # connect to SMTP server and send message
    smtp_server = cfg.get(MAIN_CONFIG_SECTION, OPT_SMTPSERVER)
    logger.info("Sending mail to %s through %s from %s" , subscribers, smtp_server, from_addr)
    s = smtplib.SMTP(smtp_server)
    #s.connect()
    s.sendmail(from_addr, subscribers.split(','), msg.as_string(False))
    s.close()
Beispiel #38
0
    def new(self, **data):
        if cherrypy.request.method == "POST":
            return self.submit_new(data)

        cherrypy.session["sr"] = ServiceRequest()

        return template.render(errors={})
Beispiel #39
0
    def send_response(self, res_type_info):
        """Presents nice recent statistics.

    It preloads data in the template for maximum responsiveness and
    interactively fetches data from the JSON API.
    """
        # Preloads the data to save a complete request.
        resolution = self.request.params.get('resolution', 'hours')
        if resolution not in stats_framework.RESOLUTIONS:
            self.abort(404)
        duration = utils.get_request_as_int(self.request,
                                            'duration',
                                            default=120,
                                            min_value=1,
                                            max_value=1000)
        now = utils.get_request_as_datetime(self.request, 'now')
        now = now or datetime.datetime.utcnow()

        description = res_type_info.DESCRIPTION.copy()
        description.update(
            stats_framework_gviz.get_description_key(resolution))
        stats_data = stats_framework.get_stats(stats.STATS_HANDLER, resolution,
                                               now, duration, False)
        template_data = self.process_data(description, stats_data)
        template_data['duration'] = duration
        template_data['now'] = now
        template_data['resolution'] = resolution
        self.response.write(
            template.render(res_type_info.TEMPLATE, template_data))
Beispiel #40
0
async def get_show(server, reader, writer, querystring, body):
    from template import render
    from rtc import get_dict_from_rtc

    uname = uos.uname()

    template_context = {
        'rtc_memory': repr(get_dict_from_rtc()),
        'sysname': uname.sysname,
        'nodename': uname.nodename,
        'id':
        ':'.join(['%02x' % char for char in reversed(machine.unique_id())]),
        'machine': uname.machine,
        'release': uname.release,
        'mpy_version': uname.version,
        'sys_modules': ', '.join(sorted(sys.modules.keys())),
        'minimal_modules': ', '.join(server.context.minimal_modules)
    }

    for attr_name in dir(server.context):
        if attr_name.startswith('_'):
            continue
        value = str(getattr(server.context, attr_name))
        print(attr_name, value)

        template_context[attr_name] = value

    await server.send_html_page(
        writer,
        filename='webswitch.html',
        content_iterator=render(filename='http_internals.html',
                                context=template_context,
                                content_iterator=None),
    )
Beispiel #41
0
    def paginate(self, filename, page_meta):
        """Paginate the content in the file
        """
        log.info('Paginating page %s' % filename)
        for pgr in self.paginator:
            log.debug('Paginating: %s' % pgr)
            html = template.render(page_meta['raw'], {
                'page': page_meta,
                'paginator': pgr
            })
            if pgr.current_page == 1:
                paginator_path = os.path.join(
                    self.config.site_dir,
                    filename.split(self.work_dir)[1][1:])
                log.debug('Generating page %s' % paginator_path)
                self.write_html(paginator_path, html)

            current_page = 'page%s' % pgr.current_page
            site_path, ext = os.path.splitext(
                filename.split(self.work_dir)[1][1:])
            if site_path == 'index':
                site_path = ''
            paginator_path = os.path.join(self.config.site_dir, site_path,
                                          current_page, 'index.html')

            log.debug('Generating page %s' % paginator_path)
            # write the rendered page
            self.write_html(paginator_path, html)
Beispiel #42
0
def gen_jobs(dir, context, alternate_template=None):
    jobs_dir = os.path.realpath(os.path.join(dir))

    template_dir = dir
    jobs_context = {
        'context': context,
        'product': context['product'],
        #'managed_service_release_jobs': context['managed_service_release_jobs'],
        'files': []
    }
    template.render(
        os.path.join(jobs_dir, context['product']['name'] + '/monit'),
        os.path.join(template_dir, 'service-adapter/monit'), jobs_context)
    template.render(
        os.path.join(jobs_dir, context['product']['name'] + '/spec'),
        os.path.join(template_dir, 'service-adapter/spec'), jobs_context)
Beispiel #43
0
    def get(self):
        limit = int(self.request.get('limit', 100))
        cursor = datastore_query.Cursor(urlsafe=self.request.get('cursor'))
        sort_by = self.request.get('sort_by', '__key__')
        if sort_by not in self.ACCEPTABLE_BOTS_SORTS:
            self.abort(400, 'Invalid sort_by query parameter')

        if sort_by[0] == '-':
            order = datastore_query.PropertyOrder(
                sort_by[1:], datastore_query.PropertyOrder.DESCENDING)
        else:
            order = datastore_query.PropertyOrder(
                sort_by, datastore_query.PropertyOrder.ASCENDING)

        now = utils.utcnow()
        cutoff = now - datetime.timedelta(
            seconds=config.settings().bot_death_timeout_secs)

        num_bots_busy_future = bot_management.BotInfo.query(
            bot_management.BotInfo.is_busy == True).count_async()
        num_bots_dead_future = bot_management.BotInfo.query(
            bot_management.BotInfo.last_seen_ts < cutoff).count_async()
        num_bots_quarantined_future = bot_management.BotInfo.query(
            bot_management.BotInfo.quarantined == True).count_async()
        num_bots_total_future = bot_management.BotInfo.query().count_async()
        fetch_future = bot_management.BotInfo.query().order(
            order).fetch_page_async(limit, start_cursor=cursor)

        # TODO(maruel): self.request.host_url should be the default AppEngine url
        # version and not the current one. It is only an issue when
        # version-dot-appid.appspot.com urls are used to access this page.
        version = bot_code.get_bot_version(self.request.host_url)
        bots, cursor, more = fetch_future.get_result()
        # Prefetch the tasks. We don't actually use the value here, it'll be
        # implicitly used by ndb local's cache when refetched by the html template.
        tasks = filter(None, (b.task for b in bots))
        ndb.get_multi(tasks)
        num_bots_busy = num_bots_busy_future.get_result()
        num_bots_dead = num_bots_dead_future.get_result()
        num_bots_quarantined = num_bots_quarantined_future.get_result()
        num_bots_total = num_bots_total_future.get_result()
        params = {
            'bots': bots,
            'current_version': version,
            'cursor': cursor.urlsafe() if cursor and more else '',
            'is_admin': acl.is_admin(),
            'is_privileged_user': acl.is_privileged_user(),
            'limit': limit,
            'now': now,
            'num_bots_alive': num_bots_total - num_bots_dead,
            'num_bots_busy': num_bots_busy,
            'num_bots_dead': num_bots_dead,
            'num_bots_quarantined': num_bots_quarantined,
            'sort_by': sort_by,
            'sort_options': self.SORT_OPTIONS,
            'xsrf_token': self.generate_xsrf_token(),
        }
        self.response.write(
            template.render('swarming/restricted_botslist.html', params))
Beispiel #44
0
  def get(self):
    limit = int(self.request.get('limit', 100))
    cursor = datastore_query.Cursor(urlsafe=self.request.get('cursor'))
    sort_by = self.request.get('sort_by', '__key__')
    if sort_by not in self.ACCEPTABLE_BOTS_SORTS:
      self.abort(400, 'Invalid sort_by query parameter')

    if sort_by[0] == '-':
      order = datastore_query.PropertyOrder(
          sort_by[1:], datastore_query.PropertyOrder.DESCENDING)
    else:
      order = datastore_query.PropertyOrder(
          sort_by, datastore_query.PropertyOrder.ASCENDING)

    now = utils.utcnow()
    cutoff = now - datetime.timedelta(
        seconds=config.settings().bot_death_timeout_secs)

    num_bots_busy_future = bot_management.BotInfo.query(
        bot_management.BotInfo.is_busy == True).count_async()
    num_bots_dead_future = bot_management.BotInfo.query(
        bot_management.BotInfo.last_seen_ts < cutoff).count_async()
    num_bots_quarantined_future = bot_management.BotInfo.query(
        bot_management.BotInfo.quarantined == True).count_async()
    num_bots_total_future = bot_management.BotInfo.query().count_async()
    fetch_future = bot_management.BotInfo.query().order(order).fetch_page_async(
        limit, start_cursor=cursor)

    # TODO(maruel): self.request.host_url should be the default AppEngine url
    # version and not the current one. It is only an issue when
    # version-dot-appid.appspot.com urls are used to access this page.
    version = bot_code.get_bot_version(self.request.host_url)
    bots, cursor, more = fetch_future.get_result()
    # Prefetch the tasks. We don't actually use the value here, it'll be
    # implicitly used by ndb local's cache when refetched by the html template.
    tasks = filter(None, (b.task for b in bots))
    ndb.get_multi(tasks)
    num_bots_busy = num_bots_busy_future.get_result()
    num_bots_dead = num_bots_dead_future.get_result()
    num_bots_quarantined = num_bots_quarantined_future.get_result()
    num_bots_total = num_bots_total_future.get_result()
    params = {
      'bots': bots,
      'current_version': version,
      'cursor': cursor.urlsafe() if cursor and more else '',
      'is_admin': acl.is_admin(),
      'is_privileged_user': acl.is_privileged_user(),
      'limit': limit,
      'now': now,
      'num_bots_alive': num_bots_total - num_bots_dead,
      'num_bots_busy': num_bots_busy,
      'num_bots_dead': num_bots_dead,
      'num_bots_quarantined': num_bots_quarantined,
      'sort_by': sort_by,
      'sort_options': self.SORT_OPTIONS,
      'xsrf_token': self.generate_xsrf_token(),
    }
    self.response.write(
        template.render('swarming/restricted_botslist.html', params))
Beispiel #45
0
	def get(self, *args):
		if (self.initRequest()):
			currentPriv = self.target.privilige
			tempvars = dict (membership = self.target, 
							operator = self.user, 
							operations = clubOperations,
							currentPriv = currentPriv)
			self.response.out.write (render (self.template, tempvars))
Beispiel #46
0
 def common(self, note):
     params = {
         "cfg": config.settings(fresh=True),
         "note": note,
         "path": self.request.path,
         "xsrf_token": self.generate_xsrf_token(),
     }
     self.response.write(template.render("swarming/restricted_config.html", params))
Beispiel #47
0
 def get(self, *args):
     if (self.initRequest()):
         currentPriv = self.target.privilige
         tempvars = dict(membership=self.target,
                         operator=self.user,
                         operations=clubOperations,
                         currentPriv=currentPriv)
         self.response.out.write(render(self.template, tempvars))
Beispiel #48
0
 def generate_feed(self, filename='atom.xml'):
     """Generate Atom feed
     """
     feed_path = os.path.join(self.config.site_dir, filename)
     feed = template.render(FEED_TEMPLATE)
     feed_path = self.get_page_name_for_site(feed_path)
     log.info('Generating Atom feed at %s' % feed_path)
     self.write_html(feed_path, feed)
Beispiel #49
0
 def generate_sitemap(self, filename='sitemap.xml'):
     map_path = os.path.join(self.config.site_dir, filename)
     log.info('Generating sitemap at %s' % map_path)
     sitemap = template.render(SITE_MAP, {
         'posts': self.posts,
         'pages': self.pages
     })
     self.write_html(map_path, sitemap)
Beispiel #50
0
 def generate_feed(self, filename='atom.xml'):
     """Generate Atom feed
     """
     feed_path = os.path.join(self.config.site_dir, filename)
     feed = template.render(FEED_TEMPLATE)
     feed_path = self.get_page_name_for_site(feed_path)
     log.info('Generating Atom feed at %s' % feed_path)
     self.write_html(feed_path, feed)
Beispiel #51
0
 def act(self, handler):
     file_list = os.listdir(handler.full_path)
     file_list_html = '\n'.join([
         '<li><a href="{}">{}</a></li>'.format(
             '/'.join([handler.full_path.rstrip('/'), _]), _)
         for _ in file_list
     ])
     handler.send_content(
         template.render("list_dir.html", lists=file_list_html))
Beispiel #52
0
 def get(self):
   namespace = self.request.get('namespace', 'default')
   hash_value = self.request.get('hash', '')
   params = {
     'hash_value': hash_value,
     'namespace': namespace,
     'onload': 'update()' if hash_value else '',
   }
   self.response.write(template.render('isolate/browse.html', params))
Beispiel #53
0
def test_1():
    test_template = {'text': "This is %s, this is only %s, if this was %s they would have given us %s.",
                     'parameters': ['what_this_is', 'what_this_is', 'what_this_is_not', 'what_they_would_have_given_us_otherwise']}
    test_data = {'what_this_is': {'text': 'a test'},
                 'what_this_is_not': {'text': 'real life'},
                 'what_they_would_have_given_us_otherwise': {'var': 'the_other_option'}}
    test_state = {'the_other_option': 'instructions on where to go and what to do'}
    output = render(test_template, test_data, test_state)
    assert output == "This is a test, this is only a test, if this was real life they would have given us instructions on where to go and what to do."
Beispiel #54
0
def login_get():
	page = Page('/login', 'Login')
	current_user = process_cookie(request.get_cookie("login"))
	
	if current_user is not None:
		return template.render("home_redirect.html",
							   {'message': "<h1>You are already logged in</h1>"})

	message = request.query.get('message')
	try:
		message = int(message)
	except:
		message = 0
	
	return template.render("login.html", {'config': config,
										  'pages': pages, 'page': page,
										  'valid': message,
										  'user': current_user})
Beispiel #55
0
 def get(self):
     template_values = {
                        "time":time.asctime(), "robocmd":self.request.get("command")
         }
     deletecommand()
     e = Command(command=self.request.get("command"))
     path = os.path.join(os.path.dirname(__file__), 'Commands.html')
     e.put()
     self.response.out.write(template.render(path, template_values))
Beispiel #56
0
 def common(self, note):
   params = {
     'cfg': config.settings(fresh=True),
     'note': note,
     'path': self.request.path,
     'xsrf_token': self.generate_xsrf_token(),
   }
   self.response.write(
       template.render('swarming/restricted_config.html', params))
Beispiel #57
0
 def common(self, note):
     params = config.settings_info()
     params.update({
         'note': note,
         'path': self.request.path,
         'xsrf_token': self.generate_xsrf_token(),
     })
     self.response.write(
         template.render('isolate/restricted_config.html', params))
Beispiel #58
0
 def get(self):
     params = {
         'digest': '',
         'message': '',
         'namespace': '',
         'xsrf_token': self.generate_xsrf_token(),
     }
     self.response.write(
         template.render('isolate/restricted_purge.html', params))
Beispiel #59
0
def create_bosh_release(context):
	target = os.getcwd()
	bosh('init', 'release')
	template.render('src/templates/all_open.json', 'src/templates/all_open.json', context)
	template.render('config/final.yml', 'config/final.yml', context)
	packages = context.get('packages', [])
	requires_cf_cli = False
	requires_docker_bosh = False
	for package in packages:
		typename = package.get('type', None)
		if typename is None:
			print >>sys.stderr, 'Package', package['name'], 'does not have a type'
			sys.exit(1)
		typedef = ([ t for t in package_types if t['typename'] == typename ] + [ None ])[0]
		if typedef is None:
			print >>sys.stderr, 'Package', package['name'], 'has unknown type', typename
			print >>sys.stderr, 'Valid types are:', ', '.join([ t['typename'] for t in package_types])
			sys.exit(1)
		if 'is_docker' not in typedef['flags']:
			add_blob_package(context, package)
		for flag in typedef['flags']:
			package[flag] = True
		for job in typedef['jobs']:
			add_bosh_job(
				context,
				package,
				job.lstrip('+-'),
				post_deploy=job.startswith('+'),
				pre_delete=job.startswith('-')
			)
		requires_cf_cli |= package.get('requires_cf_cli', False)
		requires_docker_bosh |= package.get('requires_docker_bosh', False)
	if requires_cf_cli:
		add_cf_cli(context)
	bosh('upload', 'blobs')
	output = bosh('create', 'release', '--force', '--final', '--with-tarball', '--version', context['version'])
	context['release'] = bosh_extract(output, [
		{ 'label': 'name', 'pattern': 'Release name' },
		{ 'label': 'version', 'pattern': 'Release version' },
		{ 'label': 'manifest', 'pattern': 'Release manifest' },
		{ 'label': 'tarball', 'pattern': 'Release tarball' },
	])
	context['requires_docker_bosh'] = requires_docker_bosh;
	print