Open redis service

E:\>cd E:\YifChanSoft\Database\Redis\RedisSoft\Redis-x64-3.2.100

E:\YifChanSoft\Database\Redis\RedisSoft\Redis-x64-3.2.100>redis-server --service-install redis.windows-service.conf --loglevel verbose

E:\YifChanSoft\Database\Redis\RedisSoft\Redis-x64-3.2.100>redis-cli
127.0.0.1:6379> select 8
OK
127.0.0.1:6379[8]> keys *
1) "_kombu.binding.celery"
2) "_kombu.binding.celery.pidbox"
127.0.0.1:6379[8]>

Open redis service screenshot

Put a copy of the project code somewhere, enter it, and start tasks'worker mode.
Note that the tasks file used as the worker's code should have the initialized code to start django in advance, otherwise the worker can't call conf information;

That is to say, there should be the following contents

# Add these sentences at the end of the task handler
import os
import django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "shoppingmall.settings")
django.setup()

To solve the problem of celery 4.x running on win10, install eventlet

pip install eventlet

Enter the project code where the replication is used as a celery worker

Open worker mode

celery -A celery_tasks.tasks worker -l info -P eventlet

Open screenshot of worker mode

If so, delete the index.html file in the celery code file static;
Initially call generate_static_index_html.delay() to verify the generation of index.html;

from celery_tasks.tasks import generate_static_index_html
generate_static_index_html.delay()

Verify screenshots

You can see that index.html is generated under the static folder under the project.

Open the project and enter http://127.0.0.1:8888/static/index.html/in the browser to see the generated static home page; because there is no data in the database, the page is relatively empty.

Installation of NGINX

Reference course: https://blog.csdn.net/weixin_40151334/article/details/80681173 

1. Download nginx: http://nginx.org/en/download.html 

2. Decompress nginx package

After downloading, put it in the appropriate directory. After decompression, it is as follows

3. Use the cmd command, enter the decompression directory where nginx is located, and install nginx with the following commands;

start nginx.exe

Installation screenshots

When the installation is complete, we can see the nginx task in the task manager, as shown in the figure

So far, nginx is installed.

nginx command

start nginx.exe  # open nginx
nginx -s reload  # Restart
nginx -s stop  # Stop it nginx
nginx -s quit  # Sign out nginx

Providing static home pages using NGINX

Modify nginx configuration

Find the configuration file for nginx. As shown in the figure below, we copied a source file and renamed it nginx_origin.conf for the convenience of other projects in the future.

Open the nginx.conf file with the editor and modify the configuration file as follows:

location /static {
    alias E:/Pycharm/Pycharm_save/cp15/18Django_fresh2/step206/shoppingmall206/static/;
}

location / {
    # root   html;
    root   E:/Pycharm/Pycharm_save/cp15/18Django_fresh2/step206/shoppingmall206/static/;
    index  index.html index.htm;
}

Configuration screenshots

Note that the address should be the absolute path address where you use celery's project, and that slashes / not backslashes should be used between addresses, otherwise errors will be reported.

After the configuration has been modified and saved, we use a command to restart nginx

nginx -s reload

Then, we open the browser and enter one of the two links to see the main page of the project.

http://127.0.0.1/  # Note that there must be one after that./，Otherwise it will enter nginx Default interface
http://127.0.0.1/static/index.html

Screenshots of the main page of the project

Screenshots of the cmd command of nginx, where errors are due to the use of backslashes from the win10 directory

The relationship between Django and celery can be understood as juxtaposition. Before them, there was actually an nginx server responsible for scheduling.
Generally, when users access 127.0.0.1 directly, we use nginx scheduling to return static pages in celery's nginx.
When the user visits 127.0.0.1/index, we return to IndexView which calls Django website.

We use nginx to configure websites when they are online.

Restructuring static pages when background data is modified

principle

sava_model and delete_model methods under admin.ModelAdmin are called to update data when the database data changes, and we need to regenerate static pages when the data changes.

Therefore, we can customize a class to inherit admin.ModelAdmin, rewrite the method of updating and deleting data, call the method of updating and deleting the parent class, and then call the method in celery to regenerate the static homepage.

Realization

To configure the static page to be regenerated when the data of a table changes, we need to define an xxxModelAdmin class for the table, inherit from admin.ModelAdmin and rewrite the methods therein, and the table should also inherit the xxModelAdmin class when registered in admin.

Because many tables need to be configured in this way, and the code in the class is the same, we can extract a BaseModelAdmin class, write the updated code to call back the static page, and then let the tables that need to be modified inherit the class.

Write the following code in the admin.py file of the corresponding application on the home page

from django.contrib import admin
# from django.core.cache import cache
from goods.models import GoodsType, GoodsSKU, Goods, GoodsImage, IndexGoodsBanner, IndexTypeGoodsBanner, IndexPromotionBanner
from celery_tasks.tasks import generate_static_index_html


class BaseModelAdmin(admin.ModelAdmin):
    """When the background database data changes celery Restructuring static home page"""
    def save_model(self, request, obj, form, change):
        """Called when updating or adding data"""
        super().save_model(request, obj, form, change)
        # Send out the task, let's celery worker Restructuring static home page
        generate_static_index_html.delay()

        # Clear Cached Data on Home Page
        # cache.delete("index_page_data")

    def delete_model(self, request, obj):
        """Called when data is deleted"""
        super().delete_model(request, obj)
        generate_static_index_html.delay()

        # Clear Cached Data on Home Page
        # cache.delete("index_page_data")


class GoodsTypeAdmin(BaseModelAdmin):
    pass


class IndexGoodsBannerAdmin(BaseModelAdmin):
    pass


class IndexTypeGoodsBannerAdmin(BaseModelAdmin):
    pass


class IndexPromotionBannerAdmin(BaseModelAdmin):
    pass


admin.site.register(GoodsType, GoodsTypeAdmin)
admin.site.register(GoodsSKU)
admin.site.register(Goods)
admin.site.register(GoodsImage)
admin.site.register(IndexGoodsBanner, IndexGoodsBannerAdmin)
admin.site.register(IndexTypeGoodsBanner, IndexTypeGoodsBannerAdmin)
admin.site.register(IndexPromotionBanner, IndexPromotionBannerAdmin)

So far, when we update the data in admin background, we will regenerate the static homepage. You can try it on your own.~

Posted by dshevnock on Mon, 07 Oct 2019 13:28:29 -0700