more clean but still bug in EE 9.6.2

Vladimir Ershov · Vladimir Ershov · commit 4ab60603d6e3 · 2017-02-20T14:38:08.000+03:00
diff --git a/src/char_array.c b/src/char_array.c
@@ -25,6 +25,7 @@ char_array_t *makeCharArray(void)
 
 char_array_t *sortCharArray(char_array_t *a)
 {
+	if(a->n <= 1) return a;
 	qsort(a->data, a->n, sizeof(char *), __sort_char_string);
 
 	return a;
diff --git a/src/memutils.c b/src/memutils.c
@@ -29,5 +29,6 @@ void *worker_alloc(Size size)
 
 void delete_worker_mem_ctx(void)
 {
+	MemoryContextSwitchTo(TopMemoryContext);
 	MemoryContextDelete(SchedulerWorkerContext);
 }
diff --git a/src/pgpro_scheduler.c b/src/pgpro_scheduler.c
@@ -212,7 +212,7 @@ char_array_t *readBasesToCheck(void)
 	pgstat_report_activity(STATE_RUNNING, "read configuration");
 	result = makeCharArray();
 
-	value = GetConfigOption("schedule.database", 1, 0);
+	value = GetConfigOption("schedule.database", true, false);
 	if(!value || strlen(value) == 0)
 	{
 		return result;
@@ -254,6 +254,7 @@ char_array_t *readBasesToCheck(void)
 	pfree(clean_value);
 	if(names->n == 0)
 	{
+		destroyCharArray(names);
 		return result;
 	}
 
@@ -264,46 +265,39 @@ char_array_t *readBasesToCheck(void)
 		appendStringInfo(&sql, "'%s'", names->data[i]);
 		if(i + 1  != names->n) appendStringInfo(&sql, ",");
 	} 
+	destroyCharArray(names);
 	appendStringInfo(&sql, ")");
-	SetCurrentStatementStartTimestamp();
-	StartTransactionCommand();
-	SPI_connect();
-	PushActiveSnapshot(GetTransactionSnapshot());
+
+	START_SPI_SNAP();
 
 	ret = SPI_execute(sql.data, true, 0);
 	if (ret != SPI_OK_SELECT)
 	{
-		SPI_finish();
-		PopActiveSnapshot();
-		CommitTransactionCommand();
+		STOP_SPI_SNAP();
 		elog(ERROR, "cannot select from pg_database");
 	}
-	destroyCharArray(names);
 	processed  = SPI_processed;
 	if(processed == 0)
 	{
-		SPI_finish();
-		PopActiveSnapshot();
-		CommitTransactionCommand();
+		STOP_SPI_SNAP();
 		return result;
 	}
 	for(i=0; i < processed; i++)
 	{
 		clean_value = SPI_getvalue(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1);
 		pushCharArray(result, clean_value);
 	}
-	SPI_finish();
-	PopActiveSnapshot();
-	CommitTransactionCommand();
+	STOP_SPI_SNAP();
 	sortCharArray(result);
+
 	return result;
 }
 
 void parent_scheduler_main(Datum arg)
 {
 	int rc = 0, i;
 	char_array_t *names = NULL;
-	schd_managers_poll_t *poll;
+	schd_managers_poll_t *pool;
 	schd_manager_share_t *shared;
 	bool refresh = false;
 
@@ -320,10 +314,10 @@ void parent_scheduler_main(Datum arg)
 
 	BackgroundWorkerInitializeConnection("postgres", NULL);
 	names = readBasesToCheck();
-	poll = initSchedulerManagerPool(names);
+	pool = initSchedulerManagerPool(names);
 	destroyCharArray(names);
 
-	set_supervisor_pgstatus(poll);
+	set_supervisor_pgstatus(pool);
 
 	while(!got_sigterm)
 	{
@@ -335,62 +329,62 @@ void parent_scheduler_main(Datum arg)
 			ProcessConfigFile(PGC_SIGHUP);
 			refresh = false;
 			names = NULL;
-			if(is_scheduler_enabled() != poll->enabled)
+			if(is_scheduler_enabled() != pool->enabled)
 			{
-				if(poll->enabled)
+				if(pool->enabled)
 				{
-					poll->enabled = false;
-					stopAllManagers(poll);
-					set_supervisor_pgstatus(poll);
+					pool->enabled = false;
+					stopAllManagers(pool);
+					set_supervisor_pgstatus(pool);
 				}
 				else
 				{
 					refresh = true;
-					poll->enabled = true;
+					pool->enabled = true;
 					names = readBasesToCheck();
 				}
 			}
-			else if(poll->enabled)
+			else if(pool->enabled)
 			{
 				names = readBasesToCheck();
-				if(isBaseListChanged(names, poll)) refresh = true;
+				if(isBaseListChanged(names, pool)) refresh = true;
 				else destroyCharArray(names);
 			}
 
 			if(refresh)
 			{
-				refreshManagers(names, poll);
-				set_supervisor_pgstatus(poll);
+				refreshManagers(names, pool);
+				set_supervisor_pgstatus(pool);
 				destroyCharArray(names);
 			}
 		}
 		else 
 		{
-			for(i=0; i < poll->n; i++)
+			for(i=0; i < pool->n; i++)
 			{
-				shared = dsm_segment_address(poll->workers[i]->shared);
+				shared = dsm_segment_address(pool->workers[i]->shared);
 
 				if(shared->setbychild)
 				{
-				/* elog(LOG, "got status change from: %s", poll->workers[i]->dbname); */
+				/* elog(LOG, "got status change from: %s", pool->workers[i]->dbname); */
 					shared->setbychild = false;
 					if(shared->status == SchdManagerConnected)
 					{
-						poll->workers[i]->connected = true;
+						pool->workers[i]->connected = true;
 					}
 					else if(shared->status == SchdManagerQuit)
 					{
-						removeManagerFromPoll(poll, poll->workers[i]->dbname, 1, true);
-						set_supervisor_pgstatus(poll);
+						removeManagerFromPoll(pool, pool->workers[i]->dbname, 1, true);
+						set_supervisor_pgstatus(pool);
 					}
 					else if(shared->status == SchdManagerDie)
 					{
-						removeManagerFromPoll(poll, poll->workers[i]->dbname, 1, false);
-						set_supervisor_pgstatus(poll);
+						removeManagerFromPoll(pool, pool->workers[i]->dbname, 1, false);
+						set_supervisor_pgstatus(pool);
 					}
 					else
 					{
-						elog(WARNING, "manager: %s set strange status: %d", poll->workers[i]->dbname, shared->status);
+						elog(WARNING, "manager: %s set strange status: %d", pool->workers[i]->dbname, shared->status);
 					}
 				}
 			}
@@ -400,7 +394,7 @@ void parent_scheduler_main(Datum arg)
 		CHECK_FOR_INTERRUPTS();
 		ResetLatch(MyLatch);
 	}
-	stopAllManagers(poll);
+	stopAllManagers(pool);
 	delete_worker_mem_ctx();
 
 	proc_exit(0);
diff --git a/src/sched_manager_poll.c b/src/sched_manager_poll.c
@@ -297,14 +297,8 @@ int addManagerToPoll(schd_managers_poll_t *poll, char *name, int sort)
 	schd_manager_t *man;
 	schd_manager_share_t *shm_data;
 	Size segsize;
-/*	shm_toc_estimator e;
-	shm_toc *toc; */
 	dsm_segment *seg;
 
-/*	shm_toc_initialize_estimator(&e);
-	shm_toc_estimate_chunk(&e, sizeof(schd_manager_share_t));
-	shm_toc_estimate_keys(&e, 1);
-	segsize = shm_toc_estimate(&e); */
 	segsize = (Size)sizeof(schd_manager_share_t);
 
 	CurrentResourceOwner = ResourceOwnerCreate(NULL, "pgpro_scheduler");
@@ -315,11 +309,6 @@ int addManagerToPoll(schd_managers_poll_t *poll, char *name, int sort)
 	man->connected = false;
 	memcpy(man->dbname, name, strlen(name) + 1);
 	man->shared = seg;
-/*	toc = shm_toc_create(PGPRO_SHM_TOC_MAGIC, dsm_segment_address(man->shared),
-	                         segsize);
-
-	shm_data = shm_toc_allocate(toc, sizeof(schd_manager_share_t));
-	shm_toc_insert(toc, 0, shm_data); */
 	shm_data = dsm_segment_address(man->shared);
 
 	shm_data->setbyparent = true;
diff --git a/src/scheduler_executor.c b/src/scheduler_executor.c
@@ -108,7 +108,6 @@ void executor_worker_main(Datum arg)
 	BackgroundWorkerUnblockSignals();
 
 	init_worker_mem_ctx("ExecutorMemoryContext");
-	switch_to_worker_context();
 	worker_jobs_limit = read_worker_job_limit();
 
 	while(1)
@@ -626,15 +625,15 @@ void at_executor_worker_main(Datum arg)
 	if(seg == NULL)
 		ereport(ERROR,
 			(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-			 errmsg("executor unable to map dynamic shared memory segment")));
+			 errmsg("at-executor unable to map dynamic shared memory segment")));
 	shared = dsm_segment_address(seg);
 	/* parent = BackendPidGetProc(MyBgworkerEntry->bgw_notify_pid); */
 
 	if(shared->status != SchdExecutorInit)
 	{
 		ereport(ERROR,
 			(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-			 errmsg("executor corrupted dynamic shared memory segment")));
+			 errmsg("at-executor corrupted dynamic shared memory segment")));
 	}
 	shared->start_at = GetCurrentTimestamp();
 
@@ -647,7 +646,6 @@ void at_executor_worker_main(Datum arg)
 	BackgroundWorkerUnblockSignals();
 
 	init_worker_mem_ctx("ExecutorMemoryContext");
-	switch_to_worker_context();
 
 	while(1)
 	{
@@ -730,6 +728,7 @@ int process_one_job(schd_executor_share_state_t *shared, schd_executor_status_t
 		return -1;
 	} */
 	STOP_SPI_SNAP(); /* Commit changes */
+	elog(LOG, "JOB MOVED TO PROCESSED");
 	pgstat_report_activity(STATE_RUNNING, "job initialized");
 	START_SPI_SNAP();
 
@@ -753,6 +752,7 @@ int process_one_job(schd_executor_share_state_t *shared, schd_executor_status_t
 			return -1;
 		}
 		STOP_SPI_SNAP();
+	elog(LOG, "JOB MOVED TO DONE");
 		return 1;
 	}
 
diff --git a/src/scheduler_manager.c b/src/scheduler_manager.c
@@ -58,15 +58,14 @@ int checkSchedulerNamespace(void)
 
 	schema = GetConfigOption("schedule.schema", false, true);
 
-	StartTransactionCommand();
-	SPI_connect();
-	PushActiveSnapshot(GetTransactionSnapshot());
+	START_SPI_SNAP(); 
 
 	values[0] = CStringGetTextDatum(schema);
 	count = select_count_with_args(sql, 1, argtypes, values, NULL);
 
 	if(count == -1)
 	{
+		STOP_SPI_SNAP();
 		elog(ERROR, "Scheduler manager: %s: cannot check namespace: sql error",
 													MyBgworkerEntry->bgw_name); 
 	}
@@ -82,13 +81,12 @@ int checkSchedulerNamespace(void)
 	}
 	else if(count != 1)
 	{
+		STOP_SPI_SNAP();
 		elog(ERROR, "Scheduler manager: %s: cannot check namespace: "
 					"unknown error %d", MyBgworkerEntry->bgw_name, count); 
 	}
+	STOP_SPI_SNAP();
 
-	SPI_finish();
-	PopActiveSnapshot();
-	CommitTransactionCommand();
 	if(count) {
 		SetConfigOption("search_path", schema, PGC_USERSET, PGC_S_SESSION);
 	}
@@ -1762,7 +1760,7 @@ void manager_worker_main(Datum arg)
 			{
 				got_sighup = false;
 				ProcessConfigFile(PGC_SIGHUP);
-				reload_db_role_config(database);
+				reload_db_role_config(database); 
 				refresh_scheduler_manager_context(ctx);
 				set_slots_stat_report(ctx);
 			}

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ char_array_t *makeCharArray(void)`
`25`	`25`
`26`	`26`	`char_array_t sortCharArray(char_array_t a)`
`27`	`27`	`{`
	`28`	`+ if(a->n <= 1) return a;`
`28`	`29`	`qsort(a->data, a->n, sizeof(char *), __sort_char_string);`
`29`	`30`
`30`	`31`	`return a;`
Original file line number	Diff line number	Diff line change
`@@ -29,5 +29,6 @@ void *worker_alloc(Size size)`
`29`	`29`
`30`	`30`	`void delete_worker_mem_ctx(void)`
`31`	`31`	`{`
	`32`	`+ MemoryContextSwitchTo(TopMemoryContext);`
`32`	`33`	`MemoryContextDelete(SchedulerWorkerContext);`
`33`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -212,7 +212,7 @@ char_array_t *readBasesToCheck(void)`
`212`	`212`	`pgstat_report_activity(STATE_RUNNING, "read configuration");`
`213`	`213`	`result = makeCharArray();`
`214`	`214`
`215`		`- value = GetConfigOption("schedule.database", 1, 0);`
	`215`	`+ value = GetConfigOption("schedule.database", true, false);`
`216`	`216`	`if(!value \|\| strlen(value) == 0)`
`217`	`217`	`{`
`218`	`218`	`return result;`
`@@ -254,6 +254,7 @@ char_array_t *readBasesToCheck(void)`
`254`	`254`	`pfree(clean_value);`
`255`	`255`	`if(names->n == 0)`
`256`	`256`	`{`
	`257`	`+ destroyCharArray(names);`
`257`	`258`	`return result;`
`258`	`259`	`}`
`259`	`260`
`@@ -264,46 +265,39 @@ char_array_t *readBasesToCheck(void)`
`264`	`265`	`appendStringInfo(&sql, "'%s'", names->data[i]);`
`265`	`266`	`if(i + 1 != names->n) appendStringInfo(&sql, ",");`
`266`	`267`	`}`
	`268`	`+ destroyCharArray(names);`
`267`	`269`	`appendStringInfo(&sql, ")");`
`268`		`- SetCurrentStatementStartTimestamp();`
`269`		`- StartTransactionCommand();`
`270`		`- SPI_connect();`
`271`		`- PushActiveSnapshot(GetTransactionSnapshot());`
	`270`	`+`
	`271`	`+ START_SPI_SNAP();`
`272`	`272`
`273`	`273`	`ret = SPI_execute(sql.data, true, 0);`
`274`	`274`	`if (ret != SPI_OK_SELECT)`
`275`	`275`	`{`
`276`		`- SPI_finish();`
`277`		`- PopActiveSnapshot();`
`278`		`- CommitTransactionCommand();`
	`276`	`+ STOP_SPI_SNAP();`
`279`	`277`	`elog(ERROR, "cannot select from pg_database");`
`280`	`278`	`}`
`281`		`- destroyCharArray(names);`
`282`	`279`	`processed = SPI_processed;`
`283`	`280`	`if(processed == 0)`
`284`	`281`	`{`
`285`		`- SPI_finish();`
`286`		`- PopActiveSnapshot();`
`287`		`- CommitTransactionCommand();`
	`282`	`+ STOP_SPI_SNAP();`
`288`	`283`	`return result;`
`289`	`284`	`}`
`290`	`285`	`for(i=0; i < processed; i++)`
`291`	`286`	`{`
`292`	`287`	`clean_value = SPI_getvalue(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1);`
`293`	`288`	`pushCharArray(result, clean_value);`
`294`	`289`	`}`
`295`		`- SPI_finish();`
`296`		`- PopActiveSnapshot();`
`297`		`- CommitTransactionCommand();`
	`290`	`+ STOP_SPI_SNAP();`
`298`	`291`	`sortCharArray(result);`
	`292`	`+`
`299`	`293`	`return result;`
`300`	`294`	`}`
`301`	`295`
`302`	`296`	`void parent_scheduler_main(Datum arg)`
`303`	`297`	`{`
`304`	`298`	`int rc = 0, i;`
`305`	`299`	`char_array_t *names = NULL;`
`306`		`- schd_managers_poll_t *poll;`
	`300`	`+ schd_managers_poll_t *pool;`
`307`	`301`	`schd_manager_share_t *shared;`
`308`	`302`	`bool refresh = false;`
`309`	`303`
`@@ -320,10 +314,10 @@ void parent_scheduler_main(Datum arg)`
`320`	`314`
`321`	`315`	`BackgroundWorkerInitializeConnection("postgres", NULL);`
`322`	`316`	`names = readBasesToCheck();`
`323`		`- poll = initSchedulerManagerPool(names);`
	`317`	`+ pool = initSchedulerManagerPool(names);`
`324`	`318`	`destroyCharArray(names);`
`325`	`319`
`326`		`- set_supervisor_pgstatus(poll);`
	`320`	`+ set_supervisor_pgstatus(pool);`
`327`	`321`
`328`	`322`	`while(!got_sigterm)`
`329`	`323`	`{`
`@@ -335,62 +329,62 @@ void parent_scheduler_main(Datum arg)`
`335`	`329`	`ProcessConfigFile(PGC_SIGHUP);`
`336`	`330`	`refresh = false;`
`337`	`331`	`names = NULL;`
`338`		`- if(is_scheduler_enabled() != poll->enabled)`
	`332`	`+ if(is_scheduler_enabled() != pool->enabled)`
`339`	`333`	`{`
`340`		`- if(poll->enabled)`
	`334`	`+ if(pool->enabled)`
`341`	`335`	`{`
`342`		`- poll->enabled = false;`
`343`		`- stopAllManagers(poll);`
`344`		`- set_supervisor_pgstatus(poll);`
	`336`	`+ pool->enabled = false;`
	`337`	`+ stopAllManagers(pool);`
	`338`	`+ set_supervisor_pgstatus(pool);`
`345`	`339`	`}`
`346`	`340`	`else`
`347`	`341`	`{`
`348`	`342`	`refresh = true;`
`349`		`- poll->enabled = true;`
	`343`	`+ pool->enabled = true;`
`350`	`344`	`names = readBasesToCheck();`
`351`	`345`	`}`
`352`	`346`	`}`
`353`		`- else if(poll->enabled)`
	`347`	`+ else if(pool->enabled)`
`354`	`348`	`{`
`355`	`349`	`names = readBasesToCheck();`
`356`		`- if(isBaseListChanged(names, poll)) refresh = true;`
	`350`	`+ if(isBaseListChanged(names, pool)) refresh = true;`
`357`	`351`	`else destroyCharArray(names);`
`358`	`352`	`}`
`359`	`353`
`360`	`354`	`if(refresh)`
`361`	`355`	`{`
`362`		`- refreshManagers(names, poll);`
`363`		`- set_supervisor_pgstatus(poll);`
	`356`	`+ refreshManagers(names, pool);`
	`357`	`+ set_supervisor_pgstatus(pool);`
`364`	`358`	`destroyCharArray(names);`
`365`	`359`	`}`
`366`	`360`	`}`
`367`	`361`	`else`
`368`	`362`	`{`
`369`		`- for(i=0; i < poll->n; i++)`
	`363`	`+ for(i=0; i < pool->n; i++)`
`370`	`364`	`{`
`371`		`- shared = dsm_segment_address(poll->workers[i]->shared);`
	`365`	`+ shared = dsm_segment_address(pool->workers[i]->shared);`
`372`	`366`
`373`	`367`	`if(shared->setbychild)`
`374`	`368`	`{`
`375`		`- /* elog(LOG, "got status change from: %s", poll->workers[i]->dbname); */`
	`369`	`+ /* elog(LOG, "got status change from: %s", pool->workers[i]->dbname); */`
`376`	`370`	`shared->setbychild = false;`
`377`	`371`	`if(shared->status == SchdManagerConnected)`
`378`	`372`	`{`
`379`		`- poll->workers[i]->connected = true;`
	`373`	`+ pool->workers[i]->connected = true;`
`380`	`374`	`}`
`381`	`375`	`else if(shared->status == SchdManagerQuit)`
`382`	`376`	`{`
`383`		`- removeManagerFromPoll(poll, poll->workers[i]->dbname, 1, true);`
`384`		`- set_supervisor_pgstatus(poll);`
	`377`	`+ removeManagerFromPoll(pool, pool->workers[i]->dbname, 1, true);`
	`378`	`+ set_supervisor_pgstatus(pool);`
`385`	`379`	`}`
`386`	`380`	`else if(shared->status == SchdManagerDie)`
`387`	`381`	`{`
`388`		`- removeManagerFromPoll(poll, poll->workers[i]->dbname, 1, false);`
`389`		`- set_supervisor_pgstatus(poll);`
	`382`	`+ removeManagerFromPoll(pool, pool->workers[i]->dbname, 1, false);`
	`383`	`+ set_supervisor_pgstatus(pool);`
`390`	`384`	`}`
`391`	`385`	`else`
`392`	`386`	`{`
`393`		`- elog(WARNING, "manager: %s set strange status: %d", poll->workers[i]->dbname, shared->status);`
	`387`	`+ elog(WARNING, "manager: %s set strange status: %d", pool->workers[i]->dbname, shared->status);`
`394`	`388`	`}`
`395`	`389`	`}`
`396`	`390`	`}`
`@@ -400,7 +394,7 @@ void parent_scheduler_main(Datum arg)`
`400`	`394`	`CHECK_FOR_INTERRUPTS();`
`401`	`395`	`ResetLatch(MyLatch);`
`402`	`396`	`}`
`403`		`- stopAllManagers(poll);`
	`397`	`+ stopAllManagers(pool);`
`404`	`398`	`delete_worker_mem_ctx();`
`405`	`399`
`406`	`400`	`proc_exit(0);`
Original file line number	Diff line number	Diff line change
`@@ -58,15 +58,14 @@ int checkSchedulerNamespace(void)`
`58`	`58`
`59`	`59`	`schema = GetConfigOption("schedule.schema", false, true);`
`60`	`60`
`61`		`- StartTransactionCommand();`
`62`		`- SPI_connect();`
`63`		`- PushActiveSnapshot(GetTransactionSnapshot());`
	`61`	`+ START_SPI_SNAP();`
`64`	`62`
`65`	`63`	`values[0] = CStringGetTextDatum(schema);`
`66`	`64`	`count = select_count_with_args(sql, 1, argtypes, values, NULL);`
`67`	`65`
`68`	`66`	`if(count == -1)`
`69`	`67`	`{`
	`68`	`+ STOP_SPI_SNAP();`
`70`	`69`	`elog(ERROR, "Scheduler manager: %s: cannot check namespace: sql error",`
`71`	`70`	`MyBgworkerEntry->bgw_name);`
`72`	`71`	`}`
`@@ -82,13 +81,12 @@ int checkSchedulerNamespace(void)`
`82`	`81`	`}`
`83`	`82`	`else if(count != 1)`
`84`	`83`	`{`
	`84`	`+ STOP_SPI_SNAP();`
`85`	`85`	`elog(ERROR, "Scheduler manager: %s: cannot check namespace: "`
`86`	`86`	`"unknown error %d", MyBgworkerEntry->bgw_name, count);`
`87`	`87`	`}`
	`88`	`+ STOP_SPI_SNAP();`
`88`	`89`
`89`		`- SPI_finish();`
`90`		`- PopActiveSnapshot();`
`91`		`- CommitTransactionCommand();`
`92`	`90`	`if(count) {`
`93`	`91`	`SetConfigOption("search_path", schema, PGC_USERSET, PGC_S_SESSION);`
`94`	`92`	`}`
`@@ -1762,7 +1760,7 @@ void manager_worker_main(Datum arg)`
`1762`	`1760`	`{`
`1763`	`1761`	`got_sighup = false;`
`1764`	`1762`	`ProcessConfigFile(PGC_SIGHUP);`
`1765`		`- reload_db_role_config(database);`
	`1763`	`+ reload_db_role_config(database);`
`1766`	`1764`	`refresh_scheduler_manager_context(ctx);`
`1767`	`1765`	`set_slots_stat_report(ctx);`
`1768`	`1766`	`}`