Added protobuf support
[com/gs-lite.git] / include / fta.h
1 /* ------------------------------------------------
2  Copyright 2014 AT&T Intellectual Property
3  Licensed under the Apache License, Version 2.0 (the "License");
4  you may not use this file except in compliance with the License.
5  You may obtain a copy of the License at
6  
7  http://www.apache.org/licenses/LICENSE-2.0
8  
9  Unless required by applicable law or agreed to in writing, software
10  distributed under the License is distributed on an "AS IS" BASIS,
11  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  See the License for the specific language governing permissions and
13  limitations under the License.
14  ------------------------------------------- */
15 /*
16  * fta.h: fta definition for applications
17  */
18 #ifndef FTA_H
19 #define FTA_H
20
21 #include "gslog.h"
22 #include "gsconfig.h"
23
24 typedef struct FTAID {
25     gs_uint32_t ip;  /* identifies the node */
26     gs_uint32_t port; /* identifies a process */
27     gs_uint32_t index;  /* the index identifies a particular FTA in the process */
28     gs_p_t streamid; /* streamid if set identifies an instance */
29 } FTAID;
30
31
32
33 typedef struct PRINTFUNC {
34     gs_sp_t header;
35     gs_sp_t path;
36     gs_sp_t basename;
37     FILE * fa[MAXPRINTFILES];
38     gs_uint32_t nexttime;
39     gs_uint32_t split;
40     gs_uint32_t base;
41     gs_uint32_t itt;
42     gs_uint32_t delta;
43     gs_schemahandle_t schemaid;
44     gs_int32_t split_field;
45     gs_int32_t temporal_field;
46     gs_int32_t in_use;
47 } PRINTFUNC;
48
49 /* the following defines define the FTA commands */
50
51 #define FTA_COMMAND_LOAD_PARAMS 1
52 #define FTA_COMMAND_FLUSH 2
53 #define FTA_COMMAND_GET_TEMP_STATUS 3
54 #define FTA_COMMAND_SET_SAMPLING_RATE 4
55 #define FTA_COMMAND_FILE_DONE 5
56
57 typedef gs_csp_t FTAname;
58
59 typedef gs_csp_t DEVname;
60
61 #define DEFAULTDEV 0
62
63 //      Use gs_param_handle_t defined in gscpv3/include/gstypes.h instead
64 // typedef gs_uint32_t param_handle_t;
65
66 struct FTA {
67     
68     /* reference counts managed by the RTS */
69     gs_uint32_t refcnt;
70     gs_uint32_t runrefcnt;
71     
72     /* the ID gets filled in by the runtime system */
73     FTAID ftaid;
74     
75     /* indicates if the FTA instance can be reused. Set by FTA 0 indicates
76      * that it can not be reused.
77      */
78     gs_uint32_t reusable;
79     
80     /* ftaids the HFTA is subscribed to*/
81     FTAID stream_subscribed[64];
82     
83     /* number of valid entries in stream_subscribe [0..stream_subscribed_cnt-1] */
84     gs_uint32_t stream_subscribed_cnt;
85     
86     /* State needed to print directly to a file out of a HFTA */
87     
88     PRINTFUNC printfunc;
89     
90     /* value of prefilter only used in lftas */
91     gs_uint64_t prefilter;
92     
93     /* allocates and initializes a paramterized instance of a FTA
94      */
95     struct FTA * (*alloc_fta) (FTAID ftaid, gs_uint32_t reusable,
96                                gs_int32_t command, gs_int32_t sz, void * value );
97     
98     /* release all resources associated with FTA (including the FTA) */
99     gs_retval_t (*free_fta) (struct FTA *, gs_uint32_t recursive);
100     
101     /* send control data from host to an instance of an FTA, may return status */
102     gs_retval_t (*control_fta) (struct FTA *, gs_int32_t command, gs_int32_t sz, void * value);
103     
104     /* gets called once every second. Might be delayed until the current thread execution
105      * returns into the run time system. If delayed for more then 1 second then only one
106      * call will be made at the next oportunity.
107      */
108     gs_retval_t (*clock_fta) (struct FTA *);
109     
110     /*
111      * process a packet received on the interface or a tuple received from
112      * another FTA. If ftaid is 0 then packet is of
113      * type struct packet otherwise it is a tuple as defined by the
114      * ftaid.
115      */
116     gs_retval_t (*accept_packet)(struct FTA *, FTAID * f, void * packet, gs_int32_t sz);
117 };
118
119 /* The following definitions are used or provided in automatically generated files */
120
121 typedef  struct FTA * (*alloc_fta) (FTAID ftaid, gs_uint32_t reusable,
122 gs_int32_t command, gs_int32_t sz, void * value ) ;
123
124
125 /* FTA INTERFACE */
126 /* ============== */
127 /* These functions are used by FTAs in addition to the LOW and HIGH
128  * level application interface functions.
129  */
130
131 /* start_service is called to process requests from the message queue
132  which would invoke callback functions registered by fta_register.
133  Number indicates how many seconds should be waited before the
134  function returns. If number < 0 then the function is an endless
135  loop (should be used for HFTA) if the number == 0 all currently
136  outstanding requests are processed before the function returns.
137  */
138 gs_retval_t fta_start_service(gs_int32_t number);
139
140 /* the dev name indicates on which device the FTA is supposed to execute.
141  * HFTA should always use DEFAULTDEV and a snaplen of -1
142  */
143 FTAID fta_register(FTAname name, gs_uint32_t reusable, DEVname device,
144                    alloc_fta fta_alloc_functionptr, gs_csp_t schema,gs_int32_t snaplen,
145                    gs_uint64_t prefilter);
146
147 gs_retval_t fta_unregister(FTAID f);
148
149
150 /*
151  * get the maximum snap length of all ftas registered within the current proccess
152  */
153
154 gs_retval_t fta_max_snaplen();
155
156 /*
157  * Post a tupple back to the clearing house This tuple cannot
158  * use the lfta tuple allocation functions. NOTE: post tuple will
159  * return -1 if at least one ringbuffer for that FTA which is in the atomic
160  * set has not enought space. Otherwise 0 is returned.
161  */
162 gs_retval_t hfta_post_tuple(struct FTA * self, gs_int32_t sz, void *tuple);
163
164 /* the following function fills in the FTAID array r with the FTAIDs of processes receiving
165  * tuplese from the FTA specified in f. The space array indicates how many tuples of tuplesz
166  * can still fit in the ringbuffer corresponding to the FTAID of the process with the same index
167  * in r. The return values indicates how many ring buffers are valid in r. szr indicates the memory
168  * length (in elements) of  r and space. The function will fill at most szr elements into these array.
169  * If the return value is larger then szr it is an indication that not enough memory in r and space
170  * were provided to hold all results. A return value of -1 indicates an error.
171  */
172
173 gs_retval_t hfta_get_ringbuf_space(struct FTA * f, FTAID * r, gs_int32_t* space, gs_int32_t szr, gs_int32_t tuplesz);
174
175
176 /* the following function can be used to put a ringbuffer to a process identified by the FTAID
177  * process into one of the following 3 modes. ATOMIC makes the ringbuffer part of the atomic set.
178  * A post to the atomic set either succeed or fails entirely. BESTEFFORT is the besteffort set
179  * posts to BESTEFFORT ringbuffers might fail quitely. SUSPEND will prevent any tuples of being
180  * posted to that proccess from the specified FTA.
181  */
182
183 #define HFTA_RINGBUF_ATOMIC 1
184 #define HFTA_RINGBUF_BESTEFFORT 2
185 #define HFTA_RINGBUF_SUSPEND 3
186
187 gs_retval_t hfta_set_ringbuf_type(struct FTA * f, FTAID process, gs_int32_t state);
188
189 #endif