IGNORE ME: debug iscp restart

pkg/bootstrap/service.go

@@ -99,6 +99,9 @@ func init() {
 	}
 	initSQLs = append(initSQLs, sql)
 
+	sql = predefine.GenInitISCPTaskSQL()
+	initSQLs = append(initSQLs, sql)
+
 	initSQLs = append(initSQLs, trace.InitSQLs...)
 
 	initSQLs = append(initSQLs, shardservice.InitSQLs...)

pkg/bootstrap/upgrade.go

@@ -26,6 +26,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v2_1_0"
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v2_2_0"
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v3_0_0"
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v4_0_0"
 )
 
 // initUpgrade all versions need create a upgrade handle in pkg/bootstrap/versions
@@ -45,6 +46,7 @@ func (s *service) initUpgrade() {
 	s.handles = append(s.handles, v2_1_0.Handler)
 	s.handles = append(s.handles, v2_2_0.Handler)
 	s.handles = append(s.handles, v3_0_0.Handler)
+	s.handles = append(s.handles, v4_0_0.Handler)
 }
 
 func (s *service) getFinalVersionHandle() VersionHandle {

pkg/bootstrap/versions/v4_0_0/cluster_upgreade_list.go

@@ -0,0 +1,36 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+	"github.com/matrixorigin/matrixone/pkg/catalog"
+	"github.com/matrixorigin/matrixone/pkg/predefine"
+	"github.com/matrixorigin/matrixone/pkg/util/executor"
+)
+
+var clusterUpgEntries = []versions.UpgradeEntry{
+	upg_mo_iscp_task,
+}
+var upg_mo_iscp_task = versions.UpgradeEntry{
+	Schema:    catalog.MOTaskDB,
+	TableName: catalog.MOSysDaemonTask,
+	UpgType:   versions.CREATE_NEW_TABLE,
+	UpgSql:    predefine.GenInitISCPTaskSQL(),
+	CheckFunc: func(txn executor.TxnExecutor, accountId uint32) (bool, error) {
+		ok, err := versions.CheckTableDataExist(txn, accountId, predefine.GenISCPTaskCheckSQL())
+		return ok, err
+	},
+}

pkg/bootstrap/versions/v4_0_0/log.go

@@ -0,0 +1,24 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/common/log"
+	"github.com/matrixorigin/matrixone/pkg/common/runtime"
+)
+
+func getLogger(sid string) *log.MOLogger {
+	return runtime.ServiceRuntime(sid).Logger()
+}

pkg/bootstrap/versions/v4_0_0/tenant_upgrade_list.go

@@ -0,0 +1,19 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import "github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+
+var tenantUpgEntries = []versions.UpgradeEntry{}

pkg/bootstrap/versions/v4_0_0/upgrade.go

@@ -0,0 +1,125 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"context"
+	"github.com/matrixorigin/matrixone/pkg/logutil"
+	"time"
+
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+	"github.com/matrixorigin/matrixone/pkg/catalog"
+	"github.com/matrixorigin/matrixone/pkg/common/moerr"
+	"github.com/matrixorigin/matrixone/pkg/util/executor"
+	"go.uber.org/zap"
+)
+
+var (
+	Handler = &versionHandle{
+		metadata: versions.Version{
+			Version:           "4.0.0",
+			MinUpgradeVersion: "3.0.0",
+			UpgradeCluster:    versions.Yes,
+			UpgradeTenant:     versions.Yes,
+			VersionOffset:     uint32(len(clusterUpgEntries) + len(tenantUpgEntries)),
+		},
+	}
+)
+
+type versionHandle struct {
+	metadata versions.Version
+}
+
+func (v *versionHandle) Metadata() versions.Version {
+	return v.metadata
+}
+
+func (v *versionHandle) Prepare(
+	ctx context.Context,
+	txn executor.TxnExecutor,
+	final bool) error {
+	txn.Use(catalog.MO_CATALOG)
+	return nil
+}
+
+func (v *versionHandle) HandleTenantUpgrade(
+	ctx context.Context,
+	tenantID int32,
+	txn executor.TxnExecutor,
+) error {
+
+	var (
+		err    error
+		goon   bool
+		logger func(msg string, fields ...zap.Field)
+	)
+
+	for _, upgEntry := range tenantUpgEntries {
+		goon = false
+		logger = logutil.Error
+
+		start := time.Now()
+		err = upgEntry.Upgrade(txn, uint32(tenantID))
+
+		duration := time.Since(start)
+
+		if err == nil {
+			logger = logutil.Info
+			goon = true
+		}
+
+		logger("tenant upgrade",
+			zap.String("cn", txn.Txn().TxnOptions().CN),
+			zap.String("entry", upgEntry.String()),
+			zap.Int32("tenantId", tenantID),
+			zap.String("version", v.metadata.Version),
+			zap.Duration("duration", duration),
+			zap.Error(err),
+		)
+
+		if goon {
+			continue
+		}
+		return err
+	}
+
+	return nil
+}
+
+func (v *versionHandle) HandleClusterUpgrade(
+	ctx context.Context,
+	txn executor.TxnExecutor,
+) error {
+	for _, upgEntry := range clusterUpgEntries {
+		start := time.Now()
+
+		err := upgEntry.Upgrade(txn, catalog.System_Account)
+		if err != nil {
+			getLogger(txn.Txn().TxnOptions().CN).Error("cluster upgrade entry execute error", zap.Error(err), zap.String("version", v.Metadata().Version), zap.String("upgrade entry", upgEntry.String()))
+			return err
+		}
+
+		duration := time.Since(start)
+		getLogger(txn.Txn().TxnOptions().CN).Info("cluster upgrade entry complete",
+			zap.String("upgrade entry", upgEntry.String()),
+			zap.Int64("time cost(ms)", duration.Milliseconds()),
+			zap.String("toVersion", v.Metadata().Version))
+	}
+	return nil
+}
+
+func (v *versionHandle) HandleCreateFrameworkDeps(txn executor.TxnExecutor) error {
+	return moerr.NewInternalErrorNoCtxf("Only v1.2.0 can initialize upgrade framework, current version is:%s", Handler.metadata.Version)
+}

pkg/bootstrap/versions/v4_0_0/upgrade_test.go

@@ -0,0 +1,85 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"context"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+	"github.com/matrixorigin/matrixone/pkg/common/moerr"
+	"github.com/matrixorigin/matrixone/pkg/common/runtime"
+	mock_frontend "github.com/matrixorigin/matrixone/pkg/frontend/test"
+	"github.com/matrixorigin/matrixone/pkg/pb/txn"
+	"github.com/matrixorigin/matrixone/pkg/util/executor"
+)
+
+func Test_Upgrade(t *testing.T) {
+	sid := ""
+	runtime.RunTest(
+		sid,
+		func(rt runtime.Runtime) {
+			txnOperator := mock_frontend.NewMockTxnOperator(gomock.NewController(t))
+			txnOperator.EXPECT().TxnOptions().Return(txn.TxnOptions{CN: sid}).AnyTimes()
+
+			executor := executor.NewMemTxnExecutor(func(sql string) (executor.Result, error) {
+				return executor.Result{}, nil
+			}, txnOperator)
+
+			metadata := Handler.Metadata()
+			t.Logf("version metadata:%v", metadata)
+
+			if err := Handler.Prepare(context.Background(), executor, true); err != nil {
+				t.Errorf("Prepare() error = %v", err)
+			}
+
+			if err := Handler.HandleCreateFrameworkDeps(executor); err == nil {
+				t.Errorf("HandleCreateFrameworkDeps() should report err")
+			}
+
+			if err := Handler.HandleClusterUpgrade(context.Background(), executor); err != nil {
+				t.Errorf("HandleClusterUpgrade() error = %v", err)
+			}
+
+			if err := Handler.HandleTenantUpgrade(context.Background(), 0, executor); err != nil {
+				t.Errorf("HandleTenantUpgrade() error = %v", err)
+			}
+		},
+	)
+}
+
+func Test_versionHandle_HandleClusterUpgrade(t *testing.T) {
+	clusterUpgEntries = []versions.UpgradeEntry{}
+
+	v := &versionHandle{
+		metadata: versions.Version{
+			Version: "v3.0.0",
+		},
+	}
+	sid := ""
+	txnOperator := mock_frontend.NewMockTxnOperator(gomock.NewController(t))
+	txnOperator.EXPECT().TxnOptions().Return(txn.TxnOptions{CN: sid}).AnyTimes()
+	executor2 := executor.NewMemTxnExecutor(func(sql string) (executor.Result, error) {
+		return executor.Result{}, moerr.NewInvalidInputNoCtx("return error")
+	}, txnOperator)
+
+	err := v.HandleClusterUpgrade(context.Background(),
+		executor2,
+	)
+	assert.Nil(t, err)
+}