static void process_timewarn(struct dlm_lock_data *data)
{
struct lockspace *ls;
struct timeval now;
unsigned int sec;
ls = find_ls_id(data->lockspace_id);
if (!ls)
return;
data->resource_name[data->resource_namelen] = '\0';
log_group(ls, "timewarn: lkid %x pid %d name %s",
data->id, data->ownpid, data->resource_name);
/* Problem: we don't want to get a timewarn, assume it's resolved
by the current cycle, but in fact it's from a deadlock that
formed after the checkpoints for the current cycle. Then we'd
have to hope for another warning (that may not come) to trigger
a new cycle to catch the deadlock. If our last cycle ckpt
was say N (~5?) sec before we receive the timewarn, then we
can be confident that the cycle included the lock in question.
Otherwise, we're not sure if the warning is for a new deadlock
that's formed since our last cycle ckpt (unless it's a long
enough time since the last cycle that we're confident it *is*
a new deadlock). When there is a deadlock, I suspect it will
be common to receive warnings before, during, and possibly
after the cycle that resolves it. Wonder if we should record
timewarns and match them with deadlock cycles so we can tell
which timewarns are addressed by a given cycle and which aren't. */
gettimeofday(&now, NULL);
/* don't send a new start until at least SECS after the last
we sent, and at least SECS after the last completed cycle */
sec = now.tv_sec - ls->last_send_cycle_start.tv_sec;
if (sec < DEADLOCK_CHECK_SECS) {
log_group(ls, "skip send: recent send cycle %d sec", sec);
return;
}
sec = now.tv_sec - ls->cycle_end_time.tv_sec;
if (sec < DEADLOCK_CHECK_SECS) {
log_group(ls, "skip send: recent cycle end %d sec", sec);
return;
}
gettimeofday(&ls->last_send_cycle_start, NULL);
if (cfgd_enable_deadlk)
send_cycle_start(ls);
}
/**
* Creates a cloud watch logs subscription filter, based on command line input
*/
int main(int argc, char** argv)
{
if (argc != 5)
{
std::cout << "Usage: " << std::endl << " put_subscription_filter "
<< "<filter_name> <filter_pattern> <log_group_name> " <<
"<lambda_function_arn>" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String filter_name(argv[1]);
Aws::String filter_pattern(argv[2]);
Aws::String log_group(argv[3]);
Aws::String dest_arn(argv[4]);
Aws::CloudWatchLogs::CloudWatchLogsClient cwl;
Aws::CloudWatchLogs::Model::PutSubscriptionFilterRequest request;
request.SetFilterName(filter_name);
request.SetFilterPattern(filter_pattern);
request.SetLogGroupName(log_group);
request.SetDestinationArn(dest_arn);
auto outcome = cwl.PutSubscriptionFilter(request);
if (!outcome.IsSuccess())
{
std::cout << "Failed to create cloudwatch logs subscription filter "
<< filter_name << ": " << outcome.GetError().GetMessage() <<
std::endl;
}
else
{
std::cout << "Successfully created cloudwatch logs subscription " <<
"filter " << filter_name << std::endl;
}
}
Aws::ShutdownAPI(options);
return 0;
}
