def __safe_call__(self):
box = CTK.Box()
pre = 'tmp!market!install'
# Replacements
app_id = CTK.cfg.get_val('%s!app!application_id' % (pre))
app_name = CTK.cfg.get_val('%s!app!application_name' % (pre))
root = CTK.cfg.get_val('%s!root' % (pre))
target_type = CTK.cfg.get_val('%s!target' % (pre))
target_vserver = CTK.cfg.get_val('%s!target!vserver' % (pre))
target_vserver_n = CTK.cfg.get_val('%s!target!vserver_n' % (pre))
target_directory = CTK.cfg.get_val('%s!target!directory' % (pre))
pre_vsrv = 'vserver!%s' % (target_vserver_n)
# PHP info
php_info = php.get_info(pre_vsrv)
# More replacements
props = cfg_get_surrounding_repls('pre_rule', php_info['rule'])
props.update(locals())
# Write cfg file
tools.patch_phpbb_installer()
# Apply the config
if target_type == 'vserver':
config = CONFIG_VSERVER % (props)
CTK.cfg.apply_chunk(config)
AddUsualStaticFiles(props['pre_rule_plus2'])
CTK.cfg.normalize('%s!rule' % (pre_vsrv))
elif target_type == 'directory':
config = CONFIG_DIR % (props)
CTK.cfg.apply_chunk(config)
# Redirect to post installation
box += CTK.RawHTML(
js=CTK.DruidContent__JS_to_goto(box.id, URL_POST_INSTALL))
return box.Render().toStr()
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 __build_GUI__(self):
app_fetch = CTK.cfg.get_val('%s!app_fetch' % (CFG_PREFIX))
skip = False
# Special cases
if not app_fetch:
skip = True
if not app_fetch.startswith('http'):
skip = True
# (app_fetch != 'auto')):
# Skip the phase?
if skip:
self += CTK.RawHTML(js=CTK.DruidContent__JS_to_goto_next(self.id))
return
# Report
report = CTK.Box()
report += CTK.RawHTML(_("Initiating download.."))
# Download widget
down = CTK.Downloader('package', app_fetch)
down.bind('finished', CTK.DruidContent__JS_to_goto_next(self.id))
down.bind('stopped', "") ## TODO!!
down.bind('error', "") ## TODO!!
down.bind(
'update',
"$('#%s').html('Downloaded: ' + (event.downloaded / 1024).toFixed() + ' Kb');"
% (report.id))
self += CTK.RawHTML(
'<p>%s</p>' %
(_('The application is being downloaded. Hold on tight!')))
self += down
self += report
self += CTK.RawHTML(js=down.JS_to_start())
def __safe_call__ (self):
box = CTK.Box()
pre = 'tmp!market!install'
# Replacements
app_id = CTK.cfg.get_val ('%s!app!application_id' %(pre))
app_name = CTK.cfg.get_val ('%s!app!application_name'%(pre))
root = CTK.cfg.get_val ('%s!root' %(pre))
target_type = CTK.cfg.get_val ('%s!target' %(pre))
target_vserver = CTK.cfg.get_val ('%s!target!vserver' %(pre))
target_vserver_n = CTK.cfg.get_val ('%s!target!vserver_n' %(pre))
target_directory = CTK.cfg.get_val ('%s!target!directory' %(pre))
pre_vsrv = 'vserver!%s' %(target_vserver_n)
# PHP info
php_info = php.get_info (pre_vsrv)
# Fixes Drupal bug for multilingual content
CTK.cfg['%s!encoder!gzip' %(php_info['rule'])] = '0'
# More replacements
props = cfg_get_surrounding_repls ('pre_rule', php_info['rule'])
props.update (locals())
tools.preload_installer (root)
# Apply the config
if target_type == 'vserver':
config = CONFIG_VSERVER %(props)
CTK.cfg.apply_chunk (config)
elif target_type == 'directory':
config = CONFIG_DIR %(props)
CTK.cfg.apply_chunk (config)
CTK.cfg.normalize ('%s!rule'%(pre_vsrv))
# Redirect to post installation, and from there to Thanks page
box += CTK.RawHTML (js = CTK.DruidContent__JS_to_goto (box.id, URL_POST_INSTALL))
return box.Render().toStr()
def __safe_call__(self):
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (_("Checking Requirements")))
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Goto(
_('Retry'),
market.Install.URL_INSTALL_SETUP_EXTERNAL,
do_submit=True)
# Check PHP
php_cgi_bin = php.figure_phpcgi_binary()
if not php_cgi_bin:
box += php.PHP_Interpreter_Not_Found_Widget()
box += buttons
return box.Render().toStr()
# Check PHP modules
error = tools.check_modules()
if error:
note, instructions = error
box += market.Util.InstructionBox(note,
instructions,
bin_path=php_cgi_bin)
box += buttons
return box.Render().toStr()
# Database
supported_dbs = database.get_supported_dbs(DB_SUPPORTED)
if not supported_dbs:
box += database.PreconditionError(DB_SUPPORTED)
box += buttons
return box.Render().toStr()
box += CTK.RawHTML(js=CTK.DruidContent__JS_to_goto(box.id, URL_TARGET))
return box.Render().toStr()
def __safe_call__(self):
vserver_n = CTK.cfg.get_val('%s!target!vserver_n' %
('tmp!market!install'))
pre_vsrv = 'vserver!%s' % (vserver_n)
replacements = php.figure_php_user(pre_vsrv)
market.Install_Log.log("Post installation commands")
commands = [
({
'command':
'chown -R ${php_user}:${php_group} ${app_root}/openx/var ${app_root}/openx/www/images ${app_root}/openx/plugins ${app_root}/openx/www/admin/plugins'
}),
({
'command':
'chmod -R u+w ${app_root}/openx/var ${app_root}/openx/www/images ${app_root}/openx/plugins ${app_root}/openx/www/admin/plugins'
}),
]
progress = market.CommandProgress.CommandProgress(
commands, market.Install.URL_INSTALL_DONE)
progress['php_user'] = replacements['php_user']
progress['php_group'] = replacements['php_group']
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' %
(_('Performing automatic installation')))
box += CTK.RawHTML(
'<p>%s</p>' %
(_('This process may take a while. Please, hold on.')))
box += progress
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
box += buttons
return box.Render().toStr()
def __safe_call__(self):
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (_('User configuration')))
buttons = CTK.DruidButtonsPanel()
submit = CTK.Submitter(URL_APPLY)
table = CTK.PropsTable()
table.Add(
_('Username'),
CTK.TextCfg('%s!nagiosadmin' % (PRE), False, {
'class': 'noauto',
'value': 'nagiosadmin'
}), _(NOTE_USERNAME))
table.Add(
_('Password'),
CTK.TextCfg('%s!password' % (PRE), False, {'class': 'noauto'}),
_(NOTE_PASSWORD))
table.Add(_('Email'),
CTK.TextCfg('%s!email' % (PRE), False, {'class': 'noauto'}),
_(NOTE_EMAIL))
submit += CTK.RawHTML('<h2>%s</h2>' % (_(NOTE_NAGIOSADMIN_H)))
submit += CTK.RawHTML('<p>%s</p>' % (_(NOTE_NAGIOSADMIN_P)))
submit += table
submit.bind(
'submit_success',
CTK.DruidContent__JS_to_goto(box.id, URL_USER_CONFIG_SYSTEM))
box += submit
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Submit(_('Next'), do_close=False)
box += buttons
return box.Render().toStr()
def __safe_call__(self):
box = CTK.Box()
buttons = CTK.DruidButtonsPanel()
pre = "tmp!market!install"
submit = CTK.Submitter(URL_APPLY)
table = CTK.PropsTable()
table.Add(
_('Local directory'),
CTK.TextCfg('%s!webdav_dir' % (pre), False, {'class': 'noauto'}),
_(NOTE_DIRECTORY))
submit += table
submit.bind('submit_success',
CTK.DruidContent__JS_to_goto(box.id, URL_SERVER_CONFIG))
box += CTK.RawHTML('<h2>%s</h2>' % (_('WsgiDAV configuration')))
box += CTK.RawHTML('<p>%s</p>' % (_(NOTE_DAV_CONFIG)))
box += submit
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Submit(_('Next'), do_close=False)
box += buttons
return box.Render().toStr()
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 __safe_call__(self):
vserver_n = CTK.cfg.get_val('%s!target!vserver_n' %
('tmp!market!install'))
pre_vsrv = 'vserver!%s' % (vserver_n)
replacements = php.figure_php_user(pre_vsrv)
market.Install_Log.log("Post installation commands")
commands = [
({
'function': tools.drush_site_install,
'description': _('Using Drupal shell to install Drupal')
}),
({
'command':
'chown -R ${php_user}:${php_group} ${app_root}/drupal ${app_root}/drush'
}),
]
progress = market.CommandProgress.CommandProgress(
commands, market.Install.URL_INSTALL_DONE)
progress['php_user'] = replacements['php_user']
progress['php_group'] = replacements['php_group']
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' %
(_('Performing Drupal installation')))
box += CTK.RawHTML(
'<p>%s</p>' %
(_('This process may take a while. Please, hold on.')))
box += progress
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
box += buttons
return box.Render().toStr()
def __init__(self):
CTK.Box.__init__(self, {'class': 'domain_list'})
# Load, filter and sort the domain list
try:
domains = cPickle.load(open(config.PROUD_PICKLE, 'r'))
except (IOError, EOFError
) as e: # This exception means a corrupt pickle failed to load
domains = []
domains_clean = filter(lambda d: d['publish'], domains)
domains_clean.sort(domain_cmp)
if not domains_clean: # puke in the napkin, politely
domains_clean = [{'domain': 'Sorry: list broken!', 'page_rank': 0}]
# Render the domain list
l = CTK.List()
for domain in domains_clean:
l += CTK.Box(
{'class': 'domain domain-PR%s' % (domain['page_rank'])},
CTK.RawHTML(domain['domain']))
self += l
self += CTK.RawHTML(js=DOMAIN_CLICK_JS)
def __call__ (self):
cont = CTK.Container()
cont += CTK.RawHTML ('<h2>%s</h2>' %(_(NOTE_WELCOME_H1)))
cont += Wizard.Icon ('icons', {'class': 'wizard-descr'})
box = CTK.Box ({'class': 'wizard-welcome'})
box += CTK.RawHTML ('<p>%s</p>' %(_(NOTE_WELCOME_P1)))
cont += box
icons, themes = self._check_config()
if False in [icons, themes]:
# Send the VServer num
tmp = re.findall (r'^/wizard/vserver/(\d+)/', CTK.request.url)
submit = CTK.Submitter (URL_APPLY)
submit += CTK.Hidden('%s!vsrv_num'%(PREFIX), tmp[0])
submit += CTK.Hidden('%s!icons'%(PREFIX), ('0','1')[icons])
submit += CTK.Hidden('%s!themes'%(PREFIX), ('0','1')[themes])
submit += CTK.Hidden('final', '1')
cont += submit
cont += CTK.DruidButtonsPanel_Create()
else:
cont += CTK.RawHTML ('<p>%s</p>' %(_(NOTE_WELCOME_ERR)))
cont += CTK.DruidButtonsPanel_Cancel()
return cont.Render().toStr()
def __call__(self, dialog):
# Check
errors = SavingChecks.check_config()
if errors:
# FIXME: Needs to change the dialog title to "Configuration was not saved" or something
ul = CTK.List()
for error in errors:
link = CTK.Link(error.url, CTK.RawHTML(_("Solve")))
content = CTK.Box()
content += CTK.RawHTML('%s: ' % (error.title))
content += link
ul += content
all = CTK.Box({'id': 'sanity-msg'})
all += CTK.RawHTML("<h2>%s</h2>" % (SAVE_CHECK_H1))
all += CTK.RawHTML("<p>%s</p>" % (SAVE_CHECK_P1))
all += CTK.Box({'id': "sanity-errors"}, ul)
all += CTK.RawHTML("<p>%s</p>" % (SAVE_CHECK_P2))
render = all.Render()
return render.toStr()
# Save
CTK.cfg.save()
all = CTK.Box({'id': "buttons"})
all += CTK.RawHTML("<h2>%s</h2>" %
(_("Configuration successfully saved")))
if Cherokee.server.is_alive():
# Prompt about the reset
all += CTK.RawHTML('<p>%s</p>' % (_(SAVED_RESTART)))
submit = CTK.Submitter(URL_SAVE_NONE)
submit += CTK.Hidden('none', 'foo')
submit += CTK.SubmitterButton(_('Do not restart'))
submit.bind('submit_success', dialog.JS_to_close())
all += submit
submit = CTK.Submitter(URL_SAVE_GRACEFUL)
submit += CTK.Hidden('graceful', 'foo')
submit += CTK.SubmitterButton(_('Graceful restart'))
submit.bind('submit_success', dialog.JS_to_close())
all += submit
submit = CTK.Submitter(URL_SAVE_HARD)
submit += CTK.Hidden('hard', 'foo')
submit += CTK.SubmitterButton(_('Hard restart'))
submit.bind('submit_success', dialog.JS_to_close())
all += submit
else:
# Close the dialog
all += CTK.RawHTML('<p>%s</p>' % (_(SAVED_NO_RUNNING)))
submit = CTK.Submitter(URL_SAVE_NONE)
submit += CTK.Hidden('none', 'foo')
submit.bind('submit_success', dialog.JS_to_close())
all += submit
all += CTK.RawHTML(js=submit.JS_to_submit())
render = all.Render()
return render.toStr()
def __safe_call__(self):
pre = 'tmp!market!install'
root = CTK.cfg.get_val('%s!root' % (pre))
lang = CTK.cfg.get_val('%s!lang' % (pre))
db = CTK.cfg.get_val('%s!db!db_type' % (pre))
path = os.path.join(root, 'redmine')
env = tools.get_ruby_env()
tools.write_database_configuration(root)
GEM_INST_FAST = 'gem install --no-test --no-rdoc --no-ri --verbose --local '
GEM_INST_SLOW = 'gem install --no-test --no-rdoc --verbose --local '
tpre = [
({
'command': GEM_INST_FAST + '${app_root}/rake-0.8.7.gem',
'env': env
}),
({
'command':
GEM_INST_FAST + '${app_root}/activesupport-2.3.5.gem',
'env': env
}),
({
'command':
GEM_INST_FAST + '${app_root}/activerecord-2.3.5.gem',
'env': env
}),
({
'command': GEM_INST_SLOW + '${app_root}/rack-1.0.1.gem',
'env': env
}),
({
'command': GEM_INST_FAST + '${app_root}/actionpack-2.3.5.gem',
'env': env
}),
({
'command':
GEM_INST_FAST + '${app_root}/actionmailer-2.3.5.gem',
'env': env
}),
({
'command':
GEM_INST_FAST + '${app_root}/activeresource-2.3.5.gem',
'env': env
}),
({
'command': GEM_INST_FAST + '${app_root}/rails-2.3.5.gem',
'env': env
}),
({
'command': GEM_INST_SLOW + '${app_root}/daemons-1.1.0.gem',
'env': env
}),
({
'command':
GEM_INST_SLOW + '${app_root}/eventmachine-0.12.10.gem',
'env': env
}),
({
'command': GEM_INST_FAST + '${app_root}/thin-1.2.7.gem',
'env': env
}),
({
'command':
GEM_INST_FAST + '${app_root}/cgi_multipart_eof_fix-2.5.0.gem',
'env': env
}),
({
'command': GEM_INST_FAST + '${app_root}/i18n-0.4.2.gem',
'env': env
}),
]
# PostgreSQL
if db == 'postgresql':
tdb = [
({
'command':
GEM_INST_FAST + '${app_root}/postgres-pr-0.6.3.gem',
'env': env
}),
]
# SQLite
elif db == 'sqlite3':
tdb = [
({
'command': GEM_INST_FAST + '${app_root}/sqlite3-1.3.3.gem',
'env': env
}),
({
'command':
GEM_INST_FAST + '${app_root}/sqlite3-ruby-1.3.3.gem',
'env': env
}),
]
# MySQL
elif db == 'mysql':
mysql_bin = database.mysql_bins(database.MYSQL_BIN_NAMES)
mysql_dir = os.path.realpath(mysql_bin + '/../..')
if 'mysql' in mysql_dir:
tdb = [
({
'command':
GEM_INST_FAST +
'${app_root}/mysql-2.8.1.gem -- --with-mysql-dir=%s' %
(mysql_dir),
'env':
env
}),
]
else:
tdb = [
({
'command':
GEM_INST_FAST + '${app_root}/mysql-2.8.1.gem',
'env': env
}),
]
else:
assert False, "Unsupported DB"
tpost = [
({
'command': 'cd %s && rake generate_session_store' % (path),
'env': env
}),
({
'command':
'cd %s && RAILS_ENV=production rake db:migrate' % (path),
'env':
env
}),
({
'command':
'cd %s && RAILS_ENV=production rake redmine:load_default_data %s'
% (path, tools.EOF_STR % (locals())),
'env':
env
}),
({
'command':
'chown -R ${web_user}:${web_group} ${app_root}/redmine/db'
}),
]
tasks = tpre + tdb + tpost
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (INSTALL_H2))
box += CTK.RawHTML('<p>%s</p>' % (INSTALL_P1))
box += CommandProgress(tasks, URL_CONFIG_SERVER)
box += buttons
return box.Render().toStr()
def __safe_call__(self):
ruby_min = ruby.ruby_version()
dblist = database.get_supported_dbs(DB_SUPPORTED)
db_system = [x['db'] for x in dblist]
db_redmine = DB_SUPPORTED[:]
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (_("Database Requirements")))
message = ''
if 'mysql' in db_system:
if version_to_int(ruby_min) < version_to_int('1.8.6'):
message += '<p>%s</p>' % (_(NOTE_MYSQL1))
db_redmine.remove('mysql')
elif not database.mysql_dev_path(): # required by mysql gem:
message += '<p>%s</p>' % (_(NOTE_MYSQL2))
db_redmine.remove('mysql')
box += market.Util.InstructionBox(
database.MYSQL_DEV_NOTE, database.MYSQL_DEV_INSTRUCTIONS)
if 'sqlite3' in db_system:
if version_to_int(ruby_min) < version_to_int(
'1.8.7'): # required by sqlite3 gem:
message += '<p>%s</p>' % (_(NOTE_SQLITE))
db_redmine.remove('sqlite3')
# No DBS
if db_redmine == []:
message += '<p>%s</p>' % (_(NOTE_NODBS))
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Goto(_('Retry'),
URL_DATABASE_PRE,
do_submit=True)
notice = CTK.Notice()
notice += CTK.RawHTML(message)
box += notice
box += buttons
# Some DBs present on system but not supported for some reason
elif message:
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Goto(_('Next'),
URL_DATABASE,
do_submit=True)
notice = CTK.Notice()
notice += CTK.RawHTML(message)
box += notice
box += buttons
# DB list untouched
else:
box += CTK.RawHTML(
js=CTK.DruidContent__JS_to_goto(box.id, URL_DATABASE))
return box.Render().toStr()
def __init__(self, app_name):
CTK.Box.__init__(self, {'class': 'cherokee-market-app'})
index = Distro.Index()
app = index.get_package(app_name, 'software')
maintainer = index.get_package(app_name, 'maintainer')
# Install dialog
install = InstallDialog(app_name)
# Author
by = CTK.Container()
by += CTK.RawHTML('%s ' % (_('By')))
by += CTK.LinkWindow(app['URL'], CTK.RawHTML(app['author']))
install_button = CTK.Button(_("Install"))
install_button.bind('click', install.JS_to_show())
# Report button
druid = CTK.Druid(CTK.RefreshableURL())
report_dialog = CTK.Dialog({
'title': (_("Report Application")),
'width': 480
})
report_dialog += druid
druid.bind('druid_exiting', report_dialog.JS_to_close())
report_link = CTK.Link(None, CTK.RawHTML(_("Report issue")))
report_link.bind ('click', report_dialog.JS_to_show() + \
druid.JS_to_goto('"%s/%s"'%(URL_REPORT, app_name)))
report = CTK.Container()
report += report_dialog
report += report_link
# Info
repo_url = CTK.cfg.get_val('admin!ows!repository', REPO_MAIN)
url_icon_big = os.path.join(repo_url, app['id'], "icons",
app['icon_big'])
appw = CTK.Box({'class': 'market-app-desc'})
appw += CTK.Box({'class': 'market-app-desc-icon'},
CTK.Image({'src': url_icon_big}))
appw += CTK.Box({'class': 'market-app-desc-buy'}, install_button)
appw += CTK.Box({'class': 'market-app-desc-title'},
CTK.RawHTML(app['name']))
appw += CTK.Box({'class': 'market-app-desc-version'},
CTK.RawHTML("%s: %s" % (_("Version"), app['version'])))
appw += CTK.Box({'class': 'market-app-desc-url'}, by)
appw += CTK.Box(
{'class': 'market-app-desc-packager'},
CTK.RawHTML("%s: %s" %
(_("Packager"), maintainer['name'] or _("Orphan"))))
appw += CTK.Box({'class': 'market-app-desc-category'},
CTK.RawHTML("%s: %s" %
(_("Category"), app['category'])))
appw += CTK.Box({'class': 'market-app-desc-short-desc'},
CTK.RawHTML(app['desc_short']))
appw += CTK.Box({'class': 'market-app-desc-report'}, report)
# Support
ext_description = CTK.Box({'class': 'market-app-desc-description'})
ext_description += CTK.RawHTML(app['desc_long'])
desc_panel = CTK.Box({'class': 'market-app-desc-desc-panel'})
desc_panel += ext_description
desc_panel += CTK.Box({'class': 'market-app-desc-support-box'},
SupportBox(app_name))
# Shots
shots = CTK.CarouselThumbnails()
shot_entries = app.get('screenshots', [])
if shot_entries:
for s in shot_entries:
shots += CTK.Image({
'src':
os.path.join(repo_url, app_name, "screenshots", s)
})
else:
shots += CTK.Box({'id': 'shot-box-empty'},
CTK.RawHTML('<h2>%s</h2>' %
(_("No screenshots"))))
# Tabs
tabs = CTK.Tab()
tabs.Add(_('Screenshots'), shots)
tabs.Add(_('Description'), desc_panel)
# GUI Layout
self += appw
self += tabs
self += install
def __init__ (self):
CTK.Box.__init__ (self, {'id': 'license'})
self += CTK.Box ({'id': 'license-text'}, CTK.RawHTML (GPL2_LICENSE))
def __safe_call__(self):
app_id = CTK.cfg.get_val('tmp!market!install!app!application_id')
app_name = CTK.cfg.get_val('tmp!market!install!app!application_name')
# URL Package
index = Distro.Index()
pkg = index.get_package(app_id, 'package')
repo_url = CTK.cfg.get_val('admin!ows!repository', REPO_MAIN)
url_download = os.path.join(repo_url, app_id, pkg['filename'])
CTK.cfg['tmp!market!install!download'] = url_download
# Local storage shortcut
pkg_filename_full = url_download.split('/')[-1]
pkg_filename = pkg_filename_full.split('_')[0]
pkg_revision = 0
pkg_repo_fp = os.path.join(CHEROKEE_OWS_DIR, "packages", app_id)
if os.access(pkg_repo_fp, os.X_OK):
for f in os.listdir(pkg_repo_fp):
tmp = re.findall('^%s_(\d+)' % (pkg_filename), f)
if tmp:
pkg_revision = max(pkg_revision, int(tmp[0]))
if pkg_revision > 0:
pkg_fullpath = os.path.join(
CHEROKEE_OWS_DIR, "packages", app_id,
'%s_%d.cpk' % (pkg_filename, pkg_revision))
CTK.cfg['tmp!market!install!local_package'] = pkg_fullpath
Install_Log.log("Using local repository package: %s" %
(pkg_fullpath))
box = CTK.Box()
box += CTK.RawHTML(
js=CTK.DruidContent__JS_to_goto(box.id, URL_INSTALL_SETUP))
return box.Render().toStr()
# Instance a Downloader
downloader = CTK.Downloader('package', url_download)
downloader.bind('stopped',
CTK.DruidContent__JS_to_close(downloader.id))
downloader.bind(
'finished',
CTK.DruidContent__JS_to_goto(downloader.id, URL_INSTALL_SETUP))
downloader.bind(
'error',
CTK.DruidContent__JS_to_goto(downloader.id,
URL_INSTALL_DOWNLOAD_ERROR))
stop = CTK.Button(_('Cancel'))
stop.bind('click', downloader.JS_to_stop())
buttons = CTK.DruidButtonsPanel()
buttons += stop
Install_Log.log("Downloading %s" % (url_download))
cont = CTK.Container()
cont += CTK.RawHTML('<h2>%s %s</h2>' % (_("Installing"), app_name))
cont += CTK.RawHTML(
'<p>%s</p>' %
(_('The application is being downloaded. Hold on tight!')))
cont += downloader
cont += buttons
cont += CTK.RawHTML(js=downloader.JS_to_start())
return cont.Render().toStr()
def __init__(self, refresh, right_box):
CTK.Container.__init__(self)
# Sanity check
if not CTK.cfg.keys('vserver'):
CTK.cfg['vserver!1!nick'] = 'default'
CTK.cfg['vserver!1!document_root'] = '/tmp'
CTK.cfg['vserver!1!rule!1!match'] = 'default'
CTK.cfg['vserver!1!rule!1!handler'] = 'common'
# Helper
entry = lambda klass, key: CTK.Box(
{'class': klass},
CTK.RawHTML(CTK.escape_html(CTK.cfg.get_val(key, ''))))
# Build the panel list
panel = SelectionPanel.SelectionPanel(reorder,
right_box.id,
URL_BASE,
'',
container='vservers_panel')
self += panel
# Build the Virtual Server list
vservers = CTK.cfg.keys('vserver')
vservers.sort(lambda x, y: cmp(int(x), int(y)))
vservers.reverse()
for k in vservers:
# Document root widget
droot_str = CTK.cfg.get_val('vserver!%s!document_root' % (k),
'')
droot_widget = CTK.Box({'class': 'droot'},
CTK.RawHTML(CTK.escape_html(droot_str)))
if k == vservers[-1]:
content = [
entry('nick', 'vserver!%s!nick' % (k)), droot_widget
]
panel.Add(k,
'/vserver/content/%s' % (k),
content,
draggable=False)
else:
nick = CTK.cfg.get_val('vserver!%s!nick' % (k),
_('Unknown'))
nick_esc = CTK.escape_html(nick)
# Remove
dialog = CTK.Dialog({
'title':
_('Do you really want to remove it?'),
'width':
480
})
dialog.AddButton(_('Cancel'), "close")
dialog.AddButton (_('Remove'), CTK.JS.Ajax (URL_APPLY, async=True,
data = {'vserver!%s'%(k):''},
success = dialog.JS_to_close() + \
refresh.JS_to_refresh()))
dialog += CTK.RawHTML(_(NOTE_DELETE_DIALOG) % (locals()))
self += dialog
remove = CTK.ImageStock('del')
remove.bind('click', dialog.JS_to_show() + "return false;")
# Disable
is_disabled = bool(
int(CTK.cfg.get_val('vserver!%s!disabled' % (k), "0")))
disclass = ('', 'vserver-inactive')[is_disabled][:]
disabled = CTK.ToggleButtonOnOff(not is_disabled)
disabled.bind(
'changed',
CTK.JS.Ajax(
URL_APPLY,
async=True,
data='{"vserver!%s!disabled": event.value}' % (k)))
def __safe_call__(self):
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (_("Checking Requirements")))
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
buttons += CTK.DruidButton_Goto(_('Retry'),
URL_PRECONDITION,
do_submit=True)
# Check PHP
php_cgi_bin = php.figure_phpcgi_binary()
if not php_cgi_bin:
box += php.PHP_Interpreter_Not_Found_Widget()
box += buttons
return box.Render().toStr()
# Check general modules
error = tools.check_modules()
if error:
note, instructions = error
box += market.Util.InstructionBox(note,
instructions,
bin_path=php_cgi_bin)
box += buttons
return box.Render().toStr()
# Database
supported_dbs = database.get_supported_dbs(DB_SUPPORTED)
if not supported_dbs:
box += database.PreconditionError(DB_SUPPORTED)
box += buttons
return box.Render().toStr()
# Check at least one php DB module is available
db_errors = tools.check_database_support()
if db_errors:
php_cgi_bin = php.figure_phpcgi_binary()
note, instruction_list = db_errors
box += market.Util.InstructionBox(note,
instruction_list,
bin_path=php_cgi_bin)
box += buttons
return box.Render().toStr()
# Check PHP settings
setting_errors = tools.check_settings()
if setting_errors:
box += CTK.RawHTML('<p>%s</p>' % (_(
"Some of your PHP settings do not meet Drupal's requirements. Please edit your PHP configuration files and try again."
)))
table = CTK.Table({'class': 'infosection'})
table.set_header(1)
table += [
CTK.RawHTML(x)
for x in ('%s ' % _('Setting'), '%s ' % _('Expected value'),
_('Current value'))
]
for setting_test in setting_errors:
table += [CTK.RawHTML(str(x)) for x in setting_test]
box += CTK.Indenter(table)
box += buttons
return box.Render().toStr()
box += CTK.RawHTML(js=CTK.DruidContent__JS_to_goto(box.id, URL_TARGET))
return box.Render().toStr()
def __safe_call__(self):
box = CTK.Box()
buttons = CTK.DruidButtonsPanel()
pre = 'tmp!market!install'
root = CTK.cfg.get_val('%s!root' % (pre))
project = os.path.join(root, 'project')
trac_src = os.path.join(root, 'trac')
trac_admin = os.path.join(root, 'bin', 'trac-admin')
easy_bin = os.path.join(root, 'bin', 'easy_install')
group_root = SystemInfo.get_info()['group_root']
server_user = CTK.cfg.get_val('server!user', 'root')
server_group = CTK.cfg.get_val('server!group', group_root)
# Figure out PYTHONPATH
ret = popen.popen_sync('python setup.py install --prefix=%(root)s' %
(locals()),
cd='%(root)s/Genshi-0.6' % (locals()))
err = ret['stderr'] + ret['stdout'] # Python 2.4.3 actually succeeds
tmp = re.findall(r' (%(root)s.+site-packages)' % (locals()), err)
PYTHONPATH = tmp[0]
CTK.cfg['tmp!market!install!trac!PYTHONPATH'] = PYTHONPATH
# Create site-packages
if not os.path.isdir(PYTHONPATH):
os.makedirs(PYTHONPATH)
# Build PYTHONPATH
env = os.environ.copy()
if 'PYTHONPATH' in env:
env['PYTHONPATH'] = '%s:%s' % (PYTHONPATH, env['PYTHONPATH'])
else:
env['PYTHONPATH'] = PYTHONPATH
# Installation
tasks = [
# Install dependencies
({
'command': "python setup.py install --prefix=${app_root}",
'env': env,
'cd': '%(root)s/flup-1.0.2' % (locals())
}),
({
'command': "python setup.py install --prefix=${app_root}",
'env': env,
'cd': '%(root)s/Genshi-0.6' % (locals())
}),
#({'command': "python setup.py install --prefix=${app_root}", 'env': env, 'cd': '%(root)s/pysqlite-2.6.0'%(locals())}),
({
'function': tools.install_pysqlite,
'description': _('Satisfying pysqlite requirements'),
'params': {
'root': root,
'env': str(env)
}
}),
({
'command':
"python %(trac_src)s/setup.py install --prefix=${app_root}" %
(locals()),
'env':
env,
'cd':
trac_src
}),
# Create Project
({
'command':
"%(trac_admin)s %(project)s initenv <<EOF\nTrac\n\nEOF\n" %
(locals()),
'env':
env
}),
({
'command':
"chown -R %(server_user)s:%(server_group)s %(project)s" %
(locals())
})
]
box += CTK.RawHTML('<h2>%s</h2>' % (_('Installing Trac')))
box += CTK.RawHTML(
'<p>%s</p>' %
(_('This process may take a while. Please, hold on.')))
box += CommandProgress(tasks, URL_USER_CONFIG)
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
box += buttons
return box.Render().toStr()
def __safe_call__(self):
root = CTK.cfg.get_val('%s!root' % (PRE))
target_directory = CTK.cfg.get_val('%s!target!directory' % (PRE),
'').rstrip('/')
nagiosuser = CTK.cfg.get_val('%s!nagiosuser' % (PRE))
nagiosgroup = CTK.cfg.get_val('%s!nagiosgroup' % (PRE))
nagioscmd = CTK.cfg.get_val('%s!nagioscmd' % (PRE))
email = CTK.cfg.get_val('%s!email' % (PRE))
contacts_path = os.path.join(root, 'nagios', 'etc', 'objects',
'contacts.cfg')
cmd_config = './configure --with-command-group=%(nagioscmd)s --prefix=${app_root}/nagios'
if target_directory:
cmd_config += ' --with-htmurl=%(target_directory)s --with-cgiurl=%(target_directory)s/cgi-bin'
else:
cmd_config += ' --with-htmurl=/ --with-cgiurl=/cgi-bin'
tasks = [
({
'cd': '${app_root}/nagios_core',
'command': cmd_config % (locals())
}),
({
'cd': '${app_root}/nagios_core',
'command': 'make all'
}),
({
'cd': '${app_root}/nagios_core',
'command': 'make install'
}),
({
'function': self.make_install_init
}),
({
'cd': '${app_root}/nagios_core',
'command': 'make install-config'
}),
({
'cd': '${app_root}/nagios_core',
'command': 'make install-commandmode'
}),
({
'cd':
'${app_root}/nagios_plugins',
'command':
'./configure --with-nagios-user=%(nagiosuser)s --with-nagios-group=%(nagiosgroup)s --prefix=${app_root}/nagios'
% (locals())
}),
({
'cd': '${app_root}/nagios_plugins',
'command': 'make'
}),
({
'cd': '${app_root}/nagios_plugins',
'command': 'make install'
}),
# The following two steps fix and validate the configuration
({
'command':
"sed -i.bkp 's/nagios@localhost/%(email)s/' %(contacts_path)s"
% (locals())
}),
({
'command':
'${app_root}/nagios/bin/nagios -v ${app_root}/nagios/etc/nagios.cfg'
}),
({
'command':
'chown -R %(nagiosuser)s:%(nagiosgroup)s ${app_root}/nagios' %
(locals())
})
]
box = CTK.Box()
box += CTK.RawHTML('<h2>%s</h2>' % (_('Installing Nagios')))
box += CTK.RawHTML(
'<p>%s</p>' %
(_('This process may take a while. Please, hold on.')))
box += CommandProgress(tasks, URL_LAUNCH_CONFIG)
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Cancel'))
box += buttons
return box.Render().toStr()
final = CTK.ToggleButton(
CTK.Box({'class': 'final-on'},
CTK.RawHTML(_('Final'))),
CTK.Box({'class': 'final-off'},
CTK.RawHTML(_('Non Final'))), is_final)
final.bind(
'changed',
CTK.JS.Ajax(
url_apply,
async=True,
data=
'{"vserver!%s!rule!%s!match!final": parseInt(event.value)?"0":"1"}'
% (vsrv_num, r)))
# Actions
group = CTK.Box({'class': 'sel-actions'},
[disabled, remove])
content = [group]
content += [
CTK.Box({'class': 'name'}, CTK.RawHTML(rule_name_esc)),
CTK.Box({'class': 'final'}, final),
CTK.Box({'class': 'comment'},
CTK.RawHTML(', '.join(comment)))
]
# Add the list entry
panel.Add(row_id,
'/vserver/%s/rule/content/%s' % (vsrv_num, r),
content, True, disclass)
class PanelButtons(CTK.Box):
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, refresh, right_box, vsrv_num):
CTK.Container.__init__(self)
url_base = '/vserver/%s/rule' % (vsrv_num)
url_apply = URL_APPLY % (vsrv_num)
# Build the panel list
panel = SelectionPanel.SelectionPanel(reorder,
right_box.id,
url_base,
'',
container='rules_panel')
self += panel
# Build the Rule list
rules = CTK.cfg.keys('vserver!%s!rule' % (vsrv_num))
rules.sort(lambda x, y: cmp(int(x), int(y)))
rules.reverse()
for r in rules:
rule = Rule('vserver!%s!rule!%s!match' % (vsrv_num, r))
rule_name = rule.GetName()
rule_name_esc = CTK.escape_html(rule_name)
# Comment
comment = []
handler = CTK.cfg.get_val('vserver!%s!rule!%s!handler' %
(vsrv_num, r))
if handler:
desc = filter(lambda x: x[0] == handler, HANDLERS)[0][1]
comment.append(_(desc))
auth = CTK.cfg.get_val('vserver!%s!rule!%s!auth' %
(vsrv_num, r))
if auth:
desc = filter(lambda x: x[0] == auth, VALIDATORS)[0][1]
comment.append(_(desc))
for e in CTK.cfg.keys('vserver!%s!rule!%s!encoder' %
(vsrv_num, r)):
val = CTK.cfg.get_val('vserver!%s!rule!%s!encoder!%s' %
(vsrv_num, r, e))
if val == 'allow':
comment.append(e)
elif val == 'forbid':
comment.append("no %s" % (e))
if CTK.cfg.get_val('vserver!%s!rule!%s!flcache' %
(vsrv_num, r)) == "allow":
comment.append('Cache')
if CTK.cfg.get_val('vserver!%s!rule!%s!timeout' %
(vsrv_num, r)):
comment.append('Timeout')
if CTK.cfg.get_val('vserver!%s!rule!%s!rate' % (vsrv_num, r)):
comment.append('Traffic')
if int(
CTK.cfg.get_val(
'vserver!%s!rule!%s!no_log' %
(vsrv_num, r), "0")) > 0:
comment.append('No log')
# List entry
row_id = '%s_%s' % (r, vsrv_num)
if r == rules[-1]:
content = [
CTK.Box({'class': 'name'}, CTK.RawHTML(rule_name_esc)),
CTK.Box({'class': 'comment'},
CTK.RawHTML(', '.join(comment)))
]
panel.Add(row_id,
'/vserver/%s/rule/content/%s' % (vsrv_num, r),
content,
draggable=False)
else:
# Remove
dialog = CTK.Dialog({
'title':
_('Do you really want to remove it?'),
'width':
480
})
dialog.AddButton(_('Cancel'), "close")
dialog.AddButton (_('Remove'), CTK.JS.Ajax (url_apply, async=False,
data = {'vserver!%s!rule!%s'%(vsrv_num, r):''},
success = dialog.JS_to_close() + \
refresh.JS_to_refresh()))
dialog += CTK.RawHTML(
_(NOTE_DELETE_DIALOG) % (rule_name_esc))
self += dialog
remove = CTK.ImageStock('del')
remove.bind('click', dialog.JS_to_show() + "return false;")
# Disable
is_disabled = bool(
int(
CTK.cfg.get_val(
'vserver!%s!rule!%s!disabled' % (vsrv_num, r),
"0")))
disclass = ('', 'rule-inactive')[is_disabled][:]
disabled = CTK.ToggleButtonOnOff(not is_disabled)
disabled.bind(
'changed',
CTK.JS.Ajax(
url_apply,
async=True,
data='{"vserver!%s!rule!%s!disabled": event.value}'
% (vsrv_num, r)))
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 __safe_call__(self):
root = CTK.cfg.get_val('tmp!market!install!root')
app_name = CTK.cfg.get_val('tmp!market!install!app!application_name')
cfg_changes = CTK.cfg.get_val(
'tmp!market!install!cfg_previous_changes')
# Finished
finished_file = os.path.join(root, "finished")
Install_Log.log("Creating %s" % (finished_file))
f = open(finished_file, 'w+')
f.close()
# Normalize CTK.cfg
CTK.cfg.normalize('vserver')
# Save configuration
box = CTK.Box()
if not int(cfg_changes):
CTK.cfg.save()
Install_Log.log("Configuration saved.")
Cherokee.server.restart(graceful=True)
Install_Log.log("Server gracefully restarted.")
box += CTK.RawHTML(js=SaveButton.ButtonSave__JS_to_deactive())
Install_Log.log("Finished")
# Thank user for the install
box += CTK.RawHTML('<h2>%s %s</h2>' %
(app_name, _("has been installed successfully")))
box += CTK.RawHTML("<p>%s</p>" % (_(NOTE_THANKS_P1)))
# Save / Visit
if int(cfg_changes):
box += CTK.Notice('information', CTK.RawHTML(_(NOTE_SAVE_RESTART)))
elif Cherokee.server.is_alive():
install_type = CTK.cfg.get_val('tmp!market!install!target')
nick = CTK.cfg.get_val('tmp!market!install!target!vserver')
vserver_n = CTK.cfg.get_val('tmp!market!install!target!vserver_n')
directory = CTK.cfg.get_val('tmp!market!install!target!directory')
# Host
if vserver_n and not nick:
nick = CTK.cfg.get_val("vserver!%s!nick" % (vserver_n))
if not nick or nick.lower() == "default":
sys_stats = SystemStats.get_system_stats()
nick = sys_stats.hostname
# Ports
ports = []
for b in CTK.cfg['server!bind'] or []:
port = CTK.cfg.get_val('server!bind!%s!port' % (b))
if port:
ports.append(port)
nick_port = nick
if ports and not '80' in ports:
nick_port = '%s:%s' % (nick, ports[0])
# URL
url = ''
if install_type == 'vserver' and nick:
url = 'http://%s/' % (nick_port)
elif install_type == 'directory' and vserver_n and directory:
nick = CTK.cfg.get_val('vserver!%s!nick' % (vserver_n))
url = 'http://%s%s/' % (nick_port, directory)
if url:
box += CTK.RawHTML('<p>%s ' % (_("You can now visit")))
box += CTK.LinkWindow(url,
CTK.RawHTML(_('your new application')))
box += CTK.RawHTML(' on a new window.</p>')
box += CTK.RawHTML("<h1>%s</h1>" % (_(NOTE_THANKS_P2)))
buttons = CTK.DruidButtonsPanel()
buttons += CTK.DruidButton_Close(_('Close'))
box += buttons
# Clean up CTK.cfg
for k in CTK.cfg.keys('tmp!market!install'):
if k != 'app':
del (CTK.cfg['tmp!market!install!%s' % (k)])
return box.Render().toStr()
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 __call__(self):
title = _('Virtual Servers')
# Virtual Server List
left = CTK.Box({'class': 'panel'})
left += CTK.RawHTML('<h2>%s</h2>' % (title))
# Content
refresh_r = CTK.Refreshable({'id': 'vservers_panel'})
refresh_r.register(lambda: self.PanelList(refresh_r, right).Render())
# Refresh on 'New' or 'Clone'
buttons = self.PanelButtons()
buttons.bind(
'submit_success',
refresh_r.JS_to_refresh(on_success=JS_ACTIVATE_FIRST %
(refresh_r.id)))
left += buttons
left += CTK.Box({'class': 'filterbox'},
CTK.TextField({
'class':
'filter',
'optional_string':
_('Virtual Server Filtering'),
'optional':
True
}))
right = CTK.Box({'class': 'vserver_content'})
left += refresh_r
# Refresh the list whenever the content change
right.bind('submit_success', refresh_r.JS_to_refresh())
# Refresh the list when it's been reordered
left.bind('reordered', refresh_r.JS_to_refresh())
# Figure out content panel headers. This step is very tricky.
# We have no idea what HTML headers the content HTML will
# have. In fact, the panel content is receiving only the HTML
# content only (body).
#
# The static CHILD_HEADERS class property will hold a copy of
# the headers generated by the direct render of the PageVServer
# class. It should cover most of the cases, unless a dynamically
# loaded module requires an additional header entry.
#
if not self.CHILD_HEADERS:
import PageVServer
vsrv_num = CTK.cfg.keys('vserver')[0]
render = PageVServer.RenderContent(vsrv_num).Render()
self.CHILD_HEADERS = render.headers
# Build the page
page = Page.Base(title,
body_id='vservers',
helps=HELPS,
headers=self.CHILD_HEADERS)
page += left
page += right
return page.Render()
def _build_error_raw(self):
self += CTK.RawHTML('<h1>%s</h1>' % (_('Server Launch Error')))
self += CTK.Box({'class': 'description'},
CTK.RawHTML(_('Something unexpected just happened.')))
self += CTK.Box({'class': 'backtrace'}, CTK.RawHTML(self._error_raw))
