How to implement django-tenant-schemas with a fixed URL

2020-08-06T18:43:15+00:00

Scalability and Performance
Tenants usually don’t share the same resources and hardware use. The level of use by one tenant might greatly exceed another.
Thus, an application’s performance should be scalable, while performing well with the resources it has. And this should be done in a way where a tenant’s use of resources shouldn’t affect the other tenants’ performance.
Performance and scalability can be tested using tools such as JMeter and Load Runner.

	DATABASES = {
	'default': {
	'ENGINE': 'tenant_schemas.postgresql_backend',
	'NAME': os.getenv('DB_NAME', 'pollsapi'),
	'USER': os.getenv('DB_USER', 'postgres'),
	'PASSWORD': os.getenv('DB_PASSWORD', 'postgres'),
	'HOST': os.getenv('HOST', 'localhost'),
	'PORT': os.getenv('PORT', 5432),
	}
	}

	SECRET_KEY=<your-very-secret-key>
	DB_NAME=pollsapi
	DB_USER=<your-db-user>
	DB_PASSWORD=<your-db-password>
	HOST=localhost
	DEBUG=True

	MIDDLEWARE = [
	'tenant_schemas.middleware.TenantMiddleware',
	'django.middleware.security.SecurityMiddleware',
	'django.contrib.sessions.middleware.SessionMiddleware',
	'django.middleware.common.CommonMiddleware',
	'django.middleware.csrf.CsrfViewMiddleware',
	'django.contrib.auth.middleware.AuthenticationMiddleware',
	'django.contrib.messages.middleware.MessageMiddleware',
	'django.middleware.clickjacking.XFrameOptionsMiddleware',
	]

	INSTALLED_APPS = [
	'tenant_schemas',
	'django.contrib.admin',
	'django.contrib.auth',
	'django.contrib.contenttypes',
	'django.contrib.sessions',
	'django.contrib.messages',
	'django.contrib.staticfiles',
	'rest_framework',
	'rest_framework.authtoken',
	'pollsapi.polls',
	]

	SHARED_APPS = (
	'tenant_schemas',
	'django.contrib.contenttypes',
	'django.contrib.admin',
	'django.contrib.auth',
	'django.contrib.sessions',
	'django.contrib.messages',
	'django.contrib.staticfiles',
	'rest_framework',
	'rest_framework.authtoken',
	)

	TENANT_APPS = (
	'django.contrib.contenttypes',
	'pollsapi.polls'
	)

	import uuid
	import os
	from django.db import models
	from tenant_schemas.models import TenantMixin


	# Create your models here.

	class Client(TenantMixin):
	REQUIRED_FIELDS = ('tenant_name', 'paid_until', 'schema_name', 'on_trial')
	tenant_name = models.CharField(max_length=100, unique=True, null=False, blank=False)
	tenant_uuid = models.UUIDField(default=uuid.uuid4, null=False, blank=False)
	paid_until = models.DateField()
	on_trial = models.BooleanField()
	created_on = models.DateField(auto_now_add=True)
	domain_url = models.URLField(blank=True, null=True, default=os.getenv('DOMAIN'))

	# default true, schema will be automatically created and synced when it is saved
	auto_create_schema = True

	from datetime import date
	from dateutil.relativedelta import relativedelta
	from django.core.exceptions import ObjectDoesNotExist
	from tenant_schemas.middleware import BaseTenantMiddleware
	from tenant_schemas.utils import get_public_schema_name


	class RequestIDTenantMiddleware(BaseTenantMiddleware):

	def get_tenant(self, model, hostname, request):
	try:
	public_schema = model.objects.get(schema_name=get_public_schema_name())
	except ObjectDoesNotExist:
	public_schema = model.objects.create(
	domain_url=hostname,
	schema_name=get_public_schema_name(),
	tenant_name=get_public_schema_name().capitalize(),
	paid_until=date.today() + relativedelta(months=+1),
	on_trial=True)
	public_schema.save()
	x_request_id = request.META.get('HTTP_X_REQUEST_ID', public_schema.tenant_uuid)
	tenant_model = model.objects.get(tenant_uuid=x_request_id)
	print(tenant_model, public_schema)
	return tenant_model if not None else public_schema

	import datetime
	from django.core.management.base import BaseCommand, CommandError
	from pollsapi.tenant.models import Client
	from django.utils.text import capfirst
	from django.core import exceptions


	class Command(BaseCommand):
	help = 'Create a client'

	def add_arguments(self, parser):
	"""
	Args:
	parser:
	Returns:
	"""
	for field_name in Client.REQUIRED_FIELDS:
	parser.add_argument('--%s' % field_name, action='append',
	help='Specifies the %s for the superuser.' % field_name, )

	def handle(self, args, *options):
	user_data = {}
	for field_name in Client.REQUIRED_FIELDS:
	field = Client._meta.get_field(field_name)
	user_data[field_name] = options[field_name]
	while user_data[field_name] is None:
	message = self._get_input_message(field)
	input_value = self.get_input_data(field, message)
	user_data[field_name] = input_value

	tenant = Client.objects.create(**user_data)
	tenant.save()
	if options['verbosity'] >= 1:
	self.stdout.write("Client created successfully.")

	def get_input_data(self, field, message, default=None):
	"""
	Override this method if you want to customize data inputs or
	validation exceptions.
	"""
	raw_value = input(message)
	if default and raw_value == '':
	raw_value = default
	try:
	val = field.clean(raw_value, None)
	except exceptions.ValidationError as e:
	self.stderr.write("Error: %s" % '; '.join(e.messages))
	val = None

	return val

	@staticmethod
	def _get_input_message(field, default=None):
	return '%s%s%s: ' % (
	capfirst(field.verbose_name),
	" (leave blank to use '%s')" % default if default else '',
	' (%s.%s)' % (
	field.remote_field.model._meta.object_name,
	field.m2m_target_field_name() if field.many_to_many else field.remote_field.field_name,
	) if field.remote_field else '',
	)

	from rest_framework import serializers

	class ClientSerializer(serializers.Serializer):
	tenant_uuid = serializers.UUIDField()
	tenant_name = serializers.CharField()

	SHARED_APPS = (
	'tenant_schemas',
	'pollsapi.tenant',
	...
	)

	INSTALLED_APPS = [
	'tenant_schemas',
	.....
	'pollsapi.tenant'
	]

	from rest_framework import viewsets, status
	from rest_framework.exceptions import ValidationError
	from rest_framework.permissions import AllowAny
	from rest_framework.response import Response
	from pollsapi.tenant.models import Client
	from pollsapi.tenant.serializers import ClientSerializer


	class ClientViewSet(viewsets.ViewSet):
	permission_classes = (AllowAny,)
	serializer_class = ClientSerializer

	def create(self, request):
	client = request.data or {}
	tenant_name = client.get('tenant_name')
	if tenant_name is None:
	raise ValidationError('A tenant name is mandatory.')
	tenant = Client.objects.get(tenant_name=tenant_name)
	serializer = self.serializer_class(tenant, many=False)
	return Response(serializer.data, status=status.HTTP_200_OK)

	from django.urls import path, include
	from rest_framework.routers import DefaultRouter
	from pollsapi.tenant.views import ClientViewSet

	router = DefaultRouter(trailing_slash=False)
	router.register(r'client', ClientViewSet, base_name='clients')

	urlpatterns = [
	path('', include(router.urls)),
	]

Hire the author: Maina K

Introduction

Glossary

Let’s get started

Prerequisites

Setting up PostgreSQL

Django Tenant Schemas

Tenant App

Custom Middleware

Running migrations

Creating a tenant

Finalizing on the tenant app

Testing everything out

Learning Strategy

In retrospect….

In conclusion

Tools for further study

Citations

Hire the author: Maina K

Share this:

Like this:

22 thoughts on “How to implement django-tenant-schemas with a fixed URL”

Leave a ReplyCancel reply