def __call__(self): cont = CTK.Container() check_new_cert = CTK.CheckCfgText('%s!gen_autosigned_cert' % (PREFIX), True, _("New self-signed cert.")) table = CTK.PropsTable() table.Add(_('Auto-generate Certificate'), check_new_cert, _(NOTE_GEN_SELFSIGNED_CERT)) submit = CTK.Submitter(URL_APPLY) submit += table # Certs details table = CTK.PropsTable() table.Add( _('Certificate'), CTK.TextCfg('%s!cert' % (PREFIX), False, {'class': 'noauto'}), _(NOTE_CERT)) table.Add( _('Certificate Key'), CTK.TextCfg('%s!cert_key' % (PREFIX), False, {'class': 'noauto'}), _(NOTE_CERT_KEY)) cert_details = CTK.Box({'style': 'display:none;'}) cert_details += table submit_certs = CTK.Submitter(URL_APPLY) submit_certs += cert_details # Events check_new_cert.bind( 'change', "if ($(this).find(':checked').size() <= 0) {%s} else {%s}" % (cert_details.JS_to_show(), cert_details.JS_to_hide())) # Layout cont += CTK.RawHTML("<h2>%s</h2>" % (_("Certificate file"))) cont += submit cont += submit_certs # Global Submit submit = CTK.Submitter(URL_APPLY) submit += CTK.Hidden('final', '1') cont += submit cont += CTK.DruidButtonsPanel_PrevCreate_Auto() return cont.Render().toStr()
def __init__(self, vsrv_num, refresh): CTK.Container.__init__(self) pre = "vserver!%s" % (vsrv_num) url_apply = "%s/%s" % (URL_APPLY, vsrv_num) if CTK.cfg.get_val('%s!match' % (pre)): table = CTK.PropsAuto(url_apply) table.Add( _('Match nickname'), CTK.CheckCfgText('%s!match!nick' % (pre), True, _('Match')), _(NOTE_MATCH_NICK)) submit = CTK.Submitter(url_apply) submit += CTK.Indenter(table) self += CTK.RawHTML('<h2>%s</h2>' % (_('Host Match'))) self += submit
def __init__(self, key, **kwargs): Handler.PluginHandler.__init__(self, key, **kwargs) Handler.PluginHandler.AddCommon(self) rate = CTK.CheckCfgText("%s!rate" % (key), True, _('Enabled')) table = CTK.PropsTable() table.Add(_("Auto Rate"), rate, _(NOTE_RATE)) table.Add(_("Speedup Factor"), CTK.TextCfg("%s!rate_factor" % (key), True), _(NOTE_RATE_FACTOR)) table.Add(_("Initial Boost"), CTK.TextCfg("%s!rate_boost" % (key), True), _(NOTE_RATE_BOOST)) rate.bind( 'change', """if ($('#%(rate)s :checkbox')[0].checked) { $('#%(row1)s').show(); $('#%(row2)s').show(); } else { $('#%(row1)s').hide(); $('#%(row2)s').hide(); }""" % ({ 'rate': rate.id, 'row1': table[1].id, 'row2': table[2].id })) submit = CTK.Submitter(URL_APPLY) submit += table # Streaming self += CTK.RawHTML('<h2>%s</h2>' % (_('Audio/Video Streaming'))) self += CTK.Indenter(submit) # File self += instance_plugin('file', key, show_document_root=False) # Publish VALS = [("%s!rate_factor" % (key), validations.is_float), ("%s!rate_boost" % (key), validations.is_number_gt_0)] CTK.publish('^%s' % (URL_APPLY), CTK.cfg_apply_post, validation=VALS, method="POST")
def __init__ (self, key, **kwargs): RulePlugin.__init__ (self, key) props = ({},{'class': 'noauto'})[key.startswith('tmp')] table = CTK.PropsTable() table.Add (_('Extensions'), CTK.TextCfg('%s!extensions'%(key), False, props), _(NOTE_EXTENSIONS)) table.Add (_('Check local file'), CTK.CheckCfgText('%s!check_local_file'%(key), False, _('Check'), props), _(NOTE_CHECK_LOCAL)) submit = CTK.Submitter (URL_APPLY) submit += CTK.Hidden ('key', key) submit += CTK.Hidden ('vsrv_num', kwargs.pop('vsrv_num', '')) submit += table self += submit # Validation, and Public URLs VALS = [("tmp!extensions", validations.is_extension_list), ("%s!extensions"%(key), validations.is_extension_list)] CTK.publish (URL_APPLY, commit, validation=VALS, method="POST")
def __init__(self, key, **kwargs): kwargs['show_document_root'] = False Handler.PluginHandler.__init__(self, key, **kwargs) Handler.PluginHandler.AddCommon(self) table = CTK.PropsTable() table.Add(_('SubscriberID'), CTK.TextCfg('%s!subscriberid' % (key), False), _(NOTE_SUBSCRIBERID)) table.Add(_('Version'), CTK.TextCfg('%s!version' % (key), False), _(NOTE_VERSION)) table.Add(_('Dossier Name'), CTK.TextCfg('%s!dossiername' % (key), False), _(NOTE_DOSSIERNAME)) table.Add(_('Endpoint'), CTK.TextCfg('%s!endpoint' % (key), False), _(NOTE_ENDPOINT)) table.Add(_('Validate XML'), CTK.CheckCfgText('%s!validate_xml' % (key), False), _(NOTE_VALIDATE_XML)) table.Add(_('I/O Threads'), CTK.TextCfg('%s!io_threads' % (key), True), _(NOTE_IO_THREADS)) table.Add( _("Compression Level"), CTK.ComboCfg('%s!encoder!compression_level' % (key), consts.COMPRESSION_LEVELS), _(NOTE_LEVEL)) submit = CTK.Submitter(URL_APPLY) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('Transmodel parameters'))) self += CTK.Indenter(submit) VALS = [("%s!subscriberid" % (key), validations.is_not_empty), ("%s!version" % (key), validations.is_not_empty), ("%s!dossiername" % (key), validations.is_not_empty), ("%s!endpoint" % (key), validations.is_not_empty), ("%s!io_threads" % (key), validations.is_number_gt_0)] CTK.cfg['%s!encoder' % (key)] = 'allow' CTK.publish('^%s' % (URL_APPLY), CTK.cfg_apply_post, validation=VALS, method="POST")
def build(self): table = CTK.PropsTable() table.Add( _('Collect Statistics'), CTK.CheckCfgText( 'vserver!%s!collector!enabled' % (self.graph['num']), self.collector, _('Enabled')), _(NOTE_COLLECTOR)) submit = CTK.Submitter(URL_APPLY) submit += table submit.bind('submit_success', self.refresh.JS_to_refresh()) if self.collector: self.build_graph() props = {'class': 'graph_props_bottom'} else: props = {'class': 'graph_props_top'} if CTK.cfg.get_val('server!collector') == 'rrd': self += CTK.Indenter(CTK.Box(props, submit))
def __init__(self, key, **kwargs): Auth.PluginAuth.__init__(self, key, **kwargs) self.AddCommon(supported_methods=('basic', )) table = CTK.PropsTable() table.Add(_("Server"), CTK.TextCfg("%s!server" % (self.key), False), _(NOTE_SERVER)) table.Add(_("Port"), CTK.TextCfg("%s!port" % (self.key), True), _(NOTE_PORT)) table.Add(_("Bind Domain"), CTK.TextCfg("%s!bind_dn" % (self.key), True), _(NOTE_BIND_DOMAIN)) table.Add(_("Bind Password"), CTK.TextCfg("%s!bind_pw" % (self.key), True), _(NOTE_BIND_PASSWD)) table.Add(_("Base Domain"), CTK.TextCfg("%s!base_dn" % (self.key), False), _(NOTE_BIND_DOMAIN)) table.Add(_("Filter"), CTK.TextCfg("%s!filter" % (self.key), True), _(NOTE_FILTER)) table.Add(_("Use TLS"), CTK.CheckCfgText("%s!tls" % (self.key), False, _('Enabled')), _(NOTE_USE_TLS)) table.Add(_("CA File"), CTK.TextCfg("%s!ca_file" % (self.key), True), _(NOTE_CA_FILE)) submit = CTK.Submitter(URL_APPLY) submit += table self += CTK.RawHTML("<h2>%s</h2>" % (_('LDAP Connection'))) self += CTK.Indenter(submit) # Publish VALS = [("%s!ca_file" % (self.key), validations.is_local_file_exists), ("%s!port" % (self.key), validations.is_tcp_port)] CTK.publish('^%s' % (URL_APPLY), CTK.cfg_apply_post, validation=VALS, method="POST")
def __init__(self): CTK.Container.__init__(self) table = CTK.PropsAuto(URL_APPLY) table.Add( _('Allow SSL v2'), CTK.CheckCfgText('server!tls!protocol!SSLv2', False, _("Allow")), _(NOTE_TLS_SSLv2)) table.Add(_('Handshake Timeout'), CTK.TextCfg('server!tls!timeout_handshake', True), _(NOTE_TLS_TIMEOUT)) table.Add(_('DH parameters: 512 bits'), CTK.TextCfg('server!tls!dh_param512', True), _(NOTE_DH512)) table.Add(_('DH parameters: 1024 bits'), CTK.TextCfg('server!tls!dh_param1024', True), _(NOTE_DH1024)) table.Add(_('DH parameters: 2048 bits'), CTK.TextCfg('server!tls!dh_param2048', True), _(NOTE_DH2048)) table.Add(_('DH parameters: 4096 bits'), CTK.TextCfg('server!tls!dh_param4096', True), _(NOTE_DH4096)) self += CTK.RawHTML("<h2>%s</h2>" % (_('TLS'))) self += CTK.Indenter(table)
def __init__(self): CTK.Box.__init__(self, { 'id': 'remote-services-section', 'class': 'infosection' }) submit = CTK.Submitter(REMOTE_SERVS_APPLY) submit += CTK.CheckCfgText("admin!ows!enabled", True, _(REMOTE_SERVS_ENABLE)) submit.bind('submit_success', CTK.JS.GotoURL('/')) infotable = CTK.Table({'class': 'info-table'}) infotable.set_header(column=True, num=1) if int(CTK.cfg.get_val("admin!ows!enabled", OWS_ENABLE)): if OWS_Login.is_logged(): infotable += [submit, OWS_Login.LoggedAs_Text()] else: dialog = OWS_Login.LoginDialog() dialog.bind('submit_success', CTK.JS.GotoURL('/')) link = CTK.Link( "#", CTK.RawHTML('<span>%s</span>' % (_('Sign in')))) link.bind('click', dialog.JS_to_show()) cont = CTK.Container() cont += dialog cont += link infotable += [submit, cont] else: infotable += [submit] table = CTK.Table() table.set_header(column=True, num=1) table += [CTK.RawHTML(_('Remote Services')), infotable] self += table
def __init__(self): CTK.Container.__init__(self) table = CTK.PropsAuto(URL_APPLY) table.Add(_('Status'), CTK.CheckCfgText('server!iocache', True, _('Enabled')), _(NOTE_IO_ENABLED)) table.Add(_('Max pages'), CTK.TextCfg('server!iocache!max_size', True), _(NOTE_IO_SIZE)) table.Add(_('File Min Size'), CTK.TextCfg('server!iocache!min_file_size', True), _(NOTE_IO_MIN_SIZE)) table.Add(_('File Max Size'), CTK.TextCfg('server!iocache!max_file_size', True), _(NOTE_IO_MAX_SIZE)) table.Add(_('Lasting: stat'), CTK.TextCfg('server!iocache!lasting_stat', True), _(NOTE_IO_LAST_STAT)) table.Add(_('Lasting: mmap'), CTK.TextCfg('server!iocache!lasting_mmap', True), _(NOTE_IO_LAST_MMAP)) self += CTK.RawHTML("<h2>%s</h2>" % (_('I/O cache'))) self += CTK.Indenter(table)
def __call__(self): # /source/empty if CTK.request.url.endswith('/empty'): notice = CTK.Notice('information', CTK.RawHTML(_(NOTE_NO_ENTRIES))) return notice.Render().toJSON() # /source/content/\d+ num = re.findall(r'^%s/([\d]+)$' % (URL_CONTENT), CTK.request.url)[0] tipe = CTK.cfg.get_val('source!%s!type' % (num)) nick = CTK.cfg.get_val('source!%s!nick' % (num)) cont = CTK.Container() cont += CTK.RawHTML('<h2>%s: %s</h2>' % (_('Source'), CTK.escape_html(nick))) workarea = CTK.Box({'id': 'source-workarea'}) table = CTK.PropsTable() table.Add( _('Type'), CTK.ComboCfg('source!%s!type' % (num), trans_options(SOURCE_TYPES)), _(NOTE_TYPE)) table.Add(_('Nick'), CTK.TextCfg('source!%s!nick' % (num), False), _(NOTE_NICK)) table.Add(_('Connection'), CTK.TextCfg('source!%s!host' % (num), False), _(NOTE_HOST)) if tipe == 'interpreter': NOTE_INTERPRETER = _(NOTE_INTERPRETER1) + '<br/>' + '<b>%s</b>' % ( _(NOTE_INTERPRETER2)) table.Add(_('Interpreter'), CTK.TextCfg('source!%s!interpreter' % (num), False), NOTE_INTERPRETER) table.Add(_('Spawning timeout'), CTK.TextCfg('source!%s!timeout' % (num), True), _(NOTE_TIMEOUT)) table.Add(_('Execute as User'), CTK.TextCfg('source!%s!user' % (num), True), _(NOTE_USER)) table.Add(_('Execute as Group'), CTK.TextCfg('source!%s!group' % (num), True), _(NOTE_GROUP)) table.Add( _('Inherit Environment'), CTK.CheckCfgText('source!%s!env_inherited' % (num), True, _('Enabled')), _(NOTE_ENV_INHERIT)) submit = CTK.Submitter(URL_APPLY) submit += table workarea += submit if CTK.cfg.get_val ('source!%s!type'%(num)) == 'interpreter' and \ CTK.cfg.get_val ('source!%s!env_inherited'%(num)) == '0': workarea += EnvironmentWidget(num) sources = _all_sources_per_rule() rules = [ dic.keys()[0] for dic in sources if str(num) in dic.values()[0] ] if rules: workarea += self.Source_Usage(rules) cont += workarea render = cont.Render() return render.toJSON()
def __init__(self, key, **kwargs): kwargs['show_document_root'] = False Handler.PluginHandler.__init__(self, key, **kwargs) Handler.PluginHandler.AddCommon(self) # Properties table = CTK.PropsTable() table.Add(_('Reuse connections'), CTK.TextCfg('%s!reuse_max' % (key), True), _(NOTE_REUSE_MAX)) table.Add( _('Allow Keepalive'), CTK.CheckCfgText('%s!in_allow_keepalive' % (key), True, _('Allow')), _(NOTE_ALLOW_KEEPALIVE)) table.Add( _('Preserve Host Header'), CTK.CheckCfgText('%s!in_preserve_host' % (key), False, _('Preserve')), _(NOTE_PRESERVE_HOST)) table.Add( _('Preserve Server Header'), CTK.CheckCfgText('%s!out_preserve_server' % (key), False, _('Preserve')), _(NOTE_PRESERVE_SERVER)) table.Add( _('Use VServer error handler'), CTK.CheckCfgText('%s!vserver_errors' % (key), False, _('Use it')), _(NOTE_ERROR_HANDLER)) submit = CTK.Submitter(URL_APPLY) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('Reverse Proxy Settings'))) self += CTK.Indenter(submit) # Request self += CTK.RawHTML('<h2>%s</h2>' % (_('Request'))) self += CTK.Indenter(CTK.RawHTML('<h3>%s</h3>' % (_('URL Rewriting')))) self += URL_Rewrite(key, 'in_rewrite_request') self += CTK.Indenter( CTK.RawHTML('<h3>%s</h3>' % (_('Header Addition')))) self += Header_List(key, 'in_header_add') self += CTK.Indenter(CTK.RawHTML('<h3>%s</h3>' % (_('Hide Headers')))) self += Header_Hide(key, 'in_header_hide') # Reply self += CTK.RawHTML('<h2>%s</h2>' % (_('Reply'))) self += CTK.Indenter(CTK.RawHTML('<h3>%s</h3>' % (_('URL Rewriting')))) self += URL_Rewrite(key, 'out_rewrite_request') self += CTK.Indenter( CTK.RawHTML('<h3>%s</h3>' % (_('Header Addition')))) self += Header_List(key, 'out_header_add') self += CTK.Indenter(CTK.RawHTML('<h3>%s</h3>' % (_('Hide Headers')))) self += Header_Hide(key, 'out_header_hide') # Balancer modul = CTK.PluginSelector( '%s!balancer' % (key), trans_options(Cherokee.support.filter_available(BALANCERS))) table = CTK.PropsTable() table.Add(_("Balancer"), modul.selector_widget, _(Balancer.NOTE_BALANCER)) self += CTK.RawHTML('<h2>%s</h2>' % (_('Back-end Servers'))) self += CTK.Indenter(table) self += modul
def AddCommon(self): # Parent's AddComon Handler.PluginHandler.AddCommon(self) # Add CGI related stuff table = CTK.PropsTable() if self.show_script_alias: table.Add(_("Script Alias"), CTK.TextCfg('%s!script_alias' % (self.key), True), _(NOTE_SCRIPT_ALIAS)) if self.show_change_uid: table.Add( _("Change UID"), CTK.CheckCfgText('%s!change_user' % (self.key), False, _('Change')), _(NOTE_CHANGE_USER)) table.Add( _('Error handler'), CTK.CheckCfgText('%s!error_handler' % (self.key), True, _('Enabled')), _(NOTE_ERROR_HANDLER)) table.Add( _('Check file'), CTK.CheckCfgText('%s!check_file' % (self.key), True, _('Enabled')), _(NOTE_CHECK_FILE)) table.Add( _('Pass Request Headers'), CTK.CheckCfgText('%s!pass_req_headers' % (self.key), True, _('Enabled')), _(NOTE_PASS_REQ)) table.Add( _('Allow X-Sendfile'), CTK.CheckCfgText('%s!xsendfile' % (self.key), False, _('Enabled')), _(NOTE_XSENDFILE)) submit = CTK.Submitter(URL_APPLY) submit += CTK.Indenter(table) self += CTK.RawHTML("<h2>%s</h2>" % (_('Common CGI Options'))) self += submit # X-Real-IP refresh = CTK.Refreshable({'id': 'x_real_ip'}) refresh.register(lambda: self.X_Real_IP(refresh, self.key).Render()) self += CTK.RawHTML("<h2>%s</h2>" % (_('Fixed Authentication List'))) self += CTK.Indenter(refresh) # Environment refresh = CTK.Refreshable({'id': 'cgi_environ_list'}) refresh.register(lambda: self.Environ(refresh, self.key).Render()) self += CTK.RawHTML("<h2>%s</h2>" % (_('Custom Environment Variables'))) self += CTK.Indenter(refresh) new_name = CTK.TextField({'name': 'tmp!new_name', 'class': 'noauto'}) new_value = CTK.TextField({'name': 'tmp!new_value', 'class': 'noauto'}) new_add = CTK.SubmitterButton(_('Add')) table = CTK.Table() table.set_header(1) table += [CTK.RawHTML(x) for x in (_('Name'), _('Value'))] table += [new_name, new_value, new_add] submit = CTK.Submitter(URL_APPLY) submit += CTK.Hidden('key', '%s!env' % (self.key)) submit += table submit.bind( 'submit_success', refresh.JS_to_refresh() + new_name.JS_to_clean() + new_value.JS_to_clean()) self += CTK.RawHTML("<h3>%s</h3>" % (_('Add New Custom Environment Variable'))) self += CTK.Indenter(submit) # Publish VALS = [("%s!script_alias" % (self.key), validations.is_path)] CTK.publish('^%s$' % (URL_APPLY), commit, validation=VALS, method="POST")
def __safe_call__(self): box = CTK.Box() pre = "tmp!market!install" submit = CTK.Submitter(URL_DETAILS_APPLY) table = CTK.PropsTable() table.Add( _('Admin user'), CTK.TextCfg('%s!moodle!adminuser' % (pre), False, {'class': 'required'}), _(NOTE_ADMINUSER)) table.Add( _('Admin password'), CTK.TextCfg('%s!moodle!adminpass' % (pre), False, {'class': 'required'}), _(NOTE_ADMINPASS)) table.Add( _('Full sitename'), CTK.TextCfg('%s!moodle!fullname' % (pre), False, {'class': 'required'}), _(NOTE_FULLNAME)) table.Add( _('Short sitename'), CTK.TextCfg('%s!moodle!shortname' % (pre), False, {'class': 'required'}), _(NOTE_SHORTNAME)) target_type = CTK.cfg.get_val('%s!target' % (pre)) if target_type == 'directory': target_vserver_n = CTK.cfg.get_val('%s!target!vserver_n' % (pre)) pre_vsrv = 'vserver!%s' % (target_vserver_n) vserver_nick = CTK.cfg.get_val('%s!nick' % (pre_vsrv)) vserver_match = CTK.cfg.get_val('%s!match' % (pre_vsrv), 'name') if vserver_match == 'name' and vserver_nick != 'default': submit += CTK.Hidden('%s!moodle!domain' % (pre), vserver_nick) else: table.Add( _('Domain name'), CTK.TextCfg('%s!moodle!domain' % (pre), False, {'class': 'required'}), _(NOTE_DOMAINNAME)) agree_box = CTK.Box() agree_box += CTK.RawHTML(_('Make sure you understand and accept the ')) agree_box += CTK.LinkWindow('http://docs.moodle.org/en/License', CTK.RawHTML(_('Moodle License'))) agree_box += CTK.RawHTML( _(' before proceeding. Moodle license must be accepted to proceed.' )) agree_box += CTK.CheckCfgText('%s!moodle!agreement' % (pre), False, _('Accept license'), {'class': 'required'}) submit += table submit += agree_box submit.bind('submit_success', CTK.DruidContent__JS_to_goto(table.id, URL_SERVER)) buttons = CTK.DruidButtonsPanel() buttons += CTK.DruidButton_Close(_('Cancel')) buttons += CTK.DruidButton_Submit(_('Next'), do_close=False) box = CTK.Box() box += CTK.RawHTML('<h2>%s</h2>' % (DETAILS_H2)) box += CTK.RawHTML('<p>%s</p>' % (DETAILS_P1)) box += submit box += buttons return box.Render().toStr()
def __init__(self, vsrv_num, refreshable): CTK.Container.__init__(self) pre = "vserver!%s" % (vsrv_num) url_apply = "%s/%s" % (URL_APPLY, vsrv_num) # Required SSL/TLS values table = CTK.PropsTable() table.Add(_('Certificate'), CTK.TextCfg('%s!ssl_certificate_file' % (pre), True), _(NOTE_CERT)) table.Add(_('Certificate key'), CTK.TextCfg('%s!ssl_certificate_key_file' % (pre), True), _(NOTE_CERT_KEY)) submit = CTK.Submitter(url_apply) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('Required SSL/TLS Values'))) self += CTK.Indenter(submit) # Advanced options table = CTK.PropsTable() table.Add(_('Ciphers'), CTK.TextCfg('%s!ssl_ciphers' % (pre), True), _(NOTE_CIPHERS)) table.Add( _('Server Preference'), CTK.CheckCfgText('%s!ssl_cipher_server_preference' % (pre), False, _('Prefer')), _(NOTE_CIPHER_SERVER_PREFERENCE)) table.Add( _('Client Certs. Request'), CTK.ComboCfg('%s!ssl_client_certs' % (pre), trans_options(CLIENT_CERTS)), _(NOTE_CLIENT_CERTS)) table.Add( _('Compression'), CTK.CheckCfgText('%s!ssl_compression' % (pre), False, _('Prefer')), _(NOTE_COMPRESSION)) if CTK.cfg.get_val('%s!ssl_client_certs' % (pre)): table.Add(_('CA List'), CTK.TextCfg('%s!ssl_ca_list_file' % (pre), False), _(NOTE_CA_LIST)) if CTK.cfg.get_val('%s!ssl_ca_list_file' % (pre)): table.Add( _('Verify Depth'), CTK.TextCfg('%s!ssl_verify_depth' % (pre), False, {'size': 4}), _(NOTE_VERIFY_DEPTH)) submit = CTK.Submitter(url_apply) submit.bind('submit_success', refreshable.JS_to_refresh()) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('Advanced Options'))) self += CTK.Indenter(submit) # HSTS table = CTK.PropsTable() table.Add(_('Enable HSTS'), CTK.CheckCfgText('%s!hsts' % (pre), False, _('Accept')), _(NOTE_HSTS)) if int(CTK.cfg.get_val('%s!hsts' % (pre), "0")): table.Add( _('HSTS Max-Age'), CTK.TextCfg('%s!hsts!max_age' % (pre), True, {'optional_string': _("One year")}), _(NOTE_HSTS_MAXAGE)) table.Add( _('Include Subdomains'), CTK.CheckCfgText('%s!hsts!subdomains' % (pre), True, _('Include all')), _(NOTE_HSTS_SUBDOMAINS)) submit = CTK.Submitter(url_apply) submit.bind('submit_success', refreshable.JS_to_refresh()) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('HTTP Strict Transport Security (HSTS)'))) self += CTK.Indenter(submit)
def __init__ (self, vsrv_num, refreshable): CTK.Container.__init__ (self) pre = "vserver!%s" %(vsrv_num) url_apply = "%s/%s/log" %(URL_APPLY, vsrv_num) writers = [('', _('Disabled'))] + trans_options(LOGGER_WRITERS) # Error writer table = CTK.PropsTable() table.Add (_('Write errors to'), CTK.ComboCfg('%s!error_writer!type'%(pre), writers), _(NOTE_ERRORS)) writer = CTK.cfg.get_val ('%s!error_writer!type'%(pre)) if writer == 'file': table.Add (_('Filename'), CTK.TextCfg('%s!error_writer!filename'%(pre)), _(NOTE_WRT_FILE)) elif writer == 'exec': table.Add (_('Command'), CTK.TextCfg('%s!error_writer!command'%(pre)), _(NOTE_WRT_EXEC)) submit = CTK.Submitter(url_apply) submit.bind ('submit_success', refreshable.JS_to_refresh()) submit += table self += CTK.RawHTML ('<h2>%s</h2>' % (_('Error Logging'))) self += CTK.Indenter (submit) # Access logger pre = 'vserver!%s!logger' %(vsrv_num) submit = CTK.Submitter(url_apply) submit.bind ('submit_success', refreshable.JS_to_refresh()) submit += CTK.ComboCfg(pre, trans_options(Cherokee.support.filter_available(LOGGERS))) table = CTK.PropsTable() table.Add (_('Format'), submit, _(NOTE_LOGGERS)) format = CTK.cfg.get_val(pre) if format: submit = CTK.Submitter(url_apply) submit.bind ('submit_success', refreshable.JS_to_refresh()) submit += CTK.ComboCfg('%s!access!type'%(pre), trans_options(LOGGER_WRITERS)) table.Add (_('Write accesses to'), submit, _(NOTE_ACCESSES)) submit = CTK.Submitter(url_apply) writer = CTK.cfg.get_val ('%s!access!type'%(pre)) if not writer: CTK.cfg['%s!access!type'%(pre)] = 'file' if writer == 'file' or not writer: # Set a default value if not CTK.cfg.get_val ('%s!access!filename'%(pre)): CTK.cfg['%s!access!filename'%(pre)] = os.path.join (CHEROKEE_VAR_LOG, 'cherokee.log') submit += CTK.TextCfg('%s!access!filename'%(pre), False) table.Add (_('Filename'), submit, _(NOTE_WRT_FILE)) elif writer == 'exec': submit += CTK.TextCfg('%s!access!command'%(pre)) table.Add (_('Command'), submit, _(NOTE_WRT_EXEC)) if format == 'custom': table_macros = CTK.Table ({'class': 'custom-logger-macros'}) for macro, desc in CUSTOM_MACROS_LIST: table_macros += [CTK.RawHTML('${%s}'%(macro)), CTK.RawHTML (_(desc))] collaps = CTK.CollapsibleEasy ((_('Show macros'), _('Hide'))) collaps += table_macros macros = CTK.Container() macros += CTK.RawHTML (_(NOTE_LOGGER_TEMPLATE)) macros += collaps submit = CTK.Submitter(url_apply) submit += CTK.TextCfg('%s!access_template'%(pre)) table.Add (_('Template: '), submit, macros) self += CTK.RawHTML ('<h2>%s</h2>' % (_('Access Logging'))) self += CTK.Indenter (table) # Properties if CTK.cfg.get_val (pre): table = CTK.PropsTable() table.Add (_('Time standard'), CTK.ComboCfg ('%s!utc_time'%(pre), trans_options(UTC_TIME)), _(NOTE_UTC_TIME)) table.Add (_('Accept Forwarded IPs'), CTK.CheckCfgText ('%s!x_real_ip_enabled'%(pre), False, _('Accept')), _(NOTE_X_REAL_IP)) if int (CTK.cfg.get_val('%s!x_real_ip_enabled'%(pre), "0")): table.Add (_('Don\'t check origin'), CTK.CheckCfgText ('%s!x_real_ip_access_all'%(pre), False, _('Do not check')), _(NOTE_X_REAL_IP_ALL)) if not int (CTK.cfg.get_val ('%s!x_real_ip_access_all'%(pre), "0")): table.Add (_('Accept from Hosts'), CTK.TextCfg ('%s!x_real_ip_access'%(pre)), _(NOTE_X_REAL_IP_ACCESS)) submit = CTK.Submitter(url_apply) submit.bind ('submit_success', refreshable.JS_to_refresh()) submit += table self += CTK.RawHTML ('<h3>%s</h3>' % (_('Logging Options'))) self += CTK.Indenter (submit)
def __call__(self): cont = CTK.Container() # Basic Funcionality combo_type = CTK.ComboCfg('%s!policy' % (PREFIX), trans_options(POLICIES)) table = CTK.PropsTable() table.Add(_('Type of Caching'), combo_type, _(NOTE_POLICY)) encoded_table = CTK.PropsTable() encoded_table.Add( _('Extensions'), CTK.TextCfg('%s!encoded_exts' % (PREFIX), False, {'value': ENCODED_EXTS_DEFAULT}), _(NOTE_ENC_EXTS)) encoded_box = CTK.Box({'style': 'display:none;'}) encoded_box += encoded_table combo_type.bind( 'change', "if ($(this).val() == 'dynamic') {%s} else {%s}" % (encoded_box.JS_to_hide(), encoded_box.JS_to_show())) submit = CTK.Submitter(URL_APPLY) submit += table submit += encoded_box cont += CTK.RawHTML("<h2>%s</h2>" % (_("Basic Functionality"))) cont += submit # PURGE check_auth = CTK.CheckCfgText('%s!purge' % (PREFIX), False, _("Enable")) table = CTK.PropsTable() table.Add(_('Enable PURGE requests'), check_auth, _(NOTE_AUTH)) admin_table = CTK.PropsTable() admin_table.Add( _('Admin Username'), CTK.TextCfg('%s!admin!username' % (PREFIX), False, {'class': 'noauto'}), _(NOTE_ADMIN_USER)) admin_table.Add( _('Admin Password'), CTK.TextCfg('%s!admin!password' % (PREFIX), False, {'class': 'noauto'}), _(NOTE_ADMIN_PASSWORD)) admin_box = CTK.Box({'style': 'display:none;'}) admin_box += admin_table check_auth.bind( 'change', "if ($(this).find(':checked').size() <= 0) {%s} else {%s}" % (admin_box.JS_to_hide(), admin_box.JS_to_show())) submit = CTK.Submitter(URL_APPLY) submit += table submit += admin_box cont += CTK.RawHTML("<h2>%s</h2>" % (_("Purge of Cache Objects"))) cont += submit # Global Submit submit = CTK.Submitter(URL_APPLY) submit += CTK.Hidden('final', '1') cont += submit cont += CTK.DruidButtonsPanel_PrevCreate_Auto() return cont.Render().toStr()
def __init__(self, key, **kwargs): Handler.PluginHandler.__init__(self, key, **kwargs) Handler.PluginHandler.AddCommon(self) # Listing table = CTK.PropsTable() table.Add(_('Show Size'), CTK.CheckCfgText("%s!size" % (self.key), True, _('Show')), '') table.Add(_('Show Date'), CTK.CheckCfgText("%s!date" % (self.key), True, _('Show')), '') table.Add(_('Show User'), CTK.CheckCfgText("%s!user" % (self.key), False, _('Show')), '') table.Add(_('Show Group'), CTK.CheckCfgText("%s!group" % (self.key), False, _('Show')), '') table.Add(_('Show Backup files'), CTK.CheckCfgText("%s!backup" % (self.key), False, _('Show')), '') table.Add(_('Show Hidden files'), CTK.CheckCfgText("%s!hidden" % (self.key), False, _('Show')), '') table.Add( _('Allow symbolic links'), CTK.CheckCfgText("%s!symlinks" % (self.key), True, _('Allow')), '') table.Add( _('Redirect symbolic links'), CTK.CheckCfgText("%s!redir_symlinks" % (self.key), False, _('Enabled')), '') submit = CTK.Submitter(URL_APPLY) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('Listing'))) self += CTK.Indenter(submit) # Theming table = CTK.PropsTable() table.Add(_('Theme'), CTK.ComboCfg("%s!theme" % (key), self._get_theme_list()), _(NOTE_THEME)) table.Add(_('Icons dir'), CTK.TextCfg("%s!icon_dir" % (key), True), _(NOTE_ICON_DIR)) table.Add(_('Notice files'), CTK.TextCfg("%s!notice_files" % (key), True), _(NOTE_NOTICE_FILES)) table.Add(_('Hidden files'), CTK.TextCfg("%s!hidden_files" % (key), True), _(NOTE_HIDDEN_FILES)) submit = CTK.Submitter(URL_APPLY) submit += table self += CTK.RawHTML('<h2>%s</h2>' % (_('Theming'))) self += CTK.Indenter(submit) # Publish VALS = [("%s!icon_dir" % (key), validations.is_path), ("%s!notice_files" % (key), validations.is_path_list), ("%s!hidden_files" % (key), validations.is_list)] CTK.publish('^%s$' % (URL_APPLY), CTK.cfg_apply_post, validation=VALS, method="POST")
def __init__(self, vsrv_num): CTK.Container.__init__(self) pre = "vserver!%s" % (vsrv_num) url_apply = "%s/%s" % (URL_APPLY, vsrv_num) is_default = CTK.cfg.get_lowest_entry("vserver") == int(vsrv_num) # Server ID if not is_default: table = CTK.PropsAuto(url_apply) table.Add(_('Virtual Server nickname'), CTK.TextCfg('%s!nick' % (pre)), _(NOTE_NICKNAME)) self += CTK.RawHTML('<h2>%s</h2>' % (_('Server ID'))) self += CTK.Indenter(table) # Paths table = CTK.PropsAuto(url_apply) if not CTK.cfg.get_val('%s!document_root' % (pre), '').startswith(CHEROKEE_OWS_ROOT): table.Add(_('Document Root'), CTK.TextCfg('%s!document_root' % (pre)), _(NOTE_DOCUMENT_ROOT)) else: table.Add( _('Document Root'), CTK.TextCfg('%s!document_root' % (pre), False, {'disabled': True}), _(NOTE_DOCUMENT_ROOT)) table.Add(_('Directory Indexes'), CTK.TextCfg('%s!directory_index' % (pre)), _(NOTE_DIRECTORY_INDEX)) self += CTK.RawHTML('<h2>%s</h2>' % (_('Paths'))) self += CTK.Indenter(table) if self.is_index_used(vsrv_num): tip = _(NOTE_INDEX_USAGE) else: tip = '%s %s' % (_(NOTE_INDEX_USAGE), _('Neither are in use at the moment.')) self += CTK.Indenter(CTK.Notice('information', CTK.RawHTML(tip))) # Network table = CTK.PropsAuto(url_apply) table.Add(_('Keep-alive'), CTK.CheckCfgText('%s!keepalive' % (pre), True, _('Allow')), _(NOTE_KEEPALIVE)) table.Add(_('Max Upload Size'), CTK.TextCfg('%s!post_max_len' % (pre), True), _(NOTE_MAX_UPLOAD_SIZE)) self += CTK.RawHTML('<h2>%s</h2>' % (_('Network'))) self += CTK.Indenter(table) # Advanced Virtual Hosting table = CTK.PropsAuto(url_apply) modul = CTK.PluginSelector( '%s!evhost' % (pre), trans_options(Cherokee.support.filter_available(EVHOSTS))) table.Add(_('Method'), modul.selector_widget, _(NOTE_EVHOST), False) self += CTK.RawHTML('<h2>%s</h2>' % (_('Advanced Virtual Hosting'))) self += CTK.Indenter(table) self += CTK.Indenter(modul)