uwsgi_rack_ruby23 - Online în cloud

PROGRAM:

NUME

uwsgi_rack_ruby23 - server WSGI rapid (pur C), auto-vindecare, prietenos cu dezvoltatorii

REZUMAT

uwsgi-core-local [Opțiuni...]

DESCRIERE

-s|--priză
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul implicit

-s|--socket-uwsgi
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul uwsgi

--suwsgi-socket
se leagă la socket-ul UNIX/TCP specificat folosind protocolul uwsgi peste SSL

--ssl-socket
se leagă la socket-ul UNIX/TCP specificat folosind protocolul uwsgi peste SSL

--http-socket
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul HTTP

--http-socket-modifier1
forțați modificatorul1 specificat când utilizați protocolul HTTP

--http-socket-modifier2
forțați modificatorul2 specificat când utilizați protocolul HTTP

--https-socket
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul HTTPS

--https-socket-modifier1
forțați modificatorul1 specificat când utilizați protocolul HTTPS

--https-socket-modifier2
forțați modificatorul2 specificat când utilizați protocolul HTTPS

--fastcgi-socket
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul FastCGI

--fastcgi-nph-socket
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul FastCGI (modul nph)

--fastcgi-modifier1
forțați modificatorul1 specificat când utilizați protocolul FastCGI

--fastcgi-modifier2
forțați modificatorul2 specificat când utilizați protocolul FastCGI

--scgi-socket
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul SCGI

--scgi-nph-socket
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul SCGI (modul nph)

--scgi-modifier1
forțați modificatorul1 specificat când utilizați protocolul SCGI

--scgi-modifier2
forțați modificatorul2 specificat când utilizați protocolul SCGI

--priză-brută
se leagă la socket-ul UNIX/TCP specificat utilizând protocolul RAW

--raw-modifier1
forțați modificatorul1 specificat când utilizați protocolul RAW

--raw-modifier2
forțați modificatorul2 specificat când utilizați protocolul RAW

--puwsgi-priză
se leagă la socket-ul UNIX/TCP specificat folosind protocolul uwsgi persistent (puwsgi)

--protocol
forțați protocolul specificat pentru socket-urile implicite

--socket-protocol
forțați protocolul specificat pentru socket-urile implicite

--priză-partajată
creați un socket partajat pentru închisoare avansată sau ipc

--socket-partajat-neamânat
creați un soclu partajat pentru închisoare avansată sau ipc (mod neamânat)

-p|--procese
generează numărul specificat de lucrători/procese

-p|--muncitori
generează numărul specificat de lucrători/procese

--tunet-lock
serialize accept() usage (dacă este posibil)

-t|--harakiri
setați timeout pentru harakiri

--harakiri-verbose
activați modul verbose pentru harakiri

--harakiri-no-arh
nu activați harakiri în timpul hook-ului după cerere

--no-harakiri-arh
nu activați harakiri în timpul hook-ului după cerere

--no-harakiri-după-req-hook
nu activați harakiri în timpul hook-ului după cerere

--backtrace-adâncime
setați adâncimea traseului înapoi

--mule-harakiri
setați timeout harakiri pentru sarcinile de catâr

-x|--xmlconfig
încărcați configurația din fișierul xml

-x|--xml
încărcați configurația din fișierul xml

--config
configurarea încărcării utilizând sistemul conectabil

--fallback-config
reexec uwsgi cu configurația specificată când codul de ieșire este 1

--strict
activați modul strict (substituentul nu poate fi utilizat)

--sări-zero
săriți verificarea descriptorului de fișier 0

--skip-atexit
skip atexit hooks (ignorat de maestru)

-S|--set
setați un substituent sau o opțiune

--set-placeholder
setați un substituent

--set-ph
setați un substituent

--obține tipăriți valoarea specificată a opțiunii și ieșiți

--declare-option
declara o nouă opțiune personalizată uWSGI

--declare-option2
declara o nouă opțiune personalizată uWSGI (ne-imediată)

--rezolva
plasați rezultatul unei interogări dns în substituentul specificat, sytax:
substituent=nume (opțiune imediată)

--pentru (opt logic) pentru ciclu

--pentru-glob
(opt logic) pentru ciclu (expand glob)

--de-ori
(opt logic) pentru ciclu (extinde numărul specificat la o listă începând de la 1)

--pentru-readline
(opt logic) pentru ciclu (extinde fișierul specificat la o listă de linii)

--endfor
(logica optică) sfârșit pentru ciclu

--sfarsit-pentru
(logica optică) sfârșit pentru ciclu

--dacă-opt
(logica optică) verificați opțiunea

--dacă-nu-opt
(logica optică) verificați opțiunea

--dacă-env
(logica optică) verificați variabila de mediu

--dacă-nu-env
(logica optică) verificați variabila de mediu

--ifenv
(logica optică) verificați variabila de mediu

--daca-reincarca
(logica optică) verificați pentru reîncărcare

--dacă-nu-reîncarcă
(logica optică) verificați pentru reîncărcare

--if-hostname
(logica optică) verificați numele de gazdă

--dacă-nu-hostname
(logica optică) verificați numele de gazdă

--if-hostname-match
(logica optică) încercați să potriviți numele de gazdă cu o expresie regulată

--dacă-nu-hostname-match
(logica optică) încercați să potriviți numele de gazdă cu o expresie regulată

--dacă-există
(logica optică) verificați existența fișierului/directorului

--dacă-nu-există
(logica optică) verificați existența fișierului/directorului

--dacă există
(logica optică) verificați existența fișierului/directorului

--dacă-plugin
(logica optică) verificați pluginul

--dacă-nu-plugin
(logica optică) verificați pluginul

--ifplugin
(logica optică) verificați pluginul

--dacă-fișier
(logica optică) verificați existența fișierului

--dacă-nu-fișier
(logica optică) verificați existența fișierului

--dacă-dir
(logica optică) verificați existența directorului

--dacă-nu-dir
(logica optică) verificați existența directorului

--ifdir
(logica optică) verificați existența directorului

--dacă-director
(logica optică) verificați existența directorului

--endif
(logica optică) termina dacă

--sfarsit-daca
(logica optică) termina dacă

--lista neagră
setați contextul listei negre de opțiuni

--end-listă neagră
contextul listei negre de opțiuni clare

--lista albă
setați contextul listei albe de opțiuni

--end-listă albă
contextul listei albe de opțiuni clare

--ignore-sigpipe
nu raportați (enervant) SIGPIPE

--ignore-write-errors
nu raportați (enervante) erorile write()/writev().

--toleranță-erori-de-scriere
setați numărul maxim de erori de scriere permise (implicit: fără toleranță)

--write-errors-exception-only
ridică doar o excepție pentru erorile de scriere care oferă control aplicației în sine

--disable-write-exception
dezactivați generarea de excepții pe write()/writev()

--moşteni
utilizați fișierul specificat ca șablon de configurare

--include
includeți fișierul specificat ca configurație imediată

--injectare-inainte
injectați un fișier text înainte de fișierul de configurare (șabloane avansate)

--injectare-după
injectați un fișier text după fișierul de configurare (șabloane avansate)

-d|--daemonize
daemonize uWSGI

--daemonize2
demonizați uWSGI după încărcarea aplicației

--Stop opri o instanță

--reincarca
reîncărcați o instanță

--pauză
întrerupeți o instanță

--suspenda
suspendă o instanță

--relua
reluați o instanță

--conectează-și-citește
conectați-vă la o priză și așteptați date de la acesta

--extrage
preluați/dump orice adresă acceptată la stdout

-l|--ascultă
setați dimensiunea cozii de ascultare a socketului

-v|--max-vars
setați cantitatea de structuri interne iovec/vars

--max-apps
setați numărul maxim de aplicații per lucrător

-b|--dimensiunea tamponului
setați dimensiunea tamponului intern

-m|--memorie-raport
activați raportul de memorie

--profiler
activați profilerul specificat

-c|--cgi-mode
forțați modul CGI pentru pluginurile care îl suportă

-a|--abstract-socket
forțați socketul UNIX în modul abstract (numai Linux)

-C|--chmod-socket
chmod-socket

-C|--chmod
chmod-socket

--priză-chown
prize chown Unix

--umask
setați umask

--freebind
puneți soclul în modul freebind

--hartă-priză
mapați prize la anumiți lucrători

-T|--activează firele
activați firele

--fără fire-așteaptă
nu așteptați anularea firelor la ieșire/reîncărcare

--auto-procname
setați automat numele proceselor la ceva semnificativ

--procname-prefix
adăugați un prefix la numele proceselor

--procname-prefix-spaziat
adăugați un prefix spațiat la numele proceselor

--procname-append
adăugați un șir la numele procesului

--procname
setați nume de proces

--procname-master
setați numele procesului principal

-i|--interpret unic
nu folosiți mai mulți interpreți (dacă sunt disponibile)

--nevoie-aplicație
ieșiți dacă nu se poate încărca nicio aplicație

-M|--master
activați procesul principal

--honour-stdin
nu remapați stdin la / Dev / null

--împărat
a alerga pe împărat

--imparat-proxy-socket
forțează vasalul să devină un împuternicit al împăratului

--împărat-înveliş
setează un înveliș binar pentru vasali

--împărat-înveliș-override
setați un înveliș binar pentru ca vasalii să îl încerce înaintea celui implicit

--împăratul-înveliș-fallback
setați un înveliș binar pentru ca vasalii să încerce ca ultimă soluție

--imparatul-nofollow
nu urmați legăturile simbolice când verificați mtime

--imparatul-procname
setați numele procesului Emperor

--imparatul-frecventa
setați frecvența de scanare a lui Emperor (implicit 3 secunde)

--împăratul-a cerut-bătaie-inima
stabilește toleranța împăratului cu privire la bătăile inimii

--împărat-blestem-toleranță
a stabilit împăratului toleranță cu privire la vasalii blestemati

--emperor-pidfile
scrieți Emperor pid în fișierul specificat

--imparatul-tiran
pune pe Împărat în modul Tiran

--imparatul-tiran-nofollow
nu urmați legăturile simbolice când verificați uid/gid în modul Tyrant

--împărat-statistici
rulați serverul de statistici Emperor

--imperor-stats-server
rulați serverul de statistici Emperor

--timpurii-imparat
declanșează împăratul cât mai curând posibil

--împărat-stăpânul puietului
conduce-l pe împărat în modul BroodLord

--imparatul-accelerator
setați nivelul de accelerare (în milisecunde) pentru vasali care se comportă rău (implicit 1000)

--imperor-max-throttle
setați nivelul maxim de accelerare (în milisecunde) pentru vasalii care se comportă rău (implicit 3
minute)

--imparatul-magic-exec
prefix fișierele de configurare vasali cu exec:// dacă au bitul executabil

--emperor-on-demand-extension
căutați fișierul text (nume vasal + extensie) care conține numele soclului la cerere

--imparatul-la-cerere-ext
căutați fișierul text (nume vasal + extensie) care conține numele soclului la cerere

--emperor-on-demand-directory
activați legarea modului la cerere la socket-ul Unix din directorul specificat numit
ca vasalul + .priza

--imperor-on-demand-dir
activați legarea modului la cerere la socket-ul Unix din directorul specificat numit
ca vasalul + .priza

--imperor-on-demand-exec
utilizați rezultatul comenzii specificate ca nume de socket la cerere (numele vasalului
este trecut ca singur argument)

--imparatul-extra-extensie
permite extinderea specificată în Împărat (vasalul va fi chemat cu --config)

--imparatul-extra-ext
permite extinderea specificată în Împărat (vasalul va fi chemat cu --config)

--imparatul-nu-lista neagra
dezactivați subsistemul de listare a Emperor

--imparatul-foloseste-clona
utilizați clone() în loc de fork() trecând steagurile de unshare() specificate

--șapcă-împărat
stabiliți capacitatea de vasali

--vasalii-cap
stabiliți capacitatea de vasali

--vasal-cap
stabiliți capacitatea de vasali

--imperial-monitor-list
lista de monitoare imperiale activate

--lista-imperial-monitoare
lista de monitoare imperiale activate

--vasalii-moştenire
adăugați șabloane de configurare la configurația vasali (folosește --moşteni)

--vasalii-include
includeți șabloanele de configurare în configurația vasali (folosește --include în loc de --moşteni)

--vasalii-moştenesc-înainte
adăugați șabloane de configurare la configurația vasali (folosește --moşteni, parsează înaintea vasalului
fişier)

--vasalii-include-nainte
includeți șabloanele de configurare în configurația vasali (folosește --include în loc de --moşteni,
analizează înainte de dosarul vasal)

--vasali-start-hook
rulați comanda specificată înainte ca fiecare vasal să înceapă

--vasali-oprește-cârlig
rulați comanda specificată după moartea vasalului

--vasal-sos
cere împăratului întărire când este supraîncărcat

--vasal-sos-backlog
cereți lui Emperor sos dacă coada de așteptare are mai multe articole decât valoarea specificată

--vasalii-set
setați automat opțiunea specificată (prin --a stabilit) pentru fiecare vasal

--vasal-set
setați automat opțiunea specificată (prin --a stabilit) pentru fiecare vasal

-- bătăile inimii
anunţă împăratului sănătatea

--reîncărcare-milă
setați timpul maxim (în secunde) în care așteptăm ca lucrătorii și alte procese să moară
în timpul reîncărcării/opririi

--lucrător-reîncărcare-milă
setați timpul maxim (în secunde) pe care un lucrător îl poate reîncărca/oprire (implicit este
60)

--mule-reîncărcare-milă
setați timpul maxim (în secunde) pe care îl poate lua un catâr pentru reîncărcare/oprire (implicit este
60)

--ieșire-la-reîncărcare
ieșirea forțată chiar dacă este solicitată o reîncărcare

--moare la termen
ieșire în loc de reîncărcare brutală pe SIGTERM

--force-gateway
forțați spawn-ul primului gateway înregistrat fără un master

-h|--ajutor
arată acest ajutor

-h|--utilizare
arată acest ajutor

--print-sym
imprimați conținutul simbolului binar specificat

--simbol-imprimare
imprimați conținutul simbolului binar specificat

-r|--secerator
apel waitpid(-1,...) după fiecare cerere de a scăpa de zombi

-R|--max-cereri
reîncărcați lucrătorii după numărul specificat de solicitări gestionate

--min-lucrător-durată
numărul de secunde pe care lucrătorul trebuie să ruleze înainte de a fi reîncărcat (implicit este 60)

--max-worker-time
reîncărcați lucrătorii după durata specificată de secunde (implicit este dezactivată)

-z|--socket-timeout
setați timeout prizele interne

--no-fd-trecere
dezactivați transmiterea descriptorului de fișier

--încuietori
creați numărul specificat de încuietori partajate

--blocare-motor
setați motorul de blocare

--ftok setați cheia ipcsem prin ftok() pentru a evita duplicatele

--persistent-ipcsem
nu elimina ipcsem-urile la oprire

-A|--zonă comună
creați o zonă brută de memorie partajată a paginilor specificate (notă: acceptă și keyval)

--safe-fd
nu închideți descriptorul de fișier specificat

--fd-safe
nu închideți descriptorul de fișier specificat

--cache
creați un cache partajat care conține elemente date

--cache-blocksize
setați dimensiunea blocului cache

--magazin-cache
activați memoria cache persistentă pe disc

--cache-store-sync
setați frecvența de sincronizare pentru memoria cache persistentă

--cache-no-expire
dezactivați măsurarea automată a articolelor expirate

--cache-expire-freq
setați frecvența scanărilor cache sweeper (implicit 3 secunde)

--cache-report-freeed-items
raportați în mod constant elementul din cache eliberat de sweeper (utilizați numai pentru depanare)

--cache-udp-server
legați serverul cache udp (utilizat numai pentru setare/actualizare/ștergere) la socket-ul specificat

--cache-udp-node
trimiteți actualizarea/ștergerea cache-ului către serverul cache udp specificat

--cache-sync
copiați întregul conținut al altui server cache uWSGI la pornirea serverului

--cache-use-last-modified
actualizați last_modified_at timestamp la fiecare modificare a elementului din cache (implicit este
dezactivat)

--add-cache-item
adăugați un element în cache

--load-file-in-cache
încărcați un fișier static în cache

--load-file-in-cache-gzip
încărcați un fișier static în cache cu compresie gzip

--cache2
creați o nouă generație cache partajată (sintaxă keyval)

--coadă
activați coada partajată

--queue-blocksize
setați dimensiunea blocului de coadă

--coda-magazin
activați coada persistentă pe disc

--queue-store-sync
setați frecvența de sincronizare pentru coada persistentă

-Q|--spooler
rulați un spooler în directorul specificat

--spooler-extern
mapează cererile spoolers către un director spooler gestionat de o instanță externă

--spooler-a ordonat
încercați să ordonați execuția sarcinilor spooler

--spooler-chdir
chdir() în directorul specificat înainte de fiecare sarcină de spooler

--procese-spooler
setați numărul de procese pentru spoolere

--spooler-liniștit
nu fiți pronunțat cu sarcinile spooler

--spooler-max-tasks
setați numărul maxim de sarcini de rulat înainte de a recicla un spooler

--spooler-harakiri
setați timeout harakiri pentru sarcinile spooler

--frecvența-spooler
setați frecvența spoolerului

--spooler-freq
setați frecvența spoolerului

--catâr adăugați un catâr

--catâri
adăugați numărul specificat de catâri

--fermă adăugați o fermă de catâri

--mule-msg-size
setați dimensiunea bufferului de mesaje mule

--semnal
trimite un semnal uwsgi unui server

--semnal-bufsize
setați dimensiunea tamponului pentru coada de semnale

--semnal-bufsize
setați dimensiunea tamponului pentru coada de semnale

--semnal-temporizator
adăugați un cronometru (sintaxă: )

--temporizator
adăugați un cronometru (sintaxă: )

--signal-rbtimer
adăugați un cronometru roșu negru (sintaxă: )

--rbtimer
adăugați un cronometru roșu negru (sintaxă: )

--rpc-max
numărul maxim de sloturi rpc (implicit: 64)

-L|--disable-logging
dezactivați înregistrarea cererilor

--turmă
blocați fișierul specificat înainte de a începe, ieșiți dacă este blocat

--turmă-așteaptă
blocați fișierul specificat înainte de a începe, așteptați dacă este blocat

--turma2
blocați fișierul specificat după logare/setare demon, ieșiți dacă este blocat

--turma-așteaptă2
blocați fișierul specificat după logare/setarea demonului, așteptați dacă este blocat

--pidfile
creați fișierul pid (înainte de eliminarea privilegiilor)

--pidfile2
creați fișierul pid (după căderea privilegiilor)

--chroot
chroot() în directorul specificat

--pivot-rădăcină
pivot_root() către directoarele specificate (new_root și put_old trebuie separate
cu un spațiu)

--pivot_root
pivot_root() către directoarele specificate (new_root și put_old trebuie separate
cu un spațiu)

--uid setuid la utilizatorul/uid-ul specificat

--gid setgid la grupul/gid-ul specificat

--add-gid
adăugați id-ul de grup specificat la acreditările procesului

--imediat-uid
setuid către utilizatorul/uid-ul specificat IMMEDIAT

--imediat-gid
setgid la grupul/gid specificat IMMEDIAT

--no-initgroups
dezactivați grupuri suplimentare setate prin initgroups()

--capac setați capacitatea de proces

--unshare
unshare() parte a proceselor și puneți-o într-un nou spațiu de nume

--unshare2
unshare() parte a proceselor și puneți-o într-un nou spațiu de nume după schimbarea rootfs

--setns-socket
expune un socket Unix care returnează spațiul de nume fds de la /proc/self/ns

--setns-socket-skip
omiteți intrarea specificată atunci când trimiteți descriptori de fișiere setns

--setns-skip
omiteți intrarea specificată atunci când trimiteți descriptori de fișiere setns

--setns
alăturați-vă unui spațiu de nume creat de o instanță externă uWSGI

--setns-preopen
deschide /proc/self/ns cât mai curând posibil și cache fds

--inchis
marcați instanța ca închisă (forțați execuția post_jail hooks)

--refurk
fork() din nou după căderea privilegiilor. Util pentru sistemele de închisoare

--re-furculiță
fork() din nou după căderea privilegiilor. Util pentru sistemele de închisoare

--refork-as-root
fork() din nou înainte ca privilegiile să cadă. Util pentru sistemele de închisoare

--re-furcă-ca-rădăcină
fork() din nou înainte ca privilegiile să cadă. Util pentru sistemele de închisoare

--refork-post-inchisoare
fork() din nou după închisoare. Util pentru sistemele de închisoare

--re-furca-post-inchisoare
fork() din nou după închisoare. Util pentru sistemele de închisoare

--cârlig-cât mai repede
rulați cârligul specificat cât mai curând posibil

--cârlig-pre-închisoare
rulați cârligul specificat înainte de închisoare

--cârlig-post-închisoare
rulați cârligul specificat după închisoare

--cârlig în închisoare
rulați cârligul specificat în închisoare după inițializare

--cârlig-ca-rădăcină
rulați hook-ul specificat înainte ca privilegiile să cadă

--cârlig-ca-utilizator
rulați hook-ul specificat după căderea privilegiilor

--hook-as-user-atexit
rulați hook-ul specificat înainte de a ieși din aplicație și reîncărcați

--hook-pre-app
rulați hook-ul specificat înainte de încărcarea aplicației

--hook-post-app
rulați hook-ul specificat după încărcarea aplicației

--cârlig-post-furcă
rulați cârligul specificat după fiecare furcă

--cârlig-acceptând
rulați cârligul specificat după ce fiecare lucrător intră în faza de acceptare

--hook-accepting1
rulați cârligul specificat după ce primul lucrător intră în faza de acceptare

--cârlig-acceptând-o dată
rulați cârligul specificat după ce fiecare lucrător intră în faza de acceptare (o dată
pe caz)

--hook-accepting1-once
rulați cârligul specificat după ce primul lucrător intră în faza de acceptare (o dată pe
instanță)

--hook-master-start
rulați cârligul specificat când pornește Masterul

--cârlig-atingere
rulați cârligul specificat când este atins fișierul specificat (sintaxă: )

--cârlig-împărat-începe
rulați cârligul specificat atunci când Împăratul începe

--cârlig-împărat-oprire
rulați cârligul specificat atunci când Împăratul trimite un mesaj de oprire

--cârlig-împărat-reîncărcare
rulați cârligul specificat atunci când Împăratul trimite un mesaj de reîncărcare

--cârlig-împărat-pierdut
rulați cârligul specificat atunci când conexiunea Emperor este pierdută

--cârlig-ca-vasal
rulați cârligul specificat înainte de a executa vasalul

--cârlig-ca-împărat
rulează cârligul specificat în împărat după ce vasalul a fost început

--cârlig-ca-catâr
rulați cârligul specificat în fiecare catâr

--hook-as-gateway
rulați cârligul specificat în fiecare gateway

--după-cerere-cârlig
rulați funcția/simbolul specificat după fiecare solicitare

--după-cerere-apel
rulați funcția/simbolul specificat după fiecare solicitare

--exec-cât mai repede
rulați comanda specificată cât mai curând posibil

--exec-pre-închisoare
rulați comanda specificată înainte de închisoare

--exec-post-închisoare
rulați comanda specificată după închisoare

--exec-in-inchisoare
rulați comanda specificată în închisoare după inițializare

--exec-as-root
rulați comanda specificată înainte ca privilegiile să cadă

--exec-as-user
rulați comanda specificată după căderea privilegiilor

--exec-as-user-atexit
rulați comanda specificată înainte de a ieși din aplicație și reîncărcați

--exec-pre-app
rulați comanda specificată înainte de încărcarea aplicației

--exec-post-app
rulați comanda specificată după încărcarea aplicației

--exec-ca-vasal
rulați comanda specificată înainte de a executa vasalul

--exec-ca-imparat
rulează comanda specificată în împărat după ce vasalul a fost pornit

--mount-asap
montați sistemul de fișiere cât mai curând posibil

--mount-pre-jail
montați sistemul de fișiere înainte de închis

--mount-post-jail
montați sistemul de fișiere după închisoare

--mount-in-jail
montați sistemul de fișiere în închisoare după inițializare

--mount-as-root
montați sistemul de fișiere înainte ca privilegiile să cadă

--munte-ca-vasal
montați sistemul de fișiere înainte de a executa vasalul

--munte-ca-imparat
montați sistemul de fișiere în împărat după ce vasalul a fost pornit

--umount-astap
demontați sistemul de fișiere cât mai curând posibil

--umount-pre-închisoare
demontați sistemul de fișiere înainte de închis

--umount-post-inchisoare
demontează sistemul de fișiere după închisoare

--unmount-in-jail
demontați sistemul de fișiere în închisoare după inițializare

--umount-as-root
demontați sistemul de fișiere înainte ca privilegiile să cadă

--umount-ca-vasal
demontați sistemul de fișiere înainte de a executa vasalul

--umount-ca-imparat
demontați sistemul de fișiere în împărat după ce vasalul a fost pornit

--așteptați-pentru-interfață
așteptați ca interfața de rețea specificată să apară înainte de a rula cârligele root

--wait-for-interface-timeout
setați timeout-ul pentru așteptarea interfeței

--așteaptă-interfață
așteptați ca interfața de rețea specificată să apară înainte de a rula cârligele root

--wait-interface-timeout
setați timeout-ul pentru așteptarea interfeței

--așteaptă-pentru-iface
așteptați ca interfața de rețea specificată să apară înainte de a rula cârligele root

--wait-for-iface-timeout
setați timeout-ul pentru așteptarea interfeței

--așteaptă-iface
așteptați ca interfața de rețea specificată să apară înainte de a rula cârligele root

--așteaptă-iface-timeout
setați timeout-ul pentru așteptarea interfeței

--așteaptă-pentru-fs
așteptați ca elementul de sistem de fișiere specificat să apară înainte de a rula cârlige de rădăcină

--așteptați-pentru-fișier
așteptați să apară fișierul specificat înainte de a rula hook-uri de rădăcină

--așteaptă-pentru-dir
așteptați ca directorul specificat să apară înainte de a rula hook-uri de rădăcină

--așteptați-pentru-punct de montare
așteptați ca punctul de montare specificat să apară înainte de a rula cârlige de rădăcină

--wait-for-fs-timeout
setați timpul de expirare pentru wait-for-fs/file/dir

--așteaptă-pentru-priză
așteptați ca soclu-ul specificat să fie gata înainte de a încărca aplicațiile

--wait-for-socket-timeout
setați timeout-ul pentru așteptare pentru socket

--apelați-în cel mai scurt timp
apelați funcția specificată cât mai curând posibil

--apel-pre-închisoare
apelați funcția specificată înainte de închisoare

--call-post-inchisoare
apelați funcția specificată după închisoare

--call-in-jail
apelați funcția specificată în închisoare după inițializare

--call-as-root
apelați funcția specificată înainte ca privilegiile să cadă

--call-as-user
apelați funcția specificată după căderea privilegiilor

--call-as-user-atexit
apelați funcția specificată înainte de a ieși din aplicație și reîncărcați

--call-pre-app
apelați funcția specificată înainte de încărcarea aplicației

--call-post-app
apelați funcția specificată după încărcarea aplicației

--chemare-ca-vasal
apelați funcția specificată () înainte de a executa () vasalul

--chemare-ca-vasal1
apelați funcția specificată (char *) înainte de a executa () vasalul

--chemare-ca-vasal3
apelați funcția specificată (char *, uid_t, gid_t) înainte de a executa () vasalul

--chemare-ca-imparat
apelați funcția specificată () în împărat după ce vasalul a fost început

--chemare-ca-imparat1
apelați funcția specificată (char *) în împărat după ce vasalul a fost
început

--chemare-ca-imparat2
apelați funcția specificată (char *, pid_t) în împărat după ce vasalul a fost
început

--chemare-ca-imparat4
apelați funcția specificată (char *, pid_t, uid_t, gid_t) în împărat după
vasal a fost început

--ini încărcați configurația din fișierul ini

-y|--yaml
încărcați configurația din fișierul yaml

-y|--yml
încărcați configurația din fișierul yaml

-j|--json
încărcați configurația din fișierul json

-j|--js
încărcați configurația din fișierul json

--greutate
greutatea instanței (utilizată de clustering/lb/abonamente)

--greutate automată
setați automat greutatea instanței (utilizată de clustering/lb/abonamente).

--no-server
forțați modul fără server

--mod-comandă
modul de comandă forțată

--nu-amâna-accept
dezactivați acceptarea amânată pe socluri

--tcp-nodelay
activați TCP NODELAY la fiecare cerere

--așa-ține în viață
activați TCP KEEPALIVE-urile

--deci-send-timeout
setați SO_SNDTIMEO

--socket-send-timeout
setați SO_SNDTIMEO

--deci-scrie-timeout
setați SO_SNDTIMEO

--socket-write-timeout
setați SO_SNDTIMEO

--socket-sndbuf
setați SO_SNDBUF

--socket-rcvbuf
setați SO_RCVBUF

--limita-as
limitează spațiul de adresă al proceselor/vsz

--limit-nproc
limitarea numărului de procese generabile

--reload-on-as
reîncărcați dacă spațiul de adrese este mai mare decât megaocteții specificati

--reload-on-rss
reîncărcați dacă memoria rss este mai mare decât megaocteții specificați

--evil-reload-on-as
forțează masterul să reîncarce un lucrător dacă spațiul său de adrese este mai mare decât cel specificat
megaocteți

--evil-reload-on-rss
forțați masterul să reîncarce un lucrător dacă memoria lui rss este mai mare decât cea specificată
megaocteți

--mem-collector-freq
setați frecvența colectorului de memorie atunci când există reîncărcări malefice

--reload-on-fd
reîncărcați dacă descriptorul de fișier specificat este gata

--brutal-reload-on-fd
reîncărcare brutală dacă descriptorul de fișier specificat este gata

--ksm activați Linux KSM

--pcre-jit
activați pcre jit (dacă este disponibil)

--niciodata-schimba
blocați toate paginile de memorie evitând schimbarea

--atinge-reîncărcare
reîncărcați uWSGI dacă fișierul specificat este modificat/atins

--atinge-lucrătorii-reîncărcare
declanșează reîncărcarea (numai) lucrătorilor dacă fișierul specificat este modificat/atins

--touch-lanț-reîncărcare
reîncărcarea lanțului de declanșare dacă fișierul specificat este modificat/atins

--atinge-logrotate
declanșează logrotation dacă fișierul specificat este modificat/atins

--atinge-logredeschis
jurnalul de declanșare se redeschide dacă fișierul specificat este modificat/atins

--touch-exec
executați comanda când fișierul specificat este modificat/atins (sintaxă: comandă fișier)

--semnal-tactil
semnal când fișierul specificat este modificat/atins (sintaxă: semnal fișier)

--fs-reîncărcare
reîncărcare grațioasă când obiectul de sistem de fișiere specificat este modificat

--fs-brutal-reload
reîncărcare brutală când obiectul sistemului de fișiere specificat este modificat

--fs-semnal
ridică un semnal uwsgi atunci când obiectul sistemului de fișiere specificat este modificat (sintaxă: fișier
semnal)

--verificare-punct de montare
distrugeți instanța dacă un sistem de fișiere nu mai este accesibil (util pentru Fuse
management)

--mountpoint-verificare
distrugeți instanța dacă un sistem de fișiere nu mai este accesibil (util pentru Fuse
management)

--verifica-mont
distrugeți instanța dacă un sistem de fișiere nu mai este accesibil (util pentru Fuse
management)

--mount-verificare
distrugeți instanța dacă un sistem de fișiere nu mai este accesibil (util pentru Fuse
management)

--propagare-atingere
opțiune de suprainginerire pentru sistemul cu management al semnalului scazut

--limit-post
organismul cererii de limită

--nu-orfani
ucide automat lucrătorii dacă maestrul moare (poate fi periculos pentru disponibilitate)

--prio setați prioritatea proceselor/firelor

--cpu-afinitate
setați afinitatea procesorului

--post-buffering
setați dimensiunea în octeți, după care va salva pe disc în loc de memorie

--post-buffering-bufsize
setați dimensiunea bufferului pentru read() în modul post buffering

--corp-citește-avertisment
setați înainte cantitatea de memorie permisă (în megaocteți) pentru corpul cererii
începe imprimarea unui avertisment

--încărcare-progres
activați crearea de fișiere .json în directorul specificat în timpul încărcării unui fișier

--no-default-app
nu reveniți la aplicația implicită

--manage-script-name
rescrie automat SCRIPT_NAME și PATH_INFO

--ignore-script-name
ignora SCRIPT_NAME

--catch-exceptions
raportați excepția ca ieșire http (descurajat, utilizați numai pentru testare)

--reload-on-exception
reîncărcați un lucrător atunci când este ridicată o excepție

--reload-on-exception-type
reîncărcați un lucrător atunci când este ridicat un anumit tip de excepție

--reload-on-exception-value
reîncărcați un lucrător atunci când o anumită valoare de excepție este ridicată

--reload-on-exception-repr
reîncărcați un lucrător atunci când se ridică un anumit tip de excepție + valoare (specifică limbii).

--excepție-handler
adăugați un handler de excepții

--enable-metrics
activați subsistemul de metrici

--metric
adăugați o valoare personalizată

--metric-threshold
adăugați un prag/alarmă metric

--metric-alarma
adăugați un prag/alarmă metric

--alarma-metric
adăugați un prag/alarmă metric

--metrics-dir
exportați valorile ca fișiere text în directorul specificat

--metrics-dir-restore
restaurați ultima valoare luată din directorul de metrici

--metric-dir
exportați valorile ca fișiere text în directorul specificat

--metric-dir-restore
restaurați ultima valoare luată din directorul de metrici

--metrics-no-cores
dezactivați generarea de metrici legate de nuclee

--udp rulați serverul udp la adresa specificată

--statistici
activați serverul de statistici la adresa specificată

--stats-server
activați serverul de statistici la adresa specificată

--stats-http
Prefix statistici server json ieșire cu anteturi http

--stats-minified
minimizarea statisticilor de ieșire json

--stats-min
minimizarea statisticilor de ieșire json

--stats-push
împingeți stats json la destinația specificată

--stats-pusher-default-freq
setați frecvența implicită a împingerilor de statistici

--stats-pushers-default-freq
setați frecvența implicită a împingerilor de statistici

--stats-no-cores
dezactivați generarea de statistici legate de nuclee

--stats-no-metrics
nu includeți valori în rezultatele statisticilor

--multicast
abonați-vă la grupul multicast specificat

--multicast-ttl
setați multicast ttl

--multicast-loop
setați bucla multicast (implicit 1)

--master-fifo
activați master fifo

--notify-socket
activați soclul de notificare

--subscription-notify-socket
setați soclul de notificare pentru abonamente

--legiune
a devenit membru al unei legiuni

--legion-mcast
a devenit membru al unei legiuni (comandă rapidă pentru multicast)

--legion-node
adăugați un nod unei legiuni

--legion-frec
stabiliți frecvența pachetelor de legiune

--legiune-toleranţă
stabiliți toleranța subsistemului legiune

--legiune-moarte-pe-domn-eroare
se declară ca un nod mort pentru perioada specificată de secunde dacă unul dintre
lord hooks eșuează

--legion-skew-tolerance
setați toleranța de deformare a ceasului a subsistemului legion (implicit 30 de secunde)

--stăpânul-legiune
acțiune pentru a cere alegerea Domnului

--legiune-unlord
acțiune pentru a chema Domnul să fie demis

--legion-setup
acțiune pentru a apela la configurarea legiune

--legiune-moarte
acțiune de chemare a morții legii (închiderea instanței)

--legion-join
acțiune pentru a apela la alăturarea legii (prima oară când se atinge cvorumul)

--legion-node-joined
acțiune pentru a apela la un nou nod care se alătură legiunei

--legion-node-stânga
acțiune pentru a apela legiunea care părăsește nodul

--legiune-cvorum
a stabilit cvorumul unei legiuni

--legiune-scroll
setează sulul unei legiuni

--legion-scroll-max-size
setați dimensiunea maximă a tamponului de defilare a legii

--legion-scroll-list-max-size
setați dimensiunea maximă a memoriei tampon a listei de defilare a legiunii

--subscriptions-sign-check
setați algoritmul de digest și directorul de certificate pentru sistemul de abonament securizat

--subscriptions-sign-check-tolerance
setați toleranța maximă (în secunde) de declinare a ceasului pentru abonamentul securizat
sistem

--subscriptions-sign-skip-uid
ignorați verificarea semnăturii pentru uid-ul specificat atunci când utilizați acreditările socket-urilor Unix

--abonamente-acreditări-verificare
adăugați un director pentru a căuta acreditările cheie pentru abonamente

--subscriptions-use-credentials
activați gestionarea SCM_CREDENTIALS în socket-urile UNIX de abonamente

--subscription-algo
setați algoritmul de echilibrare a sarcinii pentru sistemul de abonament

--subscription-dotsplit
încercați să reveniți la următoarea parte (pe bază de puncte) din cheia de abonament

--Aboneaza-te la
abonați-vă la serverul de abonament specificat

--Sf abonați-vă la serverul de abonament specificat

--Abonati-va
abonați-vă la serverul de abonament specificat

--abonare2
abonați-vă la serverul de abonament specificat utilizând sintaxa avansată keyval

--subscribe-freq
trimiteți anunțul de abonament la intervalul specificat

--toleranță-abonament
setați toleranța pentru serverele cu abonament

--unsubscribe-on-graceful-reload
forțați cererea de dezabonare chiar și în timpul reîncărcării grațioase

--start-dezabonat
configurați abonamente, dar nu le trimiteți (util cu master fifo)

--subscribe-with-modifier1
forțați modificatorul1 specificat la abonare

--snmp activați serverul snmp încorporat

--snmp-comunitate
setați șirul comunității snmp

--ssl-verbose
fiți detaliat despre erorile SSL

--ssl-sessions-use-cache
utilizați memoria cache uWSGI pentru stocarea sesiunilor ssl

--ssl-session-use-cache
utilizați memoria cache uWSGI pentru stocarea sesiunilor ssl

--ssl-sessions-timeout
setați expirarea sesiunilor SSL (implicit: 300 de secunde)

--ssl-session-timeout
setați expirarea sesiunilor SSL (implicit: 300 de secunde)

--sni adăugați un context SSL guvernat de SNI

--sni-dir
verificați fișierul cert/key/client_ca în directorul specificat și creați un sni/ssl
context la cerere

--sni-dir-ciphers
setați cifrurile ssl pentru opțiunea sni-dir

--ssl-enable3
activați SSLv3 (nesigur)

--ssl-opțiune
setați o opțiune ssl brută (valoare numerică)

--sni-regexp
adăugați un context SSL guvernat de SNI (cheia este o expresie regulată)

--ssl-tmp-dir
stocați fișierele temporare legate de ssl în directorul specificat

--check-interval
setați intervalul (în secunde) de verificări principale

--furcă-bombă-întârziere
sleep pentru numărul specificat de secunde când este detectată o furcă-bombă

--cale-binară
forță cale binară

--privilegied-binary-patch
corecționați binarul uwsgi cu o nouă comandă (înainte de eliminarea privilegiilor)

--patch-binar-neprivilegiat
corectează binarul uwsgi cu o nouă comandă (după căderea privilegiilor)

--privilegied-binary-patch-arg
corecționați binarul uwsgi cu o comandă și argumente noi (înainte de eliminarea privilegiilor)

--unprivilegied-binary-patch-arg
corectați binarul uwsgi cu o comandă și argumente noi (după căderea privilegiilor)

--async
activați modul asincron cu nuclee specificate

--max-fd
setați numărul maxim de descriptori de fișiere (necesită privilegii root)

--logto
setați adresa fișierului de jurnal/udp

--logto2
logați-vă la fișierul specificat sau la adresa udp după căderea privilegiilor

--log-format
setați formatul avansat pentru înregistrarea cererilor

--logformat
setați formatul avansat pentru înregistrarea cererilor

--logformat-strftime
aplicați strftime la ieșirea formatului de jurnal

--log-format-strftime
aplicați strftime la ieșirea formatului de jurnal

--logfile-chown
fișiere jurnal chown

--logfile-chmod
fișierele jurnal chmod

--log-syslog
log în syslog

--log-socket
trimite jurnale la socket-ul specificat

--req-logger
setați/adăugați un logger de solicitare

--logger-req
setați/adăugați un logger de solicitare

--logger
setați/adăugați un logger

--lista-logger
listează loggeri activați

--lista-loggers
listează loggeri activați

--threaded-logger
descărcați scrierea jurnalului într-un fir

--log-encoder
adăugați un element în lanțul codificatorului de jurnal

--log-req-encoder
adăugați un articol în lanțul codificatorului de solicitare de jurnal

--log-scurgere
scurgeți (nu afișați) liniile de jurnal care se potrivesc cu expresia regulată specificată

--log-filter
afișează numai liniile de jurnal care se potrivesc cu expresia regulată specificată

--log-rută
conectați-vă la logger-ul numit specificat dacă expresia regulă aplicată pe linia de logare se potrivește

--log-req-route
Cererile de jurnal către loggerul numit specificat dacă expresia regulă aplicată pe linia de logare se potrivește

--use-abort
apelați abort() pe segfault/fpe, ar putea fi util pentru generarea unui core dump

--alarma
creați o nouă alarmă, sintaxă:

--alarma-ieftin
utilizați firul principal de alarmă în loc să creați fire dedicate pentru alarmele bazate pe curl

--frecventa-alarma
reglați sistemul de alarmă anti-buclă (implicit 3 secunde)

--alarma-fd
ridicați alarma specificată atunci când un fd este citit pentru citire (în mod implicit citește 1 octet,
set 8 pentru eventfd)

--alarm-segfault
declanșează alarma specificată atunci când se execută gestionarea erorilor de segmentare

--segfault-alarma
declanșează alarma specificată atunci când se execută gestionarea erorilor de segmentare

--alarma-întârziere
ridicați alarma specificată atunci când coada de așteptare a socketului este plină

--backlog-alarma
ridicați alarma specificată atunci când coada de așteptare a socketului este plină

--lq-alarma
ridicați alarma specificată atunci când coada de așteptare a socketului este plină

--alarma-lq
ridicați alarma specificată atunci când coada de așteptare a socketului este plină

--alarma-ascultare-coada
ridicați alarma specificată atunci când coada de așteptare a socketului este plină

--ascultă-coadă-alarma
ridicați alarma specificată atunci când coada de așteptare a socketului este plină

--log-alarma
declanșează alarma specificată atunci când o linie de jurnal se potrivește cu expresia regulată specificată, sintaxa:
[,alarma...]

--alarm-log
declanșează alarma specificată atunci când o linie de jurnal se potrivește cu expresia regulată specificată, sintaxa:
[,alarma...]

--nu-log-alarma
săriți peste alarma specificată atunci când o linie de jurnal se potrivește cu expresia regulată specificată, sintaxa:
[,alarma...]

--not-alarm-log
săriți peste alarma specificată atunci când o linie de jurnal se potrivește cu expresia regulată specificată, sintaxa:
[,alarma...]

--lista-alarme
listează alarmele activate

--lista-alarme
listează alarmele activate

--alarm-msg-size
setați dimensiunea maximă a unui mesaj de alarmă (implicit 8192)

--log-master
delegați înregistrarea procesului principal

--log-master-bufsize
setați dimensiunea tamponului pentru master logger. mesajele de jurnal mai mari vor fi trunchiate

--log-master-stream
creați logpipe-ul principal ca SOCK_STREAM

--log-master-req-stream
creați logpipe-ul cererilor principale ca SOCK_STREAM

--jurnal-redeschide
redeschideți jurnalul după reîncărcare

--log-truncare
trunchiați jurnalul la pornire

--log-maxsize
setați dimensiunea maximă a fișierului jurnal

--log-backupname
setați numele fișierului jurnal după rotație

--logdate
jurnalele de prefix cu dată sau un șir strftime

--log-date
jurnalele de prefix cu dată sau un șir strftime

--log-prefix
jurnalele de prefix cu un șir

--log-zero
înregistrează răspunsuri fără corp

--log-lent
log cererile mai lent decât numărul specificat de milisecunde

--log-4xx
log cererile cu un răspuns 4xx

--log-5xx
log cererile cu un răspuns 5xx

--log-mare
cererile de jurnal mai mari decât dimensiunea specificată

--log-sendfile
log sendfile cereri

--log-ioerror
log cererile cu erori io

--log-micro
raportați timpul de răspuns în microsecunde în loc de milisecunde

--log-x-redirecționat-pentru
utilizați ip-ul din antetul X-Forwarded-For în loc de REMOTE_ADDR

--master-ca-rădăcină
lăsați procesul principal să ruleze ca root

--drop-după-init
privilegiile de rulare scad după inițializarea pluginului

--drop-after-apps
privilegiile de rulare scad după încărcarea aplicațiilor

--force-cwd
forțați directorul de lucru inițial la valoarea specificată

--binsh
trece peste / Bin / sh (utilizat de cârligele executive, se întoarce întotdeauna la / Bin / sh)

--chdir
chdir în directorul specificat înainte de încărcarea aplicațiilor

--chdir2
chdir în directorul specificat după încărcarea aplicațiilor

--leneş setați modul leneș (încărcați aplicațiile în lucrători în loc de master)

--lazy-apps
încărcați aplicații în fiecare lucrător în loc de master

--ieftin
setați modul ieftin (apariți lucrători numai după prima solicitare)

--mai ieftin
setați un mod mai ieftin (producerea procesului adaptiv)

--mai ieftin-inițial
setați numărul inițial de procese pentru a se genera în modul mai ieftin

--mai ieftin-algo
alegeți algoritmul utilizat pentru generarea procesului adaptiv

--pas-mai-ieftin
numărul de procese suplimentare care să apară la fiecare supraîncărcare

--mai ieftin-supraîncărcare
crește lucrătorii după supraîncărcare specificată

--listă-algo-mai-ieftine
lista cu algoritmi mai ieftini

--listă-algo-mai-ieftine
lista cu algoritmi mai ieftini

--lista-mai-ieftine
lista cu algoritmi mai ieftini

--ieftin-rss-limit-soft
nu generați noi lucrători dacă utilizarea totală a memoriei rezidente a tuturor lucrătorilor este mai mare
decât această limită

--ieftin-rss-limit-hard
dacă utilizarea totală a memoriei rezidenților lucrătorilor este mai mare, încercați să opriți lucrătorii

--inactiv setați modul inactiv (puneți uWSGI în modul ieftin după inactivitate)

--die-on-idle
închideți uWSGI când este inactiv

--montură
aplicarea încărcării sub punctul de montare

--muncitor-mont
aplicația de încărcare sub punctul de montare în lucrătorul specificat sau după ce lucrătorii apar

--fire
rulați fiecare lucrător în modul pre-threaded cu numărul specificat de fire

--thread-stacksize
setați dimensiunea stivelor de fire

--threads-stacksize
setați dimensiunea stivelor de fire

--dimensiunea stivei de fire
setați dimensiunea stivelor de fire

--firele-stive-dimensiunea
setați dimensiunea stivelor de fire

--vhost
activați modul de găzduire virtuală (pe baza variabilei SERVER_NAME)

--vhost-host
activați modul de găzduire virtuală (pe baza variabilei HTTP_HOST)

--traseu
adăugați un traseu

--route-host
adăugați o rută bazată pe antetul gazdei

--route-uri
adăugați o rută bazată pe REQUEST_URI

--route-qs
adăugați un traseu bazat pe QUERY_STRING

--route-remote-adr
adăugați o rută bazată pe REMOTE_ADDR

--route-user-agent
adăugați o rută bazată pe HTTP_USER_AGENT

--route-remote-user
adăugați o rută bazată pe REMOTE_USER

--rută-referer
adăugați o rută bazată pe HTTP_REFERER

--rută-etichetă
adăugați o etichetă de rutare (pentru a fi utilizată cu goto)

--rută-dacă
adăugați o rută în funcție de condiție

--traseu-dacă-nu
adăugați o rută în funcție de condiție (versiunea de respingere)

--rută-alergă
rulați întotdeauna acțiunea de rută specificată

--traseul-final
adăugați un traseu final

--final-route-status
adăugați o rută finală pentru starea specificată

--final-route-host
adăugați o rută finală bazată pe antetul gazdei

--final-route-uri
adăugați un traseu final bazat pe REQUEST_URI

--final-route-qs
adăugați un traseu final bazat pe QUERY_STRING

--final-route-remote-adr
adăugați o rută finală bazată pe REMOTE_ADDR

--final-route-user-agent
adăugați o rută finală bazată pe HTTP_USER_AGENT

--final-route-remote-user
adăugați o rută finală bazată pe REMOTE_USER

--final-route-referer
adăugați o rută finală bazată pe HTTP_REFERER

--final-route-label
adăugați o etichetă finală de rutare (pentru utilizare cu goto)

--traseul-final-dacă
adăugați un traseu final în funcție de condiție

--ruta-finală-dacă-nu
adăugați o rută finală în funcție de condiție (versiunea de respingere)

--final-traseu-alergare
rulați întotdeauna acțiunea de rută finală specificată

--error-route
adăugați o rută de eroare

--error-route-status
adăugați o rută de eroare pentru starea specificată

--error-route-host
adăugați o rută de eroare bazată pe antetul gazdei

--error-route-uri
adăugați o rută de eroare bazată pe REQUEST_URI

--error-route-qs
adăugați o rută de eroare bazată pe QUERY_STRING

--error-route-remote-addr
adăugați o rută de eroare bazată pe REMOTE_ADDR

--error-route-user-agent
adăugați o rută de eroare bazată pe HTTP_USER_AGENT

--error-route-remote-user
adăugați o rută de eroare bazată pe REMOTE_USER

--error-route-referer
adăugați o rută de eroare bazată pe HTTP_REFERER

--error-route-label
adăugați o etichetă de rutare a erorilor (pentru a fi utilizată cu goto)

--error-route-if
adăugați o rută de eroare în funcție de condiție

--error-route-dacă-nu
adăugați o rută de eroare în funcție de condiție (versiunea de respingere)

--error-route-run
rulați întotdeauna acțiunea de rută de eroare specificată

--ruta-răspuns
adăugați o cale de răspuns

--starea-rutei-răspuns
adăugați o rută de răspuns pentru starea specificată

--response-route-host
adăugați o rută de răspuns bazată pe antetul gazdei

--response-route-uri
adăugați o rută de răspuns bazată pe REQUEST_URI

--response-route-qs
adăugați o rută de răspuns bazată pe QUERY_STRING

--response-route-remote-adr
adăugați o rută de răspuns bazată pe REMOTE_ADDR

--response-route-user-agent
adăugați o rută de răspuns bazată pe HTTP_USER_AGENT

--response-route-remote-user
adăugați o rută de răspuns bazată pe REMOTE_USER

--referer-rută-răspuns
adăugați o rută de răspuns bazată pe HTTP_REFERER

--răspuns-rută-etichetă
adăugați o etichetă de rutare a răspunsului (pentru utilizare cu goto)

--ruta-răspuns-dacă
adăugați o rută de răspuns în funcție de condiție

--ruta-răspuns-dacă-nu
adăugați o rută de răspuns în funcție de condiție (versiunea de respingere)

--response-route-run
rulați întotdeauna acțiunea de rută de răspuns specificată

--listă-router
listează routerele activate

--listă-routere
listează routerele activate

--error-page-403
adăugați o pagină de eroare (html) pentru răspunsul 403 gestionat

--error-page-404
adăugați o pagină de eroare (html) pentru răspunsul 404 gestionat

--error-page-500
adăugați o pagină de eroare (html) pentru răspunsul 500 gestionat

--websockets-ping-freq
setați frecvența (în secunde) a pachetelor ping automate websockets

--websocket-ping-freq
setați frecvența (în secunde) a pachetelor ping automate websockets

--websockets-pong-tolerance
setați toleranța (în secunde) a subsistemului websockets ping/pong

--websocket-pong-tolerance
setați toleranța (în secunde) a subsistemului websockets ping/pong

--websockets-max-size
setați dimensiunea maximă permisă a mesajelor websocket (în Kbytes, implicit 1024)

--websocket-max-size
setați dimensiunea maximă permisă a mesajelor websocket (în Kbytes, implicit 1024)

--limită-de-intrare în bucăți
setați dimensiunea maximă a unei părți de intrare fragmentate (implicit 1 MB, în octeți)

--chunked-input-timeout
setați timeout implicit pentru intrarea în bucăți

--ceas
setați o sursă de ceas

--lista-ceas
lista ceasurilor activate

--lista-ceasuri
lista ceasurilor activate

--add-header
adăugați automat anteturi HTTP la răspuns

--rem-header
eliminați automat antetul HTTP specificat din răspuns

--del-header
eliminați automat antetul HTTP specificat din răspuns

--collect-header
stocați antetul răspunsului specificat într-o cerere var (sintaxă: header var)

--response-header-collect
stocați antetul răspunsului specificat într-o cerere var (sintaxă: header var)

--pull-header
stocați antetul răspunsului specificat într-o cerere var și eliminați-l din
răspuns (sintaxă: var header)

--verifica-static
verificați dacă există fișiere statice în directorul specificat

--check-static-docroot
verificați dacă există fișiere statice în DOCUMENT_ROOT solicitat

--verificare-statică
verificați dacă există fișiere statice în directorul specificat

--static-harta
mapați punctul de montare la directorul static (sau fișierul)

--static-map2
ca static-map, dar completând resursa solicitată la docroot

--static-skip-ext
ignorați extensia specificată de la verificările fișierelor static

--static-index
căutați fișierul specificat dacă este solicitat un director

--static-sigur
omite verificările de securitate dacă fișierul se află sub calea specificată

--static-cache-paths
puneți căile rezolvate în memoria cache uWSGI pentru perioada specificată de secunde

--static-cache-paths-name
utilizați memoria cache specificată pentru căile statice

--mimefile
setați calea fișierului pentru tipurile MIME (implicit /etc/mime.types)

--mime-file
setați calea fișierului pentru tipurile MIME (implicit /etc/mime.types)

--static-expires-type
setați antetul Expires în funcție de tipul de conținut

--static-expires-type-mtime
setați antetul Expires pe baza tipului de conținut și a mtimei fișierului

--static-expire
setați antetul Expires pe baza numelui de fișier regexp

--static-expires-mtime
setați antetul Expires pe baza numelui de fișier regexp și a fișierului mtime

--static-expires-uri
setați antetul Expires bazat pe expresia regulă REQUEST_URI

--static-expires-uri-mtime
setați antetul Expires bazat pe REQUEST_URI regexp și fișierul mtime

--static-expires-path-info
setați antetul Expires pe baza expresiei regulate PATH_INFO

--static-expires-path-info-mtime
setați antetul Expires bazat pe PATH_INFO regexp și fișierul mtime

--static-gzip
dacă expresia regulată furnizată se potrivește cu traducerea fișierului static, va căuta a
versiunea gzip

--static-gzip-all
verificați o versiune gzip a tuturor fișierelor statice solicitate

--static-gzip-dir
verificați o versiune gzip a tuturor fișierelor statice solicitate în directorul/prefixul specificat

--static-gzip-prefix
verificați o versiune gzip a tuturor fișierelor statice solicitate în directorul/prefixul specificat

--static-gzip-ext
verificați o versiune gzip a tuturor fișierelor statice solicitate cu specificația
ext/sufix

--static-gzip-sufix
verificați o versiune gzip a tuturor fișierelor statice solicitate cu specificația
ext/sufix

--gama-de-onoare
activați suportul pentru antetul Interval HTTP

--descărcare-fire
setați numărul de fire de descărcare pentru a se genera (per-lucrător, implicit 0)

--descărcare-fir
setați numărul de fire de descărcare pentru a se genera (per-lucrător, implicit 0)

--file-serve-mode
setați modul de servire a fișierelor static

--fileserve-mode
setați modul de servire a fișierelor static

--disable-sendfile
dezactivați sendfile() și bazați-vă pe plictisitor read()/write()

--verifica-cache
verificați datele de răspuns în memoria cache specificată (goală pentru memoria cache implicită)

--close-on-exec
setați close-on-exec pe prizele de conexiune (ar putea fi necesar pentru procesele de generare
în cereri)

--close-on-exec2
setați close-on-exec pe socket-urile serverului (ar putea fi necesar pentru procesele de generare în
cereri)

--mod setați modul personalizat uWSGI

--env setați variabila de mediu

--envdir
încărcați un envdir compatibil cu daemontools

--early-envdir
încărcați un envdir compatibil cu daemontools cât mai curând posibil

--unenv
variabilă de mediu nesetată

--vid
încercați să eliminați toate fișierele/socket-urile generate

--file-write
scrieți conținutul specificat în fișierul specificat (sintaxă: fișier=valoare) înainte
privilegiile scad

--cgroup
puneți procesele în cgroup-ul specificat

--cgroup-opt
setați valoarea în opțiunea cgroup specificată

--cgroup-dir-mode
setați permisiunea pentru directorul cgroup (implicit este 700)

--namespace
rulați într-un spațiu de nume nou sub rootf-urile specificate

--namespace-keep-mount
păstrați punctul de montare specificat în spațiul dvs. de nume

--ns rulați într-un spațiu de nume nou sub rootf-urile specificate

--namespace-net
adăugați spațiu de nume de rețea

--ns-net
adăugați spațiu de nume de rețea

--enable-proxy-protocol
activați suportul pentru protocolul PROXY1 (numai pentru analizatorii http)

--reutilizare-port
activați marcajul REUSE_PORT pe socket (numai BSD)

--tcp-deschidere rapidă
activați flag TCP_FASTOPEN pe socket-urile TCP cu valoarea qlen specificată

--tcp-fastopen
activați flag TCP_FASTOPEN pe socket-urile TCP cu valoarea qlen specificată

--tcp-fast-open-client
utilizați sendto(..., MSG_FASTOPEN, ...) în loc de connect() dacă este acceptat

--tcp-fastopen-client
utilizați sendto(..., MSG_FASTOPEN, ...) în loc de connect() dacă este acceptat

--zerg atașați la un server zerg

--zerg-fallback
revenire la socket-urile normale dacă serverul zerg nu este disponibil

--zerg-server
activați serverul zerg pe socket-ul UNIX specificat

--cron adăugați o sarcină cron

--cron2
adăugați o sarcină cron (sintaxa cheie=val)

--unic-cron
adăugați o sarcină cron unică

--cron-harakiri
setați timpul maxim (în secunde) în care așteptăm finalizarea comenzii cron

--legion-cron
adăugați o sarcină cron care poate fi executată numai atunci când instanța este un stăpân al legiunii specificate

--cron-legion
adăugați o sarcină cron care poate fi executată numai atunci când instanța este un stăpân al legiunii specificate

--unică-legiune-cron
adăugați o sarcină cron unică care poate fi executată numai atunci când instanța este un stăpân al celei specificate
legiune

--unică-cron-legiune
adăugați o sarcină cron unică care poate fi executată numai atunci când instanța este un stăpân al celei specificate
legiune

--buclă selectați motorul de buclă uWSGI

--lista-buclă
listează motoarele de buclă activate

--lista de bucle
listează motoarele de buclă activate

--lucrător-executiv
rulați comanda specificată ca lucrător

--worker-exec2
rulați comanda specificată ca lucrător (după post_fork hook)

--attach-daemon
atașați o comandă/daemon la procesul principal (comanda nu trebuie să intre
fundal)

--attach-control-daemon
atașați o comandă/daemon la procesul principal (comanda nu trebuie să intre
fundal), când demonul moare, moare și stăpânul

--smart-attach-daemon
atașați o comandă/daemon la procesul principal gestionat de un fișier pid (comanda are
a daemoniza)

--smart-attach-daemon2
atașați o comandă/daemon la procesul principal gestionat de un fișier pid (comanda are
a NU daemonize)

--legion-attach-daemon
la fel ca --attach-daemon dar daemon rulează numai pe nodul legion lord

--legion-smart-attach-daemon
la fel ca --smart-attach-daemon dar daemon rulează numai pe nodul legion lord

--legion-smart-attach-daemon2
la fel ca --smart-attach-daemon2 dar daemon rulează numai pe nodul legion lord

--daemons-honour-stdin
nu schimbați stdin-ul demonilor externi în / Dev / null

--attach-daemon2
varianta attach-daemon keyval (suportă și moduri inteligente)

--pluginuri
încărcați pluginuri uWSGI

--conecteaza
încărcați pluginuri uWSGI

--need-plugins
încărcați pluginuri uWSGI (ieșire în caz de eroare)

--need-plugin
încărcați pluginuri uWSGI (ieșire în caz de eroare)

--plugins-dir
adăugați un director la calea de căutare a pluginului uWSGI

--plugin-dir
adăugați un director la calea de căutare a pluginului uWSGI

--listă-pluginuri
listați pluginuri activate

--plugin-list
listați pluginuri activate

--încărcare automată
încercați să încărcați automat pluginurile când sunt găsite opțiuni necunoscute

--dlopen
încărcați orbește o bibliotecă partajată

--modificatoare-permise
listă separată prin virgulă de modificatori permisi

--remap-modifier
modificatorul cererii de remapare de la un id la altul

--dump-options
eliminați lista completă a opțiunilor disponibile

--show-config
arată configurația curentă reformatată ca ini

--binary-append-data
returnează conținutul unei resurse la stdout pentru a fi adăugat la un binar uwsgi (pentru
utilizarea de date)

--imprimare
imprimare simplă

--iprint
tipărire simplă (versiune imediată)

--Ieșire forțați ieșirea() a instanței

--csteaguri
raportați uWSGI CFLAGS (util pentru construirea de pluginuri externe)

--punct-h
aruncați uwsgi.h folosit pentru construirea nucleului (util pentru construirea de pluginuri externe)

--config-py
aruncați uwsgiconfig.py folosit pentru construirea nucleului (util pentru construirea externă
pluginuri)

--build-plugin
construiți un plugin uWSGI pentru binarul curent

--versiune
tipăriți versiunea uWSGI

Utilizați uwsgi_rack_ruby23 online folosind serviciile onworks.net