Comunicazione del sottosistema di programmazione con SRC

I comandi SRC (System Resource Controller) sono programmi eseguibili che prendono le opzioni dalla riga di comando.

Dopo che la sintassi del comando è stata verificata, i comandi richiamano le subroutine run - time SRC per costruire un datagramma UDP (User Datagram Protocol) e inviarlo al daemon srcmstr .

Le seguenti sezioni forniscono maggiori informazioni sulle subroutine SRC e come possono essere utilizzate dai sottosistemi per comunicare con il processo principale SRC:

Sottosistemi di programmazione per ricevere richieste SRC

Le attività di programmazione associate alla ricezione delle richieste SRC variano con il tipo di comunicazione specificato per il sottosistema. Il daemon srcmstr utilizza socket per ricevere richieste di lavoro da un processo di comando e costruisce la coda del socket o del messaggio necessario per inoltrare le richieste di lavoro. Ogni sottosistema deve verificare la creazione della propria coda di socket o di messaggi. Leggi le seguenti sezioni per informazioni sulle linee guida specifiche per la programmazione del tuo sottosistema per ricevere pacchetti di richiesta SRC.

Nota: Tutti i sottosistemi, indipendentemente dal tipo di comunicazione, devono definire una routine di catcher di segnale per gestire la richiesta SIGTERM .

Ricezione dei segnali SRC

I sottosistemi che utilizzano i segnali come tipo di comunicazione devono definire una routine di catcher di segnale per catturare i segnali SIGNORM e SIGFORCE . Il metodo di cattura del segnale utilizzato è sottosistema - dipendente. Di seguito sono riportati due esempi dei tipi di sottoroutine che possono essere utilizzati per questo scopo.

Ricevimento SRC i pacchetti di richiesta tramite socket

Utilizzare le seguenti linee guida quando i sottosistemi di programmazione socket per ricevere pacchetti di richiesta SRC:

• Includere la struttura del sottosistema SRC nel codice del sottosistema specificando il file /usr/include/spc.h . Questo file contiene le strutture che il sottosistema utilizza per rispondere ai comandi SRC. Inoltre, il file spc.h contiene il file srcerrno.h , che non deve essere incluso separatamente. Il file srcerrno.h contiene definizioni di codice di errore per il supporto daemon.
• Quando viene avviato un sottosistema socket, il socket su cui il sottosistema riceve i pacchetti di richiesta SRC è impostato come descrittore di file 0. Il sottosistema dovrebbe verificarlo richiamando la sottoroutine getsockname , che restituisce l'indirizzo del socket del sottosistema. Se il descrittore di file 0 non è un socket, il sottosistema deve registrare un errore e quindi uscire. Consultare "Reading Internet Datagrams Esempio Program" in Communications Programming Concepts per informazioni su come la sottoroutine getsockname può essere utilizzata per restituire l'indirizzo di un socket del sottosistema.
• Se un sottosistema esegue i sondaggi più di un socket, utilizzare la sottoroutine select per determinare quale socket ha qualcosa da leggere. Consultare "Checking for Pending Connections Esempio Programma" in Concetti Di Programmazione delle comunicazioni per ulteriori informazioni su come la sottoroutine selezionare può essere utilizzata per questo scopo.
• Utilizzare la sottoroutine recvfrom per ottenere il pacchetto di richiesta dal socket.

  Nota: L'indirizzo di ritorno per il pacchetto di risposta del sottosistema è nel pacchetto di richiesta SRC ricevuto. Questo indirizzo non deve essere confuso con l'indirizzo che la sottoroutine recvfrom restituisce come uno dei suoi parametri.

  Dopo che la sottoroutine recvfrom si completa e il pacchetto è stato ricevuto, utilizzare la sottoroutine srcrrqs per restituire un puntatore ad una struttura srchdr statica. Questo puntatore contiene l'indirizzo di ritorno per la risposta del sottosistema. Questa struttura viene sovrascritta ogni volta che la sottoroutine srcrrqs viene chiamata, quindi il suo contenuto deve essere memorizzato altrove se sarà necessario dopo la chiamata successiva alla subroutine srcrrqs .

Ricevere i pacchetti di richiesta SRC tramite code di messaggi

Utilizzare le seguenti linee guida quando i sottosistemi della coda dei messaggi di programmazione per ricevere i pacchetti di richiesta SRC:

• Include la struttura del sottosistema SRC nel codice del sottosistema specificando il file /usr/include/spc.h . Questo file contiene le strutture che il sottosistema utilizza per rispondere ai comandi SRC. Inoltre, il file spc.h include il file di inclusione srcerrno.h , che non deve essere incluso separatamente. Il file srcerrno.h contiene definizioni di codice di errore per il supporto daemon.
• Specificare -DSRCBYQUEUE come opzione di compilazione. Questo pone un tipo di messaggio (mtype) campo come primo campo nella struttura srcreq . Questa struttura deve essere utilizzata ogni volta che viene ricevuto un pacchetto SRC.
• Quando il sottosistema è stato avviato, utilizzare la sottoroutine msgget per verificare che una coda di messaggi sia stata creata alla startup del sistema. Il sottosistema deve registrare un errore e uscire se non è stata creata una coda messaggi.
• Se un sottosistema esegue il polling più di una coda di messaggi, utilizzare la sottoroutine select per determinare quale coda di messaggi ha qualcosa da leggere. Consultare "Checking for Pending Connections Esempio Programma" in Concetti Di Programmazione delle comunicazioni per informazioni su come la sottoroutine selezionare può essere utilizzata per questo scopo.
• Utilizzare la sottoroutine msgrcv o msgxrcv per ottenere il pacchetto dalla coda messaggi. L'indirizzo di ritorno per il pacchetto di risposta del sottosistema è nel pacchetto ricevuto.
• Quando la sottoroutine msgrcv o msgxrcv si completa e il pacchetto è stato ricevuto, richiamare la sottoroutine srcrrqs per terminare il processo di ricezione. La sottoroutine srcrrqs restituisce un puntatore a una struttura statica srchdr sovrascritta ogni volta che viene chiamata la sottoroutine srcrrqs . Questo puntatore contiene l'indirizzo di ritorno per la risposta del sottosistema.

Sottosistemi di programmazione per elaborare pacchetti di richiesta SRC

I sottosistemi devono essere in grado di elaborare le richieste di arresto. Facoltativamente, i sottosistemi possono supportare le richieste di avvio, di stato, di traccia e di aggiornamento.

I pacchetti di richiesta di elaborazione comportano un processo a due fasi:

Lettura pacchetti di richiesta SRC

I pacchetti di richiesta SRC sono ricevuti da sottosistemi sotto forma di una struttura srcreq come definito nel file /usr/include/spc.h . La richiesta del sottosistema risiede nella struttura subreq della struttura srcreq :

struct subreq
   short object;         /*object to act on*/
   short action;         /*action START, STOP, STATUS, TRACE,\
                           REFRESH*/
   short parm1;          /*reserved for variables*/
   short parm2;          /*reserved for variables*/
   char objname;         /*object name*/

Gliobjectcampo della struttura subreq indica l'oggetto a cui si applica la richiesta. Quando la richiesta si applica ad un sottosistema, laobjectil campo è impostato sulla costante SUBSYSTEM. Altrimenti, ilobjectil campo è impostato sul punto di codice del sottoserver o ilobjnameil campo è impostato sul PID del sottoserver come stringa di carattere. E'responsabilità del sottosistema determinare l'oggetto a cui si applica la richiesta.

Gliactioncampo specifica l'azione richiesta del sottosistema. I sottosistemi dovrebbero comprendere i codici di azione START, STOP e STATUS. I codici azione TRACE e REFRESH sono facoltativi.

Gliparm1eparm2i campi vengono utilizzati in modo diverso da ciascuna delle azioni.

Le azioni START subserver e REFRESH non utilizzano laparm1eparm2campi.

Programmazione del sottosistema di programmazione alle richieste SRC

Le azioni di sottosistema appropriate per la maggior parte delle richieste SRC sono programmate quando l'oggetto del sottosistema è definito all'SRC. Le strutture che i sottosistemi utilizzano per rispondere alle richieste SRC sono definite nel file /usr/include/spc.h . I sottosistemi possono utilizzare le seguenti sottoroutine di run - time SRC per soddisfare i requisiti di elaborazione dei comandi:

L'elaborazione della richiesta di stato richiede una combinazione di attività e subroutine.

Quando i sottosistemi ricevono richieste non possono elaborare o che non sono validi, devono inviare un pacchetto di errori con un codice di errore di SRC_SUBICMD in risposta all'ignoto, o non valido, richiesta. SRC riserva i codici di azione 0 - 255 per uso interno SRC. Se il tuo sottosistema riceve una richiesta contenente un codice azione non valido, il tuo sottosistema deve restituire un codice di errore di SRC_SUBICMD. I codici azione validi supportati da SRC sono definiti nel file spc.h . È anche possibile definire codici di azione specifici del sottosistema. Un codice azione non è valido se non è definito dall'SRC o dal tuo sottosistema.

Nota: I codici di azione 0 - 255 sono riservati all'uso SRC.

Elaborazione delle richieste di stato SRC

I sottosistemi possono essere richiesti per fornire tre tipi di rapporti di stato: stato del sottosistema lungo, stato di subserver breve e stato di subserver lungo.

Nota: Il reporting di stato del sottosistema breve viene eseguito dal daemon srcmstr . Le costanti di valore statcode e di risposta - stato per questo tipo di report sono definite nel file /usr/include/spc.h . La tabella Stato Valore costanti elenca i codici di valore di stato di risposta richiesti e suggeriti.

Codici di valore di stato di risposta

Il comando SRC lssrc visualizza le informazioni ricevute sull'output standard. Le informazioni restituite dai sottosistemi in risposta ad una richiesta di stato lungo sono lasciate alla discrezione del sottosistema. I sottosistemi che possiedono i sottoserver sono responsabili del tracciamento e della segnalazione delle modifiche di stato dei sottoserver, se desiderato. Utilizzare la sottoroutine srcstathdr per richiamare un'intestazione di stato standard per ripassare all'inizio dei dati di stato.

Le seguenti fasi sono consigliate nelle richieste di stato di elaborazione:

1. Per restituire lo stato da un sottosistema (breve o lungo), assegnare una matrice di statcode strutture più una struttura srchdr . La struttura srchdr deve avviare il buffer che si sta inviando in risposta alla richiesta di stato. La struttura statcode è definita nel file /usr/include/spc.h .

   struct statcode
   {
      short objtype;
      short status;
      char objtext [65];
      char objname [30];
   };

2. Compila ilobjtypecampo con la costante SUBSYSTEM per indicare che lo stato è per un sottosistema, oppure con un punto di codice subserver per indicare che lo stato è per un subserver.
3. Compila ilstatuscon una delle costanti di stato SRC definite nel file spc.h .
4. Compila ilobjtextcampo con il testo NLS che desideri visualizzato come stato. Questo campo deve essere una stringa terminata NULL.
5. Compila ilobjnamecampo con il nome del sottosistema o del sottoserver per cui laobjtextcampo si applica. Questo campo deve essere una stringa terminata NULL.

   Nota: Il sottosistema e il richiedente possono concordare di inviare altre informazioni definite dal sottosistema al richiedente.

Sottosistemi di programmazione per inviare pacchetti di risposta

Il pacchetto che un sottosistema ritorna all'SRC dovrebbe essere nel formato della struttura srcrep come definito nel file /usr/include/spc.h . La struttura svrreply che fa parte della struttura srcrep conterrà la risposta del sottosistema:

struct svrreply
{
   short rtncode;        /*return code from the subsystem*/
   short objtype;        /*SUBSYSTEM or SUBSERVER*/
   char objtext[65];     /*object description*/
   char objname[20];     /*object name*/
   char rtnmsg[256];     /*returned message*/
};

Utilizzare la sottoroutine srcsrpy per restituire un pacchetto al richiedente.

Creazione di una risposta

Per programmare una risposta del sottosistema, utilizzare la seguente procedura:

1. Compila il rtncodecampo con il codice di errore SRC che si applica. Utilizzare SRC_SUBMSG comertncodecampo per restituire un messaggio NLS specifico del sottosistema.
2. Compila ilobjtypecampo con la costante SUBSYSTEM per indicare che la risposta è per un sottosistema oppure con il punto di codice subserver per indicare che la risposta è per un sottoserver.
3. Compila ilobjnamecampo con il nome del sottosistema, il tipo di sottoserver o l'oggetto subserver che si applica alla risposta.
4. Compila ilrtnmsgcampo con il messaggio NLS specifico del sottosistema.
5. Chiave la voce appropriata nel parametro srcsrpy Continua . Consultare "Paccsrpy Continuazione Pacchetti" per ulteriori informazioni.

   Nota: L'ultimo pacchetto dal sottosistema deve sempre avere FINE specificato nel parametro Continua alla subroutine srcsrpy .

pacchetti di continuazione srcsrpy

Le risposte del sottosistema alle richieste SRC sono effettuate sotto forma di pacchetti di continuazione. Possono essere specificati due tipi di pacchetti di continuazione: messaggio informativo e pacchetti di risposta.

Il messaggio informativo non viene riportato al client. Viene invece stampato all'output standard del client. Il messaggio deve consistere in testo NLS, con token di messaggi compilati dal sottosistema di invio. Per inviare questo tipo di pacchetto di continuazione, specificare CONTINUA nel parametro srcsrpy subroutine Continua .

Nota: L'azione del sottosistema STOP non consente alcun tipo di prosecuzione. Tuttavia, tutte le altre richieste di azione ricevute dal sottosistema da SRC possono essere inviate un messaggio informativo.

Il pacchetto di risposta viene passato al client per un'ulteriore elaborazione. Pertanto, il pacchetto deve essere concordato dal sottosistema e dal richiedente. Un esempio di questo tipo di prosecuzione è una richiesta di stato. Quando si risponde alle richieste di stato del sottosistema, specificare STATCONTINUE nel parametro srcsrpy Continua . Quando la segnalazione di stato ha completato, o tutti i pacchetti di risposta definiti dal sottosistema sono stati inviati, specificare FINE nel parametro srcsrpy Continua . Il pacchetto viene quindi passato al client per indicare la fine della risposta.

Sottosistemi di programmazione per restituire pacchetti di errore SRC

I sottosistemi sono tenuti a restituire i pacchetti di errore sia per gli errori SRC che per gli errori non SRC.

Quando si restituisce un errore SRC, il pacchetto di risposta che il sottosistema restituisce dovrebbe essere sotto forma di struttura svrreply della struttura srcrep , con laobjnamecampo compilato con il nome del sottosistema, il tipo di sottoserver o l'oggetto subserver in errore. Se il messaggio NLS associato al numero di errore SRC non include token, il pacchetto di errori viene restituito in forma breve. Questo significa che il pacchetto di errori contiene solo il numero di errore SRC. Tuttavia, se i token sono associati al numero di errore, deve essere restituito il testo del messaggio NLS standard dal catalogo dei messaggi.

Quando si restituisce un errore non SRC, il pacchetto di risposta dovrebbe essere una struttura svrreply con lartncodecampo impostato sulla costante SRC_SUBMSG e lartnmsgcampo impostato su un messaggio NLS specifico del sottosistema. Glirtnmsgil campo viene stampato all'output standard del client.

Rispondere alle richieste di traccia

Il supporto per i comandi traceson e tracesoff è sottosistema - dipendente. Se si sceglie di supportare questi comandi, le azioni di traccia possono essere specificate per sottosistemi e sottoserver.

Le richieste di traccia del sottosistema arriveranno nel seguente modulo: una richiesta di traccia del sottosistema avrà il subreq actioncampo impostato sulla costante TRACE e il subreq objectcampo impostato sulla costante SUBSYSTEM. L'azione di traccia utilizzaparm1per indicare la traccia LONGTRACE o SHORTTRACE, eparm2per indicare TRACEON o TRACEOFF.

Quando il sottosistema riceve un pacchetto di sottosistema di traccia conparm1impostato su SHORTTRACE eparm2impostato su TRACEON, il sottosistema deve attivare la traccia breve. Viceversa, quando il sottosistema riceve un pacchetto di sottosistema di traccia conparm1impostato su LONGTRACE eparm2impostato su TRACEON, il sottosistema dovrebbe attivare long tracing. Quando il sottosistema riceve un pacchetto di sottosistema di traccia conparm2impostato su TRACEOFF, il sottosistema dovrebbe disattivare la traccia del sottosistema.

Le richieste di traccia di subserver arriveranno nel seguente modulo: la richiesta di traccia subserver avrà il subreq actioncampo impostato sulla costante TRACE e il subreq objectcampo impostato sul punto di codice del sottoserver su cui inviare lo stato. L'azione di traccia utilizzaparm1per indicare LONGTRACE o SHORTTRACE, eparm2per indicare TRACEON o TRACEOFF.

Quando il sottosistema riceve un pacchetto di subserver di traccia conparm1impostato su SHORTTRACE eparm2impostato su TRACEON, il sottosistema deve attivare il tracciamento breve del sottoserver. Viceversa, quando il sottosistema riceve un pacchetto di subserver di traccia conparm1impostato su LONGTRACE eparm2impostato su TRACEON, il sottosistema deve attivare il tracciamento lungo del sottoserver. Quando il sottosistema riceve un pacchetto di subserver di traccia conparm2impostato su TRACEOFF, il sottosistema dovrebbe disattivare la traccia del sottoserver.

Rispondere alle richieste di aggiornamento

Il supporto per le richieste di aggiornamento del sottosistema è dipendente dal sottosistema. I programmatori del sottosistema che scelgono di supportare il comando refresh dovrebbero programmare i propri sottosistemi per interagire con l'SRC nel modo seguente:

• Una richiesta di aggiornamento del sottosistema avrà la struttura subreqactioncampo impostato sulla costante REFRESH e la struttura subreqobjectcampo impostato sulla costante SUBSYSTEM. L'azione del sottosistema di aggiornamento non utilizzaparm1oppureparm2.
• Quando il sottosistema riceve la richiesta di aggiornamento, il sottosistema deve riconfigurare se stesso.