conduitConnectionHandlerArgs.h
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008 #ifndef CONDUITCONNECTIONHANDLERARGS_H
00009 #define CONDUITCONNECTIONHANDLERARGS_H
00010
00011 #include <cstdio>
00012 #include <conduit.h>
00013 #include <statusCodes.h>
00014
00015 using namespace std;
00016
00021 struct change_connectionHandlerArgs
00022 {
00023 #define __METHOD__ "change_connectionHandlerArgs"
00024 change_connectionHandlerArgs (const struct connection_handler_args & new_connectionHandlerArgs):
00025 new_connectionHandlerArgs(new_connectionHandlerArgs){}
00026
00027 void operator() (Conduit& c) {
00028
00029 chtype nativeDataType = ca_field_type(new_connectionHandlerArgs.chid);
00030
00031 c.channelRegalia.connectionState=new_connectionHandlerArgs.op;
00032
00033
00034
00035
00036
00037
00038 if (new_connectionHandlerArgs.op == CA_OP_CONN_UP){
00039
00040
00041
00042 c.channelRegalia.nelem = ca_element_count(new_connectionHandlerArgs.chid);
00043 c.channelRegalia.connectFlag = true;
00044 c.channelRegalia.hostName = (const char *) ca_host_name (new_connectionHandlerArgs.chid);
00045
00046 if (c.channelRegalia.channelID != new_connectionHandlerArgs.chid) {
00047 cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
00048 cout << "Internal CAFE WARNING for handle : " << c.handle << endl;
00049 cout << "Channel ID has changed from " << c.channelRegalia.channelID
00050 << " to " << new_connectionHandlerArgs.chid << " " << endl;
00051 cout << "This is a rare occurence and happens when the ca message buffer " << endl;
00052 cout << "is flushed ahead of schedule (does that when full) and this callback is " << endl;
00053 cout << "consequently activated before channel ID is written to the hash table " << endl;
00054 c.channelRegalia.channelID = new_connectionHandlerArgs.chid;
00055 }
00056
00057
00058
00059
00060
00061 c.channelRegalia.dataType = nativeDataType;
00062
00063
00064
00065
00066
00067
00068
00069 if (c.channelRegalia.cafeConnectionState == ICAFE_CS_NEVER_CONN ) {
00070 c.channelRequestMetaDataClient.channelID = new_connectionHandlerArgs.chid;
00071 c.channelRequestMetaDataClient.nelem = c.channelRegalia.nelem;
00072 c.channelRequestMetaDataClient.nelemCache = c.channelRegalia.nelem;
00073 c.channelRequestMetaDataClient.dataType = nativeDataType;
00074
00075
00076
00077 switch (c.channelRequestMetaDataClient.cafeDbrType)
00078 {
00079 case CAFENUM::DBR_TIME:
00080 c.channelRequestMetaDataClient.dbrDataType = dbf_type_to_DBR_TIME(nativeDataType);
00081 break;
00082 case CAFENUM::DBR_STS:
00083 c.channelRequestMetaDataClient.dbrDataType = dbf_type_to_DBR_STS(nativeDataType);
00084 break;
00085 case CAFENUM::DBR_PRIMITIVE:
00086 c.channelRequestMetaDataClient.dbrDataType = dbf_type_to_DBR(nativeDataType);
00087 break;
00088 default:
00089 c.channelRequestMetaDataClient.dbrDataType = dbf_type_to_DBR_TIME(nativeDataType);
00090 c.channelRequestMetaDataClient.cafeDbrType = CAFENUM::DBR_TIME;
00091 break;
00092 }
00093
00094
00095 c.channelRequestMetaDataClient.byteSize=dbr_size_n(
00096 c.channelRequestMetaDataClient.dbrDataType,
00097
00098 c.channelRequestMetaDataClient.nelem);
00099 }
00100
00101
00102 c.channelRequestMetaData.channelID = new_connectionHandlerArgs.chid;
00103 c.channelRequestMetaData.nelem = c.channelRegalia.nelem;
00104 c.channelRequestMetaData.nelemCache = c.channelRegalia.nelem;
00105 c.channelRequestMetaData.dataType = nativeDataType;
00106
00107
00108
00109 switch (c.channelRequestMetaData.cafeDbrType)
00110 {
00111 case CAFENUM::DBR_TIME:
00112 c.channelRequestMetaData.dbrDataType = dbf_type_to_DBR_TIME(nativeDataType);
00113 break;
00114 case CAFENUM::DBR_STS:
00115 c.channelRequestMetaData.dbrDataType = dbf_type_to_DBR_STS(nativeDataType);
00116 break;
00117 case CAFENUM::DBR_PRIMITIVE:
00118 c.channelRequestMetaData.dbrDataType = dbf_type_to_DBR(nativeDataType);
00119 break;
00120 default:
00121 c.channelRequestMetaData.dbrDataType = dbf_type_to_DBR_TIME(nativeDataType);
00122 c.channelRequestMetaData.cafeDbrType = CAFENUM::DBR_TIME;
00123 break;
00124 }
00125
00126
00127
00128
00129
00130
00131 unsigned int nelem_ctrl_buffer=1;
00132
00133 if ( c.channelRegalia.nelem > MAX_NELEM_FOR_CTRL_BUFFER) {
00134 nelem_ctrl_buffer = DEFAULT_NELEM_FOR_CTRL_BUFFER;
00135 }
00136 else {
00137 nelem_ctrl_buffer = c.channelRegalia.nelem;
00138 }
00139
00140
00141
00142 if (c.channelRegalia.cafeConnectionState == ICAFE_CS_NEVER_CONN ) {
00143 c.channelRequestMetaCtrlClient.channelID = new_connectionHandlerArgs.chid;
00144 c.channelRequestMetaCtrlClient.nelem = c.channelRegalia.nelem;
00145 c.channelRequestMetaCtrlClient.nelemCache = c.channelRegalia.nelem;
00146 c.channelRequestMetaCtrlClient.dataType = nativeDataType;
00147
00148
00149
00150 switch (c.channelRequestMetaCtrlClient.cafeDbrType)
00151 {
00152 case CAFENUM::DBR_CTRL:
00153 c.channelRequestMetaCtrlClient.dbrDataType = dbf_type_to_DBR_CTRL(nativeDataType);
00154 break;
00155 case CAFENUM::DBR_GR:
00156 c.channelRequestMetaCtrlClient.dbrDataType = dbf_type_to_DBR_GR (nativeDataType);
00157 break;
00158 default:
00159 c.channelRequestMetaCtrlClient.dbrDataType = dbf_type_to_DBR_CTRL(nativeDataType);
00160 c.channelRequestMetaCtrlClient.cafeDbrType = CAFENUM::DBR_CTRL;
00161 break;
00162 }
00163
00164 c.channelRequestMetaCtrlClient.byteSize=dbr_size_n(
00165 c.channelRequestMetaCtrlClient.dbrDataType,c.channelRequestMetaCtrlClient.nelem);
00166 }
00167
00168
00169 c.channelRequestMetaCtrl.channelID = new_connectionHandlerArgs.chid;
00170 c.channelRequestMetaCtrl.nelem = nelem_ctrl_buffer;
00171 c.channelRequestMetaCtrl.nelemCache = nelem_ctrl_buffer;
00172 c.channelRequestMetaCtrl.dataType = nativeDataType;
00173
00174
00175 switch (c.channelRequestMetaCtrl.cafeDbrType)
00176 {
00177 case CAFENUM::DBR_CTRL:
00178 c.channelRequestMetaCtrl.dbrDataType = dbf_type_to_DBR_CTRL(nativeDataType);
00179 break;
00180 case CAFENUM::DBR_GR:
00181 c.channelRequestMetaCtrl.dbrDataType = dbf_type_to_DBR_GR (nativeDataType);
00182 break;
00183 default:
00184 c.channelRequestMetaCtrl.dbrDataType = dbf_type_to_DBR_CTRL(nativeDataType);
00185 c.channelRequestMetaCtrl.cafeDbrType = CAFENUM::DBR_CTRL;
00186 break;
00187 }
00188
00189
00190
00191
00192 unsigned int nelem_stsack_buffer;
00193
00194 if ( c.channelRegalia.nelem > MAX_NELEM_FOR_STSACK_BUFFER) {
00195 nelem_stsack_buffer = DEFAULT_NELEM_FOR_STSACK_BUFFER;
00196 }
00197 else {
00198 nelem_stsack_buffer = c.channelRegalia.nelem;
00199 }
00200
00201
00202
00203 c.channelRequestMetaSTSACK.channelID = new_connectionHandlerArgs.chid;
00204 c.channelRequestMetaSTSACK.nelem = nelem_stsack_buffer;
00205 c.channelRequestMetaSTSACK.nelemCache = nelem_stsack_buffer;
00206 c.channelRequestMetaSTSACK.dataType = DBR_STRING;
00207 c.channelRequestMetaSTSACK.dbrDataType = DBR_STSACK_STRING;
00208 c.channelRequestMetaSTSACK.cafeDbrType = CAFENUM::DBR_STSACK;
00209
00210
00211
00212 c.channelRequestMetaPrimitive.channelID = new_connectionHandlerArgs.chid;
00213 c.channelRequestMetaPrimitive.nelem = c.channelRegalia.nelem;
00214 c.channelRequestMetaPrimitive.dataType = nativeDataType;;
00215 c.channelRequestMetaPrimitive.dbrDataType= dbf_type_to_DBR(nativeDataType);
00216 c.channelRequestMetaPrimitive.cafeDbrType= CAFENUM::DBR_PRIMITIVE;
00217
00219
00220
00221 if ( c.channelRegalia.nelem>1) {
00222 double tout= ((unsigned int) (c.channelRegalia.nelem*0.000001));
00223 c.channelRequestDataTypePolicy.setRequestKind(CAFENUM::LOWEST_DATATYPE);
00224 c.channelTimeoutPolicyGet.setTimeout(std::max(DEFAULT_TIMEOUT_PEND_IO_WF , tout));
00225 c.channelTimeoutPolicyPut.setTimeout(std::max(DEFAULT_TIMEOUT_PEND_IO_WF , tout));
00226 c.channelTimeoutPolicyGet.setDefaultTimeout(DEFAULT_TIMEOUT_PEND_IO_WF);
00227 c.channelTimeoutPolicyPut.setDefaultTimeout(DEFAULT_TIMEOUT_PEND_IO_WF);
00228 }
00229
00230 c.channelRegalia.cafeConnectionState = ICAFE_CS_CONN;
00231 c.status = ICAFE_CA_OP_CONN_UP;
00232 }
00233 else {
00234
00235
00236
00237
00238 c.channelRequestStatusGet.setCallbackKind(false, true);
00239 c.channelRequestStatusPut.setCallbackKind(false, true);
00240 c.channelRegalia.cafeConnectionState =ICAFE_CS_DISCONN;
00241 c.channelRegalia.connectFlag = false;
00242 c.status = ICAFE_CA_OP_CONN_DOWN;
00243 }
00244
00245
00246 }
00247
00248 private:
00249 connection_handler_args new_connectionHandlerArgs;
00250 #undef __METHOD__
00251 };
00252
00253
00258 struct change_dataBufferSize_CTRL
00259 {
00260 #define __METHOD__ "change_dataBufferSize_CTRL"
00261 change_dataBufferSize_CTRL (const chtype & new_ctrlTypeBuffer): new_ctrlTypeBuffer(new_ctrlTypeBuffer){}
00262
00263 void operator() (Conduit& c) {
00264
00265
00266
00267
00268 bool allocateMemory=false ;
00269
00270 if(c.ctrlBuffer==NULL) {
00271 allocateMemory=true;
00272 }
00273
00274 else if ( dbr_size_n(new_ctrlTypeBuffer,c.channelRequestMetaCtrl.getNelem()) > c.channelRequestMetaCtrl.getByteSize() ) {
00275 cout << "ctrlBuffer already exists= " << c.ctrlBuffer << " for channel " << c.pv
00276 << " with handle " << c.handle << endl;
00277 cout << "Freeing and reallocating ctrlBuffer" << endl;
00278 free(c.ctrlBuffer);
00279 allocateMemory=true;
00280 }
00281
00282 if (allocateMemory) {
00283
00284 c.ctrlBuffer = (db_access_val *) malloc ( dbr_size_n(new_ctrlTypeBuffer,c.channelRequestMetaCtrl.getNelem()) );
00285 c.channelRequestMetaCtrl.byteSize=dbr_size_n(new_ctrlTypeBuffer,c.channelRequestMetaCtrl.getNelem());
00286 }
00287
00288
00289 if (c.ctrlBuffer==0){
00290 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00291 printf ("Virtual memory exhausted for channel %s ", ca_name(c.channelID));
00292 printf ("Exiting CAFE");
00293 }
00294
00295 }
00296
00297 private:
00298 chtype new_ctrlTypeBuffer;
00299 #undef __METHOD__
00300 };
00301
00302
00307 struct change_dataBufferSize_PRIMITIVE
00308 {
00309 #define __METHOD__ "change_dataBufferSize_PRIMITIVE"
00310 change_dataBufferSize_PRIMITIVE (const chtype & new_dataTypeBufferNative): new_dataTypeBufferNative(new_dataTypeBufferNative){}
00311
00312 void operator() (Conduit& c) {
00313
00314 bool allocateMemory=false ;
00315
00316 if(c.putBuffer==NULL) {
00317 allocateMemory=true;
00318 }
00319 else if ( dbr_size_n(c.channelRequestMetaPrimitive.getDbrDataType(),
00320 c.channelRequestMetaPrimitive.getNelem())
00321 > c.channelRequestMetaPrimitive.getByteSize() ) {
00322 cout << "putBuffer already exists= " << c.putBuffer << " for channel " << c.pv
00323 << " with handle " << c.handle << endl;
00324 cout << "Freeing and reallocating putBuffer" << endl;
00325 free(c.putBuffer);
00326 allocateMemory=true;
00327 }
00328
00329 if (allocateMemory) {
00330
00331
00332 c.putBuffer = (db_access_val *) malloc (dbr_size_n(c.channelRequestMetaPrimitive.getDbrDataType(),
00333 c.channelRequestMetaPrimitive.getNelem()));
00334
00335 c.channelRequestMetaPrimitive.byteSize
00336 =dbr_size_n(c.channelRequestMetaPrimitive.getDbrDataType(),
00337 c.channelRequestMetaPrimitive.getNelem());
00338 }
00339
00340 if (c.putBuffer==0){
00341 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00342 printf ("Virtual memory exhausted for channel %s ", ca_name(c.channelID));
00343 printf ("Exiting CAFE");
00344 exit(0);
00345 }
00346
00347 }
00348
00349 private:
00350 chtype new_dataTypeBufferNative;
00351 #undef __METHOD__
00352 };
00353
00354
00355
00360 struct change_dataBufferSize_STSACK
00361 {
00362 #define __METHOD__ "change_dataBufferSize_STSACK"
00363 change_dataBufferSize_STSACK (){}
00364
00365 void operator() (Conduit& c) {
00366
00367 bool allocateMemory=false ;
00368
00369 if(c.stsackBuffer==NULL) {
00370
00371 allocateMemory=true;
00372 }
00373
00374 else if ( dbr_size_n(c.channelRequestMetaSTSACK.getDbrDataType(),
00375 c.channelRequestMetaSTSACK.getNelem())
00376 > c.channelRequestMetaSTSACK.getByteSize() ) {
00377 cout << "stsackBuffer already exists= " << c.stsackBuffer << " for channel " << c.pv
00378 << " with handle " << c.handle << endl;
00379 cout << "Freeing and reallocating putBuffer" << endl;
00380 free(c.stsackBuffer);
00381 allocateMemory=true;
00382 }
00383
00384 if (allocateMemory) {
00385
00386
00387 c.stsackBuffer = (db_access_val *) malloc (dbr_size_n(c.channelRequestMetaSTSACK.getDbrDataType(),
00388 c.channelRequestMetaSTSACK.getNelem()));
00389
00390 c.channelRequestMetaSTSACK.byteSize
00391 =dbr_size_n(c.channelRequestMetaSTSACK.getDbrDataType(),
00392 c.channelRequestMetaSTSACK.getNelem());
00393 }
00394
00395 }
00396 #undef __METHOD__
00397 };
00398
00399
00404 struct change_dataBufferSize_TIME
00405 {
00406 #define __METHOD__ "change_dataBufferSize_PRIMITIVE"
00407
00408 change_dataBufferSize_TIME (const chtype & new_dataTypeBuffer): new_dataTypeBuffer(new_dataTypeBuffer){}
00409
00410 void operator() (Conduit& c) {
00411
00412
00413
00414
00415 bool allocateMemory=false ;
00416
00417
00418 if(c.dataBuffer==NULL) {
00419
00420 allocateMemory=true;
00421 }
00422
00423 else if ( dbr_size_n(new_dataTypeBuffer,c.channelRegalia.getNelem()) > c.channelRequestMetaData.getByteSize() ) {
00424 cout << "dataBuffer already exists= " << c.dataBuffer << " for channel " << c.pv
00425 << " with handle " << c.handle << endl;
00426 cout << "Freeing and reallocating dataBuffer" << endl;
00427
00428 cout << dbr_size_n(new_dataTypeBuffer,c.channelRegalia.getNelem()) << " VERSUS "
00429 << c.channelRequestMetaData.getByteSize() << endl;
00430 free(c.dataBuffer);
00431 allocateMemory=true;
00432
00433 }
00434
00435 if (allocateMemory) {
00436
00437 c.dataBuffer = (db_access_val *) malloc ( dbr_size_n(new_dataTypeBuffer,c.channelRegalia.getNelem()) );
00438 c.channelRequestMetaData.byteSize=dbr_size_n(new_dataTypeBuffer,c.channelRequestMetaData.getNelem());
00439
00440 }
00441
00442 if (c.dataBuffer==NULL){
00443 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00444 printf ("Virtual memory exhausted for channel %s ", ca_name(c.channelID));
00445 printf ("Exiting CAFE");
00446
00447 exit(0);
00448 }
00449 }
00450
00451 private:
00452 chtype new_dataTypeBuffer;
00453 #undef __METHOD__
00454 };
00455
00456
00460 struct free_dataBuffers
00461 {
00462 free_dataBuffers (){}
00463
00464 void operator() (Conduit& c) {
00465
00466
00467
00468 if(c.dataBuffer) {
00469 free(c.dataBuffer);
00470 }
00471
00472 if(c.ctrlBuffer) {
00473 free(c.ctrlBuffer);
00474 }
00475
00476 if(c.stsackBuffer) {
00477 free(c.stsackBuffer);
00478 }
00479
00480 if(c.putBuffer) {
00481 free(c.putBuffer);
00482 }
00483
00484 }
00485 };
00486
00487
00488 #endif // CONDUITCONNECTIONHANDLERARGS_H