Esempio n. 1
0
  def generate_morphline_config(self, collection_name, data, uuid_name):
    """
    Input:
    data: {
      'type': {'name': 'My New Collection!' format': 'csv', 'columns': [{'name': business_id, 'included': True', 'type': 'string'}, cool, date], fieldSeparator : ",", recordSeparator: '\n', quoteChar : "\""},
      'transformation': [
        'country_code': {'replace': {'FRA': 'FR, 'CAN': 'CA'..}}
        'ip': {'geoIP': }
      ]
    }
    Output:
    Morphline content 'SOLR_LOCATOR : { ...}'
    """

    properties = {
      "collection_name":collection_name,
      "fields":self.get_field_list(data['columns']),
      "num_base_fields": len(data['columns']),
      "format_character":Indexer._format_character,
      "uuid_name" : uuid_name,
      "get_regex":Indexer._get_regex_for_type,
      "format":data['format'],
      "grok_dictionaries_location" : os.path.join(CONFIG_INDEXER_LIBS_PATH.get(), "grok_dictionaries"),
      "zk_host": zkensemble()
    }

    oozie_workspace = CONFIG_INDEXING_TEMPLATES_PATH.get()

    lookup = TemplateLookup(directories=[oozie_workspace])
    morphline = lookup.get_template("morphline_template.conf").render(**properties)

    return morphline
Esempio n. 2
0
 def taskeditform(self, id=None, *args, **kwargs):
     user = self.printuser()
     password, adsense, anonymous, mail_suffix, site_closed, read_only = self.parse_config(filename="pygroup_config")
     if read_only == "yes" and user != "admin":
         return "<a href='/'>Go to main page</a><br /><br />error, site is read only!"
     if user == "anonymous" and anonymous != "yes":
         raise cherrypy.HTTPRedirect("login")
     else:
         try:
             db.connect()
             # 用 get() 取單筆資料
             data = Task.select().where(Task.id==int(id)).get()
             output = "user:"******", owner:"+data.owner+"<br /><br />"
             if user != data.owner:
                 if user != "admin":
                     db.close()
                     return output + "error! Not authorized!"
                 else:
                     template_lookup = TemplateLookup(directories=[template_root_dir+"/templates"])
                     mytemplate = template_lookup.get_template("taskeditform.html")
                     db.close()
                     return mytemplate.render(user=user, id=id, data=data)
             else:
                 template_lookup = TemplateLookup(directories=[template_root_dir+"/templates"])
                 mytemplate = template_lookup.get_template("taskeditform.html")
                 db.close()
                 return mytemplate.render(user=user, id=id, data=data)
         except:
             db.close()
             return "error! Not authorized!"
Esempio n. 3
0
    def test_strict(self):
        t = Template("""
            % if x is UNDEFINED:
                undefined
            % else:
                x: ${x}
            % endif
        """, strict_undefined=True)

        assert result_lines(t.render(x=12)) == ['x: 12']

        assert_raises(
            NameError,
            t.render, y=12
        )

        l = TemplateLookup(strict_undefined=True)
        l.put_string("a", "some template")
        l.put_string("b", """
            <%namespace name='a' file='a' import='*'/>
            % if x is UNDEFINED:
                undefined
            % else:
                x: ${x}
            % endif
        """)

        assert result_lines(t.render(x=12)) == ['x: 12']

        assert_raises(
            NameError,
            t.render, y=12
        )
Esempio n. 4
0
def get_node_manager_user_data(boto_data, uuid, max_request_size=10, chiles=True, jpeg2000=False, log_level='vvv'):
    here = dirname(__file__)
    user_data = join(here, '../user_data')
    mako_lookup = TemplateLookup(directories=[user_data])
    template = mako_lookup.get_template('dfms_cloud_init.yaml')
    cloud_init = template.render(
        profile='aws-chiles02',
        aws_access_key_id=boto_data[0],
        aws_secret_access_key=boto_data[1],
        type='node manager',
    )

    template = mako_lookup.get_template('node_manager_start_up.bash')
    user_script = template.render(
        uuid=uuid,
        queue=QUEUE,
        region=AWS_REGION,
        max_request_size=max_request_size,
        chiles=chiles,
        jpeg2000=jpeg2000,
        log_level=log_level
    )

    user_data = get_user_data([cloud_init, user_script])
    return user_data
Esempio n. 5
0
 def taskform(self, id=0, *args, **kwargs):
     user = self.printuser()
     template_lookup = TemplateLookup(directories=[template_root_dir+"/templates"])
     # 必須要從 templates 目錄取出 tasklist.html
     # 針對 id != 0 時, 表示要回應主資料緒, 希望取出與 id 對應的資料標頭, 然後加上 Re:
     mytemplate = template_lookup.get_template("taskform.html")
     return mytemplate.render(user=user, id=id)
Esempio n. 6
0
    def __mako_render(rest, templatename, **kwargs):
        """Template Engine
        """
        if templatename.startswith('static/') is True:
            directories = [akiyoshi.dirname, 'static', templatename[7:]]
            filepath = '/'.join(directories)
            rest.log.debug(filepath)

            fp = open(filepath, "r")
            try:
                return fp.read()
            finally:
                fp.close()

        else:
            directories = [akiyoshi.dirname, 'templates']
            if akiyoshi.config.has_key('theme'):
                directories.append(akiyoshi.config['theme'])
            else:
                directories.append('default')

        tl = TemplateLookup(directories='/'.join(directories),
                            input_encoding='utf-8',
                            output_encoding='utf-8',
                            default_filters=['decode.utf8'],
                            encoding_errors='replace')

        try:
            t = tl.get_template(templatename)
        except exceptions.TopLevelLookupException, tlle:
            rest.log.error('We could not find the template directory. - %s/%s'
                         % ('/'.join(directories), templatename))
            return web.notfound()
Esempio n. 7
0
    def test_module_roundtrip(self):
        lookup = TemplateLookup()

        template = Template("""
        <%inherit file="base.html"/>

        % for x in range(5):
            ${x}
        % endfor
""", lookup=lookup)

        base = Template("""
        This is base.
        ${self.body()}
""", lookup=lookup)

        lookup.put_template("base.html", base)
        lookup.put_template("template.html", template)

        assert result_lines(template.render()) == [
            "This is base.", "0", "1", "2", "3", "4"
        ]

        lookup = TemplateLookup()
        template = ModuleTemplate(template.module, lookup=lookup)
        base = ModuleTemplate(base.module, lookup=lookup)

        lookup.put_template("base.html", base)
        lookup.put_template("template.html", template)

        assert result_lines(template.render()) == [
            "This is base.", "0", "1", "2", "3", "4"
        ]
Esempio n. 8
0
    def __call__(self, *args, **kwargs):
        dojo_theme=kwargs.pop('dojo_theme',None)
        striped=kwargs.pop('striped','odd_row,even_row')
        pdf=kwargs.pop('pdf',False)
        mako_path=kwargs.get('mako_path')
        page = self.page
        dojo_theme = dojo_theme or getattr(self.page, 'dojo_theme', None) or 'tundra'
        auth = page._checkAuth()
        if auth != AUTH_OK:
            return self.page.site.forbidden_exception
        if striped:
            kwargs['striped'] = itertools.cycle(striped.split(','))
        gnr_static_handler = page.site.getStatic('gnr')
        tpldirectories = [os.path.dirname(mako_path), page.parentdirpath] + page.resourceDirs + [
                gnr_static_handler.path(page.gnrjsversion, 'tpl')]
        lookup = TemplateLookup(directories=tpldirectories,
                                output_encoding='utf-8', encoding_errors='replace')
        template = lookup.get_template(os.path.basename(mako_path))
        page.charset = 'utf-8'
        _resources = page.site.resources.keys()
        _resources.reverse()

        arg_dict = page.build_arg_dict()
        arg_dict['mainpage'] = page
        arg_dict.update(kwargs)
        try:
            output = template.render(**arg_dict)
        except WSGIHTTPException, exc:
            return exc
Esempio n. 9
0
class PyFFTest(PipeLineTest):
    """
    Runs tests through the pyff cmdline - only mocks exit
    """

    def setUp(self):
        super(PyFFTest, self).setUp()
        self.templates = TemplateLookup(directories=[os.path.join(self.datadir, 'simple-pipeline')])
        self.output = tempfile.NamedTemporaryFile('w').name
        self.logfile = tempfile.NamedTemporaryFile('w').name
        self.signer = tempfile.NamedTemporaryFile('w').name
        self.signer_template = self.templates.get_template('signer.fd')
        with open(self.signer, "w") as fd:
            fd.write(self.signer_template.render(ctx=self))
        self.bad = tempfile.NamedTemporaryFile('w').name
        self.bad_template = self.templates.get_template('bad.fd')
        with open(self.bad, "w") as fd:
            fd.write(self.bad_template.render(ctx=self))

    def test_run_signer(self):
        out, err, exit_code = run_pyff("--loglevel=DEBUG", self.signer)
        assert err
        assert (exit_code == 0)

    def test_run_bad(self):
        out, err, exit_code = run_pyff("--loglevel=DEBUG", self.bad)
        assert 'Traceback' in err
        assert 'No pipe named snartibartifast is installed' in err
        assert (exit_code == 255)

    def test_run_signer_logfile(self):
        out, err, exit_code = run_pyff("--loglevel=DEBUG", "--logfile=%s" % self.logfile, self.signer)
        assert (exit_code == 0)

    def test_help(self):
        out, err, exit_code = run_pyff("--help")
        assert (pyffdoc in out)
        assert (exit_code == 0)

    def test_version(self):
        out, err, exit_code = run_pyff("--version")
        assert (pyffversion in out)
        assert (exit_code == 0)

    def test_bad_arg(self):
        out, err, exit_code = run_pyff("--snartibartfast")
        assert (exit_code == 2)
        assert ('snartibartfast' in out)

    def test_bad_loglevel(self):
        try:
            out, err, exit_code = run_pyff("--loglevel=TRACE")
        except ValueError as ex:
            assert ('TRACE' in str(ex))

    def tear_down(self):
        super(PyFFTest, self).tearDown()
        os.unlink(self.signer)
        os.unlink(self.output)
        os.unlink(self.logfile)
Esempio n. 10
0
File: util.py Progetto: dmick/prado
def render(path, **params):
    loader = TemplateLookup(
        directories=[os.path.dirname(path)],
        output_encoding='utf-8'
    )
    tmpl = loader.get_template(os.path.basename(path))
    return tmpl.render(**params)
Esempio n. 11
0
    def render(self, render_format):
        """Render the plugin data to the given format"""

        # Files to try out for plugin data rendering
        try_files = [
            "%s/%s.mako" % (self.from_plugin, render_format),
            "%s/text.mako" % (self.from_plugin),
            "default/%s.mako" % render_format,
            "default/text.mako",
            ]

        lookup = TemplateLookup(
            directories = PLUGINS_TEMPLATE_DIRS,
            input_encoding='utf-8',
            output_encoding='utf-8',
            )

        for basefile in try_files:
            try:
                template = lookup.get_template(basefile)
            except TopLevelLookupException:
                continue
            else:
                break
        else:
            # No template file found, something weird happened
            return "%s (!! no template found)" % self.data

        return template.render_unicode(o = self, h = debexpo.lib.helpers)
Esempio n. 12
0
    def __call__(self, path, inline=False, **kwargs):
        auth = self._checkAuth()
        if auth != AUTH_OK:
            self.raiseUnauthorized()
        tpldirectories = [os.path.dirname(path), self.parentdirpath] + self.resourceDirs + [
                self.resolvePath('gnrjs', 'gnr_d%s' % self.dojo_version, 'tpl', folder='*lib')]
        lookup = TemplateLookup(directories=tpldirectories,
                                output_encoding='utf-8', encoding_errors='replace')
        template = lookup.get_template(os.path.basename(path))
        self.response.content_type = 'application/pdf'
        filename = os.path.split(path)[-1].split('.')[0]
        inline_attr = (inline and 'inline') or 'attachment'
        self.response.add_header("Content-Disposition", str("%s; filename=%s.pdf" % (inline_attr, filename)))
        import cStringIO
        from lxml import etree
        from z3c.rml import document

        tmp = template.render(mainpage=self, **kwargs)
        tmp = tmp.replace('&', '&amp;')
        root = etree.fromstring(tmp)
        doc = document.Document(root)
        output = cStringIO.StringIO()
        doc.process(output)
        output.seek(0)
        return output.read()
Esempio n. 13
0
def mx_template(t, *args, **kwargs):
    from mako.template import Template
    from mako.lookup import TemplateLookup
    tpl_path = os.path.join(PROJECT_ROOT, 'views') 
    mylookup = TemplateLookup(directories=[tpl_path],
                              default_filters=['h', 'unicode'])
    return mylookup.get_template(t).render(*args, **kwargs)
Esempio n. 14
0
    def index(self):        
        spawns = CthulhuData.spawns()

        mylookup = TemplateLookup(directories=[current_dir + '/webroot'])
        mytemplate = mylookup.get_template('index.html')

        return mytemplate.render(spawns=spawns)
Esempio n. 15
0
File: ltmpl.py Progetto: joy01/clip
    def parse(self, template_file, variables):
        lookup = TemplateLookup(directories=self.directories)
        template = lookup.get_template(template_file)

        try:
            textbuf = template.render(**variables)
        except:
            logger.error(text_error_template().render())
            raise

        # split, strip and remove empty lines
        lines = textbuf.splitlines()
        lines = map(lambda line: line.strip(), lines)
        lines = filter(lambda line: line, lines)

        # remove comments
        lines = filter(lambda line: not line.startswith("#"), lines)

        # mako template now returns unicode strings
        lines = map(lambda line: line.encode("utf8"), lines)

        # split with shlex and perform brace expansion
        lines = map(split_and_expand, lines)

        self.lines = lines
        return lines
Esempio n. 16
0
    def index(self):        
        screeds = get_screeds()
        
        mylookup = TemplateLookup(directories=[current_dir + '/webroot'])
        mytemplate = mylookup.get_template('screed.html')

        return mytemplate.render(screeds=screeds)
Esempio n. 17
0
    def edit(self, **kwargs):
                
        if cherrypy.request.method != 'GET':
            base = ScreedBase()
            screed = Screed()
            
            for key, value in kwargs.iteritems(): 
                setattr(base, key, value)            
            
            if 'steps' in kwargs:
                if hasattr(kwargs['steps'], "strip"):
                    screed.add_fn(0, "fn", kwargs['steps'])
                else:
                    idx = 0
                    for val in kwargs['steps']:                    
                        screed.add_fn(idx, "fn", val)
                        idx += 1
            
            base.text = screed.to_json()
            base = save_screed(base)

            return str(base.id)
        
        screed = None
        if 'id' in kwargs:
            screed = get_screed(kwargs['id'])
        
        mylookup = TemplateLookup(directories=[current_dir + '/webroot'])
        mytemplate = mylookup.get_template('screed-edit.html')

        return mytemplate.render(screed = screed)
Esempio n. 18
0
def render_template(path, params=dict()):
    ''' Render a template for the given parameters 
        path:      Template absolute path
        params:    Rendering parameters
    '''
    
    full_path, file_name = get_template_path_info(path)
    
    lookup = TemplateLookup(directories=[full_path], filesystem_checks=FILE_CHECKS, module_directory=TEMPLATE_CACHE_DIR)
    template = lookup.get_template(os.path.sep + file_name)
    
    ctx_params = dict(params)
    ctx_params['include_template'] = render_template
    ctx_params['config'] = Config
    ctx_params['session'] = session
    ctx_params['helpers'] = helpers
    
    buf = StringIO()
    ctx = Context(buf, **ctx_params)
    try: 
        template.render_context(ctx)
        return buf.getvalue()
    except:
        return exceptions.html_error_template().render()
    finally:
        if buf: buf.close()
Esempio n. 19
0
        def decorated(*args, **kwargs):
            path = cherrypy.request.app.script_name + "/"
            tpl_dir = cherrypy.request.app.config[path].get('templates')
            template_name = f.template_name
            
            if tpl_dir is None:
                tpl_dir = args[0].templates
            
            try:
                values = f(*args, **kwargs)
                
                if useattr is not None:
                    template_name = values[useattr]
                
                lookup = TemplateLookup([tpl_dir])
                template = lookup.get_template(template_name)
                
                if not values.get('js'):
                    values['js'] = []

                if not values.get('css'):
                    values['css'] = []

                values['url'] = cherrypy.url

                return template.render(**values)
            
            except cherrypy.HTTPRedirect as e:
                raise e
            except cherrypy.HTTPError as e:
                raise e
            except cherrypy.NotFound as e:
                raise e
            except:
                return html_error_template().render()
Esempio n. 20
0
    def render(self, **kwargs):
        """Doc..."""

        # ADD KWARGS TO TEMPLATE RENDER PROPERTIES
        if kwargs:
            data = dict(self._data.items() + kwargs.items())
        else:
            data = self._data

        td = [self._rootDir] if isinstance(self._rootDir, basestring) else self._rootDir

        lookup = TemplateLookup(
            directories=td,
            input_encoding='utf-8',
            output_encoding='utf-8',
            encoding_errors='replace')

        template = self._template
        if template:
            if not template.startswith('/'):
                template = '/' + template

            try:
                target = lookup.get_template(template)
            except Exception, err:
                self._result   = None
                self._error    = err
                self._errorMsg = 'Failed to get template (%s):\n%s' % (
                    template,
                    exceptions.text_error_template().render().replace('%','%%') )
                self._log.writeError(self._errorMsg, self._error)
                return self.dom
Esempio n. 21
0
class MakoTemplateset(TemplatesetBase):
    '''Mako templateset (a wrapper to mako.lookup.TemplateLookup)

    Members:
    _lookup -- Mako lookup class
    '''

    _lookup = None

    def __init__(self, *args, **kwargs):
        super(MakoTemplateset, self).__init__()

        self._lookup = ExternalMakoTemplateLookup(*args, **kwargs)

    # TemplateCollection interface
    def get_template(self, name):
        fname, defname = name.rsplit(':', 1)

        tpl = self._lookup.get_template(fname)
        tpl = tpl.get_def(defname)

        return MakoTemplate(tpl)
    get_template.__doc__ = TemplatesetBase.get_template.__doc__

    def get_subset(self, name):
        return MakoTemplatesetFile(template_object=self._lookup.get_template(name))
Esempio n. 22
0
class ServerDataWriter:
    def __init__(self, *args, **kwargs):
        self.tplccdir = kwargs['tplccdir'] if 'tplccdir' in kwargs else None
        self.tpldirs = kwargs['tpldirs'] if 'tpldirs' in kwargs else [os.curdir]
        if 'tpls' not in kwargs or not isinstance(kwargs['tpls'], dict):
            exit_with_error("Output templates not defined")

        tpls_dict = {a: kwargs['tpls'][a] if a in kwargs['tpls'] and \
                         isinstance(kwargs['tpls'][a], dict) else {} \
                         for a in ['files', 'parmap']}
        self.tpls = type(
            self.__class__.__name__ + \
                ".Templates",
            (object,),
            tpls_dict
            )
        tplookup_kwargs = {
            "directories":     self.tpldirs,
            "output_encoding": 'utf-8',
            "encoding_errors": 'replace',
            "strict_undefined": True
            }
        if self.tplccdir:
            tplookup_kwargs["module_directory"] = self.tplccdir

        self.tplookup = TemplateLookup(**tplookup_kwargs)

    def render_tpl(self, tpl):
        if tpl not in self.tpls.files:
            exit_with_error("Template file not specified for template %s" % tpl)
        elif not self.tplookup.has_template(self.tpls.files[tpl]):
            exit_with_error("Template file not found: %s" % self.tpls.files[tpl])
        t = self.tplookup.get_template(self.tpls.files[tpl])
        return t.render(**self.tpls.parmap[tpl])
Esempio n. 23
0
 def get(self, filename):
     mylookup = TemplateLookup(directories=['./templates'], output_encoding='utf-8', encoding_errors='replace')
     mytemplate = mylookup.get_template(filename + '.txt')
     if not self.current_user:
         self.write(mytemplate.render(user="******"))
     else:
         self.write(mytemplate.render(user=self.current_user))
Esempio n. 24
0
 def MAKOIFY(request, *args, **kwargs):
     res = func(request, *args, **kwargs)
     if not res:
         res = {}
     if type(res) == dict:
         # use current_app/mako_templates/ as first search path.
         # the assumption is that the function's module is under current_app/
         d = os.path.join(
               os.path.dirname(sys.modules[func.__module__].__file__),
               "mako_templates/")
         lookup = TemplateLookup(directories=[d, 'mako_templates/'])
         res['request'] = request
         try:
             t = lookup.get_template(template)
             return HTTPMethod(t.render(**res))
         except:
             #if settings.DEBUG:
             if True:
                 # display Mako's debug page on template error
                 return HTTPMethod(exceptions.html_error_template()\
                                     .render(), status=500)
             raise
     else:
         # if not a dictionary or empty value, return literal result
         return res
Esempio n. 25
0
 def test_unicode_file_lookup(self):
     lookup = TemplateLookup(directories=[template_base], output_encoding="utf-8", default_filters=["decode.utf8"])
     if compat.py3k:
         template = lookup.get_template("/chs_unicode_py3k.html")
     else:
         template = lookup.get_template("/chs_unicode.html")
     eq_(flatten_result(template.render_unicode(name="毛泽东")), u("毛泽东 是 新中国的主席<br/> Welcome 你 to 北京."))
Esempio n. 26
0
    def __call__(self, filename,
                 directories=None,
                 module_directory=None,
                 collection_size=None):

        if not directories:
            directories = cherrypy.tools.mako.directories

        if not collection_size and not cherrypy.tools.mako.collection_size:
            collection_size = -1
        elif not collection_size and cherrypy.tools.mako.collection_size:
            collection_size = cherrypy.tools.mako.collection_size
        # Find the appropriate template lookup.
        key = (tuple(directories), module_directory)
        try:
            lookup = self.lookups[key]
        except KeyError:
            lookup = TemplateLookup(directories=directories,
                                    module_directory=module_directory,
                                    collection_size=collection_size,
                                    )
            self.lookups[key] = lookup
        cherrypy.request.lookup = lookup

        # Replace the current handler.
        try:
            cherrypy.request.template = t = lookup.get_template(filename)
            cherrypy.request.handler = MakoHandler(t, cherrypy.request.handler)
        except cherrypy.HTTPRedirect:
            raise
        except:
            print exceptions.html_error_template().render()
Esempio n. 27
0
 def taskeditform(self, id=None, *args, **kwargs):
     if ormdb == "sqlite":
         # 為了避免跨執行緒使用 SQLite3, 重新 connect 資料庫
         Database.connect()
     user = self.printuser()
     password, adsense, anonymous, mail_suffix, site_closed, read_only = self.parse_config(filename="pygroup_config")
     if read_only == "yes" and user != "admin":
         return "<a href='/'>Go to main page</a><br /><br />error, site is read only!"
     if user == "anonymous" and anonymous != "yes":
         raise cherrypy.HTTPRedirect("login")
     else:
         try:
             query = Task.at(int(id)).select()
             result = query.execute()
             data = result.one()
             output = "user:"******", owner:"+data.owner+"<br /><br />"
             if user != data.owner:
                 if user != "admin":
                     return output + "error! Not authorized!"
                 else:
                     template_lookup = TemplateLookup(directories=[template_root_dir+"/templates"])
                     mytemplate = template_lookup.get_template("taskeditform.html")
                     return mytemplate.render(user=user, id=id, data=data)
             else:
                 template_lookup = TemplateLookup(directories=[template_root_dir+"/templates"])
                 mytemplate = template_lookup.get_template("taskeditform.html")
                 return mytemplate.render(user=user, id=id, data=data)
         except:
             return "error! Not authorized!"
Esempio n. 28
0
def render(articles):
    from mako.lookup import TemplateLookup
    loader = TemplateLookup(directories=['./templates'],
            output_encoding='utf-8', input_encoding='utf-8')
    indextpl = loader.get_template('index_tpl.mako')
    html = indextpl.render(articles=articles, cfg=config)
    open('../index.html', 'w').write(html)
Esempio n. 29
0
def main():
    template_dir = os.path.join(HERE, "templates")
    lookup = TemplateLookup(directories=[template_dir], 
                            input_encoding="utf-8", output_encoding="utf-8")
    template = lookup.get_template("main.mako")
    with open("index.html", "w") as wf:
        wf.write(template.render(lang="ja", page_title=u"about mock"))
Esempio n. 30
0
class MakoRenderFactory(object):
    def __init__(self, template_dirs, default_mime=None, **kw):
        # we'll handle the exception formatting, thanks.
        self.format_exceptions = kw.pop('format_exceptions', True)

        self.lookup = TemplateLookup(template_dirs, **kw)
        self.default_mime = default_mime or 'text/html'

    def __call__(self, template_filename):
        # trigger error if not found
        tmp_template = self.lookup.get_template(template_filename)
        for ext, mt in _EXT_MAP.items():
            if template_filename.endswith(ext):
                mimetype = mt
                break
        else:
            mimetype = self.default_mime

        def mako_render(context):
            status = 200
            template = self.lookup.get_template(template_filename)
            try:
                content = template.render_unicode(**context)
            except:
                if not self.format_exceptions:
                    raise
                status = 500
                if mimetype == 'text/html':
                    content = exceptions.html_error_template().render()
                else:
                    # TODO: add handling for other mimetypes?
                    content = exceptions.text_error_template().render()
            return Response(content, status=status, mimetype=mimetype)

        return mako_render
Esempio n. 31
0
        compiled = process(src, filename=filename, compiler=DjangoCompiler)
        print(compiled)
        t = django.template.Template(compiled)

        ctx = django.template.Context()
        return t.render(ctx)

    processors['Django'] = django_process
except ImportError:
    pass

try:
    import pyjade.ext.mako
    import mako.template
    from mako.lookup import TemplateLookup
    dirlookup = TemplateLookup(directories=['cases/'],
                               preprocessor=pyjade.ext.mako.preprocessor)

    def mako_process(src, filename):
        t = mako.template.Template(src,
                                   lookup=dirlookup,
                                   preprocessor=pyjade.ext.mako.preprocessor,
                                   default_filters=['decode.utf8'])
        return t.render()

    processors['Mako'] = mako_process

except ImportError:
    pass


def setup_func():
Esempio n. 32
0
def mkorender(tplfile, outfile, *args, **kwargs):
    mylookup = TemplateLookup(directories=[os.getcwd()])
    tpl = Template(filename=tplfile, lookup=mylookup)
    mkorendertpl(tpl, outfile, *args, **kwargs)
Esempio n. 33
0
File: rp2.py Progetto: zack53/pyoidc
LOGGER = logging.getLogger("")
LOGFILE_NAME = 'rp.log'
hdlr = logging.FileHandler(LOGFILE_NAME)
base_formatter = logging.Formatter(
    "%(asctime)s %(name)s:%(levelname)s %(message)s")

CPC = ('%(asctime)s %(name)s:%(levelname)s '
       '[%(client)s,%(path)s,%(cid)s] %(message)s')
cpc_formatter = logging.Formatter(CPC)

hdlr.setFormatter(base_formatter)
LOGGER.addHandler(hdlr)
LOGGER.setLevel(logging.DEBUG)

LOOKUP = TemplateLookup(directories=['templates', 'htdocs'],
                        module_directory='modules',
                        input_encoding='utf-8',
                        output_encoding='utf-8')

SERVER_ENV = {}
RP = None


def setup_server_env(conf):
    global SERVER_ENV

    SERVER_ENV = dict([(k, v) for k, v in conf.__dict__.items()
                       if not k.startswith("__")])
    SERVER_ENV["template_lookup"] = LOOKUP
    SERVER_ENV["base_url"] = conf.BASE
    #SERVER_ENV["CACHE"] = {}
    SERVER_ENV["OIC_CLIENT"] = {}
Esempio n. 34
0
class LyRequestHandler(RequestHandler):

    lookup = TemplateLookup([template_dir], input_encoding="utf-8")

    def render(self, template_name, **kwargs):
        """ Redefine the render """

        # TODO: if url have ajax arg, use XXX.ajax for template
        ajax = self.get_argument('ajax', False)
        if ajax:
            x, y = template_name.split('.')
            #x += '_ajax'
            template_name = '.'.join([x, 'ajax'])

        t = self.lookup.get_template(template_name)

        args = dict(
            handler=self,
            request=self.request,
            current_user=self.current_user,
            locale=self.locale,
            _=self.locale.translate,
            static_url=self.static_url,
            xsrf_form_html=self.xsrf_form_html,
            reverse_url=self.application.reverse_url,
            LANGUAGES=self.settings['LANGUAGES'],
            STATIC_URL=self.settings['STATIC_URL'],
            THEME_URL=self.settings['THEME_URL'],

            #method
            fulltime=fulltime,
            lytime=lytime,
            has_permission=self.has_permission,
            AJAX=ajax,
        )

        args.update(kwargs)

        # We can define keyword in views with initialize()
        if hasattr(self, 'view_kwargs'):
            args.update(self.view_kwargs)

        # TODO: more readable bug track
        # http://docs.makotemplates.org/en/latest/usage.html#handling-exceptions
        try:
            html = t.render(**args)
        except:
            traceback = RichTraceback()
            html = u'''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <link rel="stylesheet" href="/static/css/mako.css" />
    <title>LuoYun Mako Template System Trac Info</title>
  </head>
  <body>
    <h1>LuoYun Mako Template System Trac Info</h1>
    <pre>'''
            for (filename, lineno, function, line) in traceback.traceback:
                html += "File %s, line %s, in %s" % (filename, lineno,
                                                     function)
                html += "%s\n" % line
            html += "%s: %s" % (str(
                traceback.error.__class__.__name__), traceback.error)
            html += "</pre></body></html>"
        self.finish(html)

    def get_current_user(self):

        try:
            session = self.db2.query(Session).filter_by(
                session_key=self.get_secure_cookie('session_key')).one()
        except MultipleResultsFound:
            logging.error('session: MultipleResultsFound, %s' %
                          self.get_secure_cookie('session_key'))
        except NoResultFound:
            return None

        # Does session expired ?
        if session.expire_date < datetime.datetime.utcnow():
            return None

        sk = self.settings["session_secret"]
        encoded_data = base64.decodestring(session.session_data)
        pickled, tamper_check = encoded_data[:-32], encoded_data[-32:]
        if md5(pickled + sk).hexdigest() != tamper_check:
            # TODO
            print "User tampered with session cookie."
            return None
        try:
            session_dict = pickle.loads(pickled)
        except:
            session_dict = {}

        user = self.db2.query(User).get(session_dict.get('user_id', 0))

        if user.islocked: return None

        if user:
            user.last_active = datetime.datetime.utcnow()
            user.last_entry = self.request.uri
            #self.db2.commit()

        return user

    def get_user_locale(self):
        user_locale = self.get_cookie("user_locale")

        if (not user_locale and self.current_user
                and self.current_user.profile):
            user_locale = self.current_user.profile.locale

        if user_locale:
            # TODO: app and template have different i18n
            gettext.translation('app',
                                settings.I18N_PATH,
                                languages=[user_locale]).install(True)
            return tornado.locale.get(user_locale)
        else:
            # Use the Accept-Language header
            return None

    def has_permission(self, perm, user=None):

        if not user:
            user = self.current_user

        if not user:
            return False

        for p in self.current_user.permissions:
            if p.codename == perm or p.codename == 'admin':
                return True

        for g in self.current_user.groups:
            for p in g.permissions:
                if p.codename == perm or p.codename == 'admin':
                    return True

        return False

    @property
    def db(self):
        return self.application.db

    @property
    def db2(self):
        return self.application.db2

    def _job_notify(self, id):
        ''' Notify the new job signal to control server '''

        rqhead = struct.pack('iii', settings.PKT_TYPE_WEB_NEW_JOB_REQUEST, 4,
                             id)

        sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        sk.connect((self.application.settings['control_server_ip'],
                    self.application.settings['control_server_port']))

        sk.sendall(rqhead)
        sk.close()

    def get_page_url(self, p, path=None):
        ''' Generate page url from given p (cur_page)

        For Pagination.
        '''

        if not path:
            path = self.request.uri

        the_p = 'p=%s' % p

        if path.count('p='):
            return re.sub('p=[0-9]+', the_p, path)
        elif path.count('?'):
            return path + '&%s' % the_p
        else:
            return path + '?%s' % the_p

    def get_no_permission_url(self):
        self.require_setting("no_permission_url", "@has_permission")
        return self.application.settings["no_permission_url"]

    def get_no_resource_url(self):
        self.require_setting("no_resource_url")
        return self.application.settings["no_resource_url"]
Esempio n. 35
0
                    message = traceback.format_exception(*sys.exc_info())
                    print(message)
                    logger.exception("%s" % err)
                    resp = ServiceError("%s" % err)
                    return resp(environ, start_response)

        LOGGER.debug("unknown side: %s" % path)
        resp = NotFound("Couldn't find the side you asked for!")
        return resp(environ, start_response)


if __name__ == '__main__':

    root = './'
    lookup = TemplateLookup(directories=[root + 'Templates', root + 'htdocs'],
                            module_directory=root + 'modules',
                            input_encoding='utf-8',
                            output_encoding='utf-8')

    def mako_renderer(template_name, context):
        mte = lookup.get_template(template_name)
        return mte.render(**context)

    usernamePasswords = {"user1": "1", "user2": "2"}

    passwordEndPointIndex = 0  # what is this, and what does its value mean?

    # JWKS: JSON Web Key
    jwksFileName = "static/jwks.json"

    # parse the parameters
    parser = argparse.ArgumentParser()
Esempio n. 36
0
class TabularRenderer(extension.BaseRenderer):

    TEMPLATE = TemplateLookup(
        directories=[os.path.join(os.path.dirname(__file__), 'templates')
                     ]).get_template('viewer.mako')

    def render(self):
        with open(self.file_path, errors='replace') as fp:
            sheets, size = self._render_grid(fp, self.metadata.ext)
            return self.TEMPLATE.render(
                base=self.assets_url,
                width=settings.TABLE_WIDTH,
                height=settings.TABLE_HEIGHT,
                sheets=json.dumps(sheets),
                options=json.dumps(size),
            )

    @property
    def file_required(self):
        return True

    @property
    def cache_result(self):
        return True

    def _render_grid(self, fp, ext, *args, **kwargs):  # assets_path, ext):
        """Render a tabular file to html
        :param fp: file pointer object
        :return: RenderResult object containing html and assets
        """
        self._renderer_tabular_metrics = {}

        sheets = self._populate_data(fp, ext)

        size = settings.SMALL_TABLE
        self._renderer_tabular_metrics['size'] = 'small'
        self._renderer_tabular_metrics['nbr_sheets'] = len(sheets)
        for sheet in sheets:
            sheet = sheets[
                sheet]  # Sheets are stored in key-value pairs of the form {sheet: (col, row)}
            if len(sheet[0]) > 9:  # Check the number of columns
                size = settings.BIG_TABLE
                self._renderer_tabular_metrics['size'] = 'big'

            if len(sheet[0]) > settings.MAX_SIZE or len(
                    sheet[1]) > settings.MAX_SIZE:
                raise exceptions.TableTooBigError(
                    'Table is too large to render.', extension=ext)

        return sheets, size

    def _populate_data(self, fp, ext):
        """Determine the appropriate library and use it to populate rows and columns
        :param fp: file pointer
        :param ext: file extension
        :return: tuple of column headers and row data
        """
        function_preference = settings.LIBS.get(ext.lower())

        for function in function_preference:
            try:
                imported = function()
            except ImportError:
                pass
            else:
                self._renderer_tabular_metrics['importer'] = function.__name__
                try:
                    return imported(fp)
                except (KeyError, ValueError):
                    raise exceptions.UnexpectedFormattingError(
                        'Unexpected formatting error.',
                        extension=self.metadata.ext,
                        formatting_function=str(function),
                    )

        # this will only occur if function_preference is an empty set
        # or all functions in the set raise an import error
        raise exceptions.MissingRequirementsError(
            'Renderer requirements are not met',
            extension=self.metadata.ext,
            function_preference=function_preference,
        )
Esempio n. 37
0
from datetime import date, datetime
from django.conf import settings
from django.http import HttpResponse
from django.template.context import Context
from mako.lookup import TemplateLookup
from common.log import logger
"""
mylookup 也可以单独使用:
@Example:
             mako_temp = mylookup.get_template(template_name)
             mako_temp.render(**data)
"""
mylookup = TemplateLookup(
    directories=settings.MAKO_TEMPLATE_DIR,
    module_directory=settings.MAKO_TEMPLATE_MODULE_DIR,
    output_encoding='utf-8',
    input_encoding='utf-8',
    encoding_errors='replace',
    collection_size=500,
)


def render_mako(template_name, dictionary={}, context_instance=None):
    """
    render the mako template and return the HttpResponse

    @param template_name: 模板名字
    @param dictionary: context字典
    @param context_instance: 初始化context,如果要使用 TEMPLATE_CONTEXT_PROCESSORS,则要使用RequestContext(request)
    @note: 因为返回是HttpResponse,所以这个方法也适合给ajax用(dataType不是json的ajax)
    @Example:
                 render_mako('mako_temp.html',{'form':form})
Esempio n. 38
0
from website.oauth.signals import oauth_complete

NODE_SETTINGS_TEMPLATE_DEFAULT = os.path.join(
    settings.TEMPLATES_PATH,
    'project',
    'addon',
    'node_settings_default.mako',
)

USER_SETTINGS_TEMPLATE_DEFAULT = os.path.join(
    settings.TEMPLATES_PATH,
    'profile',
    'user_settings_default.mako',
)

lookup = TemplateLookup(directories=[settings.TEMPLATES_PATH])


def _is_image(filename):
    mtype, _ = mimetypes.guess_type(filename)
    return mtype and mtype.startswith('image')


class AddonConfig(object):
    def __init__(self,
                 short_name,
                 full_name,
                 owners,
                 categories,
                 added_default=None,
                 added_mandatory=None,
Esempio n. 39
0
def main():
    tmpl_suffix = ".mcftmpl"
    incr_funcs = ("incr", "decr", "cur", "finish")
    speeds = ("main", "fast", "slow")
    misc = ("reset", "cleanup") + incr_funcs
    categories = ("init", "enter", "exit", "tick") + speeds + tuple(
        "finish_%s" % s for s in speeds) + misc
    category_re = re.compile(r"^(([a-z_0-9]+?)(?:_(" + "|".join(categories) +
                             "))?)%s$" % tmpl_suffix)

    src_dir = sys.argv[1] if len(sys.argv) > 1 else '.'
    tmpl_dir = os.path.join(src_dir, 'templates')
    func_dir = os.path.join(src_dir, 'functions')
    lookup = TemplateLookup(directories=['.'])
    tmpls = {}
    for f in ("home", "group", "tick", "goto") + incr_funcs:
        tmpls[f] = Template(filename="templates/%s%s" % (f, tmpl_suffix),
                            lookup=lookup)

    class Room:
        def __init__(self, dir_name):
            dir_name = dir_name.strip('/')
            self.room_dir = dir_name
            self.name = os.path.basename(dir_name)
            self.func_dir = dir_name.replace('templates', 'functions')
            self.lists = {"exit": []}
            self.vars = set()

        def consume(self, tmpl_path):
            """
            Consume one single template file, remembering whatever type it is.
            :param tmpl_path:
            :return:
            """
            m = category_re.match(os.path.basename(tmpl_path))
            var = m.group(2)
            if var == self.name:
                raise NameError(
                    "Cannot name script the same as room name: %s" % var)
            which = m.group(3)
            func = m.group(1)
            tmpl = Template(filename=tmpl_path, lookup=lookup)
            rendered = render_tmpl(tmpl, var, room=self.name)
            write_function(self.func_dir, func, rendered)

            # particle room is just different
            if self.name != 'particles':
                if var in used_names and used_names[var] != self.name:
                    raise NameError(
                        "Name collision in two rooms: %s in %s, %s" %
                        (var, self.name, used_names[var]))
                used_names[var] = self.name

            write_function(self.func_dir, "%s_home" % var,
                           tmpls["home"].render(var=var, room=self.name))
            if which in speeds and not os.path.exists(
                    tmpl_path.replace("_%s." % which, "_cur.")):
                rendered = render_tmpl(tmpl,
                                       var,
                                       suppress_loop=True,
                                       room=self.name)
                write_function(self.func_dir, "%s_cur" % var, rendered)

            # pos = "foo"
            # x, y, z = (int(x) for x in pos.split(r'[\~ ]+'))
            if func.endswith('_room_init'):
                write_function(self.func_dir, "_goto",
                               tmpls["goto"].render(room=self.name))

            if which and which not in misc:
                self.vars.add(var)
                entry = [
                    var,
                ]
                try:
                    self.lists[which] += entry
                except KeyError:
                    self.lists[which] = entry

        def generate(self):
            """
            Generate all the files for a single room (directory). First generate any specified templates. Next
            consume all the files, then generate all the room-wide files.
            :return:
            """
            self.run_shell_scripts()
            for tmpl_path in sorted(
                    glob.glob(os.path.join(self.room_dir,
                                           "*%s" % tmpl_suffix))):
                self.consume(tmpl_path)
            on_tick = []
            after_tick = []
            for which in self.lists:
                files = self.lists[which]
                rendered = tmpls["group"].render(room=self.name,
                                                 funcs=files,
                                                 which=which,
                                                 vars=self.vars)
                write_function(self.func_dir, "_%s" % which, rendered)
                if which[-4:] in speeds:
                    if len(which) == 4:
                        on_tick += [
                            which,
                        ]
                    else:
                        after_tick += [
                            which[-4:],
                        ]
            if on_tick or after_tick:
                rendered = tmpls["tick"].render(room=self.name,
                                                on_tick=on_tick,
                                                after_tick=after_tick)
                write_function(self.func_dir, "_tick", rendered)
                rendered = tmpls["finish"].render(room=self.name,
                                                  on_tick=on_tick,
                                                  after_tick=after_tick)
                write_function(self.func_dir, "_finish", rendered)
            for func in incr_funcs:
                if func == "finish":
                    continue
                rendered = tmpls[func].render(room=self.name, vars=self.vars)
                write_function(self.func_dir, "_%s" % func, rendered)
            rendered = tmpls["home"].render(var="finis", room=self.name)
            write_function(func_dir, "finish_home", rendered)

        def run_shell_scripts(self):
            """
            Run any shell scripts in the dir before generating templates. This is used to work around the fact that
            Minecraft equates one function per file, so to generate multiple functions, I have to generate multiple
            files. This seemed like a job for shell scripts.

            I thought of doing this using mako to generate mako templates, but the quoting issues....
            """
            for script in glob.glob(os.path.join(self.room_dir, "*.py]")):
                if exec(compile(open(script, "rb").read(), script,
                                'exec')) != 0:
                    sys.exit(-1)

    rooms = []
    for room_dir in glob.glob(os.path.join(tmpl_dir, '*/')):
        room = Room(room_dir)
        room.generate()
        rooms += [
            room.name,
        ]

    for f in incr_funcs + ("init", ):
        write_function(
            func_dir, "_%s" % f,
            "\n".join("function restworld:%s/_%s" % (r, f) for r in rooms))

    def sign_room(name, things, walls, button=False):
        return room_signs(
            '%s/%s' % (func_dir, name), name,
            Template(filename="%s/%s_sign%s" % (tmpl_dir, name, tmpl_suffix),
                     lookup=lookup),
            sorted(things, key=lambda x: x.name.replace('|', ' ')), walls,
            (1, 1.5, -1), button)

    sign_room("particles",
              particles, (
                  Wall(7, 5, "east", (-1, 0)),
                  Wall(7, 7, "south", (0, -1), y_first=4),
                  Wall(7, 5, "west", (1, 0)),
                  Wall(7, 5, "north", (0, 1)),
              ),
              button=True)
    commands = sign_room("effects", effects, (
        Wall(7, 5, "east", (-1, 0), used_widths=(3, 5, 3)),
        Wall(7, 5, "south", (0, -1), used_widths=(5, 5), y_first=2),
        Wall(7, 5, "west", (1, 0), used_widths=(3, 5, 3)),
        Wall(7, 5, "north", (0, 1)),
    ))
    all_effects = []
    for c in commands:
        if " air " in c:
            continue
        elif " oak_wall_sign" in c:
            all_effects.append(
                re.sub("oak_wall_sign.*", "emerald_block",
                       c).replace(" ^0 ", " ^1 "))
        else:
            all_effects.append(c)
    write_function("%s/%s" % (func_dir, "effects"), "effects_all_shown",
                   "\n".join(all_effects) + "\n")
Esempio n. 40
0
    def __init__(self,
                 short_name,
                 full_name,
                 owners,
                 categories,
                 added_default=None,
                 added_mandatory=None,
                 node_settings_model=None,
                 user_settings_model=None,
                 include_js=None,
                 include_css=None,
                 widget_help=None,
                 views=None,
                 configs=None,
                 models=None,
                 has_hgrid_files=False,
                 get_hgrid_data=None,
                 max_file_size=None,
                 high_max_file_size=None,
                 accept_extensions=True,
                 node_settings_template=None,
                 user_settings_template=None,
                 **kwargs):

        self.models = models
        self.settings_models = {}

        if node_settings_model:
            node_settings_model.config = self
            self.settings_models['node'] = node_settings_model

        if user_settings_model:
            user_settings_model.config = self
            self.settings_models['user'] = user_settings_model

        self.short_name = short_name
        self.full_name = full_name
        self.owners = owners
        self.categories = categories

        self.added_default = added_default or []
        self.added_mandatory = added_mandatory or []
        if set(self.added_mandatory).difference(self.added_default):
            raise ValueError('All mandatory targets must also be defaults.')

        self.include_js = self._include_to_static(include_js or {})
        self.include_css = self._include_to_static(include_css or {})

        self.widget_help = widget_help

        self.views = views or []
        self.configs = configs or []

        self.has_hgrid_files = has_hgrid_files
        # WARNING: get_hgrid_data can return None if the addon is added but has no credentials.
        self.get_hgrid_data = get_hgrid_data  # if has_hgrid_files and not get_hgrid_data rubeus.make_dummy()
        self.max_file_size = max_file_size
        self.high_max_file_size = high_max_file_size
        self.accept_extensions = accept_extensions

        # Provide the path the the user_settings template
        self.user_settings_template = user_settings_template
        if not user_settings_template or not os.path.exists(
                os.path.dirname(user_settings_template)):
            # Use the default template (ATM for OAuth addons)
            self.user_settings_template = USER_SETTINGS_TEMPLATE_DEFAULT

        # Provide the path the the node_settings template
        self.node_settings_template = node_settings_template
        if not node_settings_template or not os.path.exists(
                os.path.dirname(node_settings_template)):
            # Use the default template
            self.node_settings_template = NODE_SETTINGS_TEMPLATE_DEFAULT

        # Build template lookup
        template_dirs = list(
            set([
                path for path in [
                    os.path.dirname(self.user_settings_template),
                    os.path.dirname(self.node_settings_template),
                    settings.TEMPLATES_PATH
                ] if os.path.exists(path)
            ]))
        if template_dirs:
            self.template_lookup = TemplateLookup(directories=template_dirs)
        else:
            self.template_lookup = None
Esempio n. 41
0
class MakoTemplateLoader:
    '''Renders Mako templates.'''
    def __init__(self, app_path, template_subdir='templates'):
        '''
        Creates a renderer to the given template_subdir in app_path.

        The loader looks in the app_path/templates directory unless
        the template_subdir parameter overrides this default.

        You should not normally create this object because it bypasses
        the DMP cache.  Instead, call get_template_loader() or
        get_template_loader_for_path().
        '''
        # calculate the template directory and check that it exists
        if template_subdir == None:  # None skips adding the template_subdir
            template_dir = os.path.abspath(app_path)
        else:
            template_dir = os.path.abspath(
                os.path.join(app_path, template_subdir))
        # I used to check for the existence of the template dir here, but it caused error
        # checking at engine load time (too soon).  I now wait until get_template() is called,
        # which fails with a TemplateDoesNotExist exception if the template_dir doesn't exist.

        # calculate the cache root and template search directories
        self.cache_root = os.path.join(
            template_dir,
            DMP_OPTIONS.get('TEMPLATES_CACHE_DIR', '.cached_templates'))
        self.template_search_dirs = [template_dir]
        if DMP_OPTIONS.get('TEMPLATES_DIRS'):
            self.template_search_dirs.extend(DMP_OPTIONS.get('TEMPLATES_DIRS'))
        # Mako doesn't allow parent directory inheritance, such as <%inherit file="../../otherapp/templates/base.html"/>
        # including the project base directory allows this through "absolute" like <%inherit file="/otherapp/templates/base.html"/>
        # (note the leading slash, which means BASE_DIR)
        self.template_search_dirs.append(settings.BASE_DIR)

        # create the actual Mako TemplateLookup, which does the actual work
        self.tlookup = TemplateLookup(
            directories=self.template_search_dirs,
            imports=DMP_OPTIONS['DEFAULT_TEMPLATE_IMPORTS'],
            module_directory=self.cache_root,
            collection_size=2000,
            filesystem_checks=settings.DEBUG,
            input_encoding=DMP_OPTIONS.get('DEFAULT_TEMPLATE_ENCODING',
                                           'utf-8'))

    def get_template(self, template):
        '''Retrieve a *Django* API template object for the given template name, using the app_path and template_subdir
           settings in this object.  This method still uses the corresponding Mako template and engine, but it
           gives a Django API wrapper around it so you can use it the same as any Django template.

           This method corresponds to the Django templating system API.
           This method raises a Django exception if the template is not found or cannot compile.
        '''
        try:
            # wrap the mako template in an adapter that gives the Django template API
            return MakoTemplateAdapter(self.get_mako_template(template))
        except (TopLevelLookupException,
                TemplateLookupException) as e:  # Mako exception raised
            raise TemplateDoesNotExist(
                'Template "%s" not found in search path: %s.' %
                (template, self.template_search_dirs))
        except (CompileException,
                SyntaxException) as e:  # Mako exception raised
            raise TemplateSyntaxError('Template "%s" raised an error: %s' %
                                      (template, e))

    def get_mako_template(self, template):
        '''Retrieve the real *Mako* template object for the given template name without any wrapper,
           using the app_path and template_subdir settings in this object.

           This method is an alternative to get_template().  Use it when you need the actual Mako template object.
           This method raises a Mako exception if the template is not found or cannot compile.
        '''
        if template is None:
            raise TemplateLookupException(
                'Template "%s" not found in search path: %s.' %
                (template, self.template_search_dirs))

        # get the template
        template_obj = self.tlookup.get_template(template)

        # if this is the first time the template has been pulled from self.tlookup, add a few extra attributes
        if not hasattr(template_obj, 'template_path'):
            template_obj.template_path = template
        if not hasattr(template_obj, 'template_full_path'):
            template_obj.template_full_path = template_obj.filename

        # get the template
        return template_obj
Esempio n. 42
0
import glob
import common.print_color
import common.project_utils as project

console_encoding = sys.getfilesystemencoding()
script_dir = os.path.dirname(os.path.realpath(__file__))

if __name__ == '__main__':
    os.chdir(script_dir)
    from mako.template import Template
    from mako.lookup import TemplateLookup
    etc_template_dir = os.path.join(script_dir, 'helper', 'template', 'etc')
    script_template_dir = os.path.join(script_dir, 'helper', 'template',
                                       'script')
    project_lookup = TemplateLookup(
        directories=[etc_template_dir, script_template_dir],
        module_directory=os.path.join(script_dir, '.mako_modules'))

    parser = OptionParser("usage: %prog [options...]")
    parser.add_option(
        "-e",
        "--env-prefix",
        action='store',
        dest="env_prefix",
        default='AUTOBUILD_',
        help="prefix when read parameters from environment variables")
    parser.add_option("-c",
                      "--config",
                      action='store',
                      dest="config",
                      default=os.path.join(script_dir, 'config.conf'),
Esempio n. 43
0
class MakoTemplates(TemplateSystem):
    """Support for Mako templates."""

    name = "mako"

    lookup = None
    cache = {}
    filters = {}
    directories = []
    cache_dir = None

    def get_string_deps(self, text, filename=None):
        """Find dependencies for a template string."""
        lex = lexer.Lexer(text=text, filename=filename)
        lex.parse()

        deps = []
        for n in lex.template.nodes:
            keyword = getattr(n, 'keyword', None)
            if keyword in ["inherit", "namespace"] or isinstance(
                    n, parsetree.IncludeTag):
                deps.append(n.attributes['file'])
        # Some templates will include "foo.tmpl" and we need paths, so normalize them
        # using the template lookup
        for i, d in enumerate(deps):
            deps[i] = self.get_template_path(d)
        return deps

    def get_deps(self, filename):
        """Get paths to dependencies for a template."""
        text = util.read_file(filename)
        return self.get_string_deps(text, filename)

    def set_directories(self, directories, cache_folder):
        """Create a new template lookup with set directories."""
        cache_dir = os.path.join(cache_folder, '.mako.tmp')
        # Workaround for a Mako bug, Issue #825
        if sys.version_info[0] == 2:
            try:
                os.path.abspath(cache_dir).decode('ascii')
            except UnicodeEncodeError:
                cache_dir = tempfile.mkdtemp()
                LOGGER.warning(
                    'Because of a Mako bug, setting cache_dir to {0}'.format(
                        cache_dir))
        if os.path.exists(cache_dir):
            shutil.rmtree(cache_dir)
        self.directories = directories
        self.cache_dir = cache_dir
        self.create_lookup()

    def inject_directory(self, directory):
        """Add a directory to the lookup and recreate it if it's not there yet."""
        if directory not in self.directories:
            self.directories.append(directory)
            self.create_lookup()

    def create_lookup(self):
        """Create a template lookup."""
        self.lookup = TemplateLookup(directories=self.directories,
                                     module_directory=self.cache_dir,
                                     output_encoding='utf-8')

    def set_site(self, site):
        """Set the Nikola site."""
        self.site = site
        self.filters.update(self.site.config['TEMPLATE_FILTERS'])

    def render_template(self, template_name, output_name, context):
        """Render the template into output_name using context."""
        context['striphtml'] = striphtml
        template = self.lookup.get_template(template_name)
        data = template.render_unicode(**context)
        if output_name is not None:
            makedirs(os.path.dirname(output_name))
            with io.open(output_name, 'w', encoding='utf-8') as output:
                output.write(data)
        return data

    def render_template_to_string(self, template, context):
        """Render template to a string using context."""
        context.update(self.filters)
        return Template(template, lookup=self.lookup).render(**context)

    def template_deps(self, template_name):
        """Generate list of dependencies for a template."""
        # We can cache here because dependencies should
        # not change between runs
        if self.cache.get(template_name, None) is None:
            template = self.lookup.get_template(template_name)
            dep_filenames = self.get_deps(template.filename)
            deps = [template.filename]
            for fname in dep_filenames:
                deps += [fname] + self.get_deps(fname)
            self.cache[template_name] = deps
        return list(self.cache[template_name])

    def get_template_path(self, template_name):
        """Get the path to a template or return None."""
        try:
            t = self.lookup.get_template(template_name)
            return t.filename
        except exceptions.TopLevelLookupException:
            return None
Esempio n. 44
0
from flask import Flask, request
app = Flask(__name__)
from mako.template import Template as MakoTemplates
from mako.lookup import TemplateLookup
from jinja2 import Environment as Jinja2Environment
import tornado.template
import random
import time

try:
    from string import lowercase as ascii_lowercase
except ImportError:
    from string import ascii_lowercase

mylookup = TemplateLookup(directories=['/tpl'])

Jinja2Env = Jinja2Environment(line_statement_prefix='#')


def shutdown_server():
    func = request.environ.get('werkzeug.server.shutdown')
    if func is None:
        raise RuntimeError('Not running with the Werkzeug Server')
    func()


def randomword(length=8):
    return ''.join(random.choice(ascii_lowercase) for i in range(length))


@app.route("/reflect/<engine>")
Esempio n. 45
0
from mako.lookup import TemplateLookup
import os

here = os.path.normpath(os.path.dirname(__file__))

lookup = TemplateLookup(directories=[here],
                        output_encoding='utf-8',
                        encoding_errors='replace')


def render_template(template_name, **kwargs):
    t = lookup.get_template(template_name)
    return t.render(**kwargs)
Esempio n. 46
0
    def test_module_roundtrip(self):
        lookup = TemplateLookup()

        template = Template("""
        <%inherit file="base.html"/>
 
        % for x in range(5):
            ${x}
        % endfor
""",
                            lookup=lookup)

        base = Template("""
        This is base.
        ${self.body()}
""",
                        lookup=lookup)

        lookup.put_template("base.html", base)
        lookup.put_template("template.html", template)

        assert result_lines(
            template.render()) == ["This is base.", "0", "1", "2", "3", "4"]

        lookup = TemplateLookup()
        template = ModuleTemplate(template.module, lookup=lookup)
        base = ModuleTemplate(base.module, lookup=lookup)

        lookup.put_template("base.html", base)
        lookup.put_template("template.html", template)

        assert result_lines(
            template.render()) == ["This is base.", "0", "1", "2", "3", "4"]
Esempio n. 47
0
from osf.models.external import ExternalAccount
from osf.models.node import AbstractNode
from osf.models.user import OSFUser
from osf.utils.datetime_aware_jsonfield import DateTimeAwareJSONField
from osf.utils.fields import NonNaiveDateTimeField
from website import settings
from addons.base import logger, serializer
from website.oauth.signals import oauth_complete

lookup = TemplateLookup(
    directories=[settings.TEMPLATES_PATH],
    default_filters=[
        'unicode',  # default filter; must set explicitly when overriding
        # FIXME: Temporary workaround for data stored in wrong format in DB. Unescape it before it
        # gets re-escaped by Markupsafe. See [#OSF-4432]
        'temp_ampersand_fixer',
        'h',
    ],
    imports=[
        # FIXME: Temporary workaround for data stored in wrong format in DB. Unescape it before it
        # gets re-escaped by Markupsafe. See [#OSF-4432]
        'from website.util.sanitize import temp_ampersand_fixer',
    ])


class BaseAddonSettings(ObjectIDMixin, BaseModel):
    is_deleted = models.BooleanField(default=False)
    deleted = NonNaiveDateTimeField(null=True, blank=True)

    class Meta:
        abstract = True
Esempio n. 48
0
 def create_lookup(self):
     """Create a template lookup."""
     self.lookup = TemplateLookup(directories=self.directories,
                                  module_directory=self.cache_dir,
                                  output_encoding='utf-8')
Esempio n. 49
0
            'capabilities': infos,
            'terms': disclaimers,
        }

    data_file.close()
    return ret


here, _ = os.path.split(__file__)
here = os.path.abspath(here)

lookup = TemplateLookup(
    directories=[os.path.join(here, 'templates')],
    default_filters=[
        'unicode',  # default filter; must set explicitly when overriding
        'temp_ampersand_fixer',  # FIXME: Temporary workaround for data stored in wrong format in DB. Unescape it before it gets re-escaped by Markupsafe. See [#OSF-4432]
        'h',
    ],
    imports=[
        'from website.util.sanitize import temp_ampersand_fixer',  # FIXME: Temporary workaround for data stored in wrong format in DB. Unescape it before it gets re-escaped by Markupsafe. See [#OSF-4432]
    ])
template = lookup.get_template('capabilities.mako')

CAPABILITIES = read_capabilities(os.path.join(here, 'data', 'addons.json'))


def render_addon_capabilities(addons_available):

    rendered = {}

    for addon_config in addons_available:
        if addon_config.full_name in CAPABILITIES:
Esempio n. 50
0
# else:
#     default_folder='/usr/local/{{cookiecutter.package_name}}.'
# context['default_folder']=default_folder

from mako.template import Template
from mako.lookup import TemplateLookup

import os
workfolder = os.getcwd()

#mylookup = TemplateLookup(directories=[workfolder], module_directory='/tmp/mako_modules')
#mylookup = TemplateLookup(directories=[workfolder],strict_undefined=True)
#While it was usefull during programming to know each value is missing, its becoming hard to use strict_undefined=True
#Since for example when you pick trac, some variables are no longer available, hence we are getting keyErrors inside a pyramid code.
#To resolved the missing params that are specific to each framework, we need to use strict_undefined=False
mylookup = TemplateLookup(directories=[workfolder], strict_undefined=False)


def serve_template(templatename, **kwargs):
    mytemplate2 = mylookup.get_template(templatename)
    #print('Rendering: ' + templatename)
    #print(mytemplate2.render(**kwargs))
    return mytemplate2.render(**kwargs)


#This loops through a files in a workfolder. I need more testing to confirm the work folder is where I think it is.
#For now I'm changing to below where I explicily render the template by name.
# for myfolder in os.walk(workfolder):
#     for mytemplate in myfolder[2]:
#         newtemplate=serve_template(mytemplate,**context)
#         print(os.path.join(myfolder[0],mytemplate))
 def __init__(self, path, extra_vars):
     self.loader = TemplateLookup(directories=[path],
                                  output_encoding='utf-8')
     self.extra_vars = extra_vars
Esempio n. 52
0
# Copyright 2020 ETH Zurich and University of Bologna.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
#
# Fabian Schuiki <*****@*****.**>
# Florian Zaruba <*****@*****.**>

import math
import pathlib
import logging

from copy import copy
from mako.lookup import TemplateLookup
from . import util

templates = TemplateLookup(directories=[pathlib.Path(__file__).parent],
                           output_encoding="utf-8")

xbars = list()
code_package = ""
code_module = dict()


# An address map.
class AddrMap(object):
    def __init__(self):
        self.entries = list()
        self.leaves = list()
        self.nodes = list()
        pass

    def new_leaf(self, *args, **kwargs):
Esempio n. 53
0
def _write_httpd_conf(pubs,
                      default_pubs,
                      runtime_dir,
                      log_dir,
                      template_dir,
                      cache_dir,
                      cache_size,
                      host,
                      port,
                      sroot,
                      fragment=False,
                      allow_refresh=False,
                      ssl_cert_file="",
                      ssl_key_file="",
                      ssl_cert_chain_file=""):
    """Writes the webserver configuration for the depot.

        pubs            repository and publisher information, a list in the form
                        [(publisher_prefix, repo_dir, repo_prefix,
                            writable_root), ... ]
        default_pubs    default publishers, per repository, a list in the form
                        [(default_publisher_prefix, repo_dir, repo_prefix) ... ]

        runtime_dir     where we write httpd.conf files
        log_dir         where Apache should write its log files
        template_dir    where we find our Mako templates
        cache_dir       where Apache should write its cache and wsgi search idx
        cache_size      how large our cache can grow
        host            our hostname, needed to set ServerName properly
        port            the port on which Apache should listen
        sroot           the prefix into the server namespace,
                        ignored if fragment==False
        fragment        True if we should only write a file to drop into conf.d/
                        (i.e. a partial server configuration)

        allow_refresh   True if we allow the 'refresh' or 'refresh-indexes'
                        admin/0 operations

        The URI namespace we create on the web server looks like this:

        <sroot>/<repo_prefix>/<publisher>/<file, catalog etc.>/<version>/
        <sroot>/<repo_prefix>/<file, catalog etc.>/<version>/

        'sroot' is only used when the Apache server is serving other content
        and we want to separate pkg(5) resources from the other resources
        provided.

        'repo_prefix' exists so that we can disambiguate between multiple
        repositories that provide the same publisher.

        'ssl_cert_file' the location of the server certificate file.

        'ssl_key_file' the location of the server key file.

        'ssl_cert_chain_file' the location of the certificate chain file if the
            the server certificate is not signed by the top level CA.
        """

    try:
        # check our hostname
        socket.getaddrinfo(host, None)

        # Apache needs IPv6 addresses wrapped in square brackets
        if ":" in host:
            host = "[{0}]".format(host)

        # check our directories
        dirs = [runtime_dir]
        if not fragment:
            dirs.append(log_dir)
        if cache_dir:
            dirs.append(cache_dir)
        for dir in dirs + [template_dir]:
            if os.path.exists(dir) and not os.path.isdir(dir):
                raise DepotException(_("{0} is not a directory").format(dir))

        for dir in dirs:
            misc.makedirs(dir)

        # check our port
        if not fragment:
            try:
                num = int(port)
                if num <= 0 or num >= 65535:
                    raise DepotException(_("invalid port: {0}").format(port))
            except ValueError:
                raise DepotException(_("invalid port: {0}").format(port))

        # check our cache size
        try:
            num = int(cache_size)
            if num < 0:
                raise DepotException(
                    _("invalid cache size: "
                      "{0}").format(num))
        except ValueError:
            raise DepotException(
                _("invalid cache size: {0}").format(cache_size))

        httpd_conf_template_path = os.path.join(template_dir,
                                                DEPOT_HTTP_TEMPLATE)
        fragment_conf_template_path = os.path.join(template_dir,
                                                   DEPOT_FRAGMENT_TEMPLATE)

        # we're disabling unicode here because we want Mako to
        # passthrough any filesystem path names, whatever the
        # original encoding.
        conf_lookup = TemplateLookup(directories=[template_dir])
        if fragment:
            conf_template = Template(filename=fragment_conf_template_path,
                                     disable_unicode=True,
                                     lookup=conf_lookup)
            conf_path = os.path.join(runtime_dir, DEPOT_FRAGMENT_FILENAME)
        else:
            conf_template = Template(filename=httpd_conf_template_path,
                                     disable_unicode=True,
                                     lookup=conf_lookup)
            conf_path = os.path.join(runtime_dir, DEPOT_HTTP_FILENAME)

        conf_text = conf_template.render(
            pubs=pubs,
            default_pubs=default_pubs,
            log_dir=log_dir,
            cache_dir=cache_dir,
            cache_size=cache_size,
            runtime_dir=runtime_dir,
            template_dir=template_dir,
            ipv6_addr="::1",
            host=host,
            port=port,
            sroot=sroot,
            allow_refresh=allow_refresh,
            ssl_cert_file=ssl_cert_file,
            ssl_key_file=ssl_key_file,
            ssl_cert_chain_file=ssl_cert_chain_file)

        with file(conf_path, "wb") as conf_file:
            conf_file.write(conf_text)

    except socket.gaierror as err:
        raise DepotException(
            _("Unable to write Apache configuration: {host}: "
              "{err}").format(**locals()))
    except (OSError, IOError, EnvironmentError, apx.ApiException) as err:
        traceback.print_exc(err)
        raise DepotException(
            _("Unable to write depot_httpd.conf: {0}").format(err))
Esempio n. 54
0
import cgi

from mako.lookup import TemplateLookup
from mako import exceptions

tl = TemplateLookup(directories=['templates'])


def serve_template(templatename, **kwargs):
    print get_template(templatename, **kwargs)


def get_template(templatename, **kwargs):
    form = cgi.FieldStorage()
    if form.getfirst("view") == "json":
        template = "json/" + templatename
    else:
        template = templatename
    try:
        mytemplate = tl.get_template(template)
        return mytemplate.render(**kwargs)
    except:
        return exceptions.text_error_template().render()


def redirect_302(redirectionTo):
    print "Status: 302 Found"
    print "Location: " + redirectionTo
    print

Esempio n. 55
0
 def __init__(self):
     self.lookup = TemplateLookup(
         directories=[path(__file__).dirname() / 'templates'])
     self.DEBUG = True
Esempio n. 56
0
import os
import json
import argparse

import cherrypy
from mako.lookup import TemplateLookup

from bookworm.seg import search
from bookworm.repo import key_to_path

template_dir = os.path.join(os.path.dirname(__file__), 'template')
lookup = TemplateLookup(directories=[template_dir])


def get_item(match):
    meta = json.loads(match.document.get_data())
    if not meta['paths']:
        return

    key = meta['key']
    docpath = meta['paths'][0]
    #FIXME: hardcode here
    docpath = os.path.join('files', docpath.split('Documents/ebook/')[1])
    title = os.path.basename(docpath).replace('.', ' ').replace('_', ' ')

    item = {
        'rank': match.rank,
        'docid': match.docid,
        'filelink': docpath,
        'title': title,
        'key': key,
Esempio n. 57
0
from mako.template import Template
from mako.lookup import TemplateLookup

cpp_template_lookup = TemplateLookup(directories=['./templates/cpp'],
                                     encoding_errors='replace')
rust_template_lookup = TemplateLookup(directories=['./templates/rust'],
                                      encoding_errors='replace')
swift_template_lookup = TemplateLookup(directories=['./templates/swift'],
                                       encoding_errors='replace')
kotlin_template_lookup = TemplateLookup(directories=['./templates/kotlin'],
                                        encoding_errors='replace')


class Ident:
    def __init__(self, name):
        self.name = name

    @property
    def snake_case(self):
        return self.name

    @property
    def camel_case(self):
        chunks = self.name.split('_')
        if len(chunks) < 2:
            return self.name
        return ''.join(
            [chunks[0], ''.join([x.capitalize() for x in chunks[1:]])])

    @property
    def pascal_case(self):
Esempio n. 58
0
"""
import sys
reload(sys)
sys.setdefaultencoding("utf-8")

from configuration import *
from objects import *
import cherrypy
from bs4 import BeautifulSoup
from mako.lookup import TemplateLookup
from user_agents import parse

__author__ = 'sergey'

lookup = TemplateLookup(directories=["./templates"],
                        output_encoding="utf-8",
                        input_encoding="utf-8",
                        encoding_errors="replace")


class ShowNotification(object):
    def _cp_dispatch(self, vpath):
        """
        Обработка REST URL
        """
        print "ShowNotification"
        print vpath
        return self

    @cherrypy.expose
    def index(self, error=None, url=None):
        tmpl = lookup.get_template("error.html")
Esempio n. 59
0
class CrabWeb(CrabWebBase):
    """CherryPy handler for the HTML part of the crab web interface."""
    def __init__(self, crab_home, options):
        """Constructor for CrabWeb class.

        Stores a reference to the given storage backend, and
        the home directory from the config dict.  Prepares the template
        engine and instantiates a CrabWebQuery object which CherryPy
        can find as 'query'."""

        super(CrabWeb, self).__init__(cherrypy.engine)

        self.options = options
        self.templ = TemplateLookup(directories=[crab_home + '/templ'])
        self.query = CrabWebQuery()

    def subscribe(self):
        super(CrabWeb, self).subscribe()
        self.query.subscribe()

    @cherrypy.expose
    def index(self):
        """Displays the main crab dashboard."""

        try:
            jobs = self.store.get_jobs()
            return self._write_template('joblist.html', {'jobs': jobs})

        except CrabError as err:
            raise HTTPError(message=str(err))

    @cherrypy.expose
    def job(self,
            id_,
            command=None,
            finishid=None,
            barerows=None,
            unfiltered=None,
            limit=None,
            enddate=None,
            submit_config=None,
            submit_relink=None,
            submit_confirm=None,
            submit_cancel=None,
            orphan=None,
            graceperiod=None,
            timeout=None,
            success_pattern=None,
            warning_pattern=None,
            fail_pattern=None,
            note=None,
            inhibit=None,
            crabid=None,
            submit_notify=None,
            **kwargs):
        """Displays information about a current job.

        Currently also supports showing the job output.
        If command='output' but the finishid is not provided, then
        it will find the most recent output for the given job."""

        try:
            id_ = int(id_)
        except ValueError:
            raise HTTPError(400, 'Job number not a number')

        info = self.store.get_job_info(id_)
        if info is None:
            raise HTTPError(404, 'Job not found')

        if command is None:
            if limit is None:
                limit = 100
            else:
                try:
                    limit = int(limit)
                except ValueError:
                    raise HTTPError(400, 'Limit is not a number')
                if limit < 1:
                    raise HTTPError(400, 'Limit should not be less than one')
                elif limit > 1000:
                    raise HTTPError(400, 'Limit greater than a thousand')

            if unfiltered is None:
                squash_start = True
            else:
                squash_start = False

            if enddate is not None:
                try:
                    enddate = parse_datetime(enddate)
                except ValueError:
                    raise HTTPError(400, 'Start date format is invalid')

            events = self.store.get_job_events(id_, limit, end=enddate)

            if events:
                lastdatetime = format_datetime(events[-1]['datetime'])
            else:
                lastdatetime = None

            # Filter the events.
            filter = CrabEventFilter(self.store, info['timezone'])
            events = filter(events,
                            squash_start=squash_start,
                            skip_trivial=squash_start)

            if barerows is not None:
                return self._write_template('jobevents.html', {
                    'id': id_,
                    'events': events,
                    'lastdatetime': lastdatetime
                })

            # Try to convert the times to the timezone shown on the page.
            info['installed'] = filter.in_timezone(info['installed'])
            info['deleted'] = filter.in_timezone(info['deleted'])

            # Fetch configuration.
            config = self.store.get_job_config(id_)

            # Fetch job notifications.
            if config is not None:
                notification = self.store.get_job_notifications(
                    config['configid'])
            else:
                notification = None

            return self._write_template(
                'job.html', {
                    'id': id_,
                    'info': info,
                    'config': config,
                    'status': self.monitor.get_job_status(id_),
                    'notification': notification,
                    'events': events,
                    'lastdatetime': lastdatetime
                })

        elif command == 'clear':
            if submit_confirm:
                self.store.log_alarm(id_, CrabStatus.CLEARED)

                # Wait for the monitor to process new events so that
                # that the job is in an 'OK' state before we reload the page.
                with self.monitor.new_event:
                    self.monitor.new_event.wait(10)

                raise HTTPRedirect("/job/" + str(id_))

            elif submit_cancel:
                raise HTTPRedirect("/job/" + str(id_))

            else:
                return self._write_template(
                    'confirm.html', {
                        'id': id_,
                        'info': info,
                        'title': 'clear status',
                        'description': 'Reset the job status?',
                        'target': '/job/' + str(id_) + '/clear'
                    })

        elif command == 'uninhibit':
            if submit_confirm:
                self.store.disable_inhibit(id_)
                raise HTTPRedirect('/job/' + str(id_))
            elif submit_cancel:
                raise HTTPRedirect('/job/' + str(id_))
            else:
                return self._write_template(
                    'confirm.html', {
                        'id': id_,
                        'info': info,
                        'title': 'resume',
                        'description': 'Resume inhibited job?',
                        'target': '/job/' + str(id_) + '/uninhibit'
                    })

        elif command == 'delete':
            notdeleted = info['deleted'] is None
            if submit_confirm:
                if notdeleted:
                    self.store.delete_job(id_)
                else:
                    self.store.undelete_job(id_)

                raise HTTPRedirect('/job/' + str(id_))

            elif submit_cancel:
                raise HTTPRedirect('/job/' + str(id_))

            else:
                return self._write_template(
                    'confirm.html', {
                        'id':
                        id_,
                        'info':
                        info,
                        'title':
                        'delete' if notdeleted else 'undelete',
                        'description':
                        (('Delete' if notdeleted else 'Undelete') +
                         ' this job from the server?'),
                        'target':
                        '/job/' + str(id_) + '/delete'
                    })

        elif command == 'changeid':
            if submit_confirm:
                if crabid != '':
                    if self.store.get_jobs(info['host'],
                                           info['user'],
                                           include_deleted=True,
                                           crabid=crabid):
                        raise HTTPError(400,
                                        'Specified job ID already exists.')
                    else:
                        self.store.update_job(id_, crabid=crabid)
                        raise HTTPRedirect('/job/' + str(id_))
                else:
                    raise HTTPError(400, 'Specified job ID is blank.')

            elif submit_cancel:
                raise HTTPRedirect('/job/' + str(id_))

            else:
                return self._write_template(
                    'confirm.html', {
                        'id':
                        id_,
                        'info':
                        info,
                        'title':
                        'change identifier',
                        'description':
                        'Change Job ID for this job?  Please note '
                        'that the ID which will be used to report '
                        'events related to this job should be '
                        'updated at the same time to ensure that '
                        'the job continues to be correctly '
                        'identified.  This should be done in the '
                        'crontab if the CRABID variable is used, '
                        'or in the cron job itself in the case '
                        'of Crab-aware cron jobs.',
                        'target':
                        '/job/' + str(id_) + '/changeid',
                        'data': {
                            'crabid': crabid
                        }
                    })

        elif command == 'output':
            finishid_next = None
            finishid_prev = None

            if finishid is None:
                # If finishid is not specified, select the most recent
                # for this job.
                finishes = self.store.get_job_finishes(id_, limit=2)

                if not finishes:
                    raise HTTPError(404, 'No job output found')

                finish = finishes[0]
                finishid = finish['finishid']

                if len(finishes) > 1:
                    finishid_prev = finishes[1]['finishid']

            else:
                try:
                    finishid = int(finishid)
                except ValueError:
                    raise HTTPError(400, 'Finish ID is not a number')

                finishes = self.store.get_job_finishes(id_, finishid=finishid)
                if not finishes:
                    raise HTTPError(404, 'Finish ID not found or wrong job')
                finish = finishes[0]

                finishes = self.store.get_job_finishes(id_, 1, before=finishid)
                if finishes:
                    finishid_prev = finishes[0]['finishid']

                finishes = self.store.get_job_finishes(id_, 1, after=finishid)
                if finishes:
                    finishid_next = finishes[0]['finishid']

            (stdout,
             stderr) = self.store.get_job_output(finishid, info['host'],
                                                 info['user'], id_,
                                                 info['crabid'])

            filter = CrabEventFilter(self.store, info['timezone'])
            finish['datetime'] = filter.in_timezone(finish['datetime'])

            return self._write_template(
                'joboutput.html', {
                    'id': id_,
                    'info': info,
                    'finish': finish,
                    'stdout': stdout,
                    'stderr': stderr,
                    'next': finishid_next,
                    'prev': finishid_prev
                })

        elif command == 'config':
            if submit_relink:
                try:
                    orphan = int(orphan)
                except ValueError:
                    raise HTTPError(400, 'Orphan number not a number')

                self.store.relink_job_config(orphan, id_)
                raise HTTPRedirect("/job/" + str(id_))

            elif submit_config:
                try:
                    if timeout == '':
                        timeout = None
                    elif timeout is not None:
                        timeout = int(timeout)
                    if graceperiod == '':
                        graceperiod = None
                    elif graceperiod is not None:
                        graceperiod = int(graceperiod)

                    if success_pattern == '':
                        success_pattern = None
                    if warning_pattern == '':
                        warning_pattern = None
                    if fail_pattern == '':
                        fail_pattern = None

                    if note is not None:
                        note = note.strip()
                        if note == '':
                            note = None

                    inhibit = inhibit is not None

                except ValueError:
                    raise HTTPError(400, 'Time not a number')

                self.store.write_job_config(id_, graceperiod, timeout,
                                            success_pattern, warning_pattern,
                                            fail_pattern, note, inhibit)
                raise HTTPRedirect("/job/" + str(id_))

            else:
                config = self.store.get_job_config(id_)

                if config is None:
                    orphan = self.store.get_orphan_configs()
                else:
                    orphan = None

                return self._write_template('jobconfig.html', {
                    'id': id_,
                    'info': info,
                    'config': config,
                    'orphan': orphan
                })

        elif command == 'notify':
            if submit_notify:
                # Ensure that this job has a configuration entry
                # so that we can link to it.
                config = self.store.get_job_config(id_)

                if config is not None:
                    configid = config['configid']
                else:
                    configid = self.store.write_job_config(id_)

                # Make a list of notifications for this job
                # so that we can delete those which are not
                # included in the POST parameters.
                existing = set()
                for notification in self.store.get_job_notifications(configid):
                    existing.add(notification['notifyid'])

                # Update existing notifications.
                for kwarg in kwargs:
                    match = re.search('method_(new_)?(\d+)', kwarg)
                    if not match:
                        continue

                    if match.group(1):
                        key = ''.join(match.groups())
                        notifyid = None
                    else:
                        key = match.group(2)
                        notifyid = int(key)
                        existing.discard(notifyid)

                    self.store.write_notification(
                        notifyid, configid, None, None,
                        kwargs['method_' + key], kwargs['address_' + key],
                        empty_to_none(kwargs['time_' + key]),
                        empty_to_none(kwargs['timezone_' + key]),
                        'include_ok_' + key not in kwargs,
                        'include_warning_' + key not in kwargs,
                        'include_error_' + key not in kwargs,
                        'include_output_' + key in kwargs)

                # Delete existing notifications which were not present.
                for notifyid in existing:
                    self.store.delete_notification(notifyid)

                raise HTTPRedirect('/job/' + str(id_))
            else:
                config = self.store.get_job_config(id_)

                if config is not None:
                    notifications = self.store.get_job_notifications(
                        config['configid'])
                else:
                    notifications = None

                return self._write_template(
                    'editnotify.html', {
                        'match_mode': False,
                        'id': id_,
                        'info': info,
                        'notifications': notifications
                    })

        else:
            raise HTTPError(404, 'Unknown job command')

    @cherrypy.expose
    def user(self, user):
        """Displays crontabs belonging to a particular user."""
        return self._user_host_crontabs(user=user)

    @cherrypy.expose
    def host(self, host):
        """Displays crontabs belonging to a particular user."""
        return self._user_host_crontabs(host=host)

    def _user_host_crontabs(self, host=None, user=None):
        """Displays crontab listing, either by host or user."""

        jobs = {}
        raw = {}
        info = {'jobs': jobs, 'raw': raw}

        if host is None and user is not None:
            by_user = False
            info['user'] = user
            info['host'] = None
        elif host is not None and user is None:
            by_user = True
            info['host'] = host
            info['user'] = None
        else:
            raise HTTPError(500, 'Need one of host or user to be specified')

        for job in self.store.get_jobs(host, user, include_deleted=True):
            if by_user:
                key = job['user']
            else:
                key = job['host']

            if key in jobs:
                jobs[key].append(job)
            else:
                jobs[key] = [job]
                raw[key] = self.store.get_raw_crontab(job['host'], job['user'])

        return self._write_template('crontabs.html', info)

    @cherrypy.expose
    def notify(self, submit_notify=None, **kwargs):
        """Allows match-based notifications to be viewed and configured."""

        notifications = self.store.get_match_notifications()

        if submit_notify:
            # Make a list of notifications for this job
            # so that we can delete those which are not
            # included in the POST parameters.
            existing = set()
            for notification in notifications:
                existing.add(notification['notifyid'])

            # Update existing notifications.
            for kwarg in kwargs:
                match = re.search('method_(new_)?(\d+)', kwarg)
                if not match:
                    continue

                if match.group(1):
                    key = ''.join(match.groups())
                    notifyid = None
                else:
                    key = match.group(2)
                    notifyid = int(key)
                    existing.discard(notifyid)

                self.store.write_notification(
                    notifyid, None, empty_to_none(kwargs['host_' + key]),
                    empty_to_none(kwargs['user_' + key]),
                    kwargs['method_' + key], kwargs['address_' + key],
                    empty_to_none(kwargs['time_' + key]),
                    empty_to_none(kwargs['timezone_' + key]),
                    'include_ok_' + key not in kwargs, 'include_warning_' + key
                    not in kwargs, 'include_error_' + key not in kwargs,
                    'include_output_' + key in kwargs)

            # Delete existing notifications which were not present.
            for notifyid in existing:
                self.store.delete_notification(notifyid)

            raise HTTPRedirect('/')
        else:
            return self._write_template('editnotify.html', {
                'match_mode': True,
                'notifications': notifications
            })

    @cherrypy.expose
    def dynres(self, name):
        if name == 'crabutil.js':
            return self._write_template('dynres/crabutil.js', {})
        else:
            raise HTTPError(404, 'Dynamic resource not found')

    def _write_template(self, name, dict={}):
        """Returns the output from the named template when rendered
        with the given dict.

        Traps template errors and uses mako.exceptions to display them."""

        try:
            template = self.templ.get_template(name)
            return template.render(options=self.options, **dict)
        except:
            return exceptions.html_error_template().render()
Esempio n. 60
0
#
# Copyright [2010-2014] Institute of Nuclear Physics PAN, Krakow, Poland
#
# Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
# @COPYRIGHT_end
"""@package src.ec2

@copyright Copyright (c) 2012 Institute of Nuclear Physics PAS <http://www.ifj.edu.pl/>
@author Oleksandr Gituliar <*****@*****.**>
"""

import os.path

from mako.lookup import TemplateLookup

lookup = TemplateLookup(
    directories=[os.path.join(os.path.dirname(__file__), 'templates')],
    output_encoding='utf-8',
)