Viewing file:  django.pl (18.3 KB) -rwxrwxr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# script_django_desc()
sub script_django_desc
{
return "Django";
}
sub script_django_uses
{
return ( "python", "proxy" );
}
sub script_django_longdesc
{
return "Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design";
}
# script_django_versions()
sub script_django_versions
{
return ( "5.0.3", "4.2.11", "3.2.25" );
}
sub script_django_version_desc
{
local ($ver) = @_;
return $ver =~ /^(\d+)\.2/ ? "$ver (LTS)" : $ver;
}
sub script_django_can_upgrade
{
local ($sinfo, $newver) = @_;
if (&compare_versions($sinfo->{'version'}, "4.1.2") < 0) {
# Cannot upgrade from fcgi mode to proxy mode
return 0;
}
return 1;
}
sub script_django_release
{
return 4; # To fix Python requirements for version 5
}
sub script_django_gpl
{
return 1;
}
sub script_django_testable
{
return 0;
}
sub script_django_python_fullver
{
my ($ver) = @_;
$ver =~ s/(?<=\.\d)\.\d$//; # Compare against 4.2, not 4.2.8
return $ver >= 5 ? 3.10 :
$ver >= 4 ? 3.8 :
$ver >= 3.2 ? 3.7 : 3.6;
}
sub script_django_testargs
{
return ( [ 'opt', 'project testproject' ] );
}
sub script_django_category
{
return "Development";
}
sub script_django_python_modules
{
local ($d, $ver, $opts) = @_;
local ($dbtype, $dbname) = split(/_/, $opts->{'db'}, 2);
return ( "setuptools", $dbtype eq "mysql" ? "MySQLdb" : "psycopg2" );
}
# script_django_depends(&domain, version)
# Check for ruby command, ruby gems, mod_proxy
sub script_django_depends
{
local ($d, $ver) = @_;
local @rv;
# Check for python, and required version
my $python = &get_python_path($ver >= 2.2 ? 3 : 2);
$python || push(@rv, "The python command is not installed");
my $pyver = &get_python_version($python);
if ($pyver) {
if ($ver >= 4.0 && &compare_versions($pyver, "3.8") < 0) {
push(@rv, "Django 4.0 requires Python 3.8 or later");
}
elsif ($ver >= 3.2 && &compare_versions($pyver, "3.7") < 0) {
push(@rv, "Django 3.1 requires Python 3.7 or later");
}
elsif (&compare_versions($pyver, "3.6") < 0) {
push(@rv, "Django 2.2 requires Python 3.6 or later");
}
}
else {
push(@rv, "Could not work out Python version : $out");
}
return @rv;
}
# script_django_params(&domain, version, &upgrade-info)
# Returns HTML for table rows for options for installing PHP-NUKE
sub script_django_params
{
local ($d, $ver, $upgrade) = @_;
local $rv;
local $hdir = &public_html_dir($d, 1);
if ($upgrade) {
# Options are fixed when upgrading
local ($dbtype, $dbname) = split(/_/, $upgrade->{'opts'}->{'db'}, 2);
$rv .= &ui_table_row("Django database", $dbname);
$rv .= &ui_table_row("Initial project name",
$upgrade->{'opts'}->{'project'});
local $dir = $upgrade->{'opts'}->{'dir'};
$dir =~ s/^$d->{'home'}\///;
$rv .= &ui_table_row("Install directory", $dir);
}
else {
# Show editable install options
local @dbs = &domain_databases($d, [ "mysql", "postgres" ]);
$rv .= &ui_table_row("Django database",
&ui_database_select("db", undef, \@dbs, $d, "django"));
$rv .= &ui_table_row("Initial project name",
&ui_textbox("project", "myproject", 30));
# $rv .= &ui_table_row("Disable debug mode",
# &ui_yesno_radio("nodebug", 0));
$rv .= &ui_table_row("Install sub-directory under <tt>$hdir</tt>",
&ui_opt_textbox("dir", undef, 30,
"At top level " .
&ui_help("Django works best when installed at the top level")));
}
return $rv;
}
# script_django_parse(&domain, version, &in, &upgrade-info)
# Returns either a hash ref of parsed options, or an error string
sub script_django_parse
{
local ($d, $ver, $in, $upgrade) = @_;
if ($upgrade) {
# Options are always the same
return $upgrade->{'opts'};
}
else {
local $hdir = &public_html_dir($d, 0);
$in->{'dir_def'} || $in->{'dir'} =~ /\S/ && $in->{'dir'} !~ /\.\./ ||
return "Missing or invalid installation directory";
local $dir = $in->{'dir_def'} ? $hdir : "$hdir/$in->{'dir'}";
$in{'project'} =~ /^[a-zA-Z0-9]+$/ ||
return "Project name can only contain letters and numbers";
local ($newdb) = ($in->{'db'} =~ s/^\*//);
return { 'db' => $in->{'db'},
'newdb' => $newdb,
'nodebug' => $in->{'nodebug'},
'dir' => $dir,
# 'dir' => $hdir,
'idir' => "$d->{'home'}/.local",
'path' => $in->{'dir_def'} ? "/" : "/$in->{'dir'}",
# 'path' => "/",
'project' => $in{'project'} };
}
}
# script_django_check(&domain, version, &opts, &upgrade-info)
# Returns an error message if a required option is missing or invalid
sub script_django_check
{
local ($d, $ver, $opts, $upgrade) = @_;
$opts->{'idir'} ||= "$d->{'home'}/.local";
$opts->{'dir'} =~ /^\// || return "Missing or invalid install directory";
$opts->{'db'} || return "Missing database";
$opts->{'project'} ||
return "Missing project name parameter";
$opts->{'project'} !~ /^(bin|lib)$/ ||
return "Reserved name project name \`$opts->{'project'}\` cannot be used";
if (-r "$opts->{'idir'}/$opts->{'project'}") {
return "Django appears to be already installed in the selected project directory";
}
$opts->{'project'} ||
return "Missing initial project name";
$opts->{'project'} =~ /^[a-zA-Z0-9]+$/ ||
return "Project name can only contain letters and numbers";
return undef;
}
# script_django_files(&domain, version, &opts, &upgrade-info)
# Returns a list of files needed by Rails, each of which is a hash ref
# containing a name, filename and URL
sub script_django_files
{
local ($d, $ver, $opts, $upgrade) = @_;
local @files = (
{ 'name' => "source",
'file' => "Django-$ver.tar.gz",
'url' => "https://www.djangoproject.com/download/$ver/tarball/" },
{ 'name' => "flup",
'file' => "flup-1.0.3.tar.gz",
'url' => "https://files.pythonhosted.org/packages/bb/b5/26cc8f7baf0ddebd3e61a354a2bcc692cfe8005123c37ee3d8507c4c7511/flup-1.0.3.tar.gz" },
);
return @files;
}
sub script_django_commands
{
local ($d, $ver, $opts) = @_;
return (&get_python_path(), "fuser", "pip");
}
# script_django_install(&domain, version, &opts, &files, &upgrade-info)
# Actually installs PhpWiki, and returns either 1 and an informational
# message, or 0 and an error
sub script_django_install
{
local ($d, $version, $opts, $files, $upgrade, $domuser, $dompass) = @_;
local ($out, $ex);
# Get database settings
if ($opts->{'newdb'} && !$upgrade) {
local $err = &create_script_database($d, $opts->{'db'});
return (0, "Database creation failed : $err") if ($err);
}
local ($dbtype, $dbname) = split(/_/, $opts->{'db'}, 2);
local $dbuser = $dbtype eq "mysql" ? &mysql_user($d) : &postgres_user($d);
local $dbpass = $dbtype eq "mysql" ? &mysql_pass($d) : &postgres_pass($d, 1);
local $dbhost = &get_database_host($dbtype, $d);
local $domemail = $d->{'emailto_addr'};
$dbhost = undef if ($dbhost eq "localhost" || $dbhost eq "127.0.0.1");
if ($dbtype) {
local $dberr = &check_script_db_connection($d, $dbtype, $dbname,
$dbuser, $dbpass);
return (0, "Database connection failed : $dberr") if ($dberr);
}
my $dbpass_quote_escaped = &php_quotemeta($dbpass, 1);
my $python = &get_python_path();
my $pythonver = &get_python_version();
($pythonver) = $pythonver =~ /(\d+.\d+)/;
my $pythonlibs = "lib/python$pythonver";
# Create base dir
&run_as_domain_user($d, "mkdir ".quotemeta($opts->{'dir'}))
if (!-d $opts->{'dir'});
# Create target dir
if (!-d $opts->{'idir'}) {
$out = &run_as_domain_user($d, "mkdir -p ".quotemeta($opts->{'idir'}));
-d $opts->{'idir'} ||
return (0, "Failed to create directory : <tt>$out</tt>.");
}
# Create python base dir
$ENV{'PYTHONPATH'} = "$opts->{'idir'}/$pythonlibs";
&run_as_domain_user($d, "mkdir -p ".quotemeta($ENV{'PYTHONPATH'}));
# Install needed PIP modules
foreach my $pip ("contextvars", "typing", "typing-extensions", "asyncio") {
$out = &run_as_domain_user($d, "$python -m pip install --upgrade ".quotemeta($pip)." 2>&1 </dev/null");
if ($?) {
return (0, "Failed to install PIP module $pip : $out");
}
}
# Extract the source
local $temp = &transname();
local $err = &extract_script_archive($files->{'source'}, $temp, $d);
$err && return (0, "Failed to extract Django source : $err");
# Delete .pyc files from source that may be for an older python version
&run_as_domain_user($d,
"find ".quotemeta($temp)." -name '*.pyc' | xargs rm -f");
# Stop running server if upgrading
if ($upgrade) {
&script_django_stop_server($d, $opts);
}
# Install to .local
local $icmd = "(cd ".quotemeta("$temp/Django-$ver")." && ".
"$python setup.py install --prefix=".quotemeta($opts->{'idir'}).") 2>&1";
local $out = &run_as_domain_user($d, $icmd);
if ($?) {
return (0, "Django source install failed : ".
"<pre>".&html_escape($out)."</pre>");
}
# Extract and copy the flup source
local $err = &extract_script_archive($files->{'flup'}, $temp, $d);
$err && return (0, "Failed to extract flup source : $err");
local $out = &run_as_domain_user($d,
"cp -r ".quotemeta("$temp/flup-1.0.3/flup").
" ".quotemeta("$ENV{'PYTHONPATH'}/site-packages"));
if ($?) {
return (0, "flup source copy failed : ".
"<pre>".&html_escape($out)."</pre>");
}
if (!$upgrade) {
# Create the initial project
my $django_admin_file = $ver >= 4 ? 'django-admin' : 'django-admin.py';
local $icmd = "cd ".quotemeta($opts->{'idir'})." && ".
"./bin/$django_admin_file startproject ".
quotemeta($opts->{'project'})." 2>&1";
local $out = &run_as_domain_user($d, $icmd);
if ($?) {
return (-1, "Project initialization install failed : ".
"<pre>".&html_escape($out)."</pre>");
}
# Fixup settings.py to use the MySQL DB
local $pdir = "$opts->{'idir'}/$opts->{'project'}";
local $sfile = "$pdir/settings.py";
if (!-r $sfile) {
# New django moves this into a sub-directory
$sfile = "$pdir/$opts->{'project'}/settings.py";
}
-r $sfile || return (-1, "Project settings file $sfile was not found");
local $lref = &read_file_lines_as_domain_user($d, $sfile);
my $i = 0;
my $pdbtype = $dbtype eq "mysql" ? "mysql" : "postgresql_psycopg2";
my $surl = &script_path_url($d, $opts);
$surl =~ s/\/$//;
my ($engine, $gotname, $gotuser, $gotpass, $gothost);
# my $lnum = scalar(@$lref);
foreach my $l (@$lref) {
# Update Django variables
if ($l =~ /INSTALLED_APPS\s*=\s*\(/ &&
$lref->[$i+1] !~ /django.contrib.admin/) {
splice(@$lref, $i+1, 0,
" 'django.contrib.admin',");
}
if ($ver >= 4) {
if ($l =~ /ALLOWED_HOSTS\s*=\s*\[/) {
$l = "ALLOWED_HOSTS = ['localhost', '127.0.0.1', '[::1]', '.$d->{'dom'}']";
splice(@$lref, $i+1, 0,
"CSRF_TRUSTED_ORIGINS = ['$surl']");
}
}
# Disable debug mode?
if ($opts->{'nodebug'} && $l =~ /^DEBUG\s+=/) {
$l = "# $l";
}
if ($l =~ /'ENGINE':/) {
$l = " 'ENGINE': 'django.db.backends.$pdbtype',";
$engine = $i;
}
if ($l =~ /'NAME':/ && !$gotname) {
$l = " 'NAME': '$dbname',";
$gotname++;
}
if ($l =~ /'USER':/ && !$gotuser) {
$l = " 'USER': '$dbuser',";
$gotuser++;
}
if ($l =~ /'PASSWORD':/ && !$gotpass) {
$l = " 'PASSWORD': '$dbpass_quote_escaped',";
$gotpass++;
}
if ($l =~ /'HOST':/ && !$gothost) {
$l = " 'HOST': '$dbhost',";
$gothost++;
}
# if ($i == $lnum) {
# if ($opts->{'path'} && $opts->{'path'} ne '/') {
# splice(@$lref, $i+1, 0,
# "\nLOGIN_URL = '$opts->{'path'}'");
# }
# }
$i++;
}
if (!$gotname) {
splice(@$lref, $engine, 0, " 'NAME': '$dbname',");
}
if (!$gotuser) {
splice(@$lref, $engine, 0, " 'USER': '$dbuser',");
}
if (!$gotpass) {
splice(@$lref, $engine, 0, " 'PASSWORD': '$dbpass_quote_escaped',");
}
if (!$gothost) {
splice(@$lref, $engine, 0, " 'HOST': '$dbhost',");
}
&flush_file_lines_as_domain_user($d, $sfile);
# Activate the admin site
local $ufile = "$pdir/urls.py";
if (!-r $ufile) {
$ufile = "$pdir/$opts->{'project'}/urls.py";
}
local $lref = &read_file_lines_as_domain_user($d, $ufile);
foreach my $l (@$lref) {
if ($l =~ /^(\s*)#(.*django.contrib.admin.urls.*)/ ||
$l =~ /^(\s*)#(.*admin.site.root.*)/ ||
$l =~ /^(\s*)#(.*admin.site.urls.*)/) {
# Un-comment /admin/ path
$l = $1.$2;
}
elsif ($l =~ /^\s*#\s*(from django.contrib import admin)/ ||
$l =~ /^\s*#\s*(admin.autodiscover\(\))/) {
# Un-comment admin includes
$l = $1;
}
}
&flush_file_lines_as_domain_user($d, $ufile);
# Initialize the DB
local $pwd = &get_current_dir();
chdir($pdir);
# Use new migrate command
local $out = &run_as_domain_user($d,
"$python manage.py migrate 2>&1");
chdir($pwd);
if ($?) {
return (-1, "DB initialization install failed : ".
"<pre>".&html_escape($out)."</pre>");
}
# Create Django admin user
chdir($pdir);
my $dompass_esc = $dompass;
$dompass_esc =~ s/'/\\'/g;
$dompass_esc =~ s/"/\\"/g;
local $out = &run_as_domain_user($d, "echo \"from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.create_superuser('$domuser', '$domemail', '$dompass_esc')\" | $python manage.py shell 2>&1");
if ($?) {
return (-1, "Initial Django user creation failed : ".
"<tt>".&html_escape($out)."</tt>");
}
}
# Django 1.9+ uses a server process
my $port;
if ($upgrade) {
$port = $opts->{'port'};
}
else {
$port = &allocate_mongrel_port(undef, 1);
$opts->{'port'} = $port;
}
$opts->{'logfile'} ||= "$opts->{'idir'}/$opts->{'project'}/runserver.log";
# Create an init script
my $cmd = &get_django_start_cmd($d, $opts);
my $userd = $d->{'parent'} ? &get_domain($d->{'parent'}) : $d;
if (&foreign_installed("init") && $userd &&
$userd->{'unix'} && !$upgrade) {
my $killcmd = "kill -9 `fuser $opts->{'logfile'}`";
&foreign_require("init");
my $opts = { };
if ($init::init_mode eq 'upstart' ||
$init::init_mode eq 'systemd') {
# Init system will background it
$opts->{'fork'} = 0;
}
else {
$cmd .= "&";
}
&init::enable_at_boot(
"django-$d->{'dom'}-$port",
"Start Django server for $d->{'dom'}",
&command_as_user($userd->{'user'}, 0, $cmd),
&command_as_user($userd->{'user'}, 0, $killcmd),
undef,
$opts,
);
}
# Start the server process
&run_as_domain_user($d, $cmd, 1);
if (!$upgrade) {
# Configure webserver to proxy to it
&setup_mongrel_proxy($d, $opts->{'path'}, $port);
}
local $url = &script_path_url($d, $opts);
$url =~ s/\/$//;
local $adminurl = $url."/admin/";
local $rp = $opts->{'dir'};
$rp =~ s/^$d->{'home'}\///;
return (1, "Initial Django installation complete. Go to <a target=_blank href='$adminurl'>$adminurl</a> to manage it. Django is a development environment, so it doesn't do anything by itself. Some applications may require you to set the <tt>PYTHONPATH</tt> environment variable to <tt>$ENV{'PYTHONPATH'}</tt>.", "Under $rp", $url, $domuser, $dompass);
}
# script_django_uninstall(&domain, version, &opts)
# Un-installs a Rails installation, by deleting the directory and database.
# Returns 1 on success and a message, or 0 on failure and an error
sub script_django_uninstall
{
local ($d, $version, $opts) = @_;
# Remove the contents of the target directory
local $derr = &delete_script_install_directory($d, $opts);
return (0, $derr) if ($derr);
&unlink_file_as_domain_user($d,
("$opts->{'idir'}/$opts->{'project'}",
"$opts->{'idir'}/bin/sqlformat",
"$opts->{'idir'}/bin/django-admin"))
# Remove base Django tables from the database (twice, because of dependencies)
&cleanup_script_database($d, $opts->{'db'}, "(django|auth)_");
&cleanup_script_database($d, $opts->{'db'}, "(django|auth)_");
# Remove proxy path
&delete_mongrel_proxy($d, $opts->{'path'});
# Stop the server
&script_django_stop($d, { 'opts' => $opts });
# Take out the DB
if ($opts->{'newdb'}) {
&delete_script_database($d, $opts->{'db'});
}
return (1, "Django directory and tables deleted.");
}
sub script_django_db_conn_desc
{
my ($d, $opts) = @_;
my $pdir = "$opts->{'idir'}/$opts->{'project'}";
my $sfile = "$pdir/settings.py";
$sfile = "$pdir/$opts->{'project'}/settings.py" if (!-r $sfile);
$sfile =~ s/^$d->{'home'}/../;
my $db_conn_desc =
{ "$sfile" =>
{
'dbpass' =>
{
'func' => 'php_quotemeta',
'func_params' => 1,
'replace' => [ '[\'"]PASSWORD[\'"]\s*:.*?' =>
'\'PASSWORD\': \'$$sdbpass\',' ],
},
'dbuser' =>
{
'replace' => [ '[\'"]USER[\'"]\s*:.*?' =>
'\'USER\': \'$$sdbuser\',' ],
},
}
};
return $db_conn_desc;
}
# script_django_latest(version)
# Returns a URL and regular expression or callback func to get the version
sub script_django_latest
{
local ($ver) = @_;
return ( "http://www.djangoproject.com/download/",
$ver >= 5.0 ? "Django-([0-9\\.]+)\\.tar\\.gz" :
$ver >= 4.2 ? "Django-(4\\.2\\.[0-9\\.]+)\\.tar\\.gz" :
"Django-(3\\.[0-9\\.]+)\\.tar\\.gz" );
}
sub script_django_site
{
return 'http://www.djangoproject.com/';
}
sub script_django_passmode
{
return 1;
}
# script_django_stop(&domain, &sinfo)
# Stop running django webserver, and delete init script
sub script_django_stop
{
local ($d, $sinfo) = @_;
my $opts = $sinfo->{'opts'};
return undef if (!$opts->{'port'});
&script_django_stop_server($d, $opts);
&foreign_require("init");
my $name = "django-$d->{'dom'}-$opts->{'port'}";
if (defined(&init::delete_at_boot)) {
&init::delete_at_boot($name)
}
else {
&init::disable_at_boot($name);
}
}
# Start the django webserver
sub script_django_start_server
{
local ($d, $opts) = @_;
return undef if (!$opts->{'port'});
my $cmd = &get_django_start_cmd($d, $opts);
&run_as_domain_user($d, $cmd, 1);
}
# Return the PID if the node server is running
sub script_django_status_server
{
local ($d, $opts) = @_;
return ( ) if (!$opts->{'port'}); # Change to -1 once Virtualmin 5.1 is out
local @pids;
if ($opts->{'logfile'}) {
&foreign_require("proc");
@pids = &proc::find_file_processes($opts->{'logfile'});
}
return @pids;
}
# script_django_stop_server(&domain, &opts)
# Stop running django webserver
sub script_django_stop_server
{
local ($d, $opts) = @_;
return undef if (!$opts->{'port'});
if ($opts->{'logfile'}) {
&foreign_require("proc");
local @pids = &proc::find_file_processes($opts->{'logfile'});
foreach my $pid (@pids) {
&run_as_domain_user($d, "kill -9 $pid");
}
}
}
sub get_django_start_cmd
{
my ($d, $opts) = @_;
my $python = &get_python_path();
my $pythonver = &get_python_version();
($pythonver) = $pythonver =~ /(\d+.\d+)/;
my $pythonlibs = "lib/python$pythonver";
my $cmd = "cd $opts->{'idir'}/$opts->{'project'} && PYTHONPATH=$opts->{'idir'}/$pythonlibs $python manage.py runserver $opts->{'port'} >$opts->{'logfile'} 2>&1 </dev/null";
return $cmd;
}
sub script_django_migrated
{
return 1;
}
1;
|