Driving method and device for multiple network disks and electronic equipment

Abstract

The invention discloses a driving method and device for multiple network disks and electronic equipment. The method comprises the steps that an operation request for a target network disk sent by a client side is received, the target network disk is any one of a plurality of preset network disks corresponding to the client side, and the operation request is used for indicating operation on a target file stored in the target network disk; converting the operation request into a standardized request through a unified abstraction layer, and distributing the standardized request to a target adapter corresponding to a target network disk; and converting the standardized request into a target instruction which can be identified by the application program interface of the target network disk by adopting the target adapter, and calling the application program interface of the target network disk through the target adapter to execute the target instruction. According to the method and the device, the technical problem that each network disk needs to be independently configured with a client when file management is carried out on a plurality of network disks is solved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and more specifically, to a method, device, and electronic device for driving multiple network disks. Background Art

[0002] With the rapid popularization of cloud storage services, many different types of network disk services have appeared on the market. Each network disk service has its own unique application programming interface (API) and operating specifications, which brings significant inconvenience to users. Especially when it is necessary to manage and synchronize files across multiple network disks, the solutions in related technologies usually require users to configure a separate client for each network disk. Users usually need to switch between multiple network disks to complete operations such as data backup, remote sharing, and data synchronization, which increases complexity and operational difficulty. This decentralized management method is not only time-consuming, but also reduces work efficiency, especially when faced with large-scale file management and frequent data exchange needs.

[0003] To address the above-mentioned problems, no effective solutions have been proposed so far. Summary of the Invention

[0004] The embodiments of the present application provide a method, device, and electronic device for driving multiple network disks, so as to at least solve the technical problem that each network disk needs to be configured separately by the client when managing files on multiple network disks.

[0005] According to one aspect of an embodiment of the present application, a multi-network disk driving method is provided, including: receiving an operation request for a target network disk sent by a client, wherein the target network disk is any one of a plurality of preset network disks corresponding to the client, and the operation request is used to indicate an operation to be performed on a target file stored in the target network disk; converting the operation request into a standardized request through a unified abstract layer, and distributing the standardized request to a target adapter corresponding to the target network disk; using the target adapter to convert the standardized request into a target instruction recognizable by the application program interface of the target network disk, and calling the application program interface of the target network disk through the target adapter to execute the target instruction.

[0006] According to some embodiments of the present application, before receiving an operation request for a target network disk sent by a client of a target object, the method further includes: in response to a detected permission setting instruction, configuring access permission information of each object in an access control list stored in a database, wherein the access permission information of each object includes each object's access permissions to files on each network disk in a plurality of preset network disks.

[0007] According to some embodiments of the present application, the target instruction is executed by calling the application program interface of the target network disk through the target adapter, including: when the access control list contains the access rights of the object corresponding to the client to the target file, the target instruction is executed by calling the application program interface of the target network disk through the target adapter, and the execution result is obtained, wherein the execution result is used to indicate the operation result for the target file; in the process of calling the application program interface of the target network disk through the target adapter to execute the target instruction, when the execution interruption is detected, the cause of the execution interruption is sent to the unified abstraction layer through the target adapter.

[0008] According to some embodiments of the present application, an operation request is abstracted into a standardized request through a unified abstract layer, including: parsing the request header and request body in the operation request through the unified abstract layer, and determining the request method, request path, parameter information and data in the request body based on the request header and request body; converting the parameter information into standardized parameters corresponding to the standardized request defined by the unified abstract layer through the unified abstract layer; determining the standardized request based on the standardized parameters, request method, request path and data in the request body through the unified abstract layer.

[0009] According to some embodiments of the present application, the method further includes: when a new preset network disk is detected, loading the configuration information of the new preset network disk into the network disk service list, and constructing an adapter for the new preset network disk.

[0010] According to some embodiments of the present application, the method also includes: obtaining a set of historical operation records of the client within a preset historical time period from a log library, wherein the historical operation record set includes historical operation records corresponding to multiple historical operation requests; determining a file in the historical operation record set whose access times exceed a preset access threshold as a first type of access file, and caching the first type of access file at a target edge node, wherein the target edge node is determined by the geographic location information of the target object, the network status of the target object's location, and the load information of each edge node; the method also includes: predicting a second type of access file of the target object within a preset time period based on the historical operation record set, and caching the second type of access file at the target edge node, wherein the target object is the object corresponding to the client.

[0011] According to some embodiments of the present application, the method also includes: analyzing the file content and file names of files in multiple preset network disks to obtain labels corresponding to each file; mapping the files in multiple preset network disks to multiple virtual folders, wherein each virtual folder corresponds to a file with a label.

[0012] According to some embodiments of the present application, the method further includes: distributing and storing the backup data on edge nodes in multiple geographical areas, wherein each backup data is updated or deleted on the corresponding edge node according to a preset backup frequency and a preset retention period.

[0013] According to another aspect of an embodiment of the present application, a multi-network disk driving device is also provided, including: a receiving module for receiving an operation request for a target network disk sent by a client, wherein the target network disk is any one of a plurality of preset network disks corresponding to the client, and the operation request is used to indicate an operation to be performed on a target file stored in the target network disk; a first conversion module for converting the operation request into a standardized request through a unified abstract layer, and distributing the standardized request to a target adapter corresponding to the target network disk; a second conversion module for using a target adapter to convert the standardized request into a target instruction recognizable by the application program interface of the target network disk, and calling the application program interface of the target network disk through the target adapter to execute the target instruction.

[0014] According to another aspect of an embodiment of the present application, a non-volatile storage medium is provided, in which a program is stored. When the program is running, the device where the non-volatile storage medium is located is controlled to execute the above multi-network disk driving method.

[0015] According to another aspect of an embodiment of the present application, an electronic device is further provided, including: a memory and a processor, the processor being configured to run a program stored in the memory, wherein the above multi-network disk driving method is executed when the program is running.

[0016] According to another aspect of an embodiment of the present application, a computer program product is also provided, including computer instructions, which implement a method for driving multiple network disks when the computer instructions are executed by a processor.

[0017] In an embodiment of the present application, an operation request for a target network disk sent by a client is received, wherein the target network disk is any one of multiple preset network disks corresponding to the client, and the operation request is used to indicate an operation to be performed on a target file stored in the target network disk; the operation request is converted into a standardized request through a unified abstraction layer, and the standardized request is distributed to a target adapter corresponding to the target network disk; the target adapter is used to convert the standardized request into a target instruction recognizable by the application program interface of the target network disk, and the target adapter is used to call the application program interface of the target network disk to execute the target instruction. By receiving the operation request for the target network disk sent by the client, and then converting the operation request into a standardized request through the unified abstraction layer, this step can standardize requests from different network disks into standardized requests, and further using the target adapter to convert the standardized request into a target instruction recognizable by the application program interface of the target network disk, and finally calling the application program interface of the target network disk to execute the target instruction, a client can achieve the purpose of driving the application program interfaces of multiple network disks (any one of the multiple preset network disks) to perform operations, thereby solving the technical problem that when managing files on multiple network disks, each network disk requires a separate client configuration, resulting in low execution efficiency and high complexity. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0019] Figure 1 This is a hardware structure block diagram of a computer terminal for implementing a multi-network disk driving method provided in an embodiment of the present application;

[0020] Figure 2 This is a flowchart of a multi-network disk driving method provided according to an embodiment of the present application;

[0021] Figure 3 This is a schematic diagram of a verification and transaction processing module of a multi-network disk driving method provided in an embodiment of the present application;

[0022] Figure 4 It is a structural schematic diagram of a multi-network disk drive device provided according to an embodiment of the present application. DETAILED DESCRIPTION

[0023] In order to enable those skilled in the art to better understand the present invention, the following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts should fall within the scope of protection of this application.

[0024] The information collected in the embodiments of the present application is information and data authorized by the user or fully authorized by all parties, and the collection, storage, use, processing, transmission, provision, disclosure and application of the relevant data comply with the relevant laws, regulations and standards of the relevant regions, take necessary confidentiality measures, do not violate public order and good morals, and provide corresponding operation entrances for users to choose to authorize or reject the automated decision results; if the user chooses to reject, the expert decision-making process will be entered.

[0025] It should be noted that the terms "first", "second", etc. in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequential order. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments of the present application described herein can be implemented in a sequence other than those illustrated or described herein. In addition, the terms "including" and "having" and any of their variations are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0026] In order to better understand the embodiments of the present application, the technical terms involved in the embodiments of the present application are explained as follows:

[0027] A unified driver is an abstraction layer that handles API requests from multiple cloud storage service providers and converts them into standardized operations. This driver shields the differences between different cloud storage services, allowing users to easily manage multiple cloud storage resources through a single interface without having to understand the specific implementation details of each cloud storage service. This not only simplifies the operation process but also improves work efficiency, allowing users to focus more on their core tasks.

[0028] Transparent access means users can access all supported cloud storage services through a consistent interface, regardless of the underlying cloud storage implementation details. This approach ensures that users don't have to consider the technical differences between different cloud storage services during use, providing a seamless user experience and enhancing the system's usability and friendliness.

[0029] Containerization technologies, such as Docker (an open-source containerization platform that allows developers to package applications and their dependencies into lightweight, portable containers and then run these containers in any Docker-enabled environment, such as a developer's laptop, a company's test servers, or a cloud service provider's infrastructure) and Kubernetes (K8s, a system for managing container clusters that automates the deployment and management of containerized applications, supports automatic scaling and load balancing of containers, and provides high availability and disaster recovery capabilities), are used to rapidly deploy and manage applications and their dependent environments. This technology allows applications to maintain consistency in any environment, from development to testing to production. It not only speeds up application deployment but also simplifies management and maintenance, improving system flexibility and scalability.

[0030] In the related art, each network disk service has its own unique application programming interface (API) and operating specifications, which brings significant inconvenience to users. Especially when it is necessary to manage and synchronize files across multiple network disks, the solutions in the related art usually require users to configure a separate client for each network disk. Users usually need to switch between multiple network disks to complete data backup, remote sharing, data synchronization and other operations, which increases the complexity and difficulty of operation. Therefore, there is a technical problem that when managing files on multiple network disks, each network disk needs to be configured with a separate client. In order to solve this problem, a relevant solution is provided in the embodiment of the present application, which is described in detail below.

[0031] According to an embodiment of the present application, an embodiment of a method for driving multiple network disks is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0032] The method embodiments provided in the embodiments of the present application can be executed in a computer terminal or a similar computing device. Figure 1 The hardware structure block diagram of a computer terminal for implementing a multi-network disk driving method is shown in FIG. Figure 1As shown, the computer terminal 10 may include one or more (illustrated as 102a, 102b, ..., 102n in the figure) processors 102 (the processor 102 may include but is not limited to a processing device such as a microprocessor MCU or a programmable logic device FPGA), a memory 104 for storing data, and a transmission device 106 for communication functions. In addition, it may also include: a display, an input / output interface (I / O interface), a universal serial bus (USB) port (which may be included as one of the ports of the BUS bus), a network interface, a power supply and / or a camera. It will be understood by those skilled in the art that Figure 1 The structure shown is only for illustration and does not limit the structure of the above electronic device. Figure 1 More or fewer components than shown, or with Figure 1 Different configurations shown.

[0033] It should be noted that the one or more processors 102 and / or other data processing circuits described above may generally be referred to herein as "data processing circuitry." The data processing circuitry may be embodied in whole or in part as software, hardware, firmware, or any other combination thereof. Furthermore, the data processing circuitry may be a single, independent processing module, or may be incorporated in whole or in part into any of the other components of the computer terminal 10. As described in the embodiments of the present application, the data processing circuitry serves as a processor control (e.g., selection of a variable resistor terminal path connected to an interface).

[0034] The memory 104 can be used to store software programs and modules of application software, such as the program instructions / data storage device corresponding to the multi-network disk driving method in the embodiment of the present application. The processor 102 executes various functional applications and data processing by running the software programs and modules stored in the memory 104, that is, realizing the above-mentioned multi-network disk driving method. The memory 104 may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 104 may further include a memory remotely arranged relative to the processor 102, and these remote memories can be connected to the computer terminal 10 via a network. Examples of the above-mentioned network include but are not limited to the Internet, corporate intranet, local area network, mobile communication network and combinations thereof.

[0035] The transmission device 106 is configured to receive or transmit data via a network. A specific example of the aforementioned network may include a wireless network provided by the communications provider of the computer terminal 10. In one embodiment, the transmission device 106 includes a network interface controller (NIC), which can be connected to other network devices via a base station to enable communication with the Internet. In another embodiment, the transmission device 106 may be a radio frequency (RF) module, which is configured to communicate with the Internet wirelessly.

[0036] The display may be, for example, a touch screen liquid crystal display (LCD) that enables a user to interact with a user interface of the computer terminal 10 .

[0037] In the above-mentioned operating environment, an embodiment of the present application provides an embodiment of a method for driving multiple network disks. It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although the logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0038] like Figure 2 FIG. 1 is a flowchart of a method for driving multiple network disks according to an embodiment of the present application, including:

[0039] Step S202: Receive an operation request for a target network disk sent by a client.

[0040] In the technical solution provided in step S202, the target network disk is any one of the multiple preset network disks corresponding to the client, and the operation request is used to indicate the operation performed on the target file stored in the target network disk. The network disk specifically refers to different network disk service providers, which provide network disk services to users (referring to cloud storage services, allowing users to store, manage and share files on the network disk and access these files through the network). The operation request can be a request to add the target file of the target network disk (create a new file or folder in the network disk), a delete request (remove a file or folder on the network disk), a modification request (update the content or attributes of an existing file on the network disk, such as renaming, modifying file descriptions, etc.), a query request (retrieve file information in the network disk, including viewing file lists, file details, etc.), the target file can be one or more, and the operation request can also be an interactive operation on the file between the target network disk and multiple other network disks, such as adding files in the target network disk to other network disks. This cross-network disk operation request reflects the advantage of the unified drive method, that is, users can perform data migration, sharing and other operations between different network disks through a single interface without switching between different network disk clients, greatly improving the efficiency of file management and sharing.

[0041] As some optional embodiments of this application:

[0042] When a user performs a network disk operation in the unified management interface (i.e., the graphical user interface of the client mentioned above), for example, when the user clicks the "List Directory" button in the unified management interface (the corresponding operation request in this case is to list the directory), the front-end (i.e., the front-end of the client) will convert the operation request into an initial HTTP request (i.e., the client sends an operation request to the target network disk). Its goal is to convert the events or operations in the user interface into network requests in order to communicate with the back-end service. Taking the example of listing the files in a directory of the first cloud disk (in this case, the first cloud disk is the target network disk mentioned above), the front-end generates an initial Hypertext Transfer Protocol (HTTP) request, and the request address is constructed according to the unified rules as / netdrive-api / xxxcloud-drive-adapter / directory / list. Here, / netdrive-api is the root path of the universal API interface. It serves as the entry point for all network drive operation requests, acting as a gateway. All operation requests originate here, ensuring that all requests follow the same format and rules. / xxxcloud-drive-adapter specifies the network drive service's adapter module to which the request will be forwarded. This refers to the adapter module for the first cloud drive (one for each adapter), distinguishing between different network drive services. / directory / list represents the target operation of listing directories. This path design allows the multi-network drive management system to quickly identify the request intent and accurately map it to the corresponding processing module.

[0043] When handling operations requiring interaction with multiple different cloud storage services, intelligent management and automated integration methods are employed to improve user experience and management efficiency. First, when building a graphical user interface, Qt (a cross-platform GUI application development framework that provides a rich set of tools and libraries for creating high-performance GUIs) or the Electron framework (an open-source framework for creating cross-platform desktop applications using Hypertext Markup Language (HTML)) are used. Both support building cross-platform graphical user interfaces (GUIs). An automatic configuration wizard guides users through the graphical interface to add, remove, and enter authentication information for cloud storage services. With a simple and intuitive interface and step-by-step instructions, users can easily integrate cloud storage services without having to understand in-depth technical details, reducing learning costs and operational difficulty. Second, to improve file access efficiency, intelligent routing technology is employed for intelligent path resolution, combined with user history. A breadth-first search algorithm traverses the file tree structure, taking into account user access history, and selects the optimal data access path. This algorithm enables rapid access to each node in the file tree, avoiding the lengthy paths or unnecessary network jumps associated with depth-first search, thereby improving data retrieval speed. When the operation request is a multi-task concurrent request, the multi-task concurrent processing mechanism is used to support batch operations on multiple network drives at the same time, significantly improving file management efficiency. By presetting multiple threads, batch operations such as uploading and downloading files can be performed in parallel on different network drives, significantly improving file management efficiency.

[0044] As some optional embodiments of this application:

[0045] Using PyQt (Python's Qt library, used in the Qt framework, allowing the use of Python to develop Qt-based GUI applications) or Electron's front-end component library, complex network disk service selection and authentication information input steps are presented to users in an intuitive graphical interface, such as using a drop-down menu for users to select the network disk type and a text box to enter authentication information. At the same time, necessary prompts and verification logic are added to prevent users from entering incorrect information, thereby reducing user learning costs. In terms of intelligent path resolution, Python is used to implement a breadth-first search algorithm, combined with user historical access record data stored in a database. Each time a file needs to be accessed (for example, an operation request is used to access a file in the network disk), the history record is read from the database, and then the file tree structure is traversed to find the optimal data access path, reducing unnecessary network jumps. For multi-task concurrent processing, use the concurrent.futures.ThreadPoolExecutor library in Python's Python concurrency library (used to create and manage thread pools, support asynchronous execution of callable objects, and implement multi-threaded concurrent processing) to create a thread pool. Set the thread pool size reasonably based on system resources and task volume. When the user initiates a batch operation, the task is decomposed and assigned to the thread pool for concurrent execution, thereby improving file management efficiency.

[0046] Step S204: The operation request is converted into a standardized request through the unified abstraction layer, and the standardized request is distributed to the target adapter corresponding to the target network disk. The unified abstraction layer is used to abstract the operation requests for different network disks into standardized HTTP requests.

[0047] In the technical solution provided in step S204, before receiving the operation request of the target network disk sent by the client (specifically the client used by the target user), it is necessary to first complete the permission setting of the multi-network disk management system for different users, for example, in the following way: in response to the detected permission setting instruction, configure the access permission information of each object in the access control list stored in the database, wherein the access permission information of each object includes the access permission of each object to the files of each network disk in multiple preset network disks. There are many ways to implement abstracting the operation request into a standardized request through a unified abstract layer, for example: parsing the request header and request body in the operation request through the unified abstract layer, and determining the request method, request path, parameter information and data in the request body based on the request header and request body; converting the parameter information into standardized parameters corresponding to the standardized request defined by the unified abstract layer through the unified abstract layer; determining the standardized request based on the standardized parameters, request method, request path and data in the request body through the unified abstract layer.

[0048] As some optional embodiments of this application:

[0049] In order to achieve transparent access to multiple network disks, a unified abstraction layer and API standardization technology are introduced. First, a RESTful API interface that is common to multiple network disks is constructed (the RESTful API interface is an architectural style for designing network application program interfaces (APIs), based on the Representational State Transfer (REST) ​​style API interface. REST is an architectural style for designing network applications). The RESTful API interface that is common to multiple network disks abstracts the operations of all network disk services (i.e., the above-mentioned operation requests, such as uploading files, downloading files, listing directories, etc.) into standardized requests (i.e., standardized HTTP requests). This not only simplifies client development, but also improves the scalability and compatibility of the system. Developers do not need to write different codes for each network disk. From the perspective of architectural design, the solutions of related technologies lack a unified management entry, and data (for example, data in files) cannot be directly circulated between network disk clients, and the scalability is poor. When adding a new network disk, the adaptation function needs to be redeveloped. The unified abstraction layer of this application is like an intelligent hub, which converts complex multi-network disk operations into standardized processes. The unified abstraction layer parses the request header and body of the operation request and determines the request method (which specifies the operation the client wants the server to perform), the request path (which specifies the location of the resource to be operated on), parameter information (which specifies the specific conditions for certain operations and can appear in the request path or in the query string), and the data in the request body (the request body is the data sent by the client to the server, primarily carrying the data required to create or update resources). Based on the method in the request header (e.g., POST for file upload) and the request path, the unified abstraction layer intelligently identifies the network disk adapter to which the request should be forwarded, thereby determining the target adapter. The unified abstraction layer converts the standardized request into a format understandable by the target network disk API and converts the parameters in the parameter information into the standardized request parameter format defined by the unified abstraction layer. For example, different network disks may have different requirements for file upload parameters, but the unified abstraction layer converts these different parameters into a consistent format, such as standardizing the file path, file name, and file size into a predefined standardized parameter template. Finally, the standardized parameters, request method, request path, and request body data are encapsulated into a standardized request. Once the standardized request is determined, the unified abstraction layer will intelligently distribute it to the adapter of the target network disk based on the network disk identifier in the request path.

[0050] For operation requests that require parameters, such as file upload and download, the parameters are passed in the request body in JSON format. Taking file download as an example, after the user selects the file to be downloaded in the unified interface, the request body content generated by the client front end is {file_id (unique identifier of the network disk file): xxx, local_save_path (local save path): xxx}. After receiving the request, the unified abstraction layer will perform a preliminary check on the parameters to ensure that the parameter format is correct and contains the necessary information. If the parameters do not meet the requirements, such as the lack of file_id, an error response is returned directly. For example, the status code is set to 400 (Bad Request) and the status description is "parameters are missing or in the wrong format."

[0051] The unified abstraction layer converts the standardized requests sent by the client into operations that are understood by different network disk services. At the same time, it also ensures that the format and content of the request comply with the specifications of the RESTful API, thereby simplifying the complexity of development and maintenance and improving the flexibility and response speed of the system (referring to the multi-network disk management system of this application). Finally, the standardized request is sent to the adapter module of the target network disk through the RESTful API interface. No matter what kind of network disk it is, it can follow the unified specifications for operation. For example, when the operation request is to upload a file, the file and related parameters are passed in through the corresponding standardized request. The unified abstraction layer then intelligently distributes the request to the adapter module of the corresponding network disk through the RESTful API interface, without the user having to worry about the differences in the underlying APIs of different network disks.

[0052] At the same time, the multi-network disk management system of the present application adopts a multi-level security protection mechanism to ensure the security of user data. First, an identity authentication mechanism based on username and password is carried out, and modern authentication protocols such as Open Authorization 2.0 (OAuth2) are supported to ensure that only verified users (also called objects) can access their accounts (i.e., the corresponding accounts in the client). Secondly, in the entire multi-network disk management system, as long as the data transmission process is involved, Secure Sockets Layer (SSL) / Transport Layer Security (TLS) encryption technology is used to ensure the security of data transmission and prevent data from being intercepted or tampered with during transmission. The access control list is specifically a fine-grained access control list. The fine-grained access control list (ACL) allows different users (i.e., the above-mentioned objects) to set access rights to folders and files when the permission setting instruction initiated by the administrator is detected, ensuring that when the client attempts to access files in the network disk, it will first verify the user's login credentials and then check the user's access rights. In order to further enhance security, this application also takes into account multi-factor authentication, end-to-end encryption, audit logging, and anomaly detection mechanisms, which together constitute a more comprehensive and powerful security system, providing users with a higher level of data security. Finally, the permission synchronization function ensures that the user (i.e. the above-mentioned object) maintains consistent permission settings across different network disks, simplifying permission management. Access tokens for each network disk service are obtained through the OAuth 2.0 protocol and stored in the local database. At the same time, a regular check and update mechanism is implemented for the access tokens in the database. Users only need to log in to the client once to access all associated network disk services. These intelligent management and automated integration measures work together to provide users with an efficient, convenient and secure multi-network disk management environment.

[0053] As some optional embodiments of this application:

[0054] Using Python as the core development language, combined with Flask (a lightweight web application framework written in Python, suitable for rapid development of simple applications, providing a high degree of flexibility, allowing developers to select and integrate various extensions and libraries as needed) or Django (a Python-based web framework, but it is more robust than Flask, a full-stack framework that provides more built-in functions, suitable for developing complex applications, especially projects that require database interaction, user authentication, etc.) framework to build the server (referring to the computer system responsible for processing, storing and providing data in network applications, the unified abstraction layer is implemented on the server side), and isolate the development, testing, and production environments through environment variables or system configuration files. In terms of authentication, use Python's relevant libraries to implement an authentication mechanism based on usernames and passwords, and integrate the OAuth2 authentication protocol. With the help of the requests-oauthlib library (the requests-oauthlib library is a Python library specifically designed to simplify the process of using the OAuth 2 authentication protocol in HTTP requests), you can connect to third-party authentication services that support OAuth2 to ensure that only verified users can access the account. For data transmission, configure SSL / TLS certificates for the server and use Flask's SSLContext (used to configure SSL / TLS certificates and encryption parameters, directly controlling the server's HTTPS connection) or Django's SECURE_SSL_REDIRECT (as a configuration option, a Boolean value that controls whether to automatically redirect Hypertext Transfer Protocol (HTTP) requests to Hypertext Transfer Protocol Secure (SecureHTTPS), indirectly strengthening the security of the server) to enable data transmission encryption to prevent data from being intercepted or tampered with during transmission. For fine-grained access control lists, use a database such as MySQL (a relational database management system known for its high performance, stability, and open source) or PostgreSQL (PostgreSQL is a powerful open source object-relational database system that provides many advanced features and functions, such as transaction support, foreign keys, views, triggers, stored procedures, indexes, partitions, full-text search, etc.) to store user access permission information. When a user tries to access a file, the server first verifies the login credentials, then queries and checks the user's access rights from the database (that is, verifies whether the access control list contains the client's corresponding target object's access rights to the target file).To enhance security, before verifying whether the access control list contains the target object's access rights to the target file corresponding to the client, the PyOTP library (PyOTP is a Python library for generating and verifying one-time passwords (OTPs)) is used to implement multi-factor authentication. When logging in, users are required to enter a dynamic verification code in addition to their passwords. End-to-end encryption is implemented using the cryptography library (cryptography is a powerful Python cryptography library that provides advanced cryptographic functions such as encryption, digital signatures, certificate management, and hashing, and is suitable for implementing security requirements such as end-to-end encryption). Data is encrypted on the client before being uploaded to the network disk and decrypted on the client when downloaded. A logging library (such as logging, which is one of Python's standard libraries and is used to record application log information) is used to record user operations for easy auditing. In terms of permission synchronization, we use the requests library (requests is a library in Python for sending HTTP requests, which simplifies the interaction process with Web services) combined with the OAuth 2.0 protocol to obtain access tokens for each network disk service, and securely store these tokens in a local encrypted file or database. At the same time, we develop scheduled tasks to regularly synchronize permission settings between different network disks, allowing users to access all related network disk services with just one login, building an efficient, convenient and secure multi-network disk management environment.

[0055] Step S206: Use a target adapter to convert the standardized request into a target instruction recognizable by the target network disk's application program interface, and call the target network disk's application program interface through the target adapter to execute the target instruction.

[0056] In the technical solution provided in step S206, the target adapter calls the target network disk's application program interface to execute the target instruction, including: when the access control list contains the access rights of the object corresponding to the client to the target file, the target adapter calls the target network disk's application program interface to execute the target instruction and obtains the execution result, wherein the execution result is used to indicate the result of the operation on the target file; in the process of calling the target network disk's application program interface to execute the target instruction through the target adapter, if the execution interruption is detected, the target adapter sends the cause of the execution interruption to the unified abstraction layer. The adapter (the adapter module located in the multi-network disk management system) is responsible for converting the standardized request into a target instruction that can be recognized by the target network disk API, handling details such as authentication and data format conversion, and ensuring that the operation request can be correctly understood and executed. This mechanism allows the client to interact with different network disk services through a unified interface without having to worry about the underlying technical differences, greatly simplifying client development and improving the flexibility and responsiveness of the system. The unified abstraction layer uses a RESTful API interface as a communication bridge between the client and the adapter module. This design not only simplifies the client development work, but also improves the scalability and compatibility of the system.

[0057] As some optional embodiments of this application:

[0058] In the case where the access control list contains the access rights of the object corresponding to the client (i.e., the target object to which the operation request is sent by the client) to the target file, the target object has the access rights to the target file in the access control list. When a target adapter is used to convert a standardized request into a target instruction recognizable by the application program interface of the target network disk, the target adapter module (one adapter module contains one adapter, which is a one-to-one correspondence) will perform secondary processing and conversion on the parameters according to the characteristics of the target network disk API. For example, the API of the target network disk requires that the file identifier passed when downloading the file be a hash value in a specific format, and a parameter in the standardized request is an ordinary string. The target adapter module will convert it into a hash value format that meets the API requirements of the target network disk to ensure that the parameters can be correctly received and processed. After the target adapter module performs the above processing, it will convert the standardized request into a target instruction that can be recognized by the target network disk's application program interface (that is, the standardized request and related parameters will be reconstructed into a request format and parameter combination (that is, target instruction) that can be recognized by the target network disk's API according to the API characteristics and specifications of the target network disk. For example, this is achieved by adjusting the request method, modifying the request header information, and reorganizing the parameter structure. After the conversion is completed, the target adapter module uses the network request library to send a request (carrying the target instruction) to the target network disk's API. Before sending the request, it will check whether the current authentication information is valid. If it is invalid, the authentication process will be executed first to obtain a valid access token to ensure that the request can be sent successfully. When the target network disk's application program interface is called through the target adapter to execute the target instruction, the response message returned by the target network disk API is obtained. The target adapter module receives the response content of the response message and parses it. Due to the The response message formats of APIs for different cloud drives vary significantly. The target adapter module needs to convert them into the system's unified response format, namely the operation results described above. For example, the file list data returned by a cloud drive contains a large amount of redundant information. The adapter module extracts key information such as file name, file size, and file type, and reorganizes the data according to a specified format (for example, JSON), resulting in a response such as {"status_code": 200, "status_message": "Directory listing successful", "data": [{"name": "File 1", "size": "1024KB", "type": "txt"}]}. The target adapter returns the operation results to the unified abstraction layer, which receives the converted operation results from the target adapter and performs further verification and processing.If the response status code of the operation result indicates that the operation failed, the unified abstraction layer will optimize and supplement the error information according to the preset error handling logic to make it clearer and easier to understand, and then return the final operation result to the front end. The front end will then display the corresponding prompt information on the interface to inform the user of the operation result.

[0059] To improve system stability and maintainability, if an interruption is detected while executing a target instruction through the target adapter's API call to the target network drive, the target adapter will encapsulate the cause of the interruption (for example, a network error, incorrect parameters, or insufficient user permissions) in a pre-set, unified format and send it to the unified abstraction layer. Detailed log information, including the time the error occurred, request parameters, and error type, is also recorded, allowing developers to quickly locate and resolve the issue.

[0060] Before developing each network disk adapter module, it is necessary to thoroughly study the API documentation of the corresponding network disk to understand its interface calling rules, authentication methods, data formats and other information. For example, taking the target network disk as an example, first clarify the authentication process of the target network disk, the file metadata structure and the specific usage of the file operation interface. The adapter module needs to implement the corresponding authentication logic for each network disk, for example, using the access key (AccessKey) and SecretKey (referring to the access key private key (AccessKeySecret), which is used to sign and verify the HTTP request issued by the user) for signature authentication, and obtaining the access token through the OAuth 2.0 authorization code mode. Before calling the corresponding network disk API each time, the adapter module must ensure that the authentication information is valid. If the access token expires, the re-authentication process must be automatically triggered to ensure the smooth operation.

[0061] The implementation of the adapter module developed for the network disk is completely different from the development of a single network disk client in the related art. A single network disk client directly calls a specific network disk API, the code is highly coupled, and it is difficult to reuse. The adapter module of this application implements the target interface (for example, the target interface is the INetDrive interface (INetDrive interface is an interface that defines a common method for interacting with a network disk. It specifies a set of standard methods, such as file upload method (uploadFile()), file download method (downloadFile()), file list method (listFiles())), etc.), and develops independent adapter modules for each specific network disk (or network disk service provider) (one adapter module corresponds to an adapter for a network disk). These modules implement the target interface and define standard methods, for example: uploadFile() is a method defined in the INetDrive interface to describe the operation of uploading files to the network disk. The downloadFile() method is defined as part of the INetDrive interface to handle file download requests. File list method (listFiles()) is also a method defined in the INetDrive interface, which is used to list files or directories on the network disk. These methods describe the basic functions of network disk operations, such as file upload, file download, file listing, etc. Any adapter module that implements the INetDrive interface must provide implementations of these methods to ensure that all network disk operation requests can be processed under a unified framework. For example, taking the uploadFile() method as an example, in the adapter module of the target network disk, the parameters of the incoming standardized file must first be uploaded to the adapter of the target network disk, such as the local file path, target directory, etc., and then converted and encapsulated according to the requirements of the target network disk API. Finally, by calling the file upload interface of the target network disk API, the file upload operation is completed, and the upload results (that is, the above operation results, such as file ID, access link, etc.) are processed and returned to the adapter of the target network disk in a unified format.

[0062] The adapter is responsible for converting standardized interface calls (i.e. standardized requests) into specific implementations of the corresponding network disk API (i.e. target instructions recognizable by the target network disk API), ensuring that the system can flexibly adapt to the unique needs of different network disks. Taking the target network disk adapter as an example, the internal logic of the target network disk adapter deeply analyzes the API characteristics of the target network disk, and converts the standardized uploadFile() method into a target instruction recognizable by the target network disk API (e.g., upload instruction) through carefully designed parameter mapping and interface conversion, while handling details such as authentication and error feedback. For example, when processing an operation request for obtaining a file list, the adapter converts the standardized request of the listFiles() method into a directory query operation that complies with the target API specification (i.e., the target instruction corresponding to the operation request of the above file list class), and unifies the format of the returned data to meet the system's standardized output requirements. Other network disk adapters also follow similar principles, each adapting to the corresponding network disk API characteristics, and can work together under a unified interface specification.

[0063] When a new preset network disk is detected at any time, the configuration information of the new preset network disk is loaded into the network disk service list, and an adapter for the new preset network disk is constructed.

[0064] As some examples of this application:

[0065] Java's ServiceLoader (ServiceLoader is a tool class for discovering and loading service providers. It implements the service provider discovery mechanism and can dynamically find and load classes that implement specific service interfaces at runtime) or Python's importlib library (importlib is one of Python's standard libraries, used to handle the module import process. It provides a series of tools. The core function of importlib is to be able to load modules on demand). The dynamic loading mechanism implemented by the multi-network disk management system of the related technology requires downtime to update the code and redeploy if new network disk support is added, which affects service continuity. However, during runtime, the present application dynamically loads the corresponding adapter module based on the network disk service list in the system configuration file, that is, loads the configuration information of the newly added preset network disk into the network disk service list, and builds an adapter for the newly added preset network disk. For example, when support for a preset network disk needs to be added, it is only necessary to develop the preset network disk adapter module and enter its configuration information into the system. The system can automatically load the module without restarting, and quickly implement support for the preset network disk (support refers to the ability to use the multi-network disk system of this application to implement file management in the preset network disk), greatly improving the flexibility and scalability of the system.

[0066] In order to provide a smooth user experience, the network disk mounting service needs to have efficient data transmission capabilities and fast response time. For example, it is achieved in the following way: obtaining a set of historical operation records of the client within a preset historical time period from the log library, wherein the historical operation record set includes historical operation records corresponding to multiple historical operation requests; determining the files in the historical operation record set whose access times exceed the preset access threshold (for example, 50 times) as the first type of access files, and caching the first type of access files at the target edge node, wherein the target edge node is determined by the geographic location information of the target object (referring to the object corresponding to the client, that is, the object to which the operation request is sent by the client), the network status of the location of the target object, and the load information of each edge node; the method also includes: predicting the second type of access files of the target object within the preset time period based on the historical operation record set, and caching the second type of access files at the target edge node.

[0067] A caching function is implemented at the target edge node to preload data. The first type of access files are cached locally through periodic caching, access frequency detection, and lifecycle management. This reduces the time it takes to retrieve data from remote servers. Secondly, intelligent routing technology is used to intelligently select the optimal edge node based on the target object's geographic location information, network conditions, and the load conditions of each edge node, ensuring the shortest data transmission path and the lowest latency. In addition, through historical access pattern analysis, user behavior learning, and real-time trend prediction, the target object's expected access data (i.e., the second type of access files mentioned above) is predicted based on a set of historical operation records, and loaded into the target edge node in advance, further reducing data access latency. At the same time, the adaptive compression algorithm automatically selects the most suitable compression algorithm based on the file type and network conditions, minimizing the time and bandwidth required for transmission and saving traffic costs. The incremental transmission protocol only transmits changed data blocks, rather than the entire file, greatly improving transmission efficiency and is particularly suitable for small file sets that are frequently updated.

[0068] As some examples of this application:

[0069] Use Python language combined with Redis (Redis is an open source, high-performance key-value storage system that is widely used as a database, cache, and message middleware. It supports a variety of data structures, such as strings, hash tables, lists, sets, ordered sets, etc., and can be used to implement functions such as caching, session storage, real-time data analysis, and complex data structure operations) database to implement caching functions at edge nodes. With the help of Python's Redis client library (such as Redis-py, Redis-py is a Redis database client library in Python language for interacting with the Redis database), the first type of access files are periodically cached at the target edge node according to the preset time period, and the preset access frequency and preset life cycle information of the first type of access files are recorded using Redis's ordered sets and hash tables and other data structures. When the first type of access files exceeds the preset life cycle or the preset access frequency decreases, they are cleaned up. To intelligently select the optimal edge node, a third-party Python library is used to obtain the user's geographic location information (i.e., the geographic location of the target object (referring to the object corresponding to the client, i.e., the object sending the operation request through the client)). Network monitoring tools such as the psutil library (psutil is a cross-platform Python library used to obtain information on process and system utilization (CPU, memory, disk, network, etc.)) are used to monitor local network conditions (i.e., the network conditions at the location of the target object, specifically, the network conditions at the location of the client corresponding to the target object) and load information for each edge node is obtained from the cloud service provider. Through algorithms (for example, first selecting a group of close edge nodes based on geographic distance, and then further selecting the target edge node within this group based on network conditions and load), the performance of each edge node is compared to select the edge node with the shortest transmission path and lowest latency for the user. Based on the historical operation record collection, historical access patterns are analyzed and similar access behaviors are grouped. Clustering and prediction algorithms (such as time series analysis and sequential pattern mining algorithms) are used to learn user behavior, predict the second type of access files for the target object, and pre-load them to the target edge node. In terms of adaptive compression algorithms, Python's zlib (zlib is a cross-platform open source compression library that provides an interface for data compression and decompression) and bz2 (bz2 is a module in the Python standard library that encapsulates the bzip2 compression algorithm (a file compression algorithm). The bz2 module provides similar functions to zlib, but uses the bzip2 compression algorithm) and other libraries are used to automatically select appropriate compression algorithms for different file types and real-time network bandwidth conditions (obtained through network monitoring tools), thereby reducing transmission time and bandwidth consumption.For the incremental transfer protocol, a difference algorithm (diff algorithm is a method for comparing the differences between two text or data files, which can find out the newly added, modified or deleted parts of the two files) and a patch algorithm (patch algorithm is mainly used to update the old file according to the difference report generated by the diff algorithm to match the new file) are used (which can be implemented through Python) to calculate the differences in file data blocks and only transfer the changed data blocks. This is especially suitable for small file sets that are frequently updated, so as to comprehensively improve the data transmission efficiency and response speed of the network disk mounting service and provide users with a smooth experience. As another optional implementation method, for file usage pattern and preference analysis, first build a data collection module and use Python's logging function to record in detail each historical operation data of the user, including file access, creation, modification, deletion and other behaviors, and store these data in the database. For file usage pattern and preference analysis, machine learning algorithms (such as decision trees and random forests) are used to train the stored historical operation data, and the files that the user is expected to access next (i.e., the second type of access files mentioned above) are predicted based on the user's historical operation data records. Then, caching technologies such as Redis are used to load the predicted files into the cache of the target edge node in advance (i.e., the second type of access files of the target object are predicted based on the historical operation record set and loaded into the target edge node in advance), thereby reducing the waiting time for the user's actual access.

[0070] In order to further enhance the user experience, user behavior analysis and personalized service technologies are introduced, and a lightweight machine learning library is integrated to analyze the user's file usage patterns and preferences and provide personalized recommendations and services. For example, the file content and file names of files in multiple preset network disks are analyzed to obtain the labels corresponding to each file; the files in multiple preset network disks are mapped to multiple virtual folders, where each virtual folder corresponds to a file with a label. Personalized services include intelligent file classification and label suggestions to help users better organize and manage files. Based on user behavior data (user behavior data refers to the data records generated when users use the multi-network disk management system of this application, which reflect the user's behavior, preferences and interaction patterns), frequently used folders or favorites are created to simplify users' daily operations. The breadth-first search algorithm is used to traverse the file tree structure, and the optimal data access path is selected in combination with user history records, reducing unnecessary network jumps and speeding up data retrieval, which is especially suitable for large folder structures and complex directory hierarchies. Finally, by analyzing user collaboration habits, suitable team members are recommended for file sharing to promote more efficient teamwork.

[0071] As some embodiments of the present application: In terms of personalized services, develop intelligent file classification and tag suggestion functions, use natural language processing technology (such as using the jieba library for Chinese word segmentation, jieba is a Chinese word segmentation library that can effectively segment continuous Chinese character sequences into meaningful words) to analyze file content and names, automatically add tags to files, and classify files into different virtual folders according to the tags. Based on user behavior data, automatically create common folders or favorites through Python scripts. For example, if it is found that users frequently access certain types of files, a dedicated favorites folder is automatically created for these files. Use a breadth-first search algorithm, use Python to implement the algorithm logic, traverse the file tree structure, combine user history records, query relevant information from the database, select the optimal data access path, avoid unnecessary network jumps, and improve data retrieval speed under large folder structures and complex directory hierarchies. Finally, when analyzing user collaboration habits, find out the collaboration patterns between users and the combination of frequently shared files as analysis results, recommend suitable team members for file sharing based on the analysis results, and promote efficient teamwork.

[0072] Taking data security and user needs into consideration, the multi-network disk management method of the present application has a complete set of data backup and recovery mechanisms to ensure the integrity and availability of user data, and supports automatic scheduled backup functions. Users can flexibly set the preset backup frequency and preset retention period according to actual needs to ensure that important data is protected in a timely manner. For example, it is achieved in the following way: the backup data is stored in edge nodes in multiple geographical areas, wherein, for each backup data, it is updated or deleted on the corresponding edge node according to the preset backup frequency and the preset retention period. Backup data refers to a copy of the original data (the original data is divided into two categories: one is the data stored by the user in the file in the preset network disk, and the other is the data and configuration information generated by this system) created to prevent data loss, damage or tampering.

[0073] For emergencies (such as accidental deletion or data corruption), the system provides an instant recovery function. Users can quickly restore to the most recent backup point through simple and intuitive operations, minimizing the impact of data loss. To enhance system reliability and fault tolerance, a distributed backup strategy is adopted. Backup data is stored on edge nodes across multiple geographical regions. Redundant storage ensures that even if an edge node fails, other edge nodes can still provide complete backup copies. This distributed architecture improves backup data availability and effectively reduces the risk of single points of failure. Furthermore, incremental backup technology is introduced, backing up only the data blocks that have changed since the last backup (the portion of the backup data that has changed since the last backup), reducing storage space and transmission bandwidth requirements and accelerating backup speeds. Furthermore, after each backup, the system performs rigorous data verification, including hash value comparisons and file integrity checks, to ensure that the backup data is correct and recoverable. Parallel verification and multi-threaded processing are supported for large data sets to improve verification efficiency. This data backup and recovery mechanism enhances data security and provides users with reliable data protection.

[0074] As some examples of this application:

[0075] The Python language was chosen in conjunction with relevant libraries and tools to build a comprehensive data backup and recovery mechanism. The APScheduler library (APScheduler is a high-level task scheduling library written in Python that allows developers to execute scheduled tasks in a very flexible manner) was used to implement automatic scheduled backups. The preset backup frequency (e.g., daily, weekly) and the preset retention period (e.g., retaining backups from the last month) can be flexibly set through a configuration file or graphical interface. Backup tasks are triggered regularly based on these settings to back up user-specified data. For instant recovery, a simple, easy-to-use command-line tool or graphical interface was developed. When users encounter emergencies such as accidental deletion or data corruption, they only need to click the corresponding button or enter specific commands on the interface, and the system will quickly restore data from the most recent backup point. Regarding distributed backup strategies, Python's network programming library was used to communicate with edge nodes in multiple geographic regions, distributing the backup data across these edge nodes. A database was used to record the storage location and replica information for each piece of backup data. When an edge node fails, a complete backup copy can be quickly retrieved from other edge nodes. The difflib library (difflib is a module in the Python standard library used to compare differences in sequences, particularly string sequences) is used to implement incremental backup technology. During each backup, the differences in the backed-up data since the previous backup are calculated, and only the changed data blocks are backed up, thereby reducing storage space and transmission bandwidth usage and improving backup speed. After each backup is completed, the hash value of the backed-up data is calculated using the hashlib library (hashlib is part of the Python standard library used to create and process data hash values) and compared with the hash value of the original data. File integrity checks are also performed to ensure that the backup data is accurate and recoverable. For large-scale datasets, the concurrent.futures library (concurrent.futures is a module in the Python standard library used to simplify the execution of parallel and asynchronous tasks) is used to implement parallel verification and multi-threaded processing. Large-scale datasets are divided into multiple blocks for parallel verification, improving verification efficiency, thereby enhancing data security and providing users with reliable data protection.

[0076] The system of the present application adopts a lightweight distributed architecture that can dynamically add or remove edge nodes according to actual needs, realizing on-demand resource allocation and optimization. It can handle large-scale file access while keeping the system lightweight in file access scenarios of different orders of magnitude, reducing hardware and operation and maintenance costs. With the help of containerization technology (such as Docker and Kubernetes), new edge nodes can be deployed quickly and resource allocation can be flexibly adjusted according to load conditions. The system of the present application introduces a service registry (a service registry is a centralized component used to manage the discovery, registration and status tracking of service instances in a distributed system. It plays a core role in the microservice architecture. The service registry allows each service instance to dynamically register and publish its location and status information, such as IP address, port number and health status. When a service needs to call other services, it can query the service registry to obtain the latest information of the target service and initiate a call) and a unified abstraction layer to simplify the communication configuration between services and the application development process. Through automation tools (automation tools are software tools that can automatically perform tasks such as system configuration, deployment, monitoring and maintenance), the workload of manual configuration is reduced, the risk of human error is reduced, and system maintenance is made simpler and more efficient. In the system's project structure, a clear division is made between the general RESTful API interface module and each network disk adapter sub-module. A separate configuration module is set up to uniformly manage system parameters, network disk service configuration and other information, making the project structure clear and easy to maintain and expand. During the code development phase, standardized interfaces are defined strictly in accordance with the specifications. The file upload interface uses the POST method (the POST method is a method used in the HTTP protocol to submit data to the server. When using the POST method to send a request to the server, it will encapsulate the requested data in the request body and send it together) and use Swagger (Swagger is a set of toolkits for designing, building, and documenting, focusing on the design of RESTful APIs, document generation, and automatic generation of client code) to generate visual documents for developers to understand and call.

[0077] Here are some test results:

[0078] Accuracy of user behavior prediction: In the test of user behavior prediction, the accuracy of file access prediction of this application is improved by more than 40% compared with the network disk service in the related technology. The improvement is more significant in the personalized recommendation scenario, up to 65%. This is due to the system's analysis of user historical operation records and user behavior, which can accurately predict the second type of access files and load them into the cache in advance, greatly reducing the actual access time. Data backup and recovery efficiency: Data backup and recovery mechanism tests show that the automatic scheduled backup speed of this application is about 35% faster than the solution of the related technology. The instant recovery function allows users to restore the most recent backup point within 1 minute on average, significantly shortening the backup time and improving the recovery speed. The distributed backup strategy ensures that even if a node fails, other nodes can still provide a complete backup copy, enhancing system reliability and fault tolerance. File classification and tag recommendation effect: User experimental evaluation shows that the efficiency of user file organization is improved by about 25%, and the accuracy of tag application reaches more than 90%. Intelligent suggestions based on user behavior data simplify the file management process, help users better discover and utilize existing resources, and improve overall work efficiency. File Access Optimization: In file access efficiency testing, the use of intelligent path parsing and caching mechanisms increased file access speed by an average of over 40%, with even more significant improvements in frequent access scenarios, reaching up to 65%. The system analyzes user history to accurately predict user access files and caches them in advance, significantly reducing actual access time. System Stability and Reliability: Long-term environmental monitoring shows that the system's stability has reached over 99.9% during sustained high-load operation, with no major failures. Intelligent resource allocation strategies keep edge node CPU and memory utilization within efficient ranges, avoiding resource waste and ensuring high-performance system operation. Incremental backup technology and a periodic verification mechanism ensure data consistency and integrity, further enhancing system reliability. In summary, through the above-mentioned technical solutions, this application is not only innovative in its technical implementation, but also demonstrates significant performance advantages in practical applications. It not only improves data access speed but also strengthens data security and privacy protection, providing users with a more reliable and efficient cloud storage solution that can meet the needs of modern users for efficient, secure, and reliable data storage services.

[0079] The method of this application is intended to solve the problem that users can manage multiple network disk resources through a multi-network disk management system (or platform-driven application). It also solves the inefficiency problem caused by decentralized file management and complex synchronization processes that are not through network disks. It not only achieves transparent access, so that users do not need to care about the specific implementation details of the underlying network disk, but also ensures the consistency and integrity of the data. Through a unified abstraction layer and API standardization, a highly scalable driver framework is provided that can easily adapt to new network disk services in the future without the need for large-scale modification of the core code. The dynamic resource allocation and management mechanism dynamically adjusts the number of edge nodes according to the real-time load, avoids resource waste, improves response speed, improves data access speed and user experience, and enhances data security and privacy protection.

[0080] Figure 3 This is a schematic diagram of a verification and transaction processing module for a multi-network disk driving method provided in accordance with an embodiment of the present application; it shows the workflow of the verification and transaction processing module in the multi-network disk driving method. On the client side, the user submits an application: the target object on the client side actively initiates an operation request, such as accessing multiple network disk resources, performing specific data operations, etc., submits a service request to the system, and triggers subsequent verification and transaction processes. The submission verification plug-in obtains a transaction number. After the user submits the application, the submission verification plug-in first generates or obtains a transaction number from the system. The transaction number is used to give a unique identifier to the operation request initiated by the current user, facilitating subsequent process tracking, logging, and exception backtracking. Then, the submission information and submission permissions are obtained (the plug-in will collect information related to this user application (such as user identity information, application operation content, involved network disk resources, etc.), and at the same time verify whether the current user has the permission to submit the application to ensure that the request is legal and can be processed). Then, the verification request is submitted to the verification service component (the organized user application information, transaction number, etc. are sent to a dedicated verification service component, officially entering the system verification link, requesting the verification service to determine the user identity, operation legitimacy, etc.). The verification service component obtains verification information from the R&D system (for example, the verification information library and rule library built during the system development phase, which stores user permission templates, business verification logic dependency data, network disk access compliance configuration, etc.), calls the verification logic, and verifies the application submitted by the user (including transaction number, operation content, identity information, etc.) to determine whether the user operation is compliant and meets the system's preset business rules. Submit the verification plug-in to obtain the verification result. If the verification passes, enter the normal transaction submission process, submit the transaction result, and send it to the verification service component to generate a review request; if it fails, go to the rollback transaction branch and feedback the submission result.

[0081] Figure 4 is a structural diagram of a multi-network disk drive device provided according to an embodiment of the present application, such as Figure 4 Shown, including:

[0082] The receiving module 402 is used to receive an operation request for a target network disk sent by the client, wherein the target network disk is any one of a plurality of preset network disks corresponding to the client, and the operation request is used to indicate an operation to be performed on a target file stored in the target network disk.

[0083] The first conversion module 404 is configured to convert the operation request into a standardized request through a unified abstraction layer, and distribute the standardized request to a target adapter corresponding to the target network disk.

[0084] The second conversion module 406 is configured to use a target adapter to convert the standardized request into a target instruction recognizable by the target network disk's application program interface, and execute the target instruction by calling the target network disk's application program interface through the target adapter.

[0085] It should be noted that Figure 4 The multi-network drive shown is used to execute Figure 2 The multi-network disk drive method shown, therefore Figure 2 The relevant explanations in the multi-network disk driving method in also apply to the multi-network disk driving device, and will not be repeated here.

[0086] It should be noted that the various modules in the above-mentioned multi-network disk drive device can be program modules (for example, a set of program instructions that implement a certain specific function) or hardware modules. For the latter, it can be expressed in the following forms, but is not limited to this: the expression form of each of the above-mentioned modules is a processor, or the functions of each of the above-mentioned modules are implemented by a processor.

[0087] An embodiment of the present application further provides a non-volatile storage medium, which includes a stored program, wherein when the program is running, the device where the non-volatile storage medium is located is controlled to execute the multi-network disk driving method in any of the above embodiments.

[0088] An embodiment of the present application further provides an electronic device, which includes a processor, and the processor is used to run a program, wherein the multi-network disk driving method in any one of the above embodiments is executed when the program is running.

[0089] According to another aspect of the embodiments of the present application, a computer program product is further provided, including a computer program, which, when executed by a processor, implements the multi-network disk driving method in any one of the above embodiments.

[0090] In the above embodiments of the present application, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, please refer to the relevant description of other embodiments.

[0091] In the several embodiments provided in this application, it should be understood that the disclosed technical content can be implemented in other ways. Among them, the device embodiments described above are only exemplary. For example, the division of the units can be a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of units or modules, which can be electrical or other forms.

[0092] The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple units. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.

[0093] In addition, the functional units in the various embodiments of the present application may be integrated into a single processing unit, or each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0094] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the relevant technology or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions for enabling a computer device (which can be a personal computer, a server or a network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a read-only memory (ROM), a random access memory (RAM), a mobile hard disk, a magnetic disk or an optical disk.

[0095] The above is only a preferred embodiment of the present application. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present application. These improvements and modifications should also be regarded as the scope of protection of the present application.

Claims

1. A method for driving multiple network disks, characterized in that: include: Receive an operation request for a target network disk sent by a client, wherein the target network disk is any one of a plurality of preset network disks corresponding to the client, and the operation request is used to instruct an operation to be performed on a target file stored in the target network disk; Converting the operation request into a standardized request through a unified abstraction layer, and distributing the standardized request to a target adapter corresponding to the target network disk; The target adapter is used to convert the standardized request into a target instruction that can be recognized by the application program interface of the target network disk, and the target adapter calls the application program interface of the target network disk to execute the target instruction.

2. The method according to claim 1, characterized in that Before receiving the target network disk operation request sent by the client, the method further includes: In response to the detected permission setting instruction, access permission information of each object is configured in the access control list stored in the database, wherein the access permission information of each object includes the access permission of each object to the files of each network disk in the multiple preset network disks.

3. The method according to claim 2, characterized in that The step of calling the target network disk application program interface through the target adapter to execute the target instruction includes: In a case where the access control list includes access rights of the object corresponding to the client to the target file, calling the application program interface of the target network disk through the target adapter to execute the target instruction and obtain an execution result, wherein the execution result is used to indicate the result of the operation on the target file; In the process of calling the application program interface of the target network disk through the target adapter to execute the target instruction, if an execution interruption is detected, the cause of the execution interruption is sent to the unified abstraction layer through the target adapter.

4. The method according to claim 1, wherein Abstracting the operation request into a standardized request through a unified abstraction layer includes: Parsing the request header and request body in the operation request through a unified abstraction layer, and determining the request method, request path, parameter information, and data in the request body based on the request header and request body; Converting the parameter information into standardized parameters corresponding to the standardized request defined by the unified abstraction layer through the unified abstraction layer; The standardized request is determined through a unified abstraction layer according to the standardized parameters, the request method, the request path, and the data in the request body.

5. The method according to claim 1, wherein The method further includes: when a newly added preset network disk is detected, loading configuration information of the newly added preset network disk into the network disk service list, and constructing an adapter for the newly added preset network disk.

6. The method according to claim 1, characterized in that The method further comprises: Obtaining a set of historical operation records of the client within a preset historical time period from a log library, wherein the set of historical operation records includes historical operation records corresponding to multiple historical operation requests respectively; Determining a file in the historical operation record set whose access count exceeds a preset access threshold as a first type of access file, and caching the first type of access file at a target edge node, wherein the target edge node is determined by geographic location information of a target object, a network condition at a location of the target object, and load information of each edge node, and the target object is an object corresponding to the client; The method further includes: predicting a second type of access file of the target object within a preset time period based on the historical operation record set, and caching the second type of access file at the target edge node.

7. The method according to claim 1, characterized in that The method further comprises: Analyze the file contents and file names of the files in the plurality of preset network disks to obtain a label corresponding to each file; The files in the plurality of preset network disks are mapped to a plurality of virtual folders, wherein each of the virtual folders corresponds to a file of a tag.

8. The method according to claim 1, characterized in that The method further includes distributing and storing the backup data on edge nodes in multiple geographical areas, wherein each backup data is updated or deleted on the corresponding edge node according to a preset backup frequency and a preset retention period.

9. A multi-network disk drive device, characterized in that: include: a receiving module, configured to receive an operation request for a target network disk sent by a client, wherein the target network disk is any one of a plurality of preset network disks corresponding to the client, and the operation request is used to instruct an operation to be performed on a target file stored in the target network disk; A first conversion module is configured to convert the operation request into a standardized request through a unified abstraction layer, and distribute the standardized request to a target adapter corresponding to the target network disk; The second conversion module is used to use the target adapter to convert the standardized request into a target instruction that can be recognized by the application program interface of the target network disk, and to call the application program interface of the target network disk through the target adapter to execute the target instruction.

10. A non-volatile storage medium, characterized in that: The non-volatile storage medium stores a program, wherein when the program is running, the device where the non-volatile storage medium is located is controlled to execute the multi-network disk driving method according to any one of claims 1 to 8.

11. An electronic device, characterized in that: include: A memory and a processor, wherein the processor is used to run a program stored in the memory, wherein the program executes the multi-network disk driving method according to any one of claims 1 to 8 when running.

12. A computer program product comprising computer instructions, characterized in that When the computer instructions are executed by a processor, the multi-network disk driving method according to any one of claims 1 to 8 is implemented.

Images