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)
