void clmClusterTrackCallback(const SaClmClusterNotificationBufferT_4 *notificationBuffer,
SaUint32T numberOfMembers,
SaInvocationT invocation,
const SaNameT *rootCauseEntity,
const SaNtfCorrelationIdsT *correlationIds,
SaClmChangeStepT step,
SaTimeT timeSupervision,
SaAisErrorT error)
{
//Call when CLM node lock/unlock or node down/up
syslog(LOG_INFO,"Received cluster update: members in cluster=%d", numberOfMembers);
unsigned int item;
for (item = 0; item < notificationBuffer->numberOfItems; item++) {
const char* node = saAisNameBorrow(&(notificationBuffer->notification[item].clusterNode.nodeName));
if (notificationBuffer->notification[item].clusterChange == SA_CLM_NODE_JOINED) {
syslog(LOG_INFO,"Node %s JOINED", node);
} else if (notificationBuffer->notification[item].clusterChange == SA_CLM_NODE_LEFT) {
syslog(LOG_INFO,"Node %s LEFT", node);
} else {
syslog(LOG_INFO,"Node %s Change reason=%s Change step=%s",node,
(notificationBuffer->notification[item].clusterChange < clmClusterChangesNoIndex) ? clmClusterChanges[notificationBuffer->notification[item].clusterChange] : "UNKNOWN",
(step < clmChangeStepNoIndex) ? clmChangeStep[step] : "UNKOWN");
}
}
}
void print_additional_info(SaNtfNotificationHandleT notificationHandle,
const SaNtfNotificationHeaderT * notificationHeader)
{
int i;
char *dataPtr;
SaNameT name;
SaStringT info_value_str;
SaUint16T dataSize;
SaAisErrorT rc;
if (notificationHeader->additionalInfo != NULL) {
for (i=0; i<notificationHeader->numAdditionalInfo; i++) {
printf("- additionalInfo: %d -\n",i);
printf(" infoId = %u\n",notificationHeader->additionalInfo[i].infoId);
printf(" infoType = %u\n",notificationHeader->additionalInfo[i].infoType);
switch (notificationHeader->additionalInfo[i].infoType) {
case SA_NTF_VALUE_LDAP_NAME:
rc = saNtfPtrValGet(notificationHandle,
¬ificationHeader->
additionalInfo[i].infoValue,
(void **)&dataPtr,
&dataSize);
if (rc == SA_AIS_OK) {
size_t strLength = dataSize - 2;
char *newStr = (char*)malloc(strLength + 1);
memcpy(newStr, dataPtr + 2, strLength);
newStr[strLength] = '\0';
saAisNameLend(newStr, &name);
printf(" infoValue = \"%s\"\n", saAisNameBorrow(&name));
free(newStr);
} else
fprintf(stderr, "saNtfPtrValGet Error "
"%d\n", rc);
break;
case SA_NTF_VALUE_STRING:
rc = saNtfPtrValGet(notificationHandle,
¬ificationHeader->
additionalInfo[i].infoValue,
(void **)&info_value_str,
&dataSize);
if (rc == SA_AIS_OK) {
printf(" infoValue = \"%s\"\n",info_value_str);
} else
fprintf(stderr, "saNtfPtrValGet Error "
"%d\n", rc);
break;
default:
printf("Unimplemented additionalInfo type\n");
break;
}
}
}
}
void print_param(SaImmAdminOperationParamsT_2 *param) {
switch(param->paramType) {
case SA_IMM_ATTR_SAINT32T :
printf("%-50s %-12s %d (0x%x)\n", param->paramName, "SA_INT32_T",
(*((SaInt32T *)param->paramBuffer)), (*((SaInt32T *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SAUINT32T :
printf("%-50s %-12s %u (0x%x)\n", param->paramName, "SA_UINT32_T",
(*((SaUint32T *)param->paramBuffer)), (*((SaUint32T *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SAINT64T :
printf("%-50s %-12s %lld (0x%llx)\n", param->paramName, "SA_INT64_T",
(*((SaInt64T *)param->paramBuffer)), (*((SaInt64T *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SAUINT64T :
printf("%-50s %-12s %llu (0x%llx)\n", param->paramName, "SA_UINT64_T",
(*((SaUint64T *)param->paramBuffer)), (*((SaUint64T *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SATIMET :
{
char buf[32];
const time_t time = *((SaTimeT *)param->paramBuffer) / SA_TIME_ONE_SECOND;
ctime_r(&time, buf);
buf[strlen(buf) - 1] = '\0'; /* Remove new line */
printf("%-50s %-12s %llu (0x%llx, %s)\n", param->paramName, "SA_TIME_T",
(*((SaTimeT *)param->paramBuffer)), (*((SaTimeT *)param->paramBuffer)), buf);
}
break;
case SA_IMM_ATTR_SANAMET :
printf("%-50s %-12s %s\n", param->paramName, "SA_NAME_T", saAisNameBorrow((SaNameT*) param->paramBuffer));
break;
case SA_IMM_ATTR_SAFLOATT :
printf("%-50s %-12s %f\n", param->paramName, "SA_FLOAT_T", (*((SaFloatT *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SADOUBLET :
printf("%-50s %-12s %lf\n", param->paramName, "SA_DOUBLE_T", (*((SaDoubleT *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SASTRINGT :
printf("%-50s %-12s %s\n", param->paramName, "SA_STRING_T", (*((SaStringT *)param->paramBuffer)));
break;
case SA_IMM_ATTR_SAANYT :
printf("%-50s %-12s %s\n", param->paramName, "SA_ANY_T", "<Not shown>");
break;
default:
printf("%-50s <%-12s (%d)>\n", param->paramName, "Unknown value type", (int)param->paramType);
exit(EXIT_FAILURE);
}
}
static void print_header(const SaNtfNotificationHeaderT * notificationHeader,
SaNtfSubscriptionIdT subscriptionId,
SaNtfNotificationTypeT notificationType)
{
static char time[32];
if (verbose) {
printf("notificationID = %d\n",
(int)*(notificationHeader->notificationId));
printf("subscriptionId = %u\n", (unsigned int)subscriptionId);
}
/* Event type */
printf("eventType = ");
print_event_type(*notificationHeader->eventType, notificationType);
if (verbose)
printf("notificationObject.length = %zu\n",
strlen(saAisNameBorrow(notificationHeader->notificationObject)));
printf("notificationObject = \"%s\"\n",
saAisNameBorrow(notificationHeader->notificationObject));
if (verbose)
printf("notifyingObject.length = %zu\n",
strlen(saAisNameBorrow(notificationHeader->notifyingObject)));
printf("notifyingObject = \"%s\"\n",
saAisNameBorrow(notificationHeader->notifyingObject));
/* Notification Class ID in compact dot notation */
if (notificationHeader->notificationClassId->vendorId ==
SA_NTF_VENDOR_ID_SAF) {
printf("notificationClassId = SA_NTF_VENDOR_ID_SAF.%s.%u "
"(0x%x)\n",
sa_services_list[notificationHeader->
notificationClassId->majorId],
notificationHeader->notificationClassId->minorId,
notificationHeader->notificationClassId->minorId);
} else {
printf("notificationClassId = %u.%u.%u (0x%x)\n",
notificationHeader->notificationClassId->vendorId,
notificationHeader->notificationClassId->majorId,
notificationHeader->notificationClassId->minorId,
notificationHeader->notificationClassId->minorId);
}
if (verbose) {
time_t time_in_secs = *notificationHeader->eventTime/SA_TIME_ONE_SECOND;
/*Print time in human readable form also .*/
(void)strftime(time, sizeof(time), "%a %b %d %T %Z %Y", localtime(&time_in_secs));
printf("eventTime = %lld (%s)\n",*notificationHeader->eventTime, time);
}
if (verbose)
printf("lengthAdditionalText = %u\n",
notificationHeader->lengthAdditionalText);
if (notificationHeader->lengthAdditionalText > 0)
printf("additionalText = \"%s\"\n",
notificationHeader->additionalText);
}
int main(int argc, char *argv[])
{
int c;
struct option long_options[] = {
{"disable-tryagain", no_argument, 0, 'd'},
{"parameter", required_argument, 0, 'p'},
{"operation-id", required_argument, 0, 'o'},
{"operation-name", required_argument, 0, 'O'},
{"admin-owner", required_argument, 0, 'a'},
{"help", no_argument, 0, 'h'},
{"timeout", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
SaAisErrorT error;
SaImmHandleT immHandle;
SaImmAdminOwnerNameT adminOwnerName = basename(argv[0]);
bool releaseAdmo=true;
bool explicitAdmo=false;
SaImmAdminOwnerHandleT ownerHandle;
SaNameT objectName;
const SaNameT *objectNames[] = { &objectName, NULL };
SaAisErrorT operationReturnValue = -1;
SaImmAdminOperationParamsT_2 *param;
const SaImmAdminOperationParamsT_2 **params;
SaImmAdminOperationParamsT_2 **out_params=NULL;
SaImmAdminOperationIdT operationId = -1;
unsigned long timeoutVal = 60; /* Default timeout value */
int disable_tryagain = false;
int isFirst = 1;
int verbose = 0;
int params_len = 0;
/* Support for long DN */
setenv("SA_ENABLE_EXTENDED_NAMES", "1", 1);
/* osaf_extended_name_init() is added to prevent future safe use of
* osaf_extended_name_* before saImmOmInitialize and saImmOiInitialize */
osaf_extended_name_init();
params = realloc(NULL, sizeof(SaImmAdminOperationParamsT_2 *));
params[0] = NULL;
SaStringT opName = NULL;
while (1) {
c = getopt_long(argc, argv, "dp:o:O:a:t:hv", long_options, NULL);
if (c == -1) /* have all command-line options have been parsed? */
break;
switch (c) {
case 'd':
disable_tryagain = true;
break;
case 'o':
if(operationId != -1) {
fprintf(stderr, "Cannot set admin operation more then once");
exit(EXIT_FAILURE);
}
operationId = strtoll(optarg, (char **)NULL, 10);
if ((operationId == 0) && ((errno == EINVAL) || (errno == ERANGE))) {
fprintf(stderr, "Illegal operation ID\n");
exit(EXIT_FAILURE);
}
break;
case 'O':
if(operationId != -1) {
fprintf(stderr, "Cannot set admin operation more then once");
exit(EXIT_FAILURE);
}
operationId = SA_IMM_PARAM_ADMOP_ID_ESC;
params_len++;
params = realloc(params, (params_len + 1) * sizeof(SaImmAdminOperationParamsT_2 *));
param = malloc(sizeof(SaImmAdminOperationParamsT_2));
params[params_len - 1] = param;
params[params_len] = NULL;
param->paramName = strdup(SA_IMM_PARAM_ADMOP_NAME);
param->paramType = SA_IMM_ATTR_SASTRINGT;
param->paramBuffer = malloc(sizeof(SaStringT));
*((SaStringT *)(param->paramBuffer)) = strdup(optarg);
opName = strdup(optarg);
break;
case 'p':
params_len++;
params = realloc(params, (params_len + 1) * sizeof(SaImmAdminOperationParamsT_2 *));
param = malloc(sizeof(SaImmAdminOperationParamsT_2));
params[params_len - 1] = param;
params[params_len] = NULL;
if (init_param(param, optarg) == -1) {
fprintf(stderr, "Illegal parameter: %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 't':
timeoutVal = strtoll(optarg, (char **)NULL, 10);
if ((timeoutVal == 0) || (errno == EINVAL) || (errno == ERANGE)) {
fprintf(stderr, "Illegal timeout value\n");
exit(EXIT_FAILURE);
}
break;
case 'a':
adminOwnerName = (SaImmAdminOwnerNameT)malloc(strlen(optarg) + 1);
strcpy(adminOwnerName, optarg);
releaseAdmo=false;
explicitAdmo=true;
break;
case 'h':
usage(basename(argv[0]));
exit(EXIT_SUCCESS);
break;
case 'v':
verbose = 1;
break;
default:
fprintf(stderr, "Try '%s --help' for more information\n", argv[0]);
exit(EXIT_FAILURE);
break;
}
}
if (operationId == -1) {
fprintf(stderr, "error - must specify admin operation ID %llx\n", operationId);
exit(EXIT_FAILURE);
}
/* Need at least one object to operate on */
if ((argc - optind) == 0) {
fprintf(stderr, "error - wrong number of arguments\n");
exit(EXIT_FAILURE);
}
signal(SIGALRM, sigalarmh);
(void) alarm(timeoutVal);
immutilWrapperProfile.errorsAreFatal = 0;
immutilWrapperProfile.nTries = disable_tryagain ? 0 : timeoutVal;
immutilWrapperProfile.retryInterval = 1000;
error = immutil_saImmOmInitialize(&immHandle, NULL, &immVersion);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmInitialize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
if((optind < argc) && (!explicitAdmo)) {
saAisNameLend(argv[optind], &objectName);
if(strcmp(saAisNameBorrow(&objectName), OPENSAF_IMM_OBJECT_DN)==0) {
releaseAdmo=false;
adminOwnerName = (SaImmAdminOwnerNameT) malloc(strlen(OPENSAF_IMM_SERVICE_NAME) + 1);
strcpy(adminOwnerName, OPENSAF_IMM_SERVICE_NAME);
printf("[using admin-owner: '%s']\n", adminOwnerName);
}
}
error = immutil_saImmOmAdminOwnerInitialize(immHandle, adminOwnerName, releaseAdmo?SA_TRUE:SA_FALSE, &ownerHandle);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOwnerInitialize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
/* Remaining arguments should be object names on which the admin op should be performed. */
while (optind < argc) {
saAisNameLend(argv[optind], &objectName);
error = immutil_saImmOmAdminOwnerSet(ownerHandle, objectNames, SA_IMM_ONE);
if (error != SA_AIS_OK) {
if (error == SA_AIS_ERR_NOT_EXIST) {
if(strcmp(adminOwnerName, saAisNameBorrow(&objectName))==0) {
/* AdminOwnerName == ImplementerName - Could be direct admin-op on OI */
goto retry;
}
fprintf(stderr, "error - saImmOmAdminOwnerSet - object '%s' does not exist\n",
saAisNameBorrow(&objectName));
}
else
fprintf(stderr, "error - saImmOmAdminOwnerSet FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
retry:
error = immutil_saImmOmAdminOperationInvoke_o2(ownerHandle, &objectName, 0, operationId,
params, &operationReturnValue, SA_TIME_ONE_SECOND * timeoutVal, &out_params);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOperationInvoke_2 FAILED: %s\n",
saf_error(error));
exit(EXIT_FAILURE);
}
if (operationReturnValue != SA_AIS_OK ) {
unsigned int ix = 0;
if ((operationReturnValue == SA_AIS_ERR_TRY_AGAIN) && !disable_tryagain) {
sleep(1);
goto retry;
}
fprintf(stderr, "error - saImmOmAdminOperationInvoke_2 admin-op RETURNED: %s\n",
saf_error(operationReturnValue));
while(out_params && out_params[ix]) {
if(strcmp(out_params[ix]->paramName, SA_IMM_PARAM_ADMOP_ERROR) == 0) {
assert(out_params[ix]->paramType == SA_IMM_ATTR_SASTRINGT);
SaStringT errStr = (*((SaStringT *) out_params[ix]->paramBuffer));
fprintf(stderr, "error-string: %s\n", errStr);
}
++ix;
}
/* After printing error string, print all returned parameters */
if (verbose && out_params && out_params[0]) {
if(!isFirst)
printf("\n");
print_params(argv[optind], out_params);
}
exit(EXIT_FAILURE);
}
if (((opName && (strncmp(opName,"display",7)==0))||verbose) &&out_params && out_params[0]) {
if(!isFirst)
printf("\n");
else
isFirst = 0;
print_params(argv[optind], out_params);
}
error = saImmOmAdminOperationMemoryFree(ownerHandle, out_params);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOperationMemoryFree FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
if(releaseAdmo) {
error = immutil_saImmOmAdminOwnerRelease(ownerHandle, objectNames, SA_IMM_ONE);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOwnerRelease FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
}
optind++;
}
error = immutil_saImmOmAdminOwnerFinalize(ownerHandle);
if (SA_AIS_OK != error) {
fprintf(stderr, "error - saImmOmAdminOwnerFinalize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
error = immutil_saImmOmFinalize(immHandle);
if (SA_AIS_OK != error) {
fprintf(stderr, "error - saImmOmFinalize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
