chao
8 months ago
committed by
GitHub
commit
ea9c75b197
@ -1,20 +1,386 @@
|
||||
## Log Standards
|
||||
|
||||
### Log Standards
|
||||
|
||||
- The unified log package `github.com/openimsdk/open-im-server/internal/pkg/log` should be used for all logging;
|
||||
- Use structured logging formats: `log.Infow`, `log.Warnw`, `log.Errorw`, etc. For example: `log.Infow("Update post function called")`;
|
||||
- All logs should start with an uppercase letter and should not end with a `.`. For example: `log.Infow("Update post function called")`;
|
||||
- Use past tense. For example, use `Could not delete B` instead of `Cannot delete B`;
|
||||
- Adhere to log level standards:
|
||||
- Debug level logs use `log.Debugw`;
|
||||
- Info level logs use `log.Infow`;
|
||||
- Warning level logs use `log.Warnw`;
|
||||
- Error level logs use `log.Errorw`;
|
||||
- Panic level logs use `log.Panicw`;
|
||||
- Fatal level logs use `log.Fatalw`.
|
||||
- Log settings:
|
||||
- Development and test environments: The log level is set to `debug`, the log format can be set to `console` / `json` as needed, and caller is enabled;
|
||||
- Production environment: The log level is set to `info`, the log format is set to `json`, and caller is enabled. (**Note**: In the early stages of going online, to facilitate troubleshooting, the log level can be set to `debug`)
|
||||
- When logging, avoid outputting sensitive information, such as passwords, keys, etc.
|
||||
- If you are calling a logging function in a function/method with a `context.Context` parameter, it is recommended to use `log.L(ctx).Infow()` for logging.
|
||||
# OpenIM Logging and Error Handling Documentation
|
||||
|
||||
## Script Logging Documentation Link
|
||||
|
||||
If you wish to view the script's logging documentation, you can click on this link: [Logging Documentation](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/docs/contrib/bash-log.md).
|
||||
|
||||
Below is the documentation for logging and error handling in the OpenIM Go project.
|
||||
|
||||
To create a standard set of documentation that is quick to read and easy to understand, we will highlight key information about the `Logger` interface and the `CodeError` interface. This includes the purpose of each interface, key methods, and their use cases. This will help developers quickly grasp how to effectively use logging and error handling within the project.
|
||||
|
||||
## Logging (`Logger` Interface)
|
||||
|
||||
### Purpose
|
||||
The `Logger` interface aims to provide the OpenIM project with a unified and flexible logging mechanism, supporting structured logging formats for efficient log management and analysis.
|
||||
|
||||
### Key Methods
|
||||
|
||||
- **Debug, Info, Warn, Error**
|
||||
Log messages of different levels to suit various logging needs and scenarios. These methods accept a context (`context.Context`), a message (`string`), and key-value pairs (`...interface{}`), allowing the log to carry rich context information.
|
||||
|
||||
- **WithValues**
|
||||
Append key-value pair information to log messages, returning a new `Logger` instance. This helps in adding consistent context information.
|
||||
|
||||
- **WithName**
|
||||
Set the name of the logger, which helps in identifying the source of the logs.
|
||||
|
||||
- **WithCallDepth**
|
||||
Adjust the call stack depth to accurately identify the source of the log message.
|
||||
|
||||
### Use Cases
|
||||
|
||||
- Developers should choose the appropriate logging level (such as `Debug`, `Info`, `Warn`, `Error`) based on the importance of the information when logging.
|
||||
- Use `WithValues` and `WithName` to add richer context information to logs, facilitating subsequent tracking and analysis.
|
||||
|
||||
## Error Handling (`CodeError` Interface)
|
||||
|
||||
### Purpose
|
||||
The `CodeError` interface is designed to provide a unified mechanism for error handling and wrapping, making error information more detailed and manageable.
|
||||
|
||||
### Key Methods
|
||||
|
||||
- **Code**
|
||||
Return the error code to distinguish between different types of errors.
|
||||
|
||||
- **Msg**
|
||||
Return the error message description to display to the user.
|
||||
|
||||
- **Detail**
|
||||
Return detailed information about the error for further debugging by developers.
|
||||
|
||||
- **WithDetail**
|
||||
Add detailed information to the error, returning a new `CodeError` instance.
|
||||
|
||||
- **Is**
|
||||
Determine whether the current error matches a specified error, supporting a flexible error comparison mechanism.
|
||||
|
||||
- **Wrap**
|
||||
Wrap another error with additional message description, facilitating the tracing of the error's cause.
|
||||
|
||||
### Use Cases
|
||||
|
||||
- When defining errors with specific codes and messages, use error types that implement the `CodeError` interface.
|
||||
- Use `WithDetail` to add additional context information to errors for more accurate problem localization.
|
||||
- Use the `Is` method to judge the type of error for conditional branching.
|
||||
- Use the `Wrap` method to wrap underlying errors while adding more contextual descriptions.
|
||||
|
||||
## Logging Standards and Code Examples
|
||||
|
||||
In the OpenIM project, we use the unified logging package `github.com/OpenIMSDK/tools/log` for logging to achieve efficient log management and analysis. This logging package supports structured logging formats, making it easier for developers to handle log information.
|
||||
|
||||
### Logger Interface and Implementation
|
||||
|
||||
The logger interface is defined as follows:
|
||||
|
||||
```go
|
||||
type Logger interface {
|
||||
Debug(ctx context.Context, msg string, keysAndValues ...interface{})
|
||||
Info(ctx context.Context, msg string, keysAndValues ...interface{})
|
||||
Warn(ctx context.Context, msg string, err error, keysAndValues ...interface{})
|
||||
Error(ctx context.Context, msg string, err error, keysAndValues ...interface{})
|
||||
WithValues(keysAndValues ...interface{}) Logger
|
||||
WithName(name string) Logger
|
||||
WithCallDepth(depth int) Logger
|
||||
}
|
||||
```
|
||||
|
||||
Example code: Using the `Logger` interface to log at the info level.
|
||||
|
||||
```go
|
||||
func main() {
|
||||
logger := log.NewLogger().WithName("MyService")
|
||||
ctx := context.Background()
|
||||
logger.Info(ctx, "Service started", "port", "8080")
|
||||
}
|
||||
```
|
||||
|
||||
## Error Handling and Code Examples
|
||||
|
||||
We use the `github.com/OpenIMSDK/tools/errs` package for unified error handling and wrapping.
|
||||
|
||||
### CodeError Interface and Implementation
|
||||
|
||||
The error interface is defined as follows:
|
||||
|
||||
```go
|
||||
type CodeError interface {
|
||||
Code() int
|
||||
Msg() string
|
||||
Detail() string
|
||||
WithDetail(detail string) CodeError
|
||||
Is(err error, loose ...bool) bool
|
||||
Wrap(msg ...string) error
|
||||
error
|
||||
}
|
||||
```
|
||||
|
||||
Example code: Creating and using the `CodeError` interface to handle errors.
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/OpenIMSDK/tools/errs"
|
||||
)
|
||||
|
||||
func main() {
|
||||
err := errs.New(404, "Resource not found")
|
||||
err = err.WithDetail("
|
||||
|
||||
More details")
|
||||
if e, ok := err.(errs.CodeError); ok {
|
||||
fmt.Println(e.Code(), e.Msg(), e.Detail())
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Detailed Logging Standards and Code Examples
|
||||
|
||||
1. **Print key information at startup**
|
||||
It is crucial to print entry parameters and key process information at program startup. This helps understand the startup state and configuration of the program.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
fmt.Println("Program startup, version: 1.0.0")
|
||||
fmt.Printf("Connecting to database: %s\n", os.Getenv("DATABASE_URL"))
|
||||
}
|
||||
```
|
||||
|
||||
2. **Use `tools/log` and `fmt` for logging**
|
||||
Logging should be done using a specialized logging library for unified management and formatted log output.
|
||||
|
||||
**Code Example**: Logging an info level message with `tools/log`.
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
)
|
||||
|
||||
func main() {
|
||||
ctx := context.Background()
|
||||
log.Info(ctx, "Application started successfully")
|
||||
}
|
||||
```
|
||||
|
||||
3. **Use standard error output for startup failures or critical information**
|
||||
Critical error messages or program startup failures should be indicated to the user through standard error output.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func checkEnvironment() bool {
|
||||
return os.Getenv("REQUIRED_ENV") != ""
|
||||
}
|
||||
|
||||
func main() {
|
||||
if !checkEnvironment() {
|
||||
fmt.Fprintln(os.Stderr, "Missing required environment variable")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
We encapsulate it into separate tools, which can output error information through the `tools/log` package.
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
util "github.com/openimsdk/open-im-server/v3/pkg/util/genutil"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := apiCmd.Execute(); err != nil {
|
||||
util.ExitWithError(err)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
4. **Use `tools/log` package for runtime logging**
|
||||
This ensures consistency and control over logging.
|
||||
|
||||
**Code Example**: Same as the above example using `tools/log`. When `tools/log` is not initialized, consider using `fmt` for standard output.
|
||||
|
||||
5. **Error logs should be printed by the top-level caller**
|
||||
This is to avoid duplicate logging of errors, typically errors are caught and logged at the application's outermost level.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
"context"
|
||||
)
|
||||
|
||||
func doSomething() error {
|
||||
// An error occurs here
|
||||
return errs.Wrap(errors.New("An error occurred"))
|
||||
}
|
||||
|
||||
func controller() error {
|
||||
err := doSomething()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func main() {
|
||||
err := controller()
|
||||
if err != nil {
|
||||
log.Error(context.Background(), "Operation failed", err)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
6. **Handling logs for API RPC calls and non-RPC applications**
|
||||
|
||||
For API RPC calls using gRPC, logs at the information level are printed by middleware on the gRPC server side, reducing the need to manually log in each RPC method. For non-RPC applications, it's recommended to manually log key execution paths to track the application's execution flow.
|
||||
|
||||
**gRPC Server-Side Logging Middleware:**
|
||||
|
||||
In gRPC, `UnaryInterceptor` and `StreamInterceptor` can intercept Unary and Stream type RPC calls, respectively. Here's an example of how to implement a simple Unary RPC logging middleware:
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"google.golang.org/grpc"
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
"log"
|
||||
"time"
|
||||
)
|
||||
|
||||
// unaryServerInterceptor returns a new unary server interceptor that logs each request.
|
||||
func unaryServerInterceptor() grpc.UnaryServerInterceptor {
|
||||
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
|
||||
// Record the start time of the request
|
||||
start := time.Now()
|
||||
// Call the actual RPC method
|
||||
resp, err = handler(ctx, req)
|
||||
// After the request ends, log the duration and other information
|
||||
log.Printf("Request method: %s, duration: %s, error status: %v", info.FullMethod, time.Since(start), status.Code(err))
|
||||
return resp, err
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
// Create a gRPC server and add the middleware
|
||||
s := grpc.NewServer
|
||||
|
||||
(grpc.UnaryInterceptor(unaryServerInterceptor()))
|
||||
// Register your service
|
||||
|
||||
// Start the gRPC server
|
||||
log.Println("Starting gRPC server...")
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
**Logging for Non-RPC Applications:**
|
||||
|
||||
For non-RPC applications, the key is to log at appropriate places in the code to maintain an execution trace. Here's a simple example showing how to log when handling a task:
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"log"
|
||||
)
|
||||
|
||||
func processTask(taskID string) {
|
||||
// Log the start of task processing
|
||||
log.Printf("Starting task processing: %s", taskID)
|
||||
// Suppose this is where the task is processed
|
||||
|
||||
// Log after the task is completed
|
||||
log.Printf("Task processing completed: %s", taskID)
|
||||
}
|
||||
|
||||
func main() {
|
||||
// Example task ID
|
||||
taskID := "task123"
|
||||
processTask(taskID)
|
||||
}
|
||||
```
|
||||
|
||||
In both scenarios, appropriate logging can help developers and operators monitor the health of the system, trace the source of issues, and quickly locate and resolve problems. For gRPC logging, using middleware can effectively centralize log management and control. For non-RPC applications, ensuring logs are placed at critical execution points can help understand the program's operational flow and state changes.
|
||||
|
||||
### When to Wrap Errors?
|
||||
|
||||
1. **Wrap errors generated within the function**
|
||||
When an error occurs within a function, use `errs.Wrap` to add context information to the original error.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
func doSomething() error {
|
||||
// Suppose an error occurs here
|
||||
err, _ := someFunc()
|
||||
if err != nil {
|
||||
return errs.Wrap(err, "doSomething failed")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
2. **Wrap errors from system calls or other packages**
|
||||
When calling external libraries or system functions that return errors, also add context information to wrap the error.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
func readConfig(file string) error {
|
||||
_, err := os.ReadFile(file)
|
||||
if err != nil {
|
||||
return errs.Wrap(err, "Failed to read config file")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
3. **No need to re-wrap errors for internal module calls**
|
||||
|
||||
If an error has been appropriately wrapped with sufficient context information in an internal module call, there's no need to wrap it again.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
func doSomething() error {
|
||||
err := doAnotherThing()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
4. **Ensure comprehensive wrapping of errors with detailed messages**
|
||||
When wrapping errors, ensure to provide ample context information to make the error more understandable and easier to debug.
|
||||
|
||||
**Code Example**:
|
||||
```go
|
||||
func connectDatabase() error {
|
||||
err := db.Connect(config.DatabaseURL)
|
||||
if err != nil {
|
||||
return errs.Wrap(err, fmt.Sprintf("Failed to connect to database, URL: %s", config.DatabaseURL))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
```
|
||||
@ -0,0 +1,58 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 cachekey
|
||||
|
||||
const (
|
||||
ConversationKey = "CONVERSATION:"
|
||||
ConversationIDsKey = "CONVERSATION_IDS:"
|
||||
ConversationIDsHashKey = "CONVERSATION_IDS_HASH:"
|
||||
ConversationHasReadSeqKey = "CONVERSATION_HAS_READ_SEQ:"
|
||||
RecvMsgOptKey = "RECV_MSG_OPT:"
|
||||
SuperGroupRecvMsgNotNotifyUserIDsKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS:"
|
||||
SuperGroupRecvMsgNotNotifyUserIDsHashKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS_HASH:"
|
||||
ConversationNotReceiveMessageUserIDsKey = "CONVERSATION_NOT_RECEIVE_MESSAGE_USER_IDS:"
|
||||
)
|
||||
|
||||
func GetConversationKey(ownerUserID, conversationID string) string {
|
||||
return ConversationKey + ownerUserID + ":" + conversationID
|
||||
}
|
||||
|
||||
func GetConversationIDsKey(ownerUserID string) string {
|
||||
return ConversationIDsKey + ownerUserID
|
||||
}
|
||||
|
||||
func GetSuperGroupRecvNotNotifyUserIDsKey(groupID string) string {
|
||||
return SuperGroupRecvMsgNotNotifyUserIDsKey + groupID
|
||||
}
|
||||
|
||||
func GetRecvMsgOptKey(ownerUserID, conversationID string) string {
|
||||
return RecvMsgOptKey + ownerUserID + ":" + conversationID
|
||||
}
|
||||
|
||||
func GetSuperGroupRecvNotNotifyUserIDsHashKey(groupID string) string {
|
||||
return SuperGroupRecvMsgNotNotifyUserIDsHashKey + groupID
|
||||
}
|
||||
|
||||
func GetConversationHasReadSeqKey(ownerUserID, conversationID string) string {
|
||||
return ConversationHasReadSeqKey + ownerUserID + ":" + conversationID
|
||||
}
|
||||
|
||||
func GetConversationNotReceiveMessageUserIDsKey(conversationID string) string {
|
||||
return ConversationNotReceiveMessageUserIDsKey + conversationID
|
||||
}
|
||||
|
||||
func GetUserConversationIDsHashKey(ownerUserID string) string {
|
||||
return ConversationIDsHashKey + ownerUserID
|
||||
}
|
||||
@ -0,0 +1,38 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 cachekey
|
||||
|
||||
const (
|
||||
FriendIDsKey = "FRIEND_IDS:"
|
||||
TwoWayFriendsIDsKey = "COMMON_FRIENDS_IDS:"
|
||||
FriendKey = "FRIEND_INFO:"
|
||||
IsFriendKey = "IS_FRIEND:" // local cache key
|
||||
)
|
||||
|
||||
func GetFriendIDsKey(ownerUserID string) string {
|
||||
return FriendIDsKey + ownerUserID
|
||||
}
|
||||
|
||||
func GetTwoWayFriendsIDsKey(ownerUserID string) string {
|
||||
return TwoWayFriendsIDsKey + ownerUserID
|
||||
}
|
||||
|
||||
func GetFriendKey(ownerUserID, friendUserID string) string {
|
||||
return FriendKey + ownerUserID + "-" + friendUserID
|
||||
}
|
||||
|
||||
func GetIsFriendKey(possibleFriendUserID, userID string) string {
|
||||
return IsFriendKey + possibleFriendUserID + "-" + userID
|
||||
}
|
||||
@ -0,0 +1,59 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 cachekey
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
groupExpireTime = time.Second * 60 * 60 * 12
|
||||
GroupInfoKey = "GROUP_INFO:"
|
||||
GroupMemberIDsKey = "GROUP_MEMBER_IDS:"
|
||||
GroupMembersHashKey = "GROUP_MEMBERS_HASH2:"
|
||||
GroupMemberInfoKey = "GROUP_MEMBER_INFO:"
|
||||
JoinedGroupsKey = "JOIN_GROUPS_KEY:"
|
||||
GroupMemberNumKey = "GROUP_MEMBER_NUM_CACHE:"
|
||||
GroupRoleLevelMemberIDsKey = "GROUP_ROLE_LEVEL_MEMBER_IDS:"
|
||||
)
|
||||
|
||||
func GetGroupInfoKey(groupID string) string {
|
||||
return GroupInfoKey + groupID
|
||||
}
|
||||
|
||||
func GetJoinedGroupsKey(userID string) string {
|
||||
return JoinedGroupsKey + userID
|
||||
}
|
||||
|
||||
func GetGroupMembersHashKey(groupID string) string {
|
||||
return GroupMembersHashKey + groupID
|
||||
}
|
||||
|
||||
func GetGroupMemberIDsKey(groupID string) string {
|
||||
return GroupMemberIDsKey + groupID
|
||||
}
|
||||
|
||||
func GetGroupMemberInfoKey(groupID, userID string) string {
|
||||
return GroupMemberInfoKey + groupID + "-" + userID
|
||||
}
|
||||
|
||||
func GetGroupMemberNumKey(groupID string) string {
|
||||
return GroupMemberNumKey + groupID
|
||||
}
|
||||
|
||||
func GetGroupRoleLevelMemberIDsKey(groupID string, roleLevel int32) string {
|
||||
return GroupRoleLevelMemberIDsKey + groupID + "-" + strconv.Itoa(int(roleLevel))
|
||||
}
|
||||
@ -0,0 +1,81 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 cache
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/cachekey"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
|
||||
)
|
||||
|
||||
var (
|
||||
once sync.Once
|
||||
subscribe map[string][]string
|
||||
)
|
||||
|
||||
func getPublishKey(topic string, key []string) []string {
|
||||
if topic == "" || len(key) == 0 {
|
||||
return nil
|
||||
}
|
||||
once.Do(func() {
|
||||
list := []struct {
|
||||
Local config.LocalCache
|
||||
Keys []string
|
||||
}{
|
||||
{
|
||||
Local: config.Config.LocalCache.User,
|
||||
Keys: []string{cachekey.UserInfoKey, cachekey.UserGlobalRecvMsgOptKey},
|
||||
},
|
||||
{
|
||||
Local: config.Config.LocalCache.Group,
|
||||
Keys: []string{cachekey.GroupMemberIDsKey, cachekey.GroupInfoKey, cachekey.GroupMemberInfoKey},
|
||||
},
|
||||
{
|
||||
Local: config.Config.LocalCache.Friend,
|
||||
Keys: []string{cachekey.FriendIDsKey, cachekey.BlackIDsKey},
|
||||
},
|
||||
{
|
||||
Local: config.Config.LocalCache.Conversation,
|
||||
Keys: []string{cachekey.ConversationKey, cachekey.ConversationIDsKey, cachekey.ConversationNotReceiveMessageUserIDsKey},
|
||||
},
|
||||
}
|
||||
subscribe = make(map[string][]string)
|
||||
for _, v := range list {
|
||||
if v.Local.Enable() {
|
||||
subscribe[v.Local.Topic] = v.Keys
|
||||
}
|
||||
}
|
||||
})
|
||||
prefix, ok := subscribe[topic]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
res := make([]string, 0, len(key))
|
||||
for _, k := range key {
|
||||
var exist bool
|
||||
for _, p := range prefix {
|
||||
if strings.HasPrefix(k, p) {
|
||||
exist = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if exist {
|
||||
res = append(res, k)
|
||||
}
|
||||
}
|
||||
return res
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
|
||||
"github.com/OpenIMSDK/protocol/conversation"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
|
||||
)
|
||||
|
||||
type ConversationLocalCache struct {
|
||||
lock sync.Mutex
|
||||
superGroupRecvMsgNotNotifyUserIDs map[string]Hash
|
||||
conversationIDs map[string]Hash
|
||||
client *rpcclient.ConversationRpcClient
|
||||
}
|
||||
|
||||
type Hash struct {
|
||||
hash uint64
|
||||
ids []string
|
||||
}
|
||||
|
||||
func NewConversationLocalCache(client *rpcclient.ConversationRpcClient) *ConversationLocalCache {
|
||||
return &ConversationLocalCache{
|
||||
superGroupRecvMsgNotNotifyUserIDs: make(map[string]Hash),
|
||||
conversationIDs: make(map[string]Hash),
|
||||
client: client,
|
||||
}
|
||||
}
|
||||
|
||||
func (g *ConversationLocalCache) GetRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) {
|
||||
resp, err := g.client.Client.GetRecvMsgNotNotifyUserIDs(ctx, &conversation.GetRecvMsgNotNotifyUserIDsReq{
|
||||
GroupID: groupID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.UserIDs, nil
|
||||
}
|
||||
|
||||
func (g *ConversationLocalCache) GetConversationIDs(ctx context.Context, userID string) ([]string, error) {
|
||||
resp, err := g.client.Client.GetUserConversationIDsHash(ctx, &conversation.GetUserConversationIDsHashReq{
|
||||
OwnerUserID: userID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
g.lock.Lock()
|
||||
hash, ok := g.conversationIDs[userID]
|
||||
g.lock.Unlock()
|
||||
|
||||
if !ok || hash.hash != resp.Hash {
|
||||
conversationIDsResp, err := g.client.Client.GetConversationIDs(ctx, &conversation.GetConversationIDsReq{
|
||||
UserID: userID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
g.lock.Lock()
|
||||
defer g.lock.Unlock()
|
||||
g.conversationIDs[userID] = Hash{
|
||||
hash: resp.Hash,
|
||||
ids: conversationIDsResp.ConversationIDs,
|
||||
}
|
||||
|
||||
return conversationIDsResp.ConversationIDs, nil
|
||||
}
|
||||
|
||||
return hash.ids, nil
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 localcache // import "github.com/openimsdk/open-im-server/v3/pkg/common/db/localcache"
|
||||
@ -1,77 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
|
||||
"github.com/OpenIMSDK/protocol/group"
|
||||
"github.com/OpenIMSDK/tools/errs"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
|
||||
)
|
||||
|
||||
type GroupLocalCache struct {
|
||||
lock sync.Mutex
|
||||
cache map[string]GroupMemberIDsHash
|
||||
client *rpcclient.GroupRpcClient
|
||||
}
|
||||
|
||||
type GroupMemberIDsHash struct {
|
||||
memberListHash uint64
|
||||
userIDs []string
|
||||
}
|
||||
|
||||
func NewGroupLocalCache(client *rpcclient.GroupRpcClient) *GroupLocalCache {
|
||||
return &GroupLocalCache{
|
||||
cache: make(map[string]GroupMemberIDsHash, 0),
|
||||
client: client,
|
||||
}
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
|
||||
resp, err := g.client.Client.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{
|
||||
GroupIDs: []string{groupID},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(resp.GroupAbstractInfos) < 1 {
|
||||
return nil, errs.ErrGroupIDNotFound
|
||||
}
|
||||
|
||||
g.lock.Lock()
|
||||
localHashInfo, ok := g.cache[groupID]
|
||||
if ok && localHashInfo.memberListHash == resp.GroupAbstractInfos[0].GroupMemberListHash {
|
||||
g.lock.Unlock()
|
||||
return localHashInfo.userIDs, nil
|
||||
}
|
||||
g.lock.Unlock()
|
||||
|
||||
groupMembersResp, err := g.client.Client.GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
|
||||
GroupID: groupID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
g.lock.Lock()
|
||||
defer g.lock.Unlock()
|
||||
g.cache[groupID] = GroupMemberIDsHash{
|
||||
memberListHash: resp.GroupAbstractInfos[0].GroupMemberListHash,
|
||||
userIDs: groupMembersResp.UserIDs,
|
||||
}
|
||||
return g.cache[groupID].userIDs, nil
|
||||
}
|
||||
@ -0,0 +1,49 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 redispubsub
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var ctx = context.Background()
|
||||
|
||||
type Subscriber struct {
|
||||
client redis.UniversalClient
|
||||
channel string
|
||||
}
|
||||
|
||||
func NewSubscriber(client redis.UniversalClient, channel string) *Subscriber {
|
||||
return &Subscriber{client: client, channel: channel}
|
||||
}
|
||||
|
||||
func (s *Subscriber) OnMessage(ctx context.Context, callback func(string)) error {
|
||||
messageChannel := s.client.Subscribe(ctx, s.channel).Channel()
|
||||
|
||||
go func() {
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case msg := <-messageChannel:
|
||||
callback(msg.Payload)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,127 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"hash/fnv"
|
||||
"unsafe"
|
||||
|
||||
"github.com/openimsdk/localcache/link"
|
||||
"github.com/openimsdk/localcache/lru"
|
||||
)
|
||||
|
||||
type Cache[V any] interface {
|
||||
Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error)
|
||||
GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error)
|
||||
Del(ctx context.Context, key ...string)
|
||||
DelLocal(ctx context.Context, key ...string)
|
||||
Stop()
|
||||
}
|
||||
|
||||
func New[V any](opts ...Option) Cache[V] {
|
||||
opt := defaultOption()
|
||||
for _, o := range opts {
|
||||
o(opt)
|
||||
}
|
||||
|
||||
c := cache[V]{opt: opt}
|
||||
if opt.localSlotNum > 0 && opt.localSlotSize > 0 {
|
||||
createSimpleLRU := func() lru.LRU[string, V] {
|
||||
if opt.expirationEvict {
|
||||
return lru.NewExpirationLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
|
||||
} else {
|
||||
return lru.NewLayLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
|
||||
}
|
||||
}
|
||||
if opt.localSlotNum == 1 {
|
||||
c.local = createSimpleLRU()
|
||||
} else {
|
||||
c.local = lru.NewSlotLRU[string, V](opt.localSlotNum, func(key string) uint64 {
|
||||
h := fnv.New64a()
|
||||
h.Write(*(*[]byte)(unsafe.Pointer(&key)))
|
||||
return h.Sum64()
|
||||
}, createSimpleLRU)
|
||||
}
|
||||
if opt.linkSlotNum > 0 {
|
||||
c.link = link.New(opt.linkSlotNum)
|
||||
}
|
||||
}
|
||||
return &c
|
||||
}
|
||||
|
||||
type cache[V any] struct {
|
||||
opt *option
|
||||
link link.Link
|
||||
local lru.LRU[string, V]
|
||||
}
|
||||
|
||||
func (c *cache[V]) onEvict(key string, value V) {
|
||||
if c.link != nil {
|
||||
lks := c.link.Del(key)
|
||||
for k := range lks {
|
||||
if key != k { // prevent deadlock
|
||||
c.local.Del(k)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cache[V]) del(key ...string) {
|
||||
if c.local == nil {
|
||||
return
|
||||
}
|
||||
for _, k := range key {
|
||||
c.local.Del(k)
|
||||
if c.link != nil {
|
||||
lks := c.link.Del(k)
|
||||
for k := range lks {
|
||||
c.local.Del(k)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cache[V]) Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error) {
|
||||
return c.GetLink(ctx, key, fetch)
|
||||
}
|
||||
|
||||
func (c *cache[V]) GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error) {
|
||||
if c.local != nil {
|
||||
return c.local.Get(key, func() (V, error) {
|
||||
if len(link) > 0 {
|
||||
c.link.Link(key, link...)
|
||||
}
|
||||
return fetch(ctx)
|
||||
})
|
||||
} else {
|
||||
return fetch(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cache[V]) Del(ctx context.Context, key ...string) {
|
||||
for _, fn := range c.opt.delFn {
|
||||
fn(ctx, key...)
|
||||
}
|
||||
c.del(key...)
|
||||
}
|
||||
|
||||
func (c *cache[V]) DelLocal(ctx context.Context, key ...string) {
|
||||
c.del(key...)
|
||||
}
|
||||
|
||||
func (c *cache[V]) Stop() {
|
||||
c.local.Stop()
|
||||
}
|
||||
@ -0,0 +1,93 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestName(t *testing.T) {
|
||||
c := New[string](WithExpirationEvict())
|
||||
//c := New[string]()
|
||||
ctx := context.Background()
|
||||
|
||||
const (
|
||||
num = 10000
|
||||
tNum = 10000
|
||||
kNum = 100000
|
||||
pNum = 100
|
||||
)
|
||||
|
||||
getKey := func(v uint64) string {
|
||||
return fmt.Sprintf("key_%d", v%kNum)
|
||||
}
|
||||
|
||||
start := time.Now()
|
||||
t.Log("start", start)
|
||||
|
||||
var (
|
||||
get atomic.Int64
|
||||
del atomic.Int64
|
||||
)
|
||||
|
||||
incrGet := func() {
|
||||
if v := get.Add(1); v%pNum == 0 {
|
||||
//t.Log("#get count", v/pNum)
|
||||
}
|
||||
}
|
||||
incrDel := func() {
|
||||
if v := del.Add(1); v%pNum == 0 {
|
||||
//t.Log("@del count", v/pNum)
|
||||
}
|
||||
}
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
for i := 0; i < tNum; i++ {
|
||||
wg.Add(2)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for i := 0; i < num; i++ {
|
||||
c.Get(ctx, getKey(rand.Uint64()), func(ctx context.Context) (string, error) {
|
||||
return fmt.Sprintf("index_%d", i), nil
|
||||
})
|
||||
incrGet()
|
||||
}
|
||||
}()
|
||||
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
time.Sleep(time.Second / 10)
|
||||
for i := 0; i < num; i++ {
|
||||
c.Del(ctx, getKey(rand.Uint64()))
|
||||
incrDel()
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
end := time.Now()
|
||||
t.Log("end", end)
|
||||
t.Log("time", end.Sub(start))
|
||||
t.Log("get", get.Load())
|
||||
t.Log("del", del.Load())
|
||||
// 137.35s
|
||||
}
|
||||
@ -0,0 +1,5 @@
|
||||
module github.com/openimsdk/localcache
|
||||
|
||||
go 1.19
|
||||
|
||||
require github.com/hashicorp/golang-lru/v2 v2.0.7
|
||||
@ -0,0 +1,123 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 link
|
||||
|
||||
import (
|
||||
"hash/fnv"
|
||||
"sync"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type Link interface {
|
||||
Link(key string, link ...string)
|
||||
Del(key string) map[string]struct{}
|
||||
}
|
||||
|
||||
func newLinkKey() *linkKey {
|
||||
return &linkKey{
|
||||
data: make(map[string]map[string]struct{}),
|
||||
}
|
||||
}
|
||||
|
||||
type linkKey struct {
|
||||
lock sync.Mutex
|
||||
data map[string]map[string]struct{}
|
||||
}
|
||||
|
||||
func (x *linkKey) link(key string, link ...string) {
|
||||
x.lock.Lock()
|
||||
defer x.lock.Unlock()
|
||||
v, ok := x.data[key]
|
||||
if !ok {
|
||||
v = make(map[string]struct{})
|
||||
x.data[key] = v
|
||||
}
|
||||
for _, k := range link {
|
||||
v[k] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
func (x *linkKey) del(key string) map[string]struct{} {
|
||||
x.lock.Lock()
|
||||
defer x.lock.Unlock()
|
||||
ks, ok := x.data[key]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
delete(x.data, key)
|
||||
return ks
|
||||
}
|
||||
|
||||
func New(n int) Link {
|
||||
if n <= 0 {
|
||||
panic("must be greater than 0")
|
||||
}
|
||||
slots := make([]*linkKey, n)
|
||||
for i := 0; i < len(slots); i++ {
|
||||
slots[i] = newLinkKey()
|
||||
}
|
||||
return &slot{
|
||||
n: uint64(n),
|
||||
slots: slots,
|
||||
}
|
||||
}
|
||||
|
||||
type slot struct {
|
||||
n uint64
|
||||
slots []*linkKey
|
||||
}
|
||||
|
||||
func (x *slot) index(s string) uint64 {
|
||||
h := fnv.New64a()
|
||||
_, _ = h.Write(*(*[]byte)(unsafe.Pointer(&s)))
|
||||
return h.Sum64() % x.n
|
||||
}
|
||||
|
||||
func (x *slot) Link(key string, link ...string) {
|
||||
if len(link) == 0 {
|
||||
return
|
||||
}
|
||||
mk := key
|
||||
lks := make([]string, len(link))
|
||||
for i, k := range link {
|
||||
lks[i] = k
|
||||
}
|
||||
x.slots[x.index(mk)].link(mk, lks...)
|
||||
for _, lk := range lks {
|
||||
x.slots[x.index(lk)].link(lk, mk)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *slot) Del(key string) map[string]struct{} {
|
||||
return x.delKey(key)
|
||||
}
|
||||
|
||||
func (x *slot) delKey(k string) map[string]struct{} {
|
||||
del := make(map[string]struct{})
|
||||
stack := []string{k}
|
||||
for len(stack) > 0 {
|
||||
curr := stack[len(stack)-1]
|
||||
stack = stack[:len(stack)-1]
|
||||
if _, ok := del[curr]; ok {
|
||||
continue
|
||||
}
|
||||
del[curr] = struct{}{}
|
||||
childKeys := x.slots[x.index(curr)].del(curr)
|
||||
for ck := range childKeys {
|
||||
stack = append(stack, ck)
|
||||
}
|
||||
}
|
||||
return del
|
||||
}
|
||||
@ -0,0 +1,93 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 lru
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/hashicorp/golang-lru/v2/expirable"
|
||||
)
|
||||
|
||||
func NewExpirationLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) LRU[K, V] {
|
||||
var cb expirable.EvictCallback[K, *expirationLruItem[V]]
|
||||
if onEvict != nil {
|
||||
cb = func(key K, value *expirationLruItem[V]) {
|
||||
onEvict(key, value.value)
|
||||
}
|
||||
}
|
||||
core := expirable.NewLRU[K, *expirationLruItem[V]](size, cb, successTTL)
|
||||
return &ExpirationLRU[K, V]{
|
||||
core: core,
|
||||
successTTL: successTTL,
|
||||
failedTTL: failedTTL,
|
||||
target: target,
|
||||
}
|
||||
}
|
||||
|
||||
type expirationLruItem[V any] struct {
|
||||
lock sync.RWMutex
|
||||
err error
|
||||
value V
|
||||
}
|
||||
|
||||
type ExpirationLRU[K comparable, V any] struct {
|
||||
lock sync.Mutex
|
||||
core *expirable.LRU[K, *expirationLruItem[V]]
|
||||
successTTL time.Duration
|
||||
failedTTL time.Duration
|
||||
target Target
|
||||
}
|
||||
|
||||
func (x *ExpirationLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
|
||||
x.lock.Lock()
|
||||
v, ok := x.core.Get(key)
|
||||
if ok {
|
||||
x.lock.Unlock()
|
||||
x.target.IncrGetSuccess()
|
||||
v.lock.RLock()
|
||||
defer v.lock.RUnlock()
|
||||
return v.value, v.err
|
||||
} else {
|
||||
v = &expirationLruItem[V]{}
|
||||
x.core.Add(key, v)
|
||||
v.lock.Lock()
|
||||
x.lock.Unlock()
|
||||
defer v.lock.Unlock()
|
||||
v.value, v.err = fetch()
|
||||
if v.err == nil {
|
||||
x.target.IncrGetSuccess()
|
||||
} else {
|
||||
x.target.IncrGetFailed()
|
||||
x.core.Remove(key)
|
||||
}
|
||||
return v.value, v.err
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ExpirationLRU[K, V]) Del(key K) bool {
|
||||
x.lock.Lock()
|
||||
ok := x.core.Remove(key)
|
||||
x.lock.Unlock()
|
||||
if ok {
|
||||
x.target.IncrDelHit()
|
||||
} else {
|
||||
x.target.IncrDelNotFound()
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
func (x *ExpirationLRU[K, V]) Stop() {
|
||||
}
|
||||
@ -0,0 +1,105 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 lru
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/hashicorp/golang-lru/v2/simplelru"
|
||||
)
|
||||
|
||||
type layLruItem[V any] struct {
|
||||
lock sync.Mutex
|
||||
expires int64
|
||||
err error
|
||||
value V
|
||||
}
|
||||
|
||||
func NewLayLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LayLRU[K, V] {
|
||||
var cb simplelru.EvictCallback[K, *layLruItem[V]]
|
||||
if onEvict != nil {
|
||||
cb = func(key K, value *layLruItem[V]) {
|
||||
onEvict(key, value.value)
|
||||
}
|
||||
}
|
||||
core, err := simplelru.NewLRU[K, *layLruItem[V]](size, cb)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return &LayLRU[K, V]{
|
||||
core: core,
|
||||
successTTL: successTTL,
|
||||
failedTTL: failedTTL,
|
||||
target: target,
|
||||
}
|
||||
}
|
||||
|
||||
type LayLRU[K comparable, V any] struct {
|
||||
lock sync.Mutex
|
||||
core *simplelru.LRU[K, *layLruItem[V]]
|
||||
successTTL time.Duration
|
||||
failedTTL time.Duration
|
||||
target Target
|
||||
}
|
||||
|
||||
func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
|
||||
x.lock.Lock()
|
||||
v, ok := x.core.Get(key)
|
||||
if ok {
|
||||
x.lock.Unlock()
|
||||
v.lock.Lock()
|
||||
expires, value, err := v.expires, v.value, v.err
|
||||
if expires != 0 && expires > time.Now().UnixMilli() {
|
||||
v.lock.Unlock()
|
||||
x.target.IncrGetHit()
|
||||
return value, err
|
||||
}
|
||||
} else {
|
||||
v = &layLruItem[V]{}
|
||||
x.core.Add(key, v)
|
||||
v.lock.Lock()
|
||||
x.lock.Unlock()
|
||||
}
|
||||
defer v.lock.Unlock()
|
||||
if v.expires > time.Now().UnixMilli() {
|
||||
return v.value, v.err
|
||||
}
|
||||
v.value, v.err = fetch()
|
||||
if v.err == nil {
|
||||
v.expires = time.Now().Add(x.successTTL).UnixMilli()
|
||||
x.target.IncrGetSuccess()
|
||||
} else {
|
||||
v.expires = time.Now().Add(x.failedTTL).UnixMilli()
|
||||
x.target.IncrGetFailed()
|
||||
}
|
||||
return v.value, v.err
|
||||
}
|
||||
|
||||
func (x *LayLRU[K, V]) Del(key K) bool {
|
||||
x.lock.Lock()
|
||||
ok := x.core.Remove(key)
|
||||
x.lock.Unlock()
|
||||
if ok {
|
||||
x.target.IncrDelHit()
|
||||
} else {
|
||||
x.target.IncrDelNotFound()
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
func (x *LayLRU[K, V]) Stop() {
|
||||
|
||||
}
|
||||
@ -0,0 +1,118 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 lru
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"hash/fnv"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type cacheTarget struct {
|
||||
getHit int64
|
||||
getSuccess int64
|
||||
getFailed int64
|
||||
delHit int64
|
||||
delNotFound int64
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrGetHit() {
|
||||
atomic.AddInt64(&r.getHit, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrGetSuccess() {
|
||||
atomic.AddInt64(&r.getSuccess, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrGetFailed() {
|
||||
atomic.AddInt64(&r.getFailed, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrDelHit() {
|
||||
atomic.AddInt64(&r.delHit, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrDelNotFound() {
|
||||
atomic.AddInt64(&r.delNotFound, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) String() string {
|
||||
return fmt.Sprintf("getHit: %d, getSuccess: %d, getFailed: %d, delHit: %d, delNotFound: %d", r.getHit, r.getSuccess, r.getFailed, r.delHit, r.delNotFound)
|
||||
}
|
||||
|
||||
func TestName(t *testing.T) {
|
||||
target := &cacheTarget{}
|
||||
l := NewSlotLRU[string, string](100, func(k string) uint64 {
|
||||
h := fnv.New64a()
|
||||
h.Write(*(*[]byte)(unsafe.Pointer(&k)))
|
||||
return h.Sum64()
|
||||
}, func() LRU[string, string] {
|
||||
return NewExpirationLRU[string, string](100, time.Second*60, time.Second, target, nil)
|
||||
})
|
||||
//l := NewInertiaLRU[string, string](1000, time.Second*20, time.Second*5, target)
|
||||
|
||||
fn := func(key string, n int, fetch func() (string, error)) {
|
||||
for i := 0; i < n; i++ {
|
||||
//v, err := l.Get(key, fetch)
|
||||
//if err == nil {
|
||||
// t.Log("key", key, "value", v)
|
||||
//} else {
|
||||
// t.Error("key", key, err)
|
||||
//}
|
||||
v, err := l.Get(key, fetch)
|
||||
//time.Sleep(time.Second / 100)
|
||||
func(v ...any) {}(v, err)
|
||||
}
|
||||
}
|
||||
|
||||
tmp := make(map[string]struct{})
|
||||
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < 10000; i++ {
|
||||
wg.Add(1)
|
||||
key := fmt.Sprintf("key_%d", i%200)
|
||||
tmp[key] = struct{}{}
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
//t.Log(key)
|
||||
fn(key, 10000, func() (string, error) {
|
||||
//time.Sleep(time.Second * 3)
|
||||
//t.Log(time.Now(), "key", key, "fetch")
|
||||
//if rand.Uint32()%5 == 0 {
|
||||
// return "value_" + key, nil
|
||||
//}
|
||||
//return "", errors.New("rand error")
|
||||
return "value_" + key, nil
|
||||
})
|
||||
}()
|
||||
|
||||
//wg.Add(1)
|
||||
//go func() {
|
||||
// defer wg.Done()
|
||||
// for i := 0; i < 10; i++ {
|
||||
// l.Del(key)
|
||||
// time.Sleep(time.Second / 3)
|
||||
// }
|
||||
//}()
|
||||
}
|
||||
wg.Wait()
|
||||
t.Log(len(tmp))
|
||||
t.Log(target.String())
|
||||
|
||||
}
|
||||
@ -0,0 +1,51 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 lru
|
||||
|
||||
func NewSlotLRU[K comparable, V any](slotNum int, hash func(K) uint64, create func() LRU[K, V]) LRU[K, V] {
|
||||
x := &slotLRU[K, V]{
|
||||
n: uint64(slotNum),
|
||||
slots: make([]LRU[K, V], slotNum),
|
||||
hash: hash,
|
||||
}
|
||||
for i := 0; i < slotNum; i++ {
|
||||
x.slots[i] = create()
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
type slotLRU[K comparable, V any] struct {
|
||||
n uint64
|
||||
slots []LRU[K, V]
|
||||
hash func(k K) uint64
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) getIndex(k K) uint64 {
|
||||
return x.hash(k) % x.n
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
|
||||
return x.slots[x.getIndex(key)].Get(key, fetch)
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) Del(key K) bool {
|
||||
return x.slots[x.getIndex(key)].Del(key)
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) Stop() {
|
||||
for _, slot := range x.slots {
|
||||
slot.Stop()
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,136 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/openimsdk/localcache/lru"
|
||||
)
|
||||
|
||||
func defaultOption() *option {
|
||||
return &option{
|
||||
localSlotNum: 500,
|
||||
localSlotSize: 20000,
|
||||
linkSlotNum: 500,
|
||||
expirationEvict: false,
|
||||
localSuccessTTL: time.Minute,
|
||||
localFailedTTL: time.Second * 5,
|
||||
delFn: make([]func(ctx context.Context, key ...string), 0, 2),
|
||||
target: emptyTarget{},
|
||||
}
|
||||
}
|
||||
|
||||
type option struct {
|
||||
localSlotNum int
|
||||
localSlotSize int
|
||||
linkSlotNum int
|
||||
// expirationEvict: true means that the cache will be actively cleared when the timer expires,
|
||||
// false means that the cache will be lazily deleted.
|
||||
expirationEvict bool
|
||||
localSuccessTTL time.Duration
|
||||
localFailedTTL time.Duration
|
||||
delFn []func(ctx context.Context, key ...string)
|
||||
target lru.Target
|
||||
}
|
||||
|
||||
type Option func(o *option)
|
||||
|
||||
func WithExpirationEvict() Option {
|
||||
return func(o *option) {
|
||||
o.expirationEvict = true
|
||||
}
|
||||
}
|
||||
|
||||
func WithLazy() Option {
|
||||
return func(o *option) {
|
||||
o.expirationEvict = false
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalDisable() Option {
|
||||
return WithLinkSlotNum(0)
|
||||
}
|
||||
|
||||
func WithLinkDisable() Option {
|
||||
return WithLinkSlotNum(0)
|
||||
}
|
||||
|
||||
func WithLinkSlotNum(linkSlotNum int) Option {
|
||||
return func(o *option) {
|
||||
o.linkSlotNum = linkSlotNum
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalSlotNum(localSlotNum int) Option {
|
||||
return func(o *option) {
|
||||
o.localSlotNum = localSlotNum
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalSlotSize(localSlotSize int) Option {
|
||||
return func(o *option) {
|
||||
o.localSlotSize = localSlotSize
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalSuccessTTL(localSuccessTTL time.Duration) Option {
|
||||
if localSuccessTTL < 0 {
|
||||
panic("localSuccessTTL should be greater than 0")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.localSuccessTTL = localSuccessTTL
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalFailedTTL(localFailedTTL time.Duration) Option {
|
||||
if localFailedTTL < 0 {
|
||||
panic("localFailedTTL should be greater than 0")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.localFailedTTL = localFailedTTL
|
||||
}
|
||||
}
|
||||
|
||||
func WithTarget(target lru.Target) Option {
|
||||
if target == nil {
|
||||
panic("target should not be nil")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.target = target
|
||||
}
|
||||
}
|
||||
|
||||
func WithDeleteKeyBefore(fn func(ctx context.Context, key ...string)) Option {
|
||||
if fn == nil {
|
||||
panic("fn should not be nil")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.delFn = append(o.delFn, fn)
|
||||
}
|
||||
}
|
||||
|
||||
type emptyTarget struct{}
|
||||
|
||||
func (e emptyTarget) IncrGetHit() {}
|
||||
|
||||
func (e emptyTarget) IncrGetSuccess() {}
|
||||
|
||||
func (e emptyTarget) IncrGetFailed() {}
|
||||
|
||||
func (e emptyTarget) IncrDelHit() {}
|
||||
|
||||
func (e emptyTarget) IncrDelNotFound() {}
|
||||
@ -0,0 +1,127 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 rpccache
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
pbconversation "github.com/OpenIMSDK/protocol/conversation"
|
||||
"github.com/OpenIMSDK/tools/errs"
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
"github.com/openimsdk/localcache"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/cachekey"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func NewConversationLocalCache(client rpcclient.ConversationRpcClient, cli redis.UniversalClient) *ConversationLocalCache {
|
||||
lc := config.Config.LocalCache.Conversation
|
||||
log.ZDebug(context.Background(), "ConversationLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
|
||||
x := &ConversationLocalCache{
|
||||
client: client,
|
||||
local: localcache.New[any](
|
||||
localcache.WithLocalSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSlotSize(lc.SlotSize),
|
||||
localcache.WithLinkSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSuccessTTL(lc.Success()),
|
||||
localcache.WithLocalFailedTTL(lc.Failed()),
|
||||
),
|
||||
}
|
||||
if lc.Enable() {
|
||||
go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal)
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
type ConversationLocalCache struct {
|
||||
client rpcclient.ConversationRpcClient
|
||||
local localcache.Cache[any]
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) GetConversationIDs(ctx context.Context, ownerUserID string) (val []string, err error) {
|
||||
log.ZDebug(ctx, "ConversationLocalCache GetConversationIDs req", "ownerUserID", ownerUserID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "ConversationLocalCache GetConversationIDs return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "ConversationLocalCache GetConversationIDs return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[[]string](c.local.Get(ctx, cachekey.GetConversationIDsKey(ownerUserID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "ConversationLocalCache GetConversationIDs rpc", "ownerUserID", ownerUserID)
|
||||
return c.client.GetConversationIDs(ctx, ownerUserID)
|
||||
}))
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) GetConversation(ctx context.Context, userID, conversationID string) (val *pbconversation.Conversation, err error) {
|
||||
log.ZDebug(ctx, "ConversationLocalCache GetConversation req", "userID", userID, "conversationID", conversationID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "ConversationLocalCache GetConversation return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "ConversationLocalCache GetConversation return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[*pbconversation.Conversation](c.local.Get(ctx, cachekey.GetConversationKey(userID, conversationID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "ConversationLocalCache GetConversation rpc", "userID", userID, "conversationID", conversationID)
|
||||
return c.client.GetConversation(ctx, userID, conversationID)
|
||||
}))
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) {
|
||||
conv, err := c.GetConversation(ctx, userID, conversationID)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return conv.RecvMsgOpt, nil
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*pbconversation.Conversation, error) {
|
||||
conversations := make([]*pbconversation.Conversation, 0, len(conversationIDs))
|
||||
for _, conversationID := range conversationIDs {
|
||||
conversation, err := c.GetConversation(ctx, ownerUserID, conversationID)
|
||||
if err != nil {
|
||||
if errs.ErrRecordNotFound.Is(err) {
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
conversations = append(conversations, conversation)
|
||||
}
|
||||
return conversations, nil
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) getConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) (*listMap[string], error) {
|
||||
return localcache.AnyValue[*listMap[string]](c.local.Get(ctx, cachekey.GetConversationNotReceiveMessageUserIDsKey(conversationID), func(ctx context.Context) (any, error) {
|
||||
return newListMap(c.client.GetConversationNotReceiveMessageUserIDs(ctx, conversationID))
|
||||
}))
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) {
|
||||
res, err := c.getConversationNotReceiveMessageUserIDs(ctx, conversationID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return res.List, nil
|
||||
}
|
||||
|
||||
func (c *ConversationLocalCache) GetConversationNotReceiveMessageUserIDMap(ctx context.Context, conversationID string) (map[string]struct{}, error) {
|
||||
res, err := c.getConversationNotReceiveMessageUserIDs(ctx, conversationID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return res.Map, nil
|
||||
}
|
||||
@ -0,0 +1,81 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 rpccache
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
"github.com/openimsdk/localcache"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/cachekey"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func NewFriendLocalCache(client rpcclient.FriendRpcClient, cli redis.UniversalClient) *FriendLocalCache {
|
||||
lc := config.Config.LocalCache.Friend
|
||||
log.ZDebug(context.Background(), "FriendLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
|
||||
x := &FriendLocalCache{
|
||||
client: client,
|
||||
local: localcache.New[any](
|
||||
localcache.WithLocalSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSlotSize(lc.SlotSize),
|
||||
localcache.WithLinkSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSuccessTTL(lc.Success()),
|
||||
localcache.WithLocalFailedTTL(lc.Failed()),
|
||||
),
|
||||
}
|
||||
if lc.Enable() {
|
||||
go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal)
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
type FriendLocalCache struct {
|
||||
client rpcclient.FriendRpcClient
|
||||
local localcache.Cache[any]
|
||||
}
|
||||
|
||||
func (f *FriendLocalCache) IsFriend(ctx context.Context, possibleFriendUserID, userID string) (val bool, err error) {
|
||||
log.ZDebug(ctx, "FriendLocalCache IsFriend req", "possibleFriendUserID", possibleFriendUserID, "userID", userID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "FriendLocalCache IsFriend return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "FriendLocalCache IsFriend return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[bool](f.local.GetLink(ctx, cachekey.GetIsFriendKey(possibleFriendUserID, userID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "FriendLocalCache IsFriend rpc", "possibleFriendUserID", possibleFriendUserID, "userID", userID)
|
||||
return f.client.IsFriend(ctx, possibleFriendUserID, userID)
|
||||
}, cachekey.GetFriendIDsKey(possibleFriendUserID)))
|
||||
}
|
||||
|
||||
// IsBlack possibleBlackUserID selfUserID.
|
||||
func (f *FriendLocalCache) IsBlack(ctx context.Context, possibleBlackUserID, userID string) (val bool, err error) {
|
||||
log.ZDebug(ctx, "FriendLocalCache IsBlack req", "possibleBlackUserID", possibleBlackUserID, "userID", userID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "FriendLocalCache IsBlack return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "FriendLocalCache IsBlack return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[bool](f.local.GetLink(ctx, cachekey.GetIsBlackIDsKey(possibleBlackUserID, userID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "FriendLocalCache IsBlack rpc", "possibleBlackUserID", possibleBlackUserID, "userID", userID)
|
||||
return f.client.IsBlack(ctx, possibleBlackUserID, userID)
|
||||
}, cachekey.GetBlackIDsKey(userID)))
|
||||
}
|
||||
@ -0,0 +1,158 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 rpccache
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/OpenIMSDK/protocol/sdkws"
|
||||
"github.com/OpenIMSDK/tools/errs"
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
"github.com/openimsdk/localcache"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/cachekey"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func NewGroupLocalCache(client rpcclient.GroupRpcClient, cli redis.UniversalClient) *GroupLocalCache {
|
||||
lc := config.Config.LocalCache.Group
|
||||
log.ZDebug(context.Background(), "GroupLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
|
||||
x := &GroupLocalCache{
|
||||
client: client,
|
||||
local: localcache.New[any](
|
||||
localcache.WithLocalSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSlotSize(lc.SlotSize),
|
||||
localcache.WithLinkSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSuccessTTL(lc.Success()),
|
||||
localcache.WithLocalFailedTTL(lc.Failed()),
|
||||
),
|
||||
}
|
||||
if lc.Enable() {
|
||||
go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal)
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
type GroupLocalCache struct {
|
||||
client rpcclient.GroupRpcClient
|
||||
local localcache.Cache[any]
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) getGroupMemberIDs(ctx context.Context, groupID string) (val *listMap[string], err error) {
|
||||
log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs req", "groupID", groupID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "GroupLocalCache getGroupMemberIDs return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[*listMap[string]](g.local.Get(ctx, cachekey.GetGroupMemberIDsKey(groupID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "GroupLocalCache getGroupMemberIDs rpc", "groupID", groupID)
|
||||
return newListMap(g.client.GetGroupMemberIDs(ctx, groupID))
|
||||
}))
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupMember(ctx context.Context, groupID, userID string) (val *sdkws.GroupMemberFullInfo, err error) {
|
||||
log.ZDebug(ctx, "GroupLocalCache GetGroupInfo req", "groupID", groupID, "userID", userID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "GroupLocalCache GetGroupInfo return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "GroupLocalCache GetGroupInfo return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[*sdkws.GroupMemberFullInfo](g.local.Get(ctx, cachekey.GetGroupMemberInfoKey(groupID, userID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "GroupLocalCache GetGroupInfo rpc", "groupID", groupID, "userID", userID)
|
||||
return g.client.GetGroupMemberCache(ctx, groupID, userID)
|
||||
}))
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupInfo(ctx context.Context, groupID string) (val *sdkws.GroupInfo, err error) {
|
||||
log.ZDebug(ctx, "GroupLocalCache GetGroupInfo req", "groupID", groupID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "GroupLocalCache GetGroupInfo return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "GroupLocalCache GetGroupInfo return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[*sdkws.GroupInfo](g.local.Get(ctx, cachekey.GetGroupInfoKey(groupID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "GroupLocalCache GetGroupInfo rpc", "groupID", groupID)
|
||||
return g.client.GetGroupInfoCache(ctx, groupID)
|
||||
}))
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
|
||||
res, err := g.getGroupMemberIDs(ctx, groupID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return res.List, nil
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupMemberIDMap(ctx context.Context, groupID string) (map[string]struct{}, error) {
|
||||
res, err := g.getGroupMemberIDs(ctx, groupID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return res.Map, nil
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupInfos(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) {
|
||||
groupInfos := make([]*sdkws.GroupInfo, 0, len(groupIDs))
|
||||
for _, groupID := range groupIDs {
|
||||
groupInfo, err := g.GetGroupInfo(ctx, groupID)
|
||||
if err != nil {
|
||||
if errs.ErrRecordNotFound.Is(err) {
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
groupInfos = append(groupInfos, groupInfo)
|
||||
}
|
||||
return groupInfos, nil
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupMembers(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
|
||||
members := make([]*sdkws.GroupMemberFullInfo, 0, len(userIDs))
|
||||
for _, userID := range userIDs {
|
||||
member, err := g.GetGroupMember(ctx, groupID, userID)
|
||||
if err != nil {
|
||||
if errs.ErrRecordNotFound.Is(err) {
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
members = append(members, member)
|
||||
}
|
||||
return members, nil
|
||||
}
|
||||
|
||||
func (g *GroupLocalCache) GetGroupMemberInfoMap(ctx context.Context, groupID string, userIDs []string) (map[string]*sdkws.GroupMemberFullInfo, error) {
|
||||
members := make(map[string]*sdkws.GroupMemberFullInfo)
|
||||
for _, userID := range userIDs {
|
||||
member, err := g.GetGroupMember(ctx, groupID, userID)
|
||||
if err != nil {
|
||||
if errs.ErrRecordNotFound.Is(err) {
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
members[userID] = member
|
||||
}
|
||||
return members, nil
|
||||
}
|
||||
@ -0,0 +1,38 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 rpccache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func subscriberRedisDeleteCache(ctx context.Context, client redis.UniversalClient, channel string, del func(ctx context.Context, key ...string)) {
|
||||
for message := range client.Subscribe(ctx, channel).Channel() {
|
||||
log.ZDebug(ctx, "subscriberRedisDeleteCache", "channel", channel, "payload", message.Payload)
|
||||
var keys []string
|
||||
if err := json.Unmarshal([]byte(message.Payload), &keys); err != nil {
|
||||
log.ZError(ctx, "subscriberRedisDeleteCache json.Unmarshal error", err)
|
||||
continue
|
||||
}
|
||||
if len(keys) == 0 {
|
||||
continue
|
||||
}
|
||||
del(ctx, keys...)
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,112 @@
|
||||
// Copyright © 2024 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 rpccache
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/OpenIMSDK/protocol/sdkws"
|
||||
"github.com/OpenIMSDK/tools/errs"
|
||||
"github.com/OpenIMSDK/tools/log"
|
||||
"github.com/openimsdk/localcache"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/cachekey"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
|
||||
"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func NewUserLocalCache(client rpcclient.UserRpcClient, cli redis.UniversalClient) *UserLocalCache {
|
||||
lc := config.Config.LocalCache.User
|
||||
log.ZDebug(context.Background(), "UserLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
|
||||
x := &UserLocalCache{
|
||||
client: client,
|
||||
local: localcache.New[any](
|
||||
localcache.WithLocalSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSlotSize(lc.SlotSize),
|
||||
localcache.WithLinkSlotNum(lc.SlotNum),
|
||||
localcache.WithLocalSuccessTTL(lc.Success()),
|
||||
localcache.WithLocalFailedTTL(lc.Failed()),
|
||||
),
|
||||
}
|
||||
if lc.Enable() {
|
||||
go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal)
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
type UserLocalCache struct {
|
||||
client rpcclient.UserRpcClient
|
||||
local localcache.Cache[any]
|
||||
}
|
||||
|
||||
func (u *UserLocalCache) GetUserInfo(ctx context.Context, userID string) (val *sdkws.UserInfo, err error) {
|
||||
log.ZDebug(ctx, "UserLocalCache GetUserInfo req", "userID", userID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "UserLocalCache GetUserInfo return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "UserLocalCache GetUserInfo return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[*sdkws.UserInfo](u.local.Get(ctx, cachekey.GetUserInfoKey(userID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "UserLocalCache GetUserInfo rpc", "userID", userID)
|
||||
return u.client.GetUserInfo(ctx, userID)
|
||||
}))
|
||||
}
|
||||
|
||||
func (u *UserLocalCache) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string) (val int32, err error) {
|
||||
log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt req", "userID", userID)
|
||||
defer func() {
|
||||
if err == nil {
|
||||
log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt return", "value", val)
|
||||
} else {
|
||||
log.ZError(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt return", err)
|
||||
}
|
||||
}()
|
||||
return localcache.AnyValue[int32](u.local.Get(ctx, cachekey.GetUserGlobalRecvMsgOptKey(userID), func(ctx context.Context) (any, error) {
|
||||
log.ZDebug(ctx, "UserLocalCache GetUserGlobalMsgRecvOpt rpc", "userID", userID)
|
||||
return u.client.GetUserGlobalMsgRecvOpt(ctx, userID)
|
||||
}))
|
||||
}
|
||||
|
||||
func (u *UserLocalCache) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
|
||||
users := make([]*sdkws.UserInfo, 0, len(userIDs))
|
||||
for _, userID := range userIDs {
|
||||
user, err := u.GetUserInfo(ctx, userID)
|
||||
if err != nil {
|
||||
if errs.ErrRecordNotFound.Is(err) {
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
users = append(users, user)
|
||||
}
|
||||
return users, nil
|
||||
}
|
||||
|
||||
func (u *UserLocalCache) GetUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
|
||||
users := make(map[string]*sdkws.UserInfo, len(userIDs))
|
||||
for _, userID := range userIDs {
|
||||
user, err := u.GetUserInfo(ctx, userID)
|
||||
if err != nil {
|
||||
if errs.ErrRecordNotFound.Is(err) {
|
||||
continue
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
users[userID] = user
|
||||
}
|
||||
return users, nil
|
||||
}
|
||||
@ -1,98 +0,0 @@
|
||||
# OpenIM V2 至 V3 数据迁移指南
|
||||
|
||||
该指南提供了从 OpenIM V2 迁移至 V3 的详细步骤。请确保在开始迁移过程之前，熟悉所有步骤，并按照指南准确执行。
|
||||
|
||||
+ [OpenIM Chat](https://github.com/OpenIMSDK/chat)
|
||||
+ [OpenIM Server](https://github.com/OpenIMSDK/Open-IM-Server)
|
||||
|
||||
|
||||
|
||||
### 1. 数据备份
|
||||
|
||||
在开始数据迁移之前，强烈建议备份所有相关的数据以防止任何可能的数据丢失。
|
||||
|
||||
### 2. 迁移 OpenIM MySQL 数据
|
||||
|
||||
+ 位置: `open-im-server/tools/data-conversion/openim/cmd/conversion-mysql.go`
|
||||
+ 配置 `conversion-mysql.go` 文件中的数据库信息。
|
||||
+ 手动创建 V3 版本的数据库，并确保字符集为 `utf8mb4`。
|
||||
|
||||
```bash
|
||||
// V2 数据库配置
|
||||
var (
|
||||
usernameV2 = "root"
|
||||
passwordV2 = "openIM"
|
||||
addrV2 = "127.0.0.1:13306"
|
||||
databaseV2 = "openIM_v2"
|
||||
)
|
||||
|
||||
// V3 数据库配置
|
||||
var (
|
||||
usernameV3 = "root"
|
||||
passwordV3 = "openIM123"
|
||||
addrV3 = "127.0.0.1:13306"
|
||||
databaseV3 = "openim_v3"
|
||||
)
|
||||
```
|
||||
|
||||
**执行数据迁移命令：**
|
||||
|
||||
```bash
|
||||
make build BINS="conversion-mysql"
|
||||
```
|
||||
|
||||
启动的二进制在 `_output/bin/tools` 中
|
||||
|
||||
|
||||
### 3. 转换聊天消息（可选）
|
||||
|
||||
+ 只支持转换存储在 Kafka 中的消息。
|
||||
+ 位置: `open-im-server/tools/data-conversion/openim/conversion-msg/conversion-msg.go`
|
||||
+ 配置 `msg.go` 文件中的消息和服务器信息。
|
||||
|
||||
```bash
|
||||
var (
|
||||
topic = "ws2ms_chat" // V2 版本 Kafka 主题
|
||||
kafkaAddr = "127.0.0.1:9092" // V2 版本 Kafka 地址
|
||||
rpcAddr = "127.0.0.1:10130" // V3 版本 RPC 地址
|
||||
adminUserID = "openIM123456" // V3 版本管理员用户ID
|
||||
concurrency = 4 // 并发数量
|
||||
)
|
||||
```
|
||||
|
||||
**执行数据迁移命令：**
|
||||
|
||||
```bash
|
||||
make build BINS="conversion-msg"
|
||||
```
|
||||
|
||||
### 4. 转换业务服务器数据
|
||||
|
||||
+ 只支持转换存储在 Kafka 中的消息。
|
||||
+ 位置: `open-im-server/tools/data-conversion/chat/cmd/conversion-chat/chat.go`
|
||||
+ 需要手动创建 V3 版本的数据库，并确保字符集为 `utf8mb4`。
|
||||
+ 配置 `main.go` 文件中的数据库信息。
|
||||
|
||||
```bash
|
||||
// V2 数据库配置
|
||||
var (
|
||||
usernameV2 = "root"
|
||||
passwordV2 = "openIM"
|
||||
addrV2 = "127.0.0.1:13306"
|
||||
databaseV2 = "admin_chat"
|
||||
)
|
||||
|
||||
// V3 数据库配置
|
||||
var (
|
||||
usernameV3 = "root"
|
||||
passwordV3 = "openIM123"
|
||||
addrV3 = "127.0.0.1:13306"
|
||||
databaseV3 = "openim_enterprise"
|
||||
)
|
||||
```
|
||||
|
||||
**执行数据迁移命令：**
|
||||
|
||||
```bash
|
||||
make build BINS="conversion-chat"
|
||||
```
|
||||
@ -1,77 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
|
||||
"gorm.io/driver/mysql"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/logger"
|
||||
|
||||
"github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/conversion"
|
||||
"github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils"
|
||||
)
|
||||
|
||||
func main() {
|
||||
var (
|
||||
usernameV2 = "root" // Username for MySQL v2 version
|
||||
passwordV2 = "openIM" // Password for MySQL v2 version
|
||||
addrV2 = "127.0.0.1:13306" // Address for MySQL v2 version
|
||||
databaseV2 = "admin_chat" // Database name for MySQL v2 version
|
||||
)
|
||||
|
||||
var (
|
||||
usernameV3 = "root" // Username for MySQL v3 version
|
||||
passwordV3 = "openIM123" // Password for MySQL v3 version
|
||||
addrV3 = "127.0.0.1:13306" // Address for MySQL v3 version
|
||||
databaseV3 = "openim_enterprise" // Database name for MySQL v3 version
|
||||
)
|
||||
|
||||
var concurrency = 1 // Concurrency quantity
|
||||
|
||||
log.SetFlags(log.LstdFlags | log.Llongfile)
|
||||
dsnV2 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV2, passwordV2, addrV2, databaseV2)
|
||||
dsnV3 := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", usernameV3, passwordV3, addrV3, databaseV3)
|
||||
dbV2, err := gorm.Open(mysql.Open(dsnV2), &gorm.Config{Logger: logger.Discard})
|
||||
if err != nil {
|
||||
log.Println("open v2 db failed", err)
|
||||
return
|
||||
}
|
||||
dbV3, err := gorm.Open(mysql.Open(dsnV3), &gorm.Config{Logger: logger.Discard})
|
||||
if err != nil {
|
||||
log.Println("open v3 db failed", err)
|
||||
return
|
||||
}
|
||||
|
||||
var tasks utils.TakeList
|
||||
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Account) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Attribute) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Register) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.UserLoginRecord) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Admin) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.Applet) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.ForbiddenAccount) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.InvitationRegister) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.IPForbidden) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.LimitUserLoginIP) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.RegisterAddFriend) })
|
||||
tasks.Append(func() (string, error) { return utils.FindAndInsert(dbV2, dbV3, conversion.RegisterAddGroup) })
|
||||
|
||||
utils.RunTask(concurrency, tasks)
|
||||
|
||||
}
|
||||
@ -1,167 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 conversion
|
||||
|
||||
import (
|
||||
v2 "github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/v2"
|
||||
"github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/v3/admin"
|
||||
"github.com/openimsdk/open-im-server/v3/tools/data-conversion/chat/v3/chat"
|
||||
"github.com/openimsdk/open-im-server/v3/tools/data-conversion/utils"
|
||||
)
|
||||
|
||||
// ########## chat ##########
|
||||
|
||||
func Account(v v2.Account) (chat.Account, bool) {
|
||||
utils.InitTime(&v.CreateTime, &v.ChangeTime)
|
||||
return chat.Account{
|
||||
UserID: v.UserID,
|
||||
Password: v.Password,
|
||||
CreateTime: v.CreateTime,
|
||||
ChangeTime: v.ChangeTime,
|
||||
OperatorUserID: v.OperatorUserID,
|
||||
}, true
|
||||
}
|
||||
|
||||
func Attribute(v v2.Attribute) (chat.Attribute, bool) {
|
||||
utils.InitTime(&v.CreateTime, &v.ChangeTime, &v.BirthTime)
|
||||
return chat.Attribute{
|
||||
UserID: v.UserID,
|
||||
Account: v.Account,
|
||||
PhoneNumber: v.PhoneNumber,
|
||||
AreaCode: v.AreaCode,
|
||||
Email: v.Email,
|
||||
Nickname: v.Nickname,
|
||||
FaceURL: v.FaceURL,
|
||||
Gender: v.Gender,
|
||||
CreateTime: v.CreateTime,
|
||||
ChangeTime: v.ChangeTime,
|
||||
BirthTime: v.BirthTime,
|
||||
Level: v.Level,
|
||||
AllowVibration: v.AllowVibration,
|
||||
AllowBeep: v.AllowBeep,
|
||||
AllowAddFriend: v.AllowAddFriend,
|
||||
GlobalRecvMsgOpt: 0,
|
||||
}, true
|
||||
}
|
||||
|
||||
func Register(v v2.Register) (chat.Register, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return chat.Register{
|
||||
UserID: v.UserID,
|
||||
DeviceID: v.DeviceID,
|
||||
IP: v.IP,
|
||||
Platform: v.Platform,
|
||||
AccountType: v.AccountType,
|
||||
Mode: v.Mode,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func UserLoginRecord(v v2.UserLoginRecord) (chat.UserLoginRecord, bool) {
|
||||
utils.InitTime(&v.LoginTime)
|
||||
return chat.UserLoginRecord{
|
||||
UserID: v.UserID,
|
||||
LoginTime: v.LoginTime,
|
||||
IP: v.IP,
|
||||
DeviceID: v.DeviceID,
|
||||
Platform: v.Platform,
|
||||
}, true
|
||||
}
|
||||
|
||||
// ########## admin ##########
|
||||
|
||||
func Admin(v v2.Admin) (admin.Admin, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.Admin{
|
||||
Account: v.Account,
|
||||
Password: v.Password,
|
||||
FaceURL: v.FaceURL,
|
||||
Nickname: v.Nickname,
|
||||
UserID: v.UserID,
|
||||
Level: v.Level,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func Applet(v v2.Applet) (admin.Applet, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.Applet{
|
||||
ID: v.ID,
|
||||
Name: v.Name,
|
||||
AppID: v.AppID,
|
||||
Icon: v.Icon,
|
||||
URL: v.URL,
|
||||
MD5: v.MD5,
|
||||
Size: v.Size,
|
||||
Version: v.Version,
|
||||
Priority: v.Priority,
|
||||
Status: v.Status,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func ForbiddenAccount(v v2.ForbiddenAccount) (admin.ForbiddenAccount, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.ForbiddenAccount{
|
||||
UserID: v.UserID,
|
||||
Reason: v.Reason,
|
||||
OperatorUserID: v.OperatorUserID,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func InvitationRegister(v v2.InvitationRegister) (admin.InvitationRegister, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.InvitationRegister{
|
||||
InvitationCode: v.InvitationCode,
|
||||
UsedByUserID: v.UsedByUserID,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func IPForbidden(v v2.IPForbidden) (admin.IPForbidden, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.IPForbidden{
|
||||
IP: v.IP,
|
||||
LimitRegister: v.LimitRegister > 0,
|
||||
LimitLogin: v.LimitLogin > 0,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func LimitUserLoginIP(v v2.LimitUserLoginIP) (admin.LimitUserLoginIP, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.LimitUserLoginIP{
|
||||
UserID: v.UserID,
|
||||
IP: v.IP,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func RegisterAddFriend(v v2.RegisterAddFriend) (admin.RegisterAddFriend, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.RegisterAddFriend{
|
||||
UserID: v.UserID,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
|
||||
func RegisterAddGroup(v v2.RegisterAddGroup) (admin.RegisterAddGroup, bool) {
|
||||
utils.InitTime(&v.CreateTime)
|
||||
return admin.RegisterAddGroup{
|
||||
GroupID: v.GroupID,
|
||||
CreateTime: v.CreateTime,
|
||||
}, true
|
||||
}
|
||||
@ -1,77 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 v2
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// AppVersion manages PC client versions
|
||||
type AppVersion struct {
|
||||
Version string `gorm:"column:version;size:64" json:"version"`
|
||||
Type int `gorm:"column:type;primary_key" json:"type"`
|
||||
UpdateTime int `gorm:"column:update_time" json:"update_time"`
|
||||
ForceUpdate bool `gorm:"column:force_update" json:"force_update"`
|
||||
FileName string `gorm:"column:file_name" json:"file_name"`
|
||||
YamlName string `gorm:"column:yaml_name" json:"yaml_name"`
|
||||
UpdateLog string `gorm:"column:update_log" json:"update_log"`
|
||||
}
|
||||
|
||||
// Admin manages backend administrators
|
||||
type Admin struct {
|
||||
Account string `gorm:"column:account;primary_key;type:char(64)" json:"account"`
|
||||
Password string `gorm:"column:Password;type:char(64)" json:"password"`
|
||||
FaceURL string `gorm:"column:FaceURL;type:char(64)" json:"faceURL"`
|
||||
Nickname string `gorm:"column:Nickname;type:char(64)" json:"nickname"`
|
||||
UserID string `gorm:"column:UserID;type:char(64)" json:"userID"` //openIM userID
|
||||
Level int32 `gorm:"column:level;default:1" json:"level"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
}
|
||||
|
||||
// RegisterAddFriend specifies default friends when registering
|
||||
type RegisterAddFriend struct {
|
||||
UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
}
|
||||
|
||||
// RegisterAddGroup specifies default groups when registering
|
||||
type RegisterAddGroup struct {
|
||||
GroupID string `gorm:"column:group_id;primary_key;type:char(64)" json:"userID"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
}
|
||||
|
||||
// ClientInitConfig contains system-related configuration items
|
||||
type ClientInitConfig struct {
|
||||
DiscoverPageURL string `gorm:"column:discover_page_url;size:128" json:"discoverPageURL"`
|
||||
OrdinaryUserAddFriend int32 `gorm:"column:ordinary_user_add_friend; default:1" json:"ordinaryUserAddFriend"`
|
||||
BossUserID string `gorm:"column:boss_user_id;type:char(64)" json:"bossUserID"`
|
||||
AdminURL string `gorm:"column:admin_url;type:char(128)" json:"adminURL"`
|
||||
AllowSendMsgNotFriend int32 `gorm:"column:allow_send_msg_not_friend;default:1" json:"allowSendMsgNotFriend"`
|
||||
NeedInvitationCodeRegister int32 `gorm:"column:need_invitation_code_register;default:0" json:"needInvitationCodeRegister"`
|
||||
}
|
||||
|
||||
type Applet struct {
|
||||
ID string `gorm:"column:id;primary_key;size:64"`
|
||||
Name string `gorm:"column:name;uniqueIndex;size:64"`
|
||||
AppID string `gorm:"column:app_id;uniqueIndex;size:255"`
|
||||
Icon string `gorm:"column:icon;size:255"`
|
||||
URL string `gorm:"column:url;size:255"`
|
||||
MD5 string `gorm:"column:md5;size:255"`
|
||||
Size int64 `gorm:"column:size"`
|
||||
Version string `gorm:"column:version;size:64"`
|
||||
Priority uint32 `gorm:"column:priority;size:64"`
|
||||
Status uint8 `gorm:"column:status"`
|
||||
CreateTime time.Time `gorm:"column:create_time;autoCreateTime;size:64"`
|
||||
}
|
||||
@ -1,109 +0,0 @@
|
||||
// Copyright © 2023 OpenIM. All rights reserved.
|
||||
//
|
||||
// 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 v2
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// Register Registration information sheet
|
||||
type Register struct {
|
||||
UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"`
|
||||
DeviceID string `gorm:"column:device_id;type:varchar(255)" json:"deviceID"`
|
||||
IP string `gorm:"column:ip;type:varchar(32)" json:"ip"`
|
||||
Platform string `gorm:"column:platform;type:varchar(32)" json:"platform"`
|
||||
AccountType string `gorm:"column:account_type;type:varchar(32)" json:"accountType"` //email phone account
|
||||
Mode string `gorm:"column:mode;type:varchar(32)"` //user admin
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
}
|
||||
|
||||
// Account username and password table
|
||||
type Account struct {
|
||||
UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"`
|
||||
Password string `gorm:"column:password;type:varchar(255)" json:"password"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
ChangeTime time.Time `gorm:"column:change_time" json:"changeTime"`
|
||||
OperatorUserID string `gorm:"column:operator_user_id;type:varchar(64)" json:"operatorUserID"`
|
||||
}
|
||||
|
||||
// Attribute user information table
|
||||
type Attribute struct {
|
||||
UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"`
|
||||
Account string `gorm:"column:account;type:char(64)" json:"account"`
|
||||
PhoneNumber string `gorm:"column:phone_number;type:varchar(32)" json:"phoneNumber"`
|
||||
AreaCode string `gorm:"column:area_code;type:varchar(8)" json:"areaCode"`
|
||||
Email string `gorm:"column:email;type:varchar(64)" json:"email"`
|
||||
Nickname string `gorm:"column:nickname;type:varchar(64)" json:"nickname"`
|
||||
FaceURL string `gorm:"column:face_url;type:varchar(255)" json:"faceURL"`
|
||||
Gender int32 `gorm:"column:gender" json:"gender"`
|
||||
Birth uint32 `gorm:"column:birth" json:"birth"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
ChangeTime time.Time `gorm:"column:change_time" json:"changeTime"`
|
||||
BirthTime time.Time `gorm:"column:birth_time" json:"birthTime"`
|
||||
Level int32 `gorm:"column:level;default:1" json:"level"`
|
||||
AllowVibration int32 `gorm:"column:allow_vibration;default:1" json:"allowVibration"`
|
||||
AllowBeep int32 `gorm:"column:allow_beep;default:1" json:"allowBeep"`
|
||||
AllowAddFriend int32 `gorm:"column:allow_add_friend;default:1" json:"allowAddFriend"`
|
||||
}
|
||||
|
||||
// User friend relationship table
|
||||
type ForbiddenAccount struct {
|
||||
UserID string `gorm:"column:user_id;index:userID;primary_key;type:char(64)" json:"userID"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
Reason string `gorm:"column:reason;type:varchar(255)" json:"reason"`
|
||||
OperatorUserID string `gorm:"column:operator_user_id;type:varchar(255)" json:"operatorUserID"`
|
||||
}
|
||||
|
||||
// user login record table
|
||||
type UserLoginRecord struct {
|
||||
UserID string `gorm:"column:user_id;size:64" json:"userID"`
|
||||
LoginTime time.Time `gorm:"column:login_time" json:"loginTime"`
|
||||
IP string `gorm:"column:ip;type:varchar(32)" json:"ip"`
|
||||
DeviceID string `gorm:"column:device_id;type:varchar(255)" json:"deviceID"`
|
||||
Platform string `gorm:"column:platform;type:varchar(32)" json:"platform"`
|
||||
}
|
||||
|
||||
// ip login registration is prohibited
|
||||
type IPForbidden struct {
|
||||
IP string `gorm:"column:ip;primary_key;type:char(32)" json:"ip"`
|
||||
LimitRegister int32 `gorm:"column:limit_register" json:"limitRegister"`
|
||||
LimitLogin int32 `gorm:"column:limit_login" json:"limitLogin"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
}
|
||||
|
||||
// Restrict userids to certain ip addresses
|
||||
type LimitUserLoginIP struct {
|
||||
UserID string `gorm:"column:user_id;primary_key;type:char(64)" json:"userID"`
|
||||
IP string `gorm:"column:ip;primary_key;type:char(32)" json:"ip"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
}
|
||||
|
||||
// The invitation code is registered for use
|
||||
type InvitationRegister struct {
|
||||
InvitationCode string `gorm:"column:invitation_code;primary_key;type:char(32)" json:"invitationCode"`
|
||||
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
|
||||
UsedByUserID string `gorm:"column:user_id;index:userID;type:char(64)" json:"usedByUserID"`
|
||||
}
|
||||
|
||||
type SignalRecord struct {
|
||||
FileName string `gorm:"column:file_name;primary_key;type:char(128)" json:"fileName"`
|
||||
MediaType string `gorm:"column:media_type;type:char(64);index:media_type_index" json:"mediaType"`
|
||||
RoomType string `gorm:"column:room_type;type:char(20)" json:"roomType"`
|
||||
SenderID string `gorm:"column:sender_id;type:char(64);index:sender_id_index" json:"senderID"`
|
||||
RecvID string `gorm:"column:recv_id;type:char(64);index:recv_id_index" json:"recvID"`
|
||||
GroupID string `gorm:"column:group_id;type:char(64)" json:"groupID"`
|
||||
DownloadURL string `gorm:"column:download_url;type:text" json:"downloadURL"`
|
||||
CreateTime time.Time `gorm:"create_time;index:create_time_index" json:"createTime"`
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
// Copyright © 2023 OpenIM open source community. All rights reserved.
|
||||
//
|
||||
// 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 admin
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// Admin Background administrator.
|
||||
type Admin struct {
|
||||
Account string `gorm:"column:account;primary_key;type:varchar(64)"`
|
||||
Password string `gorm:"column:password;type:varchar(64)"`
|
||||
FaceURL string `gorm:"column:face_url;type:varchar(255)"`
|
||||
Nickname string `gorm:"column:nickname;type:varchar(64)"`
|
||||
UserID string `gorm:"column:user_id;type:varchar(64)"` // openIM userID
|
||||
Level int32 `gorm:"column:level;default:1" `
|
||||
CreateTime time.Time `gorm:"column:create_time"`
|
||||
}
|
||||
|
||||
func (Admin) TableName() string {
|
||||
return "admins"
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue