def render_tracks(assembly, mode, metadata_file): obj = yaml.load(metadata_file) # Just pull out the assembly ones if mode == 'preferences': generate_track_dict = generate_preferences_track_dict else: generate_track_dict = generate_predictions_track_dict tracks = [generate_track_dict(x) for x in obj if x['assembly'] == assembly] trackdb = {'tracks': tracks} render_template(trackdb, 'trackDb')
def GET(self): ''' Method:post ''' try: log.info("Dashboard:Get") render.render_template("layout.tmpl") except Exception, e: log.error(e) return HTTPAdaptor.format_response("error", "Request processing failed.")
def get_service_list_json( task_definition_template_dir, task_definition_config, task_definition_config_env ) -> list: service_list = [] files = os.listdir(task_definition_template_dir) for file in files: file_path = os.path.join(task_definition_template_dir, file) try: with open(file_path, 'r') as template: task_definitions_data = render.render_template(template.read(), task_definition_config, task_definition_config_env) except Exception as e: raise Exception("Template error. file: %s\n%s" % (file, e)) try: task_definitions = json.loads(task_definitions_data) except json.decoder.JSONDecodeError as e: raise Exception("{e.__class__.__name__} {e}\njson:\n{json}".format(e=e, json=task_definitions_data)) for t in task_definitions: service_list.append(Service(task_definition=t, stop_before_deploy=False, primary_placement=False)) return service_list
def test_templates(args): h1("Step: Check ECS Template") environment = None files = os.listdir(args.environment_yaml_dir) if files is None or len(files) == 0: raise Exception("environment yaml file not found.") services_config = yaml.load(args.services_yaml) for f in files: file_path = os.path.join(args.environment_yaml_dir, f) if os.path.isfile(file_path): with open(file_path, 'r') as environment_yaml: environment_config = yaml.load(environment_yaml.read()) environment = environment_config.get("environment") if environment is None: raise VariableNotFoundException("%s requires parameter `environment`." % file_path) environment = render.render_template( str(environment), environment_config, args.task_definition_config_env ) ecs.service.get_service_list_yaml( services_config=services_config, environment_config=environment_config, is_task_definition_config_env=args.task_definition_config_env, environment=environment ) get_scheduled_task_list( services_config=services_config, environment_config=environment_config, is_task_definition_config_env=args.task_definition_config_env, environment=environment ) success("Template check environment `{environment}` done.".format(environment=environment))
def wrapper(request, *args, **kwargs): module_name = get_template_app_folder(func.__module__) response = func(request, *args, **kwargs) if isinstance(response, HttpResponse): return response template_name, context_processors, mimetype = process_response( response, func.__name__) if prefix: if isinstance(template_name, (list, tuple)): template_name = map(correct_path, template_name) else: template_name = correct_path(template_name, prefix) else: template_name = correct_path(template_name, module_name) context_processors['App'] = module_name context_processors['View'] = func.__name__ context_processors['Layout'] = correct_path('base.html', prefix or module_name) return render_template(template_name, context_processors, context_instance=RequestContext(request), mimetype=mimetype)
def get_variables(deploy_name: str, name: str, base_service_config: dict, environment_config: dict, is_task_definition_config_env: bool): variables = {"item": name} service_config = {} # ベースの値を取得 variables.update(base_service_config) service_config.update(base_service_config) # ベースのvars base_vars = base_service_config.get("vars") if base_vars: variables.update(base_vars) # 各環境の設定値を取得 variables.update(environment_config) # 各環境の設定を取得 environment_config_services = environment_config.get(deploy_name) if environment_config_services: environment_service = environment_config_services.get(name) if environment_service: variables.update(environment_service) service_config.update(environment_service) environment_vars = environment_service.get("vars") if environment_vars: variables.update(environment_vars) # varsをrenderする vars_renderd = render.render_template(yaml.dump(variables), variables, is_task_definition_config_env) variables.update(yaml.load(vars_renderd)) return service_config, variables
def POST(self): ''' Method:post ''' try: log.info("CI:Post") query = HTTPAdaptor.format_query(web.ctx.env["QUERY_STRING"]) body = HTTPAdaptor.format_form_data(web.data()) if not (query.has_key("action") and query.has_key("commit_id")): raise "Invalid query string" commit_id = query["commit_id"] sopt = SQLAdaptor() if query["action"] == "Revoke": sopt.SetCommitStatus(commit_id, 6) elif query["action"] == "Ignore": sopt.SetCommitStatus(commit_id, 5) author = "mxu" request_num = sopt.GetUnprocessedRequest(author) request_url = "/".join([config.server["cvproxy"],"myunprocessedrequests"]) author_info = {"name":author, "request_url":request_url, "request_num":request_num} dashboard_url = "/".join([config.server["cvproxy"], "dashboard"]) navi = [ {"name":"Dashboard", "url":dashboard_url, "theme":"unselected" }, {"name":"Current review request", "url":"#", "theme":"selected" } ] result = { "category": body["category"], "comment": body["comment"], "choice": query["action"] } sopt.InsertActionInfo(commit_id, author, query["action"], body["category"], body["comment"]) return render.render_template('current_review_result.tmpl', author = author_info, navi = navi, commit_id = commit_id, result = result ) except Exception, e: log.error(e) return HTTPAdaptor.format_response("error", "Request processing failed.")
def get_deploy_list( services_yaml, environment_yaml, task_definition_template_dir, task_definition_config_json, task_definition_config_env, deploy_service_group, template_group ): h1("Step: Check ECS Template") scheduled_task_list = [] deploy_scheduled_task_list = [] if services_yaml: services_config = yaml.load(services_yaml) environment_config = yaml.load(environment_yaml) environment = environment_config.get("environment") if environment is None: raise VariableNotFoundException("environment-yaml requires parameter `environment`.") environment = render.render_template(str(environment), environment_config, task_definition_config_env) service_list = ecs.service.get_service_list_yaml( services_config=services_config, environment_config=environment_config, is_task_definition_config_env=task_definition_config_env, environment=environment ) scheduled_task_list = get_scheduled_task_list( services_config=services_config, environment_config=environment_config, is_task_definition_config_env=task_definition_config_env, environment=environment ) deploy_scheduled_task_list = get_deploy_scheduled_task_list( scheduled_task_list, deploy_service_group, template_group) else: task_definition_config = json.load(task_definition_config_json) environment = task_definition_config['environment'] service_list = ecs.service.get_service_list_json( task_definition_template_dir=task_definition_template_dir, task_definition_config=task_definition_config, task_definition_config_env=task_definition_config_env ) deploy_service_list = ecs.service.get_deploy_service_list(service_list, deploy_service_group, template_group) # duplicate name check for deploy_service in deploy_service_list: for deploy_scheduled_task in deploy_scheduled_task_list: if deploy_service.family == deploy_scheduled_task.family: raise Exception('Duplicate family name `{family}` found.'.format(family=deploy_service.family)) if len(deploy_service_list) == 0 and len(deploy_scheduled_task_list) == 0: error("Deployment target not found.") sys.exit(1) success("Template check environment `{environment}` done.".format(environment=environment)) return service_list, deploy_service_list, scheduled_task_list, deploy_scheduled_task_list, environment
def GET(self): ''' Method:get ''' try: log.info("CI:Get") query = HTTPAdaptor.format_query(web.ctx.env["QUERY_STRING"]) if not (query.has_key("action") and query.has_key("commit_id")): raise "Invalid query string" sopt = SQLAdaptor() author = "mxu" commit_id = query["commit_id"] sopt.SetCommitStatus(commit_id, 6) request_num = sopt.GetUnprocessedRequest(author) request_url = "/".join( [config.server["cvproxy"], "myunprocessedrequests"]) author_info = { "name": author, "request_url": request_url, "request_num": request_num } dashboard_url = "/".join([config.server["cvproxy"], "dashboard"]) navi = [{ "name": "Dashboard", "url": dashboard_url, "theme": "unselected" }, { "name": "Current review request", "url": "#", "theme": "selected" }] sopt.InsertActionInfo(commit_id, query["action"], author, comment) result = { "category": "An issue", "comment": "Haha!", "choice": query["action"] } return render.render_template('current_review_result.tmpl', author=author_info, navi=navi, commit_id=commit_id, result=result) except Exception, e: log.error(e) return HTTPAdaptor.format_response("error", "Request processing failed.")
def chat_groupchats(request, **kwargs): query = request.query count_str = query.get('count', [0])[0] count = try_to_int(count_str, null=0) kwargs.update(count=count) user = request.auth_get_user() chats = db.get_chats_by_user(user.id, limit=count) kwargs.update(chats=chats) return render_template(request, 'templates/chat/groupchats.html', kwargs=kwargs)
def my_error(request, message=None, is_ajax=False): code = request.response.code if message is None: message = request.responses.get(code, ("other", "Another ERROR")) kwargs = { 'code': code, 'message': message, 'code_span': gen_code(code), 'base_vars': { 'title': 'ERROR' } } if is_ajax: ajax_dict = { 'html': render_template(request, 'shared/Error.html', kwargs=kwargs), 'title': 'Error' } return json.dumps(ajax_dict) else: return render_template(request, 'shared/Error.html', kwargs=kwargs)
def render_to_response(self, context, **response_kwargs): """ Returns a response with a template rendered with the given context. """ context['App'] = get_template_app_folder(self.__module__) context['View'] = self.__class__.__name__.lower() context['Layout'] = correct_path('base.html', context['App']) return render_template( response_kwargs.pop('template', self.get_template_names()), context_processors=context, context_instance=RequestContext(self.request), **response_kwargs )
def index(request, response): if request.method == "POST": url = request.POST.get('url') email = request.POST.get('email') # song = Song(link=url) # session.add(song) # session.commit() create_query(url, email) download.delay(url, email) response.text = "Вам будет отправлено письмо на email" return response data = render_template("index.html") response.text = data return response
def manage_edit_password_POST(request, **kwargs): data = request.POST_query old_password, new_password, confirm_password = data["old_password"][0].strip(), data["new_password"][0].strip(), \ data["confirm_password"][0].strip() user = request.auth_get_user() print(old_password, new_password, confirm_password) if not old_password or not new_password or not confirm_password or \ new_password != confirm_password or not equal_passhash(user.password, old_password): kwargs.setdefault('message', 'bad password') return render_template(request, 'templates/auth/manage/edit_password.html', kwargs=kwargss) pass_hex = convert_pass_to_passhash(new_password) db.update_user(user.id, password=pass_hex) return redirect_to(request, '/auth/manage/index/')
def chat_enjoy(request, **kwargs): query = request.query chat_id = query.get2('chat_id') if chat_id is None or try_to_int(chat_id) is None: request.response.code = 444 return my_error(request, message=("chat", "chat not found")) user = request.auth_get_user() # chat = db.get_chats_by_user(user_id=user.id, chat_id=chat_id, is_users=True) chat = db.find_chat({'id': chat_id}, is_users=True) if chat is None: request.response.code = 444 return my_error(request, message=("chat", "chat not found")) elif any(u.id == user.id for u in chat.users): request.response.code = 444 return my_error(request, message=("chat", "chat has user")) return render_template(request, 'templates/chat/enjoychat.html', kwargs={'chat':chat})
def chat(request): query = request.query # chat_id, chat_password = request.query_get('chat_id'), request.query_get('chat_id') chat_id = query.get2('chat_id') if chat_id is None or try_to_int(chat_id) is None: request.response.code = 404 return my_error(request, message=("chat", "bad chat_id")) # return redirect_to(request, '/') chat = db.find_chat({'id': chat_id}) if chat is None: request.response.code = 404 return my_error(request, message=("chat", "chat not found")) user = request.auth_get_user() chat = db.get_chats_by_user(user_id=user.id, chat_id=chat_id) if chat is None: return redirect_to(request, f'/chat/enjoy_chat?chat_id={chat_id}') kwargs = {} return render_template(request, 'templates/chat/chat.html', kwargs=kwargs)
def myauth_register_POST(request): data = request.POST_query login, password, nickname, photodata = data.get2('login'), data.get2('password'), data.get2('nickname'), \ data.get2('photodata', '') ajax_json = {} user = find_user(login=login) if user is None: photopath = save_photo(photodata) pass_hex = convert_pass_to_passhash(password) user_id = create_user(login, pass_hex, nickname, photopath) session_hash, user_id = create_session(request, login, user_id) request.auth_is = True request.auth_session = db.find_session(user_id, session_hash) ajax_json.update(header_right=render_template( request, 'shared/render_header-right.html', kwargs={'auth': True}), redirect=True, newurl='/') redirect_to(request, is_manual=True) return json.dumps(ajax_json) else: pass ajax_json.update(message='Bad request') return json.dumps(ajax_json)
def myauth_login_POST(request): data = request.POST_query login, password = data["login"][0], data["password"][0] ajax_json = {} user = find_user(login=login) if user is not None: if equal_passhash(user.password, password): session_hash, user_id = create_session(request, user.login, user.id) request.auth_is = True request.auth_session = db.find_session(user_id, session_hash) ajax_json.update(header_right=render_template( request, 'shared/render_header-right.html', kwargs={'auth': True}), redirect=True, newurl='/') redirect_to(request, is_manual=True) return json.dumps(ajax_json) else: pass ajax_json.update(message='Bad request') return json.dumps(ajax_json)
def myauth(request, **kwargs): kwargs.setdefault('message', '') return render_template(request, 'templates/auth/register.html', kwargs=kwargs)
def list_product_content(request, product_id): company_info = CompanyInfo.objects.get(id=1) products = Product.objects.filter(is_valid=1).values("name", "id") product_info = Product.objects.get(is_valid=1, id=product_id) return render_template("product_page.html", **locals())
def GET(self): ''' Method:get ''' try: log.info("CI:Get") query = HTTPAdaptor.format_query(web.ctx.env["QUERY_STRING"]) if not (query.has_key("author") and query.has_key("commit_id") and query.has_key("token")): raise InvalidQueryStringError author = query.get("author") commit_id = query.get("commit_id") token = query.get("token") # if not utils.validate_token( author = author, commit_id = commit_id, url = config.server["cvproxy"],token = token): # raise AuthenticationError sopt = SQLAdaptor() request_num = sopt.GetUnprocessedRequest(author) request_url = "/".join( [config.server["cvproxy"], "myunprocessedrequests"]) author_info = { "name": author, "request_url": request_url, "request_num": request_num } dashboard_url = "/".join([config.server["cvproxy"], "dashboard"]) navi = [ # {"name":"Dashboard", # "url":dashboard_url, # "theme":"unselected" # }, { "name": "Current review request", "url": "#", "theme": "selected" } ] url = { "ignore": { "absolute": "/".join([ config.server["cvproxy"], "submitaction?action=ignore&commit_id=%s" % commit_id ]), "relative": "submitaction?action=Ignore&commit_id=%s" % commit_id }, "revoke": { "absolute": "/".join([ config.server["cvproxy"], "submitaction?action=revoke&commit_id=%s" % commit_id ]), "relative": "submitaction?action=Revoke&commit_id=%s" % commit_id } } cijob = sopt.GetJobNameByCommit(commit_id) files_committed = sopt.GetCommitedFilesNum(commit_id) downstreamjobs = sopt.GetDownstreamJobs(cijob) if downstreamjobs: project_info = sopt.GetProjectInfo(downstreamjobs[0]) test_info = sopt.GetTestSummary(downstreamjobs) results, failed_jobs = sopt.GetTestResult(downstreamjobs) else: project_info = sopt.GetProjectInfo(cijob) test_info = sopt.GetTestSummary([cijob]) results, failed_jobs = sopt.GetTestResult([cijob]) log.debug("downstream jobs: %s" % downstreamjobs) log.debug("project_info: %s" % project_info) log.debug("test_info: %s" % test_info) info = { "product": project_info["product"], "platform": project_info["platform"], "version": project_info["version"], "files_committed": files_committed, "tests_executed": test_info["tests"], "failures": test_info["failures"] } ci_url = config.ciserver["urlprefix"] jobs = [] jobs.append({ "jobpage": "/".join([ci_url, cijob[0]]), "name": cijob[0], "overview": "/".join([ci_url, cijob[0], cijob[1]]), "console": "/".join([ci_url, cijob[0], cijob[1], "console"]), "workspace": "/".join([ci_url, cijob[0], "ws"]), "testresult": "/".join([ci_url, cijob[0], cijob[1], "TestReport/?"]), "logs": "/".join([ci_url, cijob[0], cijob[1], "artifact/logs"]), "results": results, "failed_jobs": opts.FormatFailedJobs(failed_jobs) }) categories = sopt.GetCategory() diff_list = sopt.GetDiffSetByCommit(commit_id) codes = opts.FormatDiffs(diff_list) return render.render_template('current_review_request.tmpl', author=author_info, navi=navi, url=url, commit_id=commit_id, info=info, categories=categories, jobs=jobs, codes=codes) except Exception, e: log.error(e) return HTTPAdaptor.format_response("error", "Request processing failed.")
def slides(num): md_file = 'lesson-{}/index.md'.format(num) return render_template('slides.html', doc=get_doc(md_file))
def get_service_list_yaml( services_config: dict, environment_config: dict, is_task_definition_config_env: bool, environment: str ) -> list: try: services = services_config["services"] except KeyError: return [] task_definition_template_dict = services_config["taskDefinitionTemplates"] service_list = [] service_name_list = [] for service_name in services: if service_name in service_name_list: raise Exception("'%s' is duplicate service." % service_name) service_name_list.append(service_name) # 設定値と変数を取得 service_config, variables = get_variables( deploy_name = 'services', name=service_name, base_service_config=services.get(service_name), environment_config=environment_config, is_task_definition_config_env=is_task_definition_config_env ) # parameter check & build docker environment env = [{"name": "ENVIRONMENT", "value": environment}] registrator = service_config.get("registrator") if registrator is not None: registrator = render.render_template(str(registrator), variables, is_task_definition_config_env) try: registrator = bool(strtobool(registrator)) except ValueError: raise ParameterInvalidException( "Service `{service_name}` parameter `registrator` must be bool".format(service_name=service_name) ) if registrator: env.append({"name": "SERVICE_NAME", "value": environment}) env.append({"name": "SERVICE_TAGS", "value": service_name}) cluster = service_config.get("cluster") if cluster is None: raise ParameterNotFoundException("Service `{service_name}` requires parameter `cluster`" .format(service_name=service_name)) cluster = render.render_template(str(cluster), variables, is_task_definition_config_env) env.append({"name": "CLUSTER_NAME", "value": cluster}) service_group = service_config.get("serviceGroup") if service_group is not None: service_group = render.render_template(str(service_group), variables, is_task_definition_config_env) env.append({"name": "SERVICE_GROUP", "value": service_group}) service_template_group = service_config.get("templateGroup") if service_template_group is not None: service_template_group = render.render_template( str(service_template_group), variables, is_task_definition_config_env) env.append({"name": "TEMPLATE_GROUP", "value": service_template_group}) desired_count = service_config.get("desiredCount") if desired_count is None: raise ParameterNotFoundException("Service `{service_name}` requires parameter `desiredCount`" .format(service_name=service_name)) desired_count = render.render_template(str(desired_count), variables, is_task_definition_config_env) try: int(desired_count) except ValueError: raise ParameterInvalidException("Service `{service_name}` parameter `desiredCount` is int" .format(service_name=service_name)) env.append({"name": "DESIRED_COUNT", "value": desired_count}) minimum_healthy_percent = service_config.get("minimumHealthyPercent") if minimum_healthy_percent is not None: minimum_healthy_percent = render.render_template(str(minimum_healthy_percent), variables, is_task_definition_config_env) try: int(minimum_healthy_percent) except ValueError: raise ParameterInvalidException("Service `{service_name}` parameter `minimumHealthyPercent` is int" .format(service_name=service_name)) env.append({"name": "MINIMUM_HEALTHY_PERCENT", "value": minimum_healthy_percent}) maximum_percent = service_config.get("maximumPercent") if maximum_percent is not None: maximum_percent = render.render_template(str(maximum_percent), variables, is_task_definition_config_env) try: int(maximum_percent) except ValueError: raise ParameterInvalidException( "Service `{service_name}` parameter `maximumPercent` is int".format(service_name=service_name) ) env.append({"name": "MAXIMUM_PERCENT", "value": str(maximum_percent)}) distinct_instance = service_config.get("distinctInstance") if distinct_instance is not None: distinct_instance = render.render_template(str(distinct_instance), variables, is_task_definition_config_env) try: distinct_instance = bool(strtobool(distinct_instance)) except ValueError: raise ParameterInvalidException("Service `{service_name}` parameter `distinctInstance` must be bool" .format(service_name=service_name)) if distinct_instance: env.append({"name": "DISTINCT_INSTANCE", "value": "true"}) placement_strategy = service_config.get("placementStrategy") placement_strategy_list = None if placement_strategy is not None: placement_strategy_list = [] for strategy in placement_strategy: strategy = render.render_template(json.dumps(strategy), variables, is_task_definition_config_env) strategy = json.loads(strategy) placement_strategy_list.append(strategy) env.append({"name": "PLACEMENT_STRATEGY", "value": str(placement_strategy)}) primary_placement = service_config.get("primaryPlacement") if primary_placement is not None: primary_placement = render.render_template(str(primary_placement), variables, is_task_definition_config_env) try: primary_placement = bool(strtobool(primary_placement)) except ValueError: raise ParameterInvalidException("Service `{service_name}` parameter `primaryPlacement` must be bool" .format(service_name=service_name)) if primary_placement: env.append({"name": "PRIMARY_PLACEMENT", "value": "true"}) task_definition_template = service_config.get("taskDefinitionTemplate") if task_definition_template is None: raise ParameterNotFoundException("Service `{service_name}` requires parameter `taskDefinitionTemplate`" .format(service_name=service_name)) service_task_definition_template = task_definition_template_dict.get(task_definition_template) if service_task_definition_template is None or len(service_task_definition_template) == 0: raise Exception("'%s' taskDefinitionTemplate not found. " % service_name) if not isinstance(service_task_definition_template, str): raise Exception("'%s' taskDefinitionTemplate specified template value must be str. " % service_name) try: task_definition_data = render.render_template(service_task_definition_template, variables, is_task_definition_config_env) except jinja2.exceptions.UndefinedError: logger.error("Service `%s` jinja2 varibles Undefined Error." % service_name) raise try: task_definition = json.loads(task_definition_data) except json.decoder.JSONDecodeError as e: raise Exception( "Service `{service}`: {e.__class__.__name__} {e}\njson:\n{json}".format(service=service_name, e=e, json=task_definition_data)) load_balancers = service_config.get("loadBalancers") rendered_balancers = None if load_balancers is not None: rendered_balancers = [] for balancer in load_balancers: d = {} target_group_arn = balancer.get('targetGroupArn') load_balancer_name = balancer.get('loadBalancerName') if target_group_arn is None and load_balancer_name is None: raise ParameterInvalidException("Service `{service_name}` parameter `loadBalancers`" " required `targetGroupArn` or `loadBalancerName`" .format(service_name=service_name)) if target_group_arn is not None and load_balancer_name is not None: raise ParameterInvalidException("Service `{service_name}` parameter `loadBalancers`" " do not set `targetGroupArn` and `loadBalancerName`" .format(service_name=service_name)) if target_group_arn is not None: target_group_arn = render.render_template(str(target_group_arn), variables, is_task_definition_config_env) d.update({"targetGroupArn": target_group_arn}) if load_balancer_name is not None: load_balancer_name = render.render_template(str(load_balancer_name), variables, is_task_definition_config_env) d.update({"loadBalancerName": load_balancer_name}) container_name = balancer.get('containerName') if container_name is None: raise ParameterInvalidException("Service `{service_name}` parameter `loadBalancers`" " required `containerName`" .format(service_name=service_name)) container_name = render.render_template(str(container_name), variables, is_task_definition_config_env) d.update({"containerName": container_name}) container_port = balancer.get('containerPort') if container_port is None: raise ParameterInvalidException("Service `{service_name}` parameter `loadBalancers`" " required `containerPort`" .format(service_name=service_name)) container_port = render.render_template(str(container_port), variables, is_task_definition_config_env) try: container_port = int(container_port) except ValueError: raise ParameterInvalidException("Service `{service_name}`" " parameter `containerPort` in `loadBlancers` must be int" .format(service_name=service_name)) d.update({"containerPort": container_port}) rendered_balancers.append(d) env.append({"name": "LOAD_BALANCER", "value": "true"}) # set parameters to docker environment for container_definitions in task_definition.get("containerDefinitions"): task_environment = container_definitions.get("environment") container_env = copy.copy(env) if task_environment is not None: if not isinstance(task_environment, list): raise Exception("'%s' taskDefinitionTemplate environment value must be list. " % service_name) container_env.extend(task_environment) container_definitions["environment"] = container_env # disabledになったらリストから外す disabled = service_config.get("disabled") if disabled is not None: disabled = render.render_template(str(disabled), variables, is_task_definition_config_env) try: disabled = bool(strtobool(disabled)) except ValueError: raise ParameterInvalidException("Service `{service_name}` parameter `disabled` must be bool" .format(service_name=service_name)) if disabled: continue # stop before deploy stop_before_deploy = service_config.get("stopBeforeDeploy") if stop_before_deploy is not None: stop_before_deploy = render.render_template(str(stop_before_deploy), variables, is_task_definition_config_env) try: stop_before_deploy = bool(strtobool(stop_before_deploy)) except ValueError: raise ParameterInvalidException("Service `{service_name}` parameter `stop_before_deploy` must be bool" .format(service_name=service_name)) else: stop_before_deploy = False service_list.append( Service( task_definition=task_definition, stop_before_deploy=stop_before_deploy, primary_placement=primary_placement, placement_strategy=placement_strategy_list, load_balancers=rendered_balancers ) ) return service_list
def home(): return render_template('index.html')
#!/usr/bin/python import render import os import sys import xmlrpclib import subprocess import settings from datetime import datetime config = settings.load_settings() x = xmlrpclib.ServerProxy(config['xmlrpc_endpoint']) page = x.wp.getPage(config['blog_id'], config['participants_page_id'], config['username'], config['password']) text = render.render_template('templates/users.tmpl', datetime.now().strftime("%Y/%m/%d")) page['description'] = text x.wp.editPage(config['blog_id'], config['participants_page_id'], config['username'], config['password'], page, True)
def check_jinja(request, response): data = render_template('check.html', title="Boorsok") response.text = data
def chat_createchat(request, **kwargs): query = request.query return render_template(request, 'templates/chat/createchat.html', kwargs=kwargs)
args = sys.argv[1:] if args[0] == '-q': dry_run = True quick_view = True args = args[1:] if args[0] == '-n': dry_run = True args = args[1:] date = args[0] with open('ledger', 'a') as f: f.write("\n") f.write(render.render_template('templates/ledger', date)) if not dry_run: subprocess.check_call(["git", "commit", "ledger", "-m", "Update for %s" % (date,)]) debts = render.get_debts() punt = [] with open('ledger', 'a') as f: f.write("\n") for (user, debt) in debts: if debt < 30: continue punt.append(user) f.write("""\ %(date)s Punt Pool:Owed:%(user)s $-%(debt)s
#!/usr/bin/python import render import os import sys import xmlrpclib import subprocess import settings from datetime import datetime config=settings.load_settings() x = xmlrpclib.ServerProxy(config['xmlrpc_endpoint']) page = x.wp.getPage(config['blog_id'], config['participants_page_id'], config['username'], config['password']) text = render.render_template('templates/users.tmpl',datetime.now().strftime("%Y/%m/%d")) page['description'] = text x.wp.editPage(config['blog_id'], config['participants_page_id'], config['username'], config['password'],page,True)
#!/usr/bin/python import render import xmlrpclib import json from config import * with open('secret.txt', 'r') as f: secret = json.load(f) passwd = secret['wordpress']['password'] x = xmlrpclib.ServerProxy(XMLRPC_ENDPOINT) page = x.wp.getPage(BLOG_ID, PARTICIPANTS_PAGE_ID, USER, passwd) text = render.render_template('templates/users.tmpl') page['description'] = text x.wp.editPage(BLOG_ID, PARTICIPANTS_PAGE_ID, USER, passwd, page, True)
if args[0] == '-r': dry_run = True reminder = True args = args[1:] if args[0] == '-n': dry_run = True send_mail = False args = args[1:] date = args[0] with open('ledger', 'a') as f: f.write("\n") f.write(render.render_template('templates/ledger', date)) if not dry_run: subprocess.check_call( ["git", "commit", "ledger", "-m", "Update for %s" % (date, )]) debts = render.get_debts() punt = [] with open('ledger', 'a') as f: f.write("\n") for (user, debt) in debts: if debt < 30: continue punt.append(user) f.write("""\
def manage_index(request, **kwargs): user = request.auth_get_user() kwargs.setdefault('user', user) return render_template(request, 'templates/auth/manage/index.html', kwargs=kwargs)
# encoding: utf-8 import render import os import sys import xmlrpclib import subprocess import datetime import yaml import settings config = settings.load_settings() dry_run = False args = sys.argv[1:] if args[0] == "-n": dry_run = True args = args[1:] date = args[0] debts = render.get_debts() email = render.render_template("templates/email.txt", date, mail=config["mail"]) if dry_run: print email if not dry_run: p = subprocess.Popen(["mutt", "-H", "-"], stdin=subprocess.PIPE) p.communicate(email)
def links(): return render_template('doc.html', doc=get_doc('links/index.md'))
USER = '******' BLOG_ID = 1 dry_run = False args = sys.argv[1:] if args[0] == '-n': dry_run = True args = args[1:] date = args[0] today = str(datetime.date.today()) with open('ledger', 'a') as f: f.write("\n") f.write(render.render_template('templates/ledger', date)) subprocess.check_call(["git", "commit", "ledger", "-m", "Update for %s" % (date,)]) debts = render.get_debts() punt = [] with open('ledger', 'a') as f: f.write("\n") for (user, debt) in debts: if debt < 30: continue punt.append(user) f.write("""\ %(today)s Punt Pool:Owed:%(user)s $-%(debt)s
def generate_email(): dry_run = False args = sys.argv[1:] if args[0] == '-n': dry_run = True args = args[1:] date = args[0] with open('ledger', 'a') as f: f.write("\n") f.write(render.render_template('templates/ledger', date)) if not dry_run: subprocess.check_call(["git", "commit", "ledger", "-m", "Update for %s" % (date,)]) debts = render.get_debts() punt = [] with open('ledger', 'a') as f: f.write("\n") for (user, debt) in debts: if debt <= (FINE_SIZE * 6): continue punt.append(user) f.write(PUNT_TEXT % {'user': user, 'debt': debt, 'date': date}) if not dry_run: text = render.render_template('templates/week.tmpl', date, punt=punt) lines = text.split("\n") title = lines[0] body = "\n".join(lines[1:]) page = dict(title = title, description = body) with open('secret.txt', 'r') as f: secret = json.load(f) passwd = secret['wordpress']['password'] x = xmlrpclib.ServerProxy(XMLRPC_ENDPOINT) x.metaWeblog.newPost(BLOG_ID, USER, passwd, page, True) email = render.render_template('templates/email.html', date, punt=punt) if dry_run: print email else: send_email('*****@*****.**', email) with open('out/email.txt', 'w') as f: f.write(email) if punt: with open('bloggers.yml') as b: bloggers = yaml.safe_load(b) for p in punt: if bloggers.get(p) and 'end' not in bloggers[p]: bloggers[p]['end'] = date with open('bloggers.yml','w') as b: yaml.safe_dump(bloggers, b) if not dry_run: subprocess.check_call(["git", "commit", "ledger", "bloggers.yml", "-m", "Punts for %s" % (date,)]) # if it's a dry run, lets set the ledger back to the beginning state if dry_run: subprocess.check_call(["git", "checkout", "ledger"]) if punt: subprocess.check_call(["git", "checkout", "bloggers.yml"])
def manage_edit_password(request, **kwargs): kwargs.setdefault('message', '') return render_template(request, 'templates/auth/manage/edit_password.html', kwargs=kwargs)
def generate_email(): dry_run = False args = sys.argv[1:] if args[0] == '-n': dry_run = True args = args[1:] date = args[0] with open('ledger', 'a') as f: f.write("\n") f.write(render.render_template('templates/ledger', date)) if not dry_run: subprocess.check_call( ["git", "commit", "ledger", "-m", "Update for %s" % (date, )]) debts = render.get_debts() punt = [] with open('ledger', 'a') as f: f.write("\n") for (user, debt) in debts: if debt <= (FINE_SIZE * 6): continue punt.append(user) f.write(PUNT_TEXT % {'user': user, 'debt': debt, 'date': date}) if not dry_run: text = render.render_template('templates/week.tmpl', date, punt=punt) lines = text.split("\n") title = lines[0] body = "\n".join(lines[1:]) page = dict(title=title, description=body) with open('secret.txt', 'r') as f: secret = json.load(f) passwd = secret['wordpress']['password'] x = xmlrpclib.ServerProxy(XMLRPC_ENDPOINT) x.metaWeblog.newPost(BLOG_ID, USER, passwd, page, True) email = render.render_template('templates/email.html', date, punt=punt) if dry_run: print email else: send_email('*****@*****.**', email) with open('out/email.txt', 'w') as f: f.write(email) if punt: with open('bloggers.yml') as b: bloggers = yaml.safe_load(b) for p in punt: if bloggers.get(p) and 'end' not in bloggers[p]: bloggers[p]['end'] = date with open('bloggers.yml', 'w') as b: yaml.safe_dump(bloggers, b) if not dry_run: subprocess.check_call([ "git", "commit", "ledger", "bloggers.yml", "-m", "Punts for %s" % (date, ) ]) # if it's a dry run, lets set the ledger back to the beginning state if dry_run: subprocess.check_call(["git", "checkout", "ledger"]) if punt: subprocess.check_call(["git", "checkout", "bloggers.yml"])
def home_page(request): company_info = CompanyInfo.objects.get(id=1) products = Product.objects.filter(is_valid=1).values("name", "id") return render_template("home_page.html", **locals())
import settings config = settings.load_settings() dry_run = False args = sys.argv[1:] if args[0] == '-n': dry_run = True args = args[1:] date = args[0] debts = render.get_debts() text = render.render_template('templates/week.tmpl', date) if dry_run: print >>sys.stderr, "Dry run only, not posting:" print text else: lines = text.split("\n") title = lines[0] body = "\n".join(lines[1:]) page = dict(title = title, description = body) passwd = config['password'] x = xmlrpclib.ServerProxy(config['xmlrpc_endpoint']) x.metaWeblog.newPost(config['blog_id'], config['username'], passwd, page, config['publish']) if config['publish']:
if args[0] == '-r': dry_run = True reminder = True args = args[1:] if args[0] == '-n': dry_run = True send_mail = False args = args[1:] date = args[0] with open('ledger', 'a') as f: f.write("\n") f.write(render.render_template('templates/ledger', date)) if not dry_run: subprocess.check_call(["git", "commit", "ledger", "-m", "Update for %s" % (date,)]) debts = render.get_debts() punt = [] with open('ledger', 'a') as f: f.write("\n") for (user, debt) in debts: if debt < 30: continue punt.append(user) f.write("""\ %(date)s Punt
def GET(self): ''' Method:get ''' try: log.info("CI:Get") query = HTTPAdaptor.format_query(web.ctx.env["QUERY_STRING"]) if not (query.has_key("author") and query.has_key("commit_id") and query.has_key("token")): raise InvalidQueryStringError author = query.get("author") commit_id = query.get("commit_id") token = query.get("token") # if not utils.validate_token( author = author, commit_id = commit_id, url = config.server["cvproxy"],token = token): # raise AuthenticationError sopt = SQLAdaptor() request_num = sopt.GetUnprocessedRequest(author) request_url = "/".join([config.server["cvproxy"],"myunprocessedrequests"]) author_info = {"name":author, "request_url":request_url, "request_num":request_num} dashboard_url = "/".join([config.server["cvproxy"], "dashboard"]) navi = [ # {"name":"Dashboard", # "url":dashboard_url, # "theme":"unselected" # }, {"name":"Current review request", "url":"#", "theme":"selected" } ] url = {"ignore": {"absolute": "/".join([config.server["cvproxy"],"submitaction?action=ignore&commit_id=%s" % commit_id]), "relative": "submitaction?action=Ignore&commit_id=%s" % commit_id}, "revoke": {"absolute": "/".join([config.server["cvproxy"],"submitaction?action=revoke&commit_id=%s" % commit_id]), "relative": "submitaction?action=Revoke&commit_id=%s" % commit_id} } cijob = sopt.GetJobNameByCommit(commit_id) files_committed = sopt.GetCommitedFilesNum(commit_id) downstreamjobs = sopt.GetDownstreamJobs(cijob) if downstreamjobs: project_info = sopt.GetProjectInfo(downstreamjobs[0]) test_info = sopt.GetTestSummary(downstreamjobs) results, failed_jobs = sopt.GetTestResult(downstreamjobs) else: project_info = sopt.GetProjectInfo(cijob) test_info = sopt.GetTestSummary([cijob]) results, failed_jobs = sopt.GetTestResult([cijob]) log.debug("downstream jobs: %s" % downstreamjobs) log.debug("project_info: %s" % project_info) log.debug("test_info: %s" % test_info) info = {"product": project_info["product"], "platform":project_info["platform"], "version":project_info["version"], "files_committed": files_committed, "tests_executed": test_info["tests"], "failures":test_info["failures"]} ci_url = config.ciserver["urlprefix"] jobs = [] jobs.append( {"jobpage":"/".join([ci_url,cijob[0]]), "name":cijob[0], "overview": "/".join([ci_url,cijob[0],cijob[1]]), "console": "/".join([ci_url,cijob[0],cijob[1],"console"]), "workspace": "/".join([ci_url,cijob[0],"ws"]), "testresult": "/".join([ci_url,cijob[0],cijob[1],"TestReport/?"]), "logs": "/".join([ci_url,cijob[0],cijob[1],"artifact/logs"]), "results": results, "failed_jobs": opts.FormatFailedJobs(failed_jobs) } ) categories = sopt.GetCategory() diff_list = sopt.GetDiffSetByCommit(commit_id) codes = opts.FormatDiffs(diff_list) return render.render_template('current_review_request.tmpl', author = author_info, navi = navi, url = url, commit_id = commit_id, info = info, categories = categories, jobs = jobs, codes = codes) except Exception, e: log.error(e) return HTTPAdaptor.format_response("error", "Request processing failed.")