def handle(self, *args, **options):
path = os.path.join(settings.BASE_DIR, 'settings', '{}.py'.format(setting_local_settings_filename.value))
if os.path.exists(path):
self.stdout.write(self.style.NOTICE('Existing settings file at: {0}. Backup, remove this file, and try again.'.format(path)))
else:
with open(path, 'w+') as file_object:
file_object.write(
SETTING_FILE_TEMPLATE.format(get_random_secret_key())
)
def initialize_system(self, force=False):
system_path = os.path.join(settings.MEDIA_ROOT, SYSTEM_DIR)
settings_path = os.path.join(settings.MEDIA_ROOT, 'mayan_settings')
secret_key_file_path = os.path.join(system_path, SECRET_KEY_FILENAME)
if not os.path.exists(settings.MEDIA_ROOT) or force:
# Create the media folder
try:
os.makedirs(settings.MEDIA_ROOT)
except OSError as exception:
if exception.errno == errno.EEXIST and force:
pass
# Touch media/__init__.py
Command.touch(os.path.join(settings.MEDIA_ROOT, '__init__.py'))
# Create media/settings
try:
os.makedirs(settings_path)
except OSError as exception:
if exception.errno == errno.EEXIST and force:
pass
# Touch media/settings/__init__.py
Command.touch(os.path.join(settings_path, '__init__.py'))
# Create the media/system folder
try:
os.makedirs(system_path)
except OSError as exception:
if exception.errno == errno.EEXIST and force:
pass
version_file_path = os.path.join(system_path, 'VERSION')
with open(version_file_path, 'w') as file_object:
file_object.write(mayan.__version__)
with open(secret_key_file_path, 'w') as file_object:
secret_key = get_random_secret_key()
file_object.write(secret_key)
settings.SECRET_KEY = secret_key
else:
self.stdout.write(
self.style.NOTICE(
'Existing media files at: {0}. Backup, remove this folder, '
'and try again. Or use the --force argument'.format(
settings.MEDIA_ROOT
)
)
)
def generate_secret_key(self):
print('[Generating secret key]')
from django.conf import settings
from django.core.management.utils import get_random_secret_key
if os.path.exists(settings.SECRET_KEY_FILE):
print('- Secret file already exists!')
return
os.makedirs(settings.CONFIG_DIR, exist_ok=True)
with open(settings.SECRET_KEY_FILE, 'w') as f:
f.write(get_random_secret_key())
print('- Secret key generated.')
def upload_local_settings():
require('srvr', 'path', provided_by=env.servers)
with cd(env.path):
with settings(warn_only=True):
if run('ls {}/settings/local.py'.format(PROJECT_NAME)).failed:
db_host = prompt('Database host: ')
db_pwd = prompt('Database password: '******'{}/settings/local_{}.py'.format(PROJECT_NAME, env.srvr),
'{}/settings/local.py'.format(PROJECT_NAME), mode='0664')
run('echo >> {}/settings/local.py'.format(PROJECT_NAME))
run('echo '
'"DATABASES[\'default\'][\'PASSWORD\'] = \'{}\'" >>'
'{}/settings/local.py'.format(db_pwd, PROJECT_NAME))
run('echo '
'"DATABASES[\'default\'][\'HOST\'] = \'{}\'" >>'
'{}/settings/local.py'.format(db_host, PROJECT_NAME))
run('echo '
'"SECRET_KEY = \'{}\'" >>'
'{}/settings/local.py'.format(
get_random_secret_key(), PROJECT_NAME))
https://docs.djangoproject.com/en/1.8/ref/settings/
"""
import os
import raven
from copy import deepcopy
from utils.shortcuts import get_env
from django.core.management import utils
production_env = get_env("OJ_ENV", "dev") == "production"
if production_env:
from .production_settings import *
else:
from .dev_settings import *
# with open(os.path.join(DATA_DIR, "config", "secret.key"), "r") as f:
SECRET_KEY = utils.get_random_secret_key()
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Applications
VENDOR_APPS = [
'django.contrib.auth',
'django.contrib.sessions',
'django.contrib.contenttypes',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'django_dramatiq',
'django_dbconn_retry',
]
def handle(self, *args, **options):
env_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), '../../../.env'))
if Command.confirm(options):
self.set_secret_key(env_path, get_random_secret_key())
env = Env()
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__))
ENV = env("ENVIRONMENT", default="local")
if ENV not in ("local", "dev", "staging", "production"):
warnings.warn(
"ENVIRONMENT env variable must be one of local, dev, staging or production"
)
DEBUG = env("DEBUG", default=False)
SECRET_KEY = env("DJANGO_SECRET_KEY", default=get_random_secret_key())
HOSTED_SEATS_LIMIT = env.int("HOSTED_SEATS_LIMIT", default=0)
# Google Analytics Configuration
GOOGLE_ANALYTICS_KEY = env("GOOGLE_ANALYTICS_KEY", default="")
GOOGLE_SERVICE_ACCOUNT = env("GOOGLE_SERVICE_ACCOUNT", default=None)
if not GOOGLE_SERVICE_ACCOUNT:
warnings.warn(
"GOOGLE_SERVICE_ACCOUNT not configured, getting organisation usage will not work"
)
GA_TABLE_ID = env("GA_TABLE_ID", default=None)
if not GA_TABLE_ID:
warnings.warn(
"GA_TABLE_ID not configured, getting organisation usage will not work")
heroku_url = match.group(2)
# Add the redis add-ons (the heroku one needs a config flag)
run_heroku_command([
"addons:create", "heroku-redis:hobby-dev", "--maxmemory_policy",
"allkeys-lru"
])
# Set build packs
run_heroku_command(
["buildpacks:set", "https://github.com/heroku/heroku-buildpack-nginx.git"])
run_heroku_command(["buildpacks:add", "--index", "1", "heroku/nodejs"])
run_heroku_command(["buildpacks:add", "--index", "2", "heroku/python"])
# Set config variables
secret_key = get_random_secret_key()
command = [
"config:set", "DISABLE_COLLECTSTATIC=1",
"DJANGO_SECRET_KEY=%s" % secret_key
]
command.append("DEBUG=1" if args.enable_debug else "DEBUG=0")
if args.fast_cache_timeout:
command.append("PUBLIC_FAST_CACHE_TIMEOUT=%d" % args.fast_cache_timeout)
if args.slow_cache_timeout:
command.append("PUBLIC_SLOW_CACHE_TIMEOUT=%d" % args.slow_cache_timeout)
if args.tab_cache_timeout:
command.append("TAB_PAGES_CACHE_TIMEOUT=%d" % args.tab_cache_timeout)
run_heroku_command(command)
# Set up a remote, if applicable
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
data.makeDirs(data.getPath(data.user, 'authserver'))
CONFIG_PATH = data.getPath(data.user, 'authserver', 'config')
config = ConfigParser(interpolation=None)
config.add_section('security')
config.add_section('web')
config.read(CONFIG_PATH)
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = config.get('security', 'key', fallback=None)
if not SECRET_KEY:
SECRET_KEY = get_random_secret_key().replace('%', '-')
config.set('security', 'key', SECRET_KEY)
with open(CONFIG_PATH, 'w') as f:
config.write(f)
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = config.getboolean('security', 'debug', fallback=False)
if DEBUG:
os.environ['PYTHONASYNCIODEBUG'] = '1'
def build_allowed_hosts():
result = {'localhost', '[::1]'}
result.update(socket.gethostbyname_ex(socket.gethostname())[2])
result.update(socket.gethostbyname_ex('localhost')[2])
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
def generate_secret_key(_ctx):
from django.core.management.utils import get_random_secret_key
print(get_random_secret_key())
"""
import os
import sys
import dj_database_url
from django.core.management.utils import get_random_secret_key
from pathlib import Path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.getenv("DJANGO_SECRET_KEY", get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.getenv("DEBUG", "False") == "True"
ALLOWED_HOSTS = os.getenv("DJANGO_ALLOWED_HOSTS",
"127.0.0.1,localhost").split(",")
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
"wagtail.contrib.settings.context_processors.settings",
],
},
},
]
WSGI_APPLICATION = "cms.wsgi.application"
# Set a SECRET_KEY in the environment when running multiple instances
SECRET_KEY = env("SECRET_KEY", default=utils.get_random_secret_key())
# Set the environment variable to the correct host when deployed
# https://docs.djangoproject.com/en/3.1/ref/settings/#std:setting-ALLOWED_HOSTS
ALLOWED_HOSTS = env.list("ALLOWED_HOSTS", default=[".localhost", "127.0.0.1"])
# Database
# https://docs.djangoproject.com/en/3.1/ref/settings/#databases
DATABASES = {
"default": env.db(default=f"sqlite:///{BASE_DIR}/db.sqlite3"),
}
# Password validation
# https://docs.djangoproject.com/en/3.1/ref/settings/#auth-password-validators
https://docs.djangoproject.com/en/2.0/ref/settings/
"""
import os
from django.core.management import utils
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
# See secret.py for how this is generated; uses a file 'secret.txt' in the root
# directory
SECRET_KEY = os.environ.get('DJANGO_SECRET', utils.get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = bool(os.environ.get('DEBUG', False))
ALLOWED_HOSTS = os.environ.get('DJANGO_HOSTS', '*').split(',')
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
def create_new_secret_key(configuration):
key = get_random_secret_key()
configuration['Keys'] = {'SECRET_KEY': key}
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
import os
import dj_database_url
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve(strict=True).parent.parent
SECRET_KEY = os.environ.get("SECRET_KEY", default=get_random_secret_key())
DEBUG = int(os.environ.get("DEBUG", default=0))
# 'DJANGO_ALLOWED_HOSTS' should be a single string of hosts with a space between each.
# For example: 'DJANGO_ALLOWED_HOSTS=localhost 127.0.0.1 [::1]'
# ALLOWED_HOSTS = os.environ.get("DJANGO_ALLOWED_HOSTS").split(" ")
ALLOWED_HOSTS = ["localhost", "127.0.0.1", "clothesmanager.herokuapp.com"]
# IPS for debug tool
INTERNAL_IPS = ["127.0.0.1"]
if os.environ.get("USE_DOCKER") == "yes":
import socket
ALLOWED_HOSTS += [socket.gethostbyname(socket.gethostname())]
class CheckSecretKeyFallbacksTest(SimpleTestCase):
@override_settings(SECRET_KEY_FALLBACKS=[("abcdefghijklmnopqrstuvwx" * 2) + "ab"])
def test_okay_secret_key_fallbacks(self):
self.assertEqual(
len(settings.SECRET_KEY_FALLBACKS[0]),
base.SECRET_KEY_MIN_LENGTH,
)
self.assertGreater(
len(set(settings.SECRET_KEY_FALLBACKS[0])),
base.SECRET_KEY_MIN_UNIQUE_CHARACTERS,
)
self.assertEqual(base.check_secret_key_fallbacks(None), [])
def test_no_secret_key_fallbacks(self):
with self.settings(SECRET_KEY_FALLBACKS=None):
del settings.SECRET_KEY_FALLBACKS
self.assertEqual(
base.check_secret_key_fallbacks(None),
[
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS", id=base.W025.id),
],
)
@override_settings(
SECRET_KEY_FALLBACKS=[base.SECRET_KEY_INSECURE_PREFIX + get_random_secret_key()]
)
def test_insecure_secret_key_fallbacks(self):
self.assertEqual(
base.check_secret_key_fallbacks(None),
[
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[0]", id=base.W025.id),
],
)
@override_settings(SECRET_KEY_FALLBACKS=[("abcdefghijklmnopqrstuvwx" * 2) + "a"])
def test_low_length_secret_key_fallbacks(self):
self.assertEqual(
len(settings.SECRET_KEY_FALLBACKS[0]),
base.SECRET_KEY_MIN_LENGTH - 1,
)
self.assertEqual(
base.check_secret_key_fallbacks(None),
[
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[0]", id=base.W025.id),
],
)
@override_settings(SECRET_KEY_FALLBACKS=["abcd" * 20])
def test_low_entropy_secret_key_fallbacks(self):
self.assertGreater(
len(settings.SECRET_KEY_FALLBACKS[0]),
base.SECRET_KEY_MIN_LENGTH,
)
self.assertLess(
len(set(settings.SECRET_KEY_FALLBACKS[0])),
base.SECRET_KEY_MIN_UNIQUE_CHARACTERS,
)
self.assertEqual(
base.check_secret_key_fallbacks(None),
[
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[0]", id=base.W025.id),
],
)
@override_settings(
SECRET_KEY_FALLBACKS=[
("abcdefghijklmnopqrstuvwx" * 2) + "ab",
"badkey",
]
)
def test_multiple_keys(self):
self.assertEqual(
base.check_secret_key_fallbacks(None),
[
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[1]", id=base.W025.id),
],
)
@override_settings(
SECRET_KEY_FALLBACKS=[
("abcdefghijklmnopqrstuvwx" * 2) + "ab",
"badkey1",
"badkey2",
]
)
def test_multiple_bad_keys(self):
self.assertEqual(
base.check_secret_key_fallbacks(None),
[
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[1]", id=base.W025.id),
Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[2]", id=base.W025.id),
],
)
"""
import os
import importlib
from pathlib import Path
from decouple import config
from django.urls import reverse_lazy
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = Path(__file__).resolve().parent.parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = config('SECRET_KEY', default=get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = config('DEBUG_MODE', default=True, cast=bool)
# custom env
WORK_DIR = config('WORK_DIR', default='')
Path(WORK_DIR).mkdir(parents=True, exist_ok=True)
USE_HTTPS = config('USE_HTTPS', default=False, cast=bool)
ALLOWED_HOSTS = config('ALLOWED_HOSTS', default='*').split(',')
CORS_ORIGIN_ALLOW_ALL = True
with open(BASE_DIR / 'purpleserver' / 'VERSION', "r") as v:
VERSION = v.read()
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
# Load secrety key
try:
SECRET_KEY = config('SECRET_KEY')
# If error, generate a random secret key and save in secret_key.py
except:
SETTINGS_DIR = os.path.abspath(os.path.dirname(__file__))
get_random_secret_key(os.path.join(SETTINGS_DIR, 'secret_key.py'))
from .secret_key import SECRET_KEY
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = config('DEBUG', cast=bool, default=False)
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.messages',
'django.contrib.sessions',
from pathlib import Path
from django.core.management import utils
path = Path(__file__).resolve().parents[1] / 'var/secret.txt'
if not path.exists():
print('Secret key generated')
path.write_text(utils.get_random_secret_key())
SECRET_KEY = path.read_text()
from pathlib import Path
from decouple import config
from datetime import timedelta
from django.urls import reverse_lazy
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = Path(__file__).resolve().parent.parent.parent
with open(BASE_DIR / "server" / "VERSION", "r") as v:
VERSION = v.read().strip()
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = config("SECRET_KEY", default=get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = config("DEBUG_MODE", default=True, cast=bool)
# custom env
WORK_DIR = config("WORK_DIR", default="")
Path(WORK_DIR).mkdir(parents=True, exist_ok=True)
USE_HTTPS = config("USE_HTTPS", default=False, cast=bool)
ALLOWED_HOSTS = config("ALLOWED_HOSTS", default="*").split(",")
CORS_ORIGIN_ALLOW_ALL = True
CORS_ALLOW_ALL_ORIGINS = True
CORS_ALLOW_CREDENTIALS = True
def handle(self, *args, **options):
self.stdout.write(get_random_secret_key())
"""
import os
from django.urls import reverse_lazy
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
CUR_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
BASE_DIR = os.path.join(CUR_DIR, "..")
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.environ.get('SECRET_KEY', get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = bool(os.environ.get('DEBUG_MODE', True))
SECURE_DOMAIN = os.environ.get('SECURE', False)
ALLOWED_HOSTS = [
'127.0.0.1',
'localhost'
]
CORS_ORIGIN_ALLOW_ALL = True
if SECURE_DOMAIN:
global SECURE_SSL_REDIRECT
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # generate_secret.py from django.core.management import utils print(utils.get_random_secret_key())
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
import os
from pathlib import Path
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.getenv('DJANGO_SECRET_KEY', default=get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ["*"]
# Application definition
INSTALLED_APPS = [
'django.contrib.admin', 'django.contrib.auth',
'django.contrib.contenttypes', 'django.contrib.sessions',
'django.contrib.messages', 'django.contrib.staticfiles', 'correction_api',
'rest_framework'
]
from django.core.management import utils
with open("temp", 'w') as tempFile:
tempFile.write(utils.get_random_secret_key())
def get_env_value(env_variable):
if not env_variable in os.environ:
os.environ[env_variable] = get_random_secret_key()
return os.environ[env_variable]
#!/usr/bin/env python3
from os.path import isfile
from django.core.management import utils
# Bail if .env exists already
if isfile('.env'):
print('.env file already present; exiting.')
exit(0)
try:
new_secret = utils.get_random_secret_key()
with open('example.env', 'rt') as env_in:
with open('.env', 'wt') as env_out:
for line in env_in:
env_out.write(line.replace('replaceme', new_secret))
print('.env written.')
except OSError as err:
print('OS Error: {}'.format(err))
except:
print('Unexpected error.')
import getpass
import os
import pathlib
import sys
from django.core.management.utils import get_random_secret_key
from invoke import task
BASE_DIR = os.path.dirname(__file__)
BASE_DIRNAME = os.path.dirname(BASE_DIR)
PROJECT_DIRNAME = os.path.basename(os.path.dirname(__file__))
EMPEROR_MODE = True
VASSALS = f'{BASE_DIRNAME}/vassals'
USERNAME = os.getlogin()
SECRET_FILE = f'{BASE_DIR}/{PROJECT_DIRNAME}/settings/secret.py'
SECRET_KEY = get_random_secret_key()
@task
def init(c):
"""Initialize project."""
try:
VENV_ROOT = str(pathlib.Path(os.environ['VIRTUAL_ENV']).parent).replace("/", "\/") # noqa
except KeyError:
print('Activate your virtualenv and run the inv command again')
return
EMPEROR_MODE = confirm('Do you want to configure your uWSGI vassal in emperor mode? (no=stand-alone)')
if EMPEROR_MODE:
vassals = input(f'We will use "{VASSALS}" as the directory for the vassals, or specify the path: ') or VASSALS
bonjour = confirm('Do you want to use Bonjour for OSX (Yes) or Avahi for Linux (No)? ')
if bonjour:
import json
from django.core.management.utils import get_random_secret_key
secret = {}
secret['SECRET_KEY'] = get_random_secret_key()
secret['DB_HOST'] = ''
secret['DB_USER'] = ''
secret['DB_DATABASE'] = ''
secret['DB_PASSWORD'] = ''
secret['ALLOWED_HOSTS'] = ['localhost', '127.0.0.1']
secret = json.dumps(secret)
f = open('secret.json', 'w')
f.write(secret)
f.close()
"""
from decouple import config
from pathlib import Path
import os
from django.core.management import utils
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
# Use secret key from env variable or generate a random key
SECRET_KEY = config('PT_LINUX_SECRET_KEY',
default=utils.get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
# Set 'PT_LINUX_DEBUG' env variable to '1' if you want to enable debug
DEBUG = config('PT_LINUX_DEBUG', default=False, cast=bool)
ALLOWED_HOSTS = ['localhost', '127.0.0.1', 'linux-blog-django']
# Application definition
INSTALLED_APPS = [
'frontend',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
from pathlib import Path
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = Path(__file__).resolve().parents[1]
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
key_file = Path('key')
if not Path('key').exists():
# gerar uma chave secreta caso nenhuma exista (projeto recém-instalado)
key_file.touch()
with open(key_file, 'w') as f:
f.write(get_random_secret_key())
# SECURITY WARNING: keep the secret key used in production secret!
with open(key_file) as f:
SECRET_KEY = f.read()
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False
ALLOWED_HOSTS = ['localhost']
# Application definition
INSTALLED_APPS = [
'candlesticks',
]
For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.0/ref/settings/
"""
import os
import dj_database_url
from django.core.management.utils import get_random_secret_key
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.getenv('SECRET_KEY', get_random_secret_key())
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.getenv('DEBUG', False)
ALLOWED_HOSTS = os.getenv('ALLOWED_HOSTS', '').split(',')
# Application definition
INSTALLED_APPS = [
'music_publisher.apps.MusicPublisherConfig',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
import getpass
import os
import pathlib
import sys
from django.core.management.utils import get_random_secret_key
from invoke import task
BASE_DIR = os.path.dirname(__file__)
BASE_DIRNAME = os.path.dirname(BASE_DIR)
PROJECT_DIRNAME = os.path.basename(os.path.dirname(__file__))
EMPEROR_MODE = True
VASSALS = f'{BASE_DIRNAME}/vassals'
USERNAME = os.getlogin()
SECRET_FILE = f'{BASE_DIR}/{PROJECT_DIRNAME}/settings/secret.py'
SECRET_KEY = get_random_secret_key()
@task
def init(c):
try:
VENV_ROOT = str(pathlib.Path(
os.environ['VIRTUAL_ENV']).parent).replace("/", "\/") # noqa
except KeyError:
print('Activate your virtualenv and run the inv command again')
return
EMPEROR_MODE = confirm(
'Do you want to configure your uWSGI vassal in emperor mode? (no=stand-alone)'
)
if EMPEROR_MODE:
vassals = input(
# This file is a part of IntelOwl https://github.com/intelowlproject/IntelOwl
# See the file 'LICENSE' for copying permission.
# flake8: noqa
import os
from datetime import timedelta
from django.core.files.storage import FileSystemStorage
from django.core.management.utils import get_random_secret_key
from intel_owl import secrets
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.environ.get("DJANGO_SECRET", None) or get_random_secret_key()
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.environ.get("DEBUG", False) == "True"
DJANGO_LOG_DIRECTORY = "/var/log/intel_owl/django"
PROJECT_LOCATION = "/opt/deploy/intel_owl"
MEDIA_ROOT = "/opt/deploy/files_required"
DISABLE_LOGGING_TEST = os.environ.get("DISABLE_LOGGING_TEST", False) == "True"
MOCK_CONNECTIONS = os.environ.get("MOCK_CONNECTIONS", False) == "True"
TEST_MODE = MOCK_CONNECTIONS
LDAP_ENABLED = os.environ.get("LDAP_ENABLED", False) == "True"
RADIUS_AUTH_ENABLED = os.environ.get("RADIUS_AUTH_ENABLED", False) == "True"
LOCAL_STORAGE = os.environ.get("LOCAL_STORAGE", "True") == "True"
# Storage settings
if LOCAL_STORAGE:
def test_get_random_secret_key(self):
key = get_random_secret_key()
self.assertEqual(len(key), 50)
for char in key:
self.assertIn(char, 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)')
https://docs.djangoproject.com/en/1.11/ref/settings/
"""
import os
from django.core.management import utils
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = utils.get_random_secret_key()
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
def generate_secret_key():
return get_random_secret_key()
secret = ask_text("Facebook App Secret")
client_id = ask_text("Facebook App ID (not client token)")
return dict(secret=secret, client_id=client_id)
def ask_google():
secret = ask_text("Google Secret")
client_id = ask_text("Google Client ID")
return dict(secret=secret, client_id=client_id)
if __name__ == "__main__":
context = {
'now': str(datetime.now()),
'secret_key': get_random_secret_key(),
}
heading("Facebook")
if ask_yes_no("Do you want to configure auth via Facebook?\n"
"You'll need the app secret and client."):
context['facebook'] = ask_facebook()
heading("Google")
if ask_yes_no("Do you want to configure auth via Google?\n"
"You'll need the app secret and client."):
context['google'] = ask_google()
heading("Rendering settings...")
with open('config/settings.py', 'w') as out:
out.write(settings_template.render(context, request=None))
#!/usr/bin/env python from django.core.management.utils import get_random_secret_key print(get_random_secret_key())
# Use this to generate secret keys for each environment from django.core.management.utils import get_random_secret_key print(get_random_secret_key())
def test_get_random_secret_key(self):
key = get_random_secret_key()
self.assertEqual(len(key), 50)
for char in key:
self.assertIn(char, 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)')
def handle(self, *args, **options):
# copy folder
self.stdout.write('copy folder')
copytree(getcwd(), self.DEPLOY_FOLDER)
# modify settings
lines = list()
with open(join(self.DEPLOY_FOLDER, 'server', 'settings.py'),
'r') as settings:
for line in settings:
if 'DEBUG =' in line:
line = 'DEBUG = False\n'
self.stdout.write('disabled debug mode')
if 'SECRET_KEY' in line:
line = "SECRET_KEY = '"
line += utils.get_random_secret_key() + "'\n"
self.stdout.write('generated secret key')
if 'ALLOWED_HOSTS' in line:
line = "ALLOWED_HOSTS = ['*']\n"
if 'STATIC_ROOT' in line:
line = "STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')\n"
lines.append(line)
with open(join(self.DEPLOY_FOLDER, 'server', 'settings.py'),
'w') as settings:
for line in lines:
settings.write(line)
# update npm
if isdir(join(self.DEPLOY_FOLDER, 'node_modules')):
self.stdout.write('delete node_modules')
rmtree(join(self.DEPLOY_FOLDER, 'node_modules'))
call(['npm', 'install'], cwd=self.DEPLOY_FOLDER)
# compile sass
call(
[
'python3',
'manage.py',
'compilesass',
],
cwd=self.DEPLOY_FOLDER,
)
# clone client
call(
['git', 'clone', 'https://github.com/bp-flugsimulator/client.git'],
cwd=join(self.DEPLOY_FOLDER, 'downloads'),
)
# update packages
call(
['python3', 'install.py', '--update'],
cwd=self.DEPLOY_FOLDER,
)
call(
['python3', 'install.py', '--update'],
cwd=join(self.DEPLOY_FOLDER, 'downloads'),
)
# delete unused files
for path, dir_names, file_names in walk(self.DEPLOY_FOLDER):
for directory in dir_names:
if ((len(directory) > 3) and
(directory[0] is '.')) or (directory in self.IGNORE_LIST):
rmtree(join(path, directory))
self.stdout.write('removed ' + join(path, directory))
for file in file_names:
if ((len(file) > 3) and
(file[0] is '.')) or (file in self.IGNORE_LIST):
remove(join(path, file))
self.stdout.write('removed ' + join(path, file))
# zip client and delete folder
print('zip client')
make_archive(
join(self.DEPLOY_FOLDER, 'downloads', 'client'),
'zip',
join(self.DEPLOY_FOLDER, 'downloads', 'client'),
)
self.stdout.write('delete client folder')
rmtree(join(self.DEPLOY_FOLDER, 'downloads', 'client'))
# collect static files
self.stdout.write('collect static files')
call(
['python3', 'manage.py', 'collectstatic', '--noinput'],
cwd=self.DEPLOY_FOLDER,
)
# set up database
if isfile(join(self.DEPLOY_FOLDER, 'db.sqlite3')):
remove(join(self.DEPLOY_FOLDER, 'db.sqlite3'))
self.stdout.write('deleted database')
for file in listdir(join(self.DEPLOY_FOLDER, 'frontend',
'migrations')):
if isfile(
join(
self.DEPLOY_FOLDER,
'frontend',
'migrations',
file,
)) and not ('0001_initial.py' in file
or '__init__.py' in file):
remove(
join(
self.DEPLOY_FOLDER,
'frontend',
'migrations',
file,
))
self.stdout.write('remove ' + join(
self.DEPLOY_FOLDER,
'frontend',
'migrations',
file,
))
call(
['python3', 'manage.py', 'makemigrations'],
cwd=self.DEPLOY_FOLDER,
)
call(
['python3', 'manage.py', 'migrate'],
cwd=self.DEPLOY_FOLDER,
)
# zip
self.stdout.write('zip server')
make_archive(
join(getcwd(), pardir, 'server'),
'zip',
self.DEPLOY_FOLDER,
)
self.stdout.write('delete deploy folder')
rmtree(self.DEPLOY_FOLDER)
def handle(self, *args, **options):
return get_random_secret_key()
def handle(self, **options):
# pop standard args
project_name = options.pop('name')
target = options.pop('directory')
# Make sure given name is not already in use by another python package/module.
try:
__import__(project_name)
except ImportError:
pass
else:
sys.exit("'%s' conflicts with the name of an existing "
"Python module and cannot be used as a project "
"name. Please try another name." % project_name)
# Create a random SECRET_KEY to put it in the main settings.
options['secret_key'] = get_random_secret_key()
# Add custom args
import coderedcms
codered_path = os.path.dirname(coderedcms.__file__)
template_path = os.path.join(codered_path, 'project_template')
options['template'] = template_path
options['extensions'] = ['py', 'html', 'rst', 'md']
options['files'] = ['Dockerfile']
# Set options
message = "Creating a CodeRed CMS project called %(project_name)s"
if options.get('sitename'):
message += " for %(sitename)s"
else:
options['sitename'] = project_name
if options.get('domain'):
message += " (%(domain)s)"
# Stip protocol out of domain if it is present.
options['domain'] = options['domain'].split('://')[-1]
# Figure out www logic.
if options['domain'].startswith('www.'):
options['domain_nowww'] = options['domain'].split('www.')[-1]
else:
options['domain_nowww'] = options['domain']
else:
options['domain'] = 'localhost'
options['domain_nowww'] = options['domain']
# Print a friendly message
print(
message % {
'project_name': project_name,
'sitename': options.get('sitename'),
'domain': options.get('domain'),
})
# Run command
super().handle('project', project_name, target, **options)
# Be a friend once again.
print("Success! %(project_name)s has been created" %
{'project_name': project_name})
nextsteps = """
Next steps:
1. cd %(directory)s/
2. python manage.py migrate
3. python manage.py createsuperuser
4. python manage.py runserver
5. Go to http://localhost:8000/admin/ and start editing!
"""
print(nextsteps % {'directory': target if target else project_name})
