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))
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})
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})
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})
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
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 )
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)
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 }]
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)
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>"})
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
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)
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 )
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)
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})
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
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='{{="<&>"}}'), "<&>") 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))
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)
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>"})
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))
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)
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()
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
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)
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) )
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)
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), )
def infoPage(response, title='', message='', redirect=''): vars = dict(title=title, pageTitle=title, message=message, redirect=redirect) response.out.write(render(InfoPageTempl, vars)) return True
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)
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))
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)
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)
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()
def new(self, **data): if cherrypy.request.method == "POST": return self.submit_new(data) cherrypy.session["sr"] = ServiceRequest() return template.render(errors={})
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))
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), )
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)
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)
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))
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))
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))
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))
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))
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)
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)
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))
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))
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."
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})
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))
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))
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))
def get(self): params = { 'digest': '', 'message': '', 'namespace': '', 'xsrf_token': self.generate_xsrf_token(), } self.response.write( template.render('isolate/restricted_purge.html', params))
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