Bairan.Zhang/AI_Printer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(printer): remove controller legacy and unify printer naming

Browse Source
This commit is contained in:
admin
2026-03-01 14:06:38 +08:00
parent e694a85997
commit 57adabaa3f
16 changed files with 111 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/control_plane/CMakeLists.txt
View File

@@ -1,6 +1,6 @@
idf_component_register(
SRCS
"src/controller_lifecycle.c"
"src/control_plane_lifecycle.c"
INCLUDE_DIRS
"include"
PRIV_INCLUDE_DIRS

24
components/control_plane/include/control_plane.h
View File

@@ -9,25 +9,25 @@ extern "C" {
#endif
typedef enum {
CONTROLLER_LIFECYCLE_STATE_STOPPED = 0,
CONTROLLER_LIFECYCLE_STATE_STARTING,
CONTROLLER_LIFECYCLE_STATE_RUNNING,
CONTROLLER_LIFECYCLE_STATE_DEGRADED,
CONTROLLER_LIFECYCLE_STATE_STOPPING,
} controller_lifecycle_state_t;
CONTROL_PLANE_LIFECYCLE_STATE_STOPPED = 0,
CONTROL_PLANE_LIFECYCLE_STATE_STARTING,
CONTROL_PLANE_LIFECYCLE_STATE_RUNNING,
CONTROL_PLANE_LIFECYCLE_STATE_DEGRADED,
CONTROL_PLANE_LIFECYCLE_STATE_STOPPING,
} control_plane_lifecycle_state_t;
typedef struct {
controller_lifecycle_state_t state;
control_plane_lifecycle_state_t state;
esp_err_t last_error;
uint32_t start_attempt;
int64_t last_transition_ms;
char last_stage[32];
} controller_lifecycle_status_t;
} control_plane_lifecycle_status_t;
esp_err_t controller_lifecycle_start(void);
esp_err_t controller_lifecycle_stop(void);
void controller_lifecycle_get_status(controller_lifecycle_status_t *out_status);
const char *controller_lifecycle_state_str(controller_lifecycle_state_t state);
esp_err_t control_plane_lifecycle_start(void);
esp_err_t control_plane_lifecycle_stop(void);
void control_plane_lifecycle_get_status(control_plane_lifecycle_status_t *out_status);
const char *control_plane_lifecycle_state_str(control_plane_lifecycle_state_t state);
#ifdef __cplusplus
}

60
components/control_plane/src/controller_lifecycle.c → components/control_plane/src/control_plane_lifecycle.c
View File

@@ -9,10 +9,10 @@
#include "freertos/semphr.h"
#include "freertos/task.h"
static const char *TAG = "controller_lifecycle";
static const char *TAG = "control_plane_lifecycle";
static SemaphoreHandle_t s_lock;
static controller_lifecycle_status_t s_status = {
.state = CONTROLLER_LIFECYCLE_STATE_STOPPED,
static control_plane_lifecycle_status_t s_status = {
.state = CONTROL_PLANE_LIFECYCLE_STATE_STOPPED,
.last_error = ESP_OK,
.start_attempt = 0,
.last_transition_ms = 0,
@@ -30,7 +30,7 @@ static bool lifecycle_lock_take(uint32_t timeout_ms) {
return s_lock != NULL && xSemaphoreTake(s_lock, pdMS_TO_TICKS(timeout_ms)) == pdTRUE;
}
static void lifecycle_set_state_locked(controller_lifecycle_state_t state,
static void lifecycle_set_state_locked(control_plane_lifecycle_state_t state,
esp_err_t last_error,
const char *stage) {
s_status.state = state;
@@ -40,17 +40,17 @@ static void lifecycle_set_state_locked(controller_lifecycle_state_t state,
domain_diag_set_gauge(DOMAIN_DIAG_GAUGE_LIFECYCLE_STATE, (int32_t)state);
}
const char *controller_lifecycle_state_str(controller_lifecycle_state_t state) {
const char *control_plane_lifecycle_state_str(control_plane_lifecycle_state_t state) {
switch (state) {
case CONTROLLER_LIFECYCLE_STATE_STOPPED:
case CONTROL_PLANE_LIFECYCLE_STATE_STOPPED:
return "stopped";
case CONTROLLER_LIFECYCLE_STATE_STARTING:
case CONTROL_PLANE_LIFECYCLE_STATE_STARTING:
return "starting";
case CONTROLLER_LIFECYCLE_STATE_RUNNING:
case CONTROL_PLANE_LIFECYCLE_STATE_RUNNING:
return "running";
case CONTROLLER_LIFECYCLE_STATE_DEGRADED:
case CONTROL_PLANE_LIFECYCLE_STATE_DEGRADED:
return "degraded";
case CONTROLLER_LIFECYCLE_STATE_STOPPING:
case CONTROL_PLANE_LIFECYCLE_STATE_STOPPING:
return "stopping";
default:
return "unknown";
@@ -124,7 +124,7 @@ static esp_err_t lifecycle_run_step_with_retry(const char *stage, lifecycle_step
return ESP_FAIL;
}
esp_err_t controller_lifecycle_start(void) {
esp_err_t control_plane_lifecycle_start(void) {
domain_diag_counter_add(DOMAIN_DIAG_COUNTER_LIFECYCLE_START_ATTEMPT, 1);
if (!lifecycle_lock_take(1000)) {
@@ -133,18 +133,18 @@ esp_err_t controller_lifecycle_start(void) {
return ESP_ERR_TIMEOUT;
}
if (s_status.state == CONTROLLER_LIFECYCLE_STATE_RUNNING) {
if (s_status.state == CONTROL_PLANE_LIFECYCLE_STATE_RUNNING) {
xSemaphoreGive(s_lock);
return ESP_OK;
}
if (s_status.state == CONTROLLER_LIFECYCLE_STATE_STARTING ||
s_status.state == CONTROLLER_LIFECYCLE_STATE_STOPPING) {
if (s_status.state == CONTROL_PLANE_LIFECYCLE_STATE_STARTING ||
s_status.state == CONTROL_PLANE_LIFECYCLE_STATE_STOPPING) {
xSemaphoreGive(s_lock);
return ESP_ERR_INVALID_STATE;
}
s_status.start_attempt++;
lifecycle_set_state_locked(CONTROLLER_LIFECYCLE_STATE_STARTING, ESP_OK, "bootstrap");
lifecycle_set_state_locked(CONTROL_PLANE_LIFECYCLE_STATE_STARTING, ESP_OK, "bootstrap");
xSemaphoreGive(s_lock);
bool system_started = false;
@@ -176,12 +176,12 @@ esp_err_t controller_lifecycle_start(void) {
image_generation_schedule_prewarm();
if (lifecycle_lock_take(1000)) {
lifecycle_set_state_locked(CONTROLLER_LIFECYCLE_STATE_RUNNING, ESP_OK, "running");
lifecycle_set_state_locked(CONTROL_PLANE_LIFECYCLE_STATE_RUNNING, ESP_OK, "running");
xSemaphoreGive(s_lock);
}
domain_diag_counter_add(DOMAIN_DIAG_COUNTER_LIFECYCLE_START_SUCCESS, 1);
ESP_LOGI(TAG, "controller lifecycle started");
ESP_LOGI(TAG, "control-plane lifecycle started");
return ESP_OK;
start_failed:
@@ -196,20 +196,20 @@ start_failed:
}
if (lifecycle_lock_take(1000)) {
lifecycle_set_state_locked(CONTROLLER_LIFECYCLE_STATE_DEGRADED, rc, failed_stage);
lifecycle_set_state_locked(CONTROL_PLANE_LIFECYCLE_STATE_DEGRADED, rc, failed_stage);
xSemaphoreGive(s_lock);
}
domain_diag_counter_add(DOMAIN_DIAG_COUNTER_LIFECYCLE_START_FAILED, 1);
domain_diag_record_error("lifecycle_start", rc, failed_stage);
ESP_LOGE(TAG,
"controller lifecycle start failed at stage=%s, rc=0x%x",
"control-plane lifecycle start failed at stage=%s, rc=0x%x",
failed_stage,
(unsigned)rc);
return rc;
}
esp_err_t controller_lifecycle_stop(void) {
esp_err_t control_plane_lifecycle_stop(void) {
domain_diag_counter_add(DOMAIN_DIAG_COUNTER_LIFECYCLE_STOP_ATTEMPT, 1);
if (!lifecycle_lock_take(1000)) {
@@ -218,17 +218,17 @@ esp_err_t controller_lifecycle_stop(void) {
return ESP_ERR_TIMEOUT;
}
if (s_status.state == CONTROLLER_LIFECYCLE_STATE_STOPPED) {
if (s_status.state == CONTROL_PLANE_LIFECYCLE_STATE_STOPPED) {
xSemaphoreGive(s_lock);
return ESP_OK;
}
if (s_status.state == CONTROLLER_LIFECYCLE_STATE_STARTING ||
s_status.state == CONTROLLER_LIFECYCLE_STATE_STOPPING) {
if (s_status.state == CONTROL_PLANE_LIFECYCLE_STATE_STARTING ||
s_status.state == CONTROL_PLANE_LIFECYCLE_STATE_STOPPING) {
xSemaphoreGive(s_lock);
return ESP_ERR_INVALID_STATE;
}
lifecycle_set_state_locked(CONTROLLER_LIFECYCLE_STATE_STOPPING, ESP_OK, "stopping");
lifecycle_set_state_locked(CONTROL_PLANE_LIFECYCLE_STATE_STOPPING, ESP_OK, "stopping");
xSemaphoreGive(s_lock);
esp_err_t first_err = ESP_OK;
@@ -250,26 +250,26 @@ esp_err_t controller_lifecycle_stop(void) {
if (lifecycle_lock_take(1000)) {
if (first_err == ESP_OK) {
lifecycle_set_state_locked(CONTROLLER_LIFECYCLE_STATE_STOPPED, ESP_OK, "stopped");
lifecycle_set_state_locked(CONTROL_PLANE_LIFECYCLE_STATE_STOPPED, ESP_OK, "stopped");
} else {
lifecycle_set_state_locked(CONTROLLER_LIFECYCLE_STATE_DEGRADED, first_err, "stop_failed");
lifecycle_set_state_locked(CONTROL_PLANE_LIFECYCLE_STATE_DEGRADED, first_err, "stop_failed");
}
xSemaphoreGive(s_lock);
}
if (first_err == ESP_OK) {
domain_diag_counter_add(DOMAIN_DIAG_COUNTER_LIFECYCLE_STOP_SUCCESS, 1);
ESP_LOGI(TAG, "controller lifecycle stopped");
ESP_LOGI(TAG, "control-plane lifecycle stopped");
} else {
domain_diag_counter_add(DOMAIN_DIAG_COUNTER_LIFECYCLE_STOP_FAILED, 1);
domain_diag_record_error("lifecycle_stop", first_err, "controller stop failed");
ESP_LOGE(TAG, "controller lifecycle stop failed, rc=0x%x", (unsigned)first_err);
domain_diag_record_error("lifecycle_stop", first_err, "control-plane stop failed");
ESP_LOGE(TAG, "control-plane lifecycle stop failed, rc=0x%x", (unsigned)first_err);
}
return first_err;
}
void controller_lifecycle_get_status(controller_lifecycle_status_t *out_status) {
void control_plane_lifecycle_get_status(control_plane_lifecycle_status_t *out_status) {
if (out_status == NULL) {
return;
}