static PyObject *pyAssertState(PyObject *self, PyObject *args) {
void *handle;
char *state;
if (!PyArg_ParseTuple(args, "ls", &handle, &state)) {
PyErr_SetString(RulesError, "pyAssertState Invalid argument");
return NULL;
}
unsigned int result = assertState(handle, state);
if (result == RULES_OK) {
return Py_BuildValue("i", 1);
} else if (result == ERR_EVENT_NOT_HANDLED) {
return Py_BuildValue("i", 0);
} else {
if (result == ERR_OUT_OF_MEMORY) {
PyErr_NoMemory();
} else {
char *message;
if (asprintf(&message, "Could not assert state, error code: %d", result)) {
PyErr_NoMemory();
} else {
PyErr_SetString(RulesError, message);
free(message);
}
}
return NULL;
}
}
void ThreadStatus::initializeQuery()
{
assertState({ThreadState::DetachedFromQuery}, __PRETTY_FUNCTION__);
thread_group = std::make_shared<ThreadGroupStatus>();
performance_counters.setParent(&thread_group->performance_counters);
memory_tracker.setParent(&thread_group->memory_tracker);
thread_group->memory_tracker.setDescription("(for query)");
thread_group->thread_numbers.emplace_back(thread_number);
thread_group->master_thread_number = thread_number;
thread_group->master_thread_os_id = os_thread_id;
initPerformanceCounters();
thread_state = ThreadState::AttachedToQuery;
}
static VALUE rbAssertState(VALUE self, VALUE handle, VALUE state) {
Check_Type(handle, T_FIXNUM);
Check_Type(state, T_STRING);
unsigned int result = assertState((void *)FIX2LONG(handle), RSTRING_PTR(state));
if (result == RULES_OK) {
return INT2FIX(1);
} else if (result == ERR_EVENT_NOT_HANDLED) {
return INT2FIX(0);
} else {
if (result == ERR_OUT_OF_MEMORY) {
rb_raise(rb_eNoMemError, "Out of memory");
} else {
rb_raise(rb_eException, "Could not assert event, error code: %d", result);
}
}
return Qnil;
}
void ThreadStatus::detachQuery(bool exit_if_already_detached, bool thread_exits)
{
if (exit_if_already_detached && thread_state == ThreadState::DetachedFromQuery)
{
thread_state = thread_exits ? ThreadState::Died : ThreadState::DetachedFromQuery;
return;
}
assertState({ThreadState::AttachedToQuery}, __PRETTY_FUNCTION__);
finalizePerformanceCounters();
/// Detach from thread group
performance_counters.setParent(&ProfileEvents::global_counters);
memory_tracker.reset();
/// Must reset pointer to thread_group's memory_tracker, because it will be destroyed two lines below.
memory_tracker.setParent(nullptr);
query_context = nullptr;
thread_group.reset();
thread_state = thread_exits ? ThreadState::Died : ThreadState::DetachedFromQuery;
}
void ThreadStatus::attachQuery(const ThreadGroupStatusPtr & thread_group_, bool check_detached)
{
if (thread_state == ThreadState::AttachedToQuery)
{
if (check_detached)
throw Exception("Can't attach query to the thread, it is already attached", ErrorCodes::LOGICAL_ERROR);
return;
}
assertState({ThreadState::DetachedFromQuery}, __PRETTY_FUNCTION__);
if (!thread_group_)
throw Exception("Attempt to attach to nullptr thread group", ErrorCodes::LOGICAL_ERROR);
/// Attach current thread to thread group and copy useful information from it
thread_group = thread_group_;
performance_counters.setParent(&thread_group->performance_counters);
memory_tracker.setParent(&thread_group->memory_tracker);
{
std::lock_guard lock(thread_group->mutex);
logs_queue_ptr = thread_group->logs_queue_ptr;
query_context = thread_group->query_context;
if (!global_context)
global_context = thread_group->global_context;
/// NOTE: A thread may be attached multiple times if it is reused from a thread pool.
thread_group->thread_numbers.emplace_back(thread_number);
}
initPerformanceCounters();
thread_state = ThreadState::AttachedToQuery;
}
void SshRemoteProcessRunnerPrivate::assertState(State allowedState,
const char *func)
{
assertState(QList<State>() << allowedState, func);
}
