def GUI_new(self):
# Build the port list
ports = [('', _("Choose"))]
for b in CTK.cfg.keys("server!bind"):
tmp = self._render_port_name(b)
ports.append(tmp)
# Table
table = CTK.PropsTable()
table.Add(
_('Incoming IP/Port'),
CTK.ComboCfg('%s!bind' % (self.key), ports, {'class': 'noauto'}),
'')
submit = CTK.Submitter(URL_APPLY)
submit += CTK.Hidden('key', self.key)
submit += CTK.Hidden('vsrv_num', self.vsrv_num)
submit += table
self += submit
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 __init__(self, key, **kwargs):
kwargs['show_document_root'] = False
Handler.PluginHandler.__init__(self, key, **kwargs)
Handler.PluginHandler.AddCommon(self)
# Ensure POST track is enabled
if not CTK.cfg.get_val('server!post_track'):
self += CTK.Notice('warning', CTK.RawHTML(_(WARNING_NO_TRACK)))
# Properties
table = CTK.PropsTable()
table.Add(
_('Target language'),
CTK.ComboCfg('%s!lang' % (key), trans_options(DWRITER_LANGS)),
_(NOTE_LANGUAGES))
submit = CTK.Submitter(URL_APPLY)
submit += CTK.Indenter(table)
self += submit
def __init__(self, key, **kwargs):
RulePlugin.__init__(self, key)
is_new = key.startswith('tmp')
idx = (1, 0)[is_new]
# Set the first method is empty
if not CTK.cfg.get_val('%s!method' % (key)):
CTK.cfg['%s!method' % (key)] = METHODS[idx:][0][0]
table = CTK.PropsTable()
table.Add(
_('Method'),
CTK.ComboCfg('%s!method' % (key), METHODS[idx:], ({}, {
'class': 'noauto'
})[is_new]), _(NOTE_METHOD))
submit = CTK.Submitter(URL_APPLY)
submit += CTK.Hidden('key', key)
submit += CTK.Hidden('vsrv_num', kwargs.pop('vsrv_num', ''))
submit += table
self += submit
def __init__(self, key):
CTK.Container.__init__(self)
table = CTK.PropsTable()
table.Add(
_('Show'),
CTK.ComboCfg('tmp!new_show', trans_options(REDIR_SHOW),
{'class': 'noauto'}), _(NOTE_SHOW))
table.Add(
_('Regular Expression'),
CTK.TextCfg('tmp!new_regex', False, {'class': 'noauto'}),
_(NOTE_REGEX))
table.Add(
_('Substitution'),
CTK.TextCfg('tmp!new_subst', False, {'class': 'noauto'}),
_(NOTE_SUBSTITUTION))
submit = CTK.Submitter(URL_APPLY)
submit += CTK.Hidden('key', '%s!rewrite' % (key))
submit += table
self += submit
def __init__ (self):
CTK.Box.__init__ (self)
pre = "tmp!market!install!target"
# Even though vserver must have a nick, there's been people
# reporting crahes on the cmp funciontion because they have
# vservers nick no nick property.
vsrv_keys = []
for k in CTK.cfg.keys('vserver'):
if CTK.cfg.get_val('vserver!%s!nick'%(k)):
vsrv_keys.append(k)
vsrv_keys.sort (cmp_domain)
vservers = []
for v in vsrv_keys:
vservers.append ((v, CTK.cfg.get_val("vserver!%s!nick"%(v))))
table = CTK.PropsTable()
table.Add (_('Virtual Server'), CTK.ComboCfg('%s!vserver_n'%(pre), vservers, {'class':'noauto'}), _(NOTE_VSERVER_SELECT))
table.Add (_('Directory'), CTK.TextCfg('%s!directory'%(pre), False, {'class':'noauto'}), _(NOTE_DIRECTORY))
self += table
def __init__(self, key, **kwargs):
Handler.PluginHandler.__init__(self, key, **kwargs)
Handler.PluginHandler.AddCommon(self)
table = CTK.PropsTable()
table.Add(_("Options"),
CTK.ComboCfg('%s!options' % (key), trans_options(OPTIONS)),
_(NOTE_OPTIONS))
table.Add(_("No dictionary"),
CTK.CheckCfgText("%s!nodict" % (self.key), True, ''),
_(NOTE_NODICT))
table.Add(_("Catalogs"),
CTK.CheckCfgText("%s!catalogs" % (self.key), True, ''),
_(NOTE_CATALOGS))
table.Add(
_("XInclude"),
CTK.CheckCfgText("%s!xinclude" % (self.key), True, _('Enabled')),
_(NOTE_XINCLUDE))
table.Add(
_("XincludeStyle"),
CTK.CheckCfgText("%s!xincludestyle" % (self.key), True,
_('Enabled')), _(NOTE_XINCLUDESTYLE))
table.Add(_("Content-Type"), CTK.TextCfg('%s!contenttype' % (key),
True), _(NOTE_CONTENTTYPE))
table.Add(_("Stylesheet"), CTK.TextCfg('%s!stylesheet' % (key), True),
_(NOTE_STYLESHEET))
submit = CTK.Submitter(URL_APPLY)
submit += table
self += CTK.RawHTML("<h2>%s</h2>" % (_('XML Parser Settings')))
self += CTK.Indenter(submit)
VALS = [("%s!stylesheet" % (self.key),
validations.is_local_file_exists)]
CTK.publish('^%s' % (URL_APPLY),
CTK.cfg_apply_post,
validation=VALS,
method="POST")
def __init__(self, key, **kwargs):
Auth.PluginAuth.__init__(self, key, **kwargs)
self.AddCommon(supported_methods=('basic', 'digest'))
table = CTK.PropsTable()
table.Add(_('Host'), CTK.TextCfg("%s!host" % (self.key), True),
_(NOTE_HOST))
table.Add(_('Port'), CTK.TextCfg("%s!port" % (self.key), True),
_(NOTE_PORT))
table.Add(_('Unix Socket'),
CTK.TextCfg("%s!unix_socket" % (self.key), True),
_(NOTE_UNIX))
table.Add(_('DB User'), CTK.TextCfg("%s!user" % (self.key), False),
_(NOTE_USER))
table.Add(_('DB Password'), CTK.TextCfg("%s!passwd" % (self.key),
True), _(NOTE_PASSWD))
table.Add(_('Database'), CTK.TextCfg("%s!database" % (self.key),
False), _(NOTE_DB))
table.Add(_('SQL Query'), CTK.TextCfg("%s!query" % (self.key), False),
_(NOTE_SQL))
table.Add(
_('Password Hash'),
CTK.ComboCfg("%s!hash" % (self.key), trans_options(HASHES),
{'id': 'mysql_hash'}), _(NOTE_HASH))
submit = CTK.Submitter(URL_APPLY)
submit += table
self += CTK.RawHTML("<h2>%s</h2>" % (_('MySQL Connection')))
self += CTK.Indenter(submit)
self += CTK.RawHTML(js=BASIC_HASH_HACK)
# Publish
VALS = [("%s!passwdfile" % (self.key),
validations.is_local_file_exists)]
CTK.publish('^%s' % (URL_APPLY),
CTK.cfg_apply_post,
validation=VALS,
method="POST")
def AddCommon (self, supported_methods):
assert type(supported_methods) is tuple
if len(supported_methods) > 1:
methods = trans_options (VALIDATOR_METHODS)
else:
methods = trans_options (filter (lambda x: x[0] in supported_methods, VALIDATOR_METHODS))
table = CTK.PropsTable()
table.Add (_("Methods"), CTK.ComboCfg("%s!methods"%(self.key), trans_options(methods), {'id': 'auth_method'}), _(NOTE_METHODS))
table.Add (_("Realm"), CTK.TextCfg("%s!realm" %(self.key), False), _(NOTE_REALM))
table.Add (_("Users"), CTK.TextCfg("%s!users" %(self.key), True), _(NOTE_USERS))
submit = CTK.Submitter (URL_APPLY)
submit += table
self += CTK.RawHTML ('<h2>%s</h2>' %(_('Authentication Details')))
self += CTK.Indenter(submit)
# Publish
VALS = [("%s!users"%(self.key), validations.is_safe_id_list)]
CTK.publish ('^%s'%(URL_APPLY), CTK.cfg_apply_post, validation=VALS, method="POST")
def __init__ (self, refresh, dbtypes):
CTK.Box.__init__ (self)
# Collect data
supported = get_supported_dbs (dbtypes)
types = [(x['db'], x['name']) for x in supported]
# Populate cfg with the current type
if not CTK.cfg.get_val('%s!db_type'%(KEY_PRE)):
CTK.cfg['%s!db_type' %(KEY_PRE)] = types[0][0]
# Build widget
combo = CTK.ComboCfg ('%s!db_type'%(KEY_PRE), trans_options(types))
table = CTK.PropsTable()
table.Add (_('Engine'), combo, _(NOTE_DBTYPE))
submit = CTK.Submitter (URL_DBTYPE_APPLY)
submit.bind ('submit_success',
CTK.DruidContent__JS_if_internal_submit (refresh.JS_to_refresh()))
submit += table
self += submit
def __safe_call__(self):
pre = "tmp!market!install"
table = CTK.PropsTable()
table.Add(
_('Language'),
CTK.ComboCfg('%s!lang' % (pre), tools.OPTS_LANG, {
'class': 'noauto',
'selected': 'en'
}), _(LANG_NOTE))
submit = CTK.Submitter(URL_APPLY)
submit += table
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Goto(_('Next'), URL_INSTALL, do_submit=True)
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (LANG_H2))
box += CTK.RawHTML('<p>%s</p>' % (LANG_P1))
box += submit
box += buttons
return box.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 GUI_mod(self):
pre = '%s!bind' % (self.key)
tmp = CTK.cfg.keys(pre)
tmp.sort(lambda x, y: cmp(int(x), int(y)))
if tmp:
table = CTK.Table({'id': 'rule-table-bind'})
table.set_header(1)
table += [
CTK.RawHTML(x) for x in (_('Port'), _('Bind to'), _('TLS'), '')
]
for b in tmp:
server_bind = CTK.cfg.get_val('%s!%s' % (pre, b))
port = CTK.cfg.get_val("server!bind!%s!port" % (server_bind))
bind = CTK.cfg.get_val(
"server!bind!%s!interface" % (server_bind), '')
tls_ = CTK.cfg.get_val("server!bind!%s!tls" % (server_bind),
False)
tls = [_("No"), _("Yes")][int(tls_)]
delete = None
if len(tmp) > 1:
delete = CTK.ImageStock('del')
delete.bind(
'click',
CTK.JS.Ajax(
URL_APPLY,
data={'%s!%s' % (pre, b): ''},
complete="$('#%s').trigger('submit_success');" %
(self.id)))
table += [
CTK.RawHTML(port),
CTK.RawHTML(bind),
CTK.RawHTML(tls), delete
]
self += CTK.RawHTML('<h3>%s</h3>' % (_('Selected Ports')))
self += CTK.Indenter(table)
# Don't show port already being listened to
left = CTK.cfg.keys("server!bind")
rule_used = []
for b in CTK.cfg.keys(pre):
port_num = CTK.cfg.get_val('%s!%s' % (pre, b))
if port_num in left:
left.remove(port_num)
if left:
ports = [('', _("Choose"))]
for b in left:
tmp = self._render_port_name(b)
ports.append(tmp)
next_bind = CTK.cfg.get_next_entry_prefix('%s!bind' % (self.key))
table = CTK.PropsTable()
table.Add(_('Incoming IP/Port'), CTK.ComboCfg(next_bind, ports),
'')
self += CTK.RawHTML('<h3>%s</h3>' % (_('Assign new IP/Port')))
submit = CTK.Submitter(URL_APPLY)
submit += table
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, refreshable, key, url_apply, **kwargs):
CTK.Container.__init__(self, **kwargs)
# List
entries = CTK.cfg.keys(key)
entries.sort(sorting_func)
if entries:
table = CTK.Table({'id': 'error-redirection'})
table.set_header(1)
table += [
CTK.RawHTML(x) for x in ('Error', 'Redirection', 'Type', '')
]
for i in entries:
show = CTK.ComboCfg('%s!%s!show' % (key, i),
trans_options(REDIRECTION_TYPE))
redir = CTK.TextCfg('%s!%s!url' % (key, i), False)
rm = CTK.ImageStock('del')
table += [CTK.RawHTML(i), redir, show, rm]
rm.bind(
'click',
CTK.JS.Ajax(url_apply,
data={"%s!%s" % (key, i): ''},
complete=refreshable.JS_to_refresh()))
submit = CTK.Submitter(url_apply)
submit += table
self += submit
# Add new
redir_codes = [('default', _('Default Error'))]
redir_codes += filter(lambda x: not x[0] in entries, ERROR_CODES)
table = CTK.PropsTable()
table.Add(_('Error'),
CTK.ComboCfg('new_error', redir_codes, {'class': 'noauto'}),
_(NOTE_ERROR))
table.Add(_('Redirection'),
CTK.TextCfg('new_redir', False, {'class': 'noauto'}),
_(NOTE_REDIR))
table.Add(
_('Type'),
CTK.ComboCfg('new_type', trans_options(REDIRECTION_TYPE),
{'class': 'noauto'}), _(NOTE_TYPE))
submit = CTK.Submitter(url_apply)
dialog = CTK.Dialog({'title': _('Add New Custom Error'), 'width': 540})
dialog.AddButton(_("Close"), 'close')
dialog.AddButton(_("Add"), submit.JS_to_submit())
submit += table
submit += CTK.HiddenField({'name': 'key', 'value': key})
submit.bind('submit_success', refreshable.JS_to_refresh())
submit.bind('submit_success', dialog.JS_to_close())
dialog += submit
self += dialog
add_new = CTK.Button(_('Add New'))
add_new.bind('click', dialog.JS_to_show())
self += add_new
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, 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 __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)
