CN111459897A - Method and device for controlling write-in of shared directory by using quota of distributed file storage directory - Google Patents

Method and device for controlling write-in of shared directory by using quota of distributed file storage directory Download PDF

Info

Publication number
CN111459897A
CN111459897A CN202010168525.1A CN202010168525A CN111459897A CN 111459897 A CN111459897 A CN 111459897A CN 202010168525 A CN202010168525 A CN 202010168525A CN 111459897 A CN111459897 A CN 111459897A
Authority
CN
China
Prior art keywords
directory
quota
nfs
cluster
shared
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
CN202010168525.1A
Other languages
Chinese (zh)
Inventor
吴昊
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Suzhou Inspur Intelligent Technology Co Ltd
Original Assignee
Suzhou Inspur Intelligent Technology Co Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Suzhou Inspur Intelligent Technology Co Ltd filed Critical Suzhou Inspur Intelligent Technology Co Ltd
Priority to CN202010168525.1A priority Critical patent/CN111459897A/en
Publication of CN111459897A publication Critical patent/CN111459897A/en
Withdrawn legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/10—File systems; File servers
    • G06F16/17—Details of further file system functions
    • G06F16/176—Support for shared access to files; File sharing support
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/10—File systems; File servers
    • G06F16/18—File system types
    • G06F16/182—Distributed file systems
    • G06F16/1824—Distributed file systems implemented using Network-attached Storage [NAS] architecture
    • G06F16/183—Provision of network file services by network file servers, e.g. by using NFS, CIFS

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Data Mining & Analysis (AREA)
  • Databases & Information Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Information Retrieval, Db Structures And Fs Structures Therefor (AREA)

Abstract

The invention provides a method for controlling writing of a shared directory by using distributed file storage directory quotas, which comprises the steps of starting NFS shared service, modifying a cluster to-be-mounted directory by modifying an NFS configuration file, then creating the cluster mounted shared directory, adding L IMIT parameters, recording directory quotas, setting a cluster local state directory quota by using a L IMIT command, mounting a client by using a mount command, synchronizing the cluster directory quota to a mounted shared state of the cluster mounted shared directory by using a dynamic command, inquiring the directory quota by using a query command, judging whether the directory quotas are synchronous or not by judging whether the limited quota is the same as $ L IMIT or not, and synchronously checking the directory quotas.

Description

Method and device for controlling write-in of shared directory by using quota of distributed file storage directory
Technical Field
The invention belongs to the technical field of distributed file storage, and particularly relates to a method and a device for controlling writing of a shared directory by using a quota of a distributed file storage directory.
Background
The distributed file storage system is widely applied to the fields of IT enterprises, cloud computing, big data, virtualization and the like.
Meanwhile, the demand of the fields on the directory quota function of the storage system is higher and higher, only the directory quota function is provided for users, only the quota can be applied to the directory and the write-in data on the storage cluster system, the use of the storage system cannot be met, and the synchronous quota can be applied to the mounted directory and the write-in data of the client on the client mounted to the cluster. Because the quota limit of the directory of the existing distributed file system can not be carried out on the mounted directory and the data written in the client, the robustness, the usability and the function richness of the storage system are reduced, and the competitiveness of a distributed file storage product is seriously influenced.
Disclosure of Invention
The invention provides a method and a device for controlling writing of a shared directory by using a distributed file storage directory quota, which can synchronously limit the mounted shared directory and the client written data for a client mounted to a cluster.
In order to achieve the above object, the present invention provides a method for controlling write-in of a shared directory by using a quota of a distributed file storage directory, which comprises the following steps:
s1: opening NFS sharing service for the distributed file system;
s2: modifying and storing the to-be-mounted directory of the cluster by modifying the NFS configuration file; then, creating a cluster mounting shared directory; the cluster mounting shared directory comprises a cluster local state and a mounting shared state;
s3, adding L IMIT parameters, recording the quota of the directory quota, and setting the quota of the local directory of the cluster by using a L IMIT command;
s4: mounting the client through a mount command;
s5: and adding a dynamic parameter, and synchronizing the cluster catalog quota to the mount sharing state of the cluster mount sharing catalog by adopting a dynamic command.
Further, the method includes S6, adopting query command to inquire the catalog quota, judging whether the catalog quota is synchronous or not by judging whether the limit quota is the same as $ L IMIT or not, and synchronously checking the catalog quota.
Further, step S1 includes: firstly, opening NFS shared service through icfs-admin-NFS-start, and then newly adding dir _ quota _ NFS parameter in dirQuota configuration file in/home/dirQuota directory; after the NFS sharing service is opened, $ dir _ quota _ NFS is set to ON.
Further, step S2 includes: modifying and storing a directory $ NFS _ DIR to be mounted of a cluster through modifying an NFS _ conf configuration file in a/usr/NFS directory; a cluster mount shared directory is then created using icfs-admin-NFS-create-share-p $ NFS _ DIR-a-rw-d.
Further, step S3 includes adding and configuring L IMIT parameter in dirquota _ conf, recording the catalog quota limit, and using icfs-admin-quota-set-DIR-p $ NFS _ DIR-limit $ L IMIT to set the catalog quota, and limiting the cluster local state.
Further, step S4 includes: adding a client _ ip parameter in dirquota _ conf, and mounting the client by using mount-tnfs $ client _ ip, wherein the mount is 3 for NFS _ DIR/media-o vers; mount client for $ NFS _ DIR is queried using mount | grep $ NFS _ DIR, and $ client _ ip is used to check if the client is in the whitelist.
Further, step S5 includes: adding into dirquota _ conf, setting dynamic as TRUE, using icfs-admin-DIR-quota-dynamic to set the cluster directory quota to dynamic parameter, synchronizing to mount sharing state of $ NFS _ DIR mount sharing directory.
Further, step S6 includes querying the directory quota using the icfs-DIR-quota-query $ NFS _ DIR, and if there is a result SHARE _ STATUS and the limit quota is the same as $ L IMIT, then the synchronization is successful;
starting a multithreading process dirquota _ nfs _ process, setting a directory quota to be 10K, quickly writing 20K files through a client dd if/dev/zero of/media/file 1bs of 2K count of 10, if the result returns that the quota exceeds the quota limit quota exceeded, setting success, returning 1 by the program, and otherwise returning 0.
The invention also provides a device for controlling the writing of the shared directory by the distributed file storage directory quota, which comprises an NFS opening module, an NFS sharing establishing module, a directory quota setting module, a mounted client module and a directory quota synchronizing module;
the NFS starting module is used for starting NFS sharing service for the distributed file system;
creating an NFS sharing module, modifying the cluster to-be-mounted directory by modifying the NFS configuration file, and storing the modified cluster to-be-mounted directory; then, creating a cluster mounting shared directory; the cluster mounting shared directory comprises a cluster local state and a mounting shared state;
the directory quota setting module is used for adding L IMIT parameters, recording directory quota, and setting cluster local state directory quota by using L IMIT command;
the mounting client module mounts the client through a mount command;
the catalog quota synchronizing module is used for adding a dynamic parameter and synchronizing the cluster catalog quota to the mount sharing state of the cluster mount sharing catalog by adopting a dynamic command.
Furthermore, the device also comprises a quota inquiry module and a quota synchronous check module;
the query quota module is used for querying the directory quota by adopting a query command;
the quota synchronization check module is used for judging whether the directory quotas are synchronous or not by judging whether the limit quotas are the same as $ L IMIT or not and carrying out synchronization check on the directory quotas.
The effect provided in the summary of the invention is only the effect of the embodiment, not all the effects of the invention, and one of the above technical solutions has the following advantages or beneficial effects:
the embodiment of the invention provides a method for controlling writing of a shared directory by a distributed file storage directory quota, which comprises the steps of starting a NFS shared service of a distributed file system, modifying and storing a cluster to-be-mounted directory by modifying an NFS configuration file, creating a cluster mounted shared directory, wherein the cluster mounted shared directory comprises a cluster local state and a mounted shared state, adding L an IMIT parameter, recording a directory quota limit, setting a cluster local state directory by using a L IMIT command, mounting a client by a mount command, adding a dynamic parameter, synchronizing the cluster directory to the mounted shared state of the cluster mounted shared directory by using a dynamic command, querying the directory by using a query command, judging whether the quota limit is the same as a L IMIT quota, judging whether the directory quota is synchronous, synchronously checking the directory synchronously, and performing synchronous checking on the directory.
Drawings
Fig. 1 is a flowchart of a method for controlling write-in of a shared directory by using a quota of a distributed file storage directory in embodiment 1 of the present invention;
fig. 2 is a diagram illustrating a structure of a device for controlling writing of a shared directory by a distributed file storage directory quota in embodiment 1 of the present invention;
fig. 3 is a functional diagram illustrating the NFS module opening function in embodiment 1 of the present invention;
fig. 4 is a schematic diagram illustrating the creation of an NFS sharing module in embodiment 1 of the present invention;
fig. 5 is a schematic functional diagram of a module for setting a directory quota in embodiment 1 of the present invention;
fig. 6 is a schematic functional diagram of a mount client module in embodiment 1 of the present invention;
fig. 7 is a schematic diagram showing functions of a directory quota synchronization module, a query quota module, and a quota synchronization check module in embodiment 1 of the present invention.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Example 1
Embodiment 1 of the present invention provides a method for controlling writing of a shared directory by using a quota of a distributed file storage directory, and for example, fig. 1 shows a flowchart of a method for controlling writing of a shared directory by using a quota of a distributed file storage directory.
In step S101, the NFS sharing service is opened for the distributed file system; firstly, the NFS sharing service is started through icfs-admin-NFS-start, then a dir _ quota _ NFS parameter is newly added in a dirQuota _ conf configuration file in a/home/dirQuota directory, and after the NFS service is opened, the $ dir _ quota _ NFS is set to ON.
In step S102, modifying and saving the to-be-mounted directory of the cluster by modifying the NFS configuration file; a cluster mount shared directory is then created. Modifying an NFS _ conf configuration file in a/usr/NFS directory, modifying and storing a directory to be mounted by a cluster, $ NFS _ DIR; then, an icfs-admin-NFS-create-share-p $ NFS _ DIR-a-rw-d is used to create a cluster mount shared directory, and the $ NFS _ DIR directory is divided into a local state and a mount shared state.
In step S103, adding L IMIT parameter, recording catalog quota limit, using L IMIT command to set cluster local catalog quota, adding and configuring L IMIT parameter in dirquota _ conf, recording catalog quota limit, using icfs-admin-quota-set-DIR-p $ NFS _ DIR-limit $ L IMIT to set catalog quota, at this time, limiting cluster local state of NFS _ DIR, and sharing state has no quota limit.
In step S104, mount the client by mount command; adding a client _ ip parameter in dirquota _ conf, and mounting the client by using mount-t NFS $ client _ ip, wherein the mount is 3 for NFS _ DIR/media-o vers; mount client for $ NFS _ DIR is queried using mount | grep $ NFS _ DIR, and $ client _ ip is used to check if the client is in the whitelist.
In step S105: and adding a dynamic parameter, and synchronizing the cluster catalog quota to the mount sharing state of the cluster mount sharing catalog by adopting a dynamic command. Adding in dirquota _ conf, setting dynamic as TRUE, using icfs-admin-DIR-quota-dynamic to set the cluster directory quota to dynamic parameter, synchronizing to the shared state of $ NFS _ DIR mount directory.
In step S106, the query command is used to query the directory quota.
In step S107, the directory quota is determined to be synchronous by determining whether the limit quota is the same as $ L, and a synchronization check is performed on the directory quota, the directory quota is queried by using icfs-DIR-quota-query $ NFS _ DIR, if there is a result SHARE _ STATUS and the limit quota is the same as $ L, the synchronization succeeds, at this time, the backend starts a multithreading process dirquota _ NFS _ process, sets the directory quota to 10K, and quickly writes a 20K file through a client dd if/dev/zeroof/media/file 1bs is 10K count, if the result return quota exceeds the limit quoteaxecuted, the program is successfully set, and returns 1, otherwise returns 0.
Based on the method for controlling the write-in of the shared directory by the quota of the distributed file storage directory, the invention also provides a device for controlling the write-in of the shared directory by the quota of the distributed file storage directory, and as shown in fig. 2, a schematic diagram of the device for controlling the write-in of the shared directory by the quota of the distributed file storage directory is provided.
A functional schematic diagram of the NFS module starting is given as figure 3; firstly, the NFS sharing service is started through icfs-admin-NFS-start, then a dir _ quota _ NFS parameter is newly added in a dirQuota _ conf configuration file in a/home/dirQuota directory, and after the NFS service is opened, the $ dir _ quota _ NFS is set to ON.
As shown in fig. 4, a schematic diagram of creating an NFS sharing module is shown, an NFS _ conf configuration file in a/usr/NFS directory is modified, and a directory to be mounted by a cluster is modified and saved as $ NFS _ DIR; then, an icfs-admin-NFS-create-share-p $ NFS _ DIR-a-rw-d is used to create a cluster mount shared directory, and the $ NFS _ DIR directory is divided into a local state and a mount shared state.
Adding L IMIT parameter in dirquota _ conf, recording catalog quota limit, and using icfs-admin-quota-set-DIR-p $ NFS _ DIR-limit $ L IMIT to set catalog quota, at this time, only limit the local state of $ NFS _ DIR, and the shared state has no quota limit.
Fig. 6 is a functional diagram of a mount client module; adding a client _ ip parameter in dirquota _ conf, and mounting the client by using mount-t NFS $ client _ ip, wherein the mount is 3 for NFS _ DIR/media-o vers; mount client for $ NFS _ DIR is queried using mount | grep $ NFS _ DIR, and $ client _ ip is used to check if the client is in the whitelist.
Adding in dirquota _ conf and setting dynamic as TRUE, using icfs-admin-DIR-quota-dynamic to set dynamic parameter set for cluster directory quota to synchronize to shared state of $ NFS _ DIR mounted directory, using icfs-DIR-quota-query DIR quotas, if result SHARE _ STATUS exists and limit quota is the same as $ L IMIT, then synchronization is successful, at this time, starting a multi-thread dirquota _ NFS _ process, setting directory quota to 10K, and if result if/dev/zeof/media/file 1bs is 10K, then fast writing back to 20K count, if result exceeds $ L IMIT, then returning back to background program, otherwise returning back to 0.
The device for controlling the writing of the shared directory by the distributed file storage directory quota, provided by the invention, opens the NFS service through the 'opening NFS module'; creating an NFS shared directory by means of a 'create NFS shared module'; setting a local quota state of the shared directory through a directory quota setting module; carrying out fuse client mounting through a mounting client module; synchronizing the local state of the directory quota to a shared state through a directory quota synchronizing module; the shared state quota of the mounted shared directory is successfully set by the query quota module; and judging whether the program function is normal or not by starting the result of quickly writing the quota file exceeding the mount directory through the multithreading by the quota synchronous check module.
The foregoing is merely exemplary and illustrative of the present invention and various modifications, additions and substitutions may be made by those skilled in the art to the specific embodiments described without departing from the scope of the present invention as defined in the accompanying claims.

Claims (10)

1. The method for controlling the write-in of the shared directory by the quota control of the distributed file storage directory is characterized by comprising the following steps of:
s1: opening NFS sharing service for the distributed file system;
s2: modifying and storing the to-be-mounted directory of the cluster by modifying the NFS configuration file; then, creating a cluster mounting shared directory; the cluster mounting shared directory comprises a cluster local state and a mounting shared state;
s3, adding L IMIT parameters, recording the quota of the directory quota, and setting the quota of the local directory of the cluster by using a L IMIT command;
s4: mounting the client through a mount command;
s5: and adding a dynamic parameter, and synchronizing the cluster catalog quota to the mount sharing state of the cluster mount sharing catalog by adopting a dynamic command.
2. The method for controlling the writing of the shared directory by the quota of the distributed file storage directory of claim 1, further comprising S6, querying the directory quota by a query command, determining whether the directory quota is synchronous by determining whether the limit quota is the same as $ L IMIT, and synchronously checking the directory quota.
3. The method for controlling writing of the shared directory by the directory quota of the distributed file storage according to claim 1, wherein the step S1 includes: firstly, opening NFS shared service through icfs-admin-NFS-start, and then newly adding dir _ quota _ NFS parameter in dirQuota configuration file in/home/dirQuota directory; after the NFS sharing service is opened, $ dir _ quota _ NFS is set to ON.
4. The method for controlling writing of the shared directory by the directory quota of the distributed file storage according to claim 1, wherein the step S2 includes: modifying and storing a directory $ NFS _ DIR to be mounted of a cluster through modifying an NFS _ conf configuration file in a/usr/NFS directory; a cluster mount shared directory is then created using icfs-admin-NFS-create-share-p $ NFS _ DIR-a-rw-d.
5. The method for distributed file storage directory quota controlling shared directory write as in claim 1, wherein step S3 comprises adding and configuring L IMIT parameter in dirquota _ conf, recording directory quota limit, and using icfs-admin-quota-set-DIR-p $ NFS _ DIR-limit $ L IMIT to set directory quota and limit cluster local state.
6. The method according to claim 1, wherein step S4 includes: adding a client _ ip parameter in dirquota _ conf, and mounting the client by using mount-t NFS $ client _ ip, wherein the mount is 3 for NFS _ DIR/media-o vers; mount client for $ NFS _ DIR is queried using mount | grep $ NFS _ DIR, and $ client _ ip is used to check if the client is in the whitelist.
7. The method for controlling writing of the shared directory by the directory quota of the distributed file storage according to claim 1, wherein the step S5 includes: adding into dirquota _ conf, setting dynamic as TRUE, using icfs-admin-DIR-quota-dynamic to set the cluster directory quota to dynamic parameter, synchronizing to mount sharing state of $ NFS _ DIR mount sharing directory.
8. The method of distributed file storage directory quota controlling shared directory writes of claim 2, wherein step S6 includes querying the directory quota using an icfs-DIR-quota-query $ NFS _ DIR, if there is a result SHARE _ STATUS and the limit quota is the same as $ L IMIT, then the synchronization is successful;
starting a multithreading process dirquota _ nfs _ process, setting a directory quota to be 10K, quickly writing 20K files through a client ddif ═ dev/zero of ═ media/file1bs ═ 2K count ═ 10, if the result return quota exceeds the quota limit quota exceeded, setting success, the program returns 1, otherwise, returns 0.
9. The device for controlling the writing of the shared directory by the quota control of the distributed file storage directory is characterized by comprising an NFS starting module, an NFS sharing establishing module, a directory quota setting module, a mounting client module and a directory quota synchronizing module;
the NFS starting module is used for starting NFS sharing service for the distributed file system;
the creating NFS sharing module modifies the to-be-mounted directory of the cluster and stores the to-be-mounted directory by modifying the NFS configuration file; then, creating a cluster mounting shared directory; the cluster mounting shared directory comprises a cluster local state and a mounting shared state;
the set catalog quota module is used for adding L IMIT parameters, recording catalog quota, and setting cluster local state catalog quota by using L IMIT command;
the mounting client module mounts the client through a mount command;
the catalog quota synchronizing module is used for adding a dynamic parameter and synchronizing the cluster catalog quota to a mount sharing state of the cluster mount sharing catalog by adopting a dynamic command.
10. The apparatus for controlling write-in of a shared directory by quota of a distributed file storage directory according to claim 9, further comprising a query quota module and a quota synchronization check module;
the query quota module is used for querying the directory quota by adopting a query command;
the quota synchronization check module is used for judging whether the directory quotas are synchronous or not by judging whether the limit quotas are the same as $ L IMIT or not and carrying out synchronization check on the directory quotas.
CN202010168525.1A 2020-03-13 2020-03-13 Method and device for controlling write-in of shared directory by using quota of distributed file storage directory Withdrawn CN111459897A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202010168525.1A CN111459897A (en) 2020-03-13 2020-03-13 Method and device for controlling write-in of shared directory by using quota of distributed file storage directory

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202010168525.1A CN111459897A (en) 2020-03-13 2020-03-13 Method and device for controlling write-in of shared directory by using quota of distributed file storage directory

Publications (1)

Publication Number Publication Date
CN111459897A true CN111459897A (en) 2020-07-28

Family

ID=71685754

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202010168525.1A Withdrawn CN111459897A (en) 2020-03-13 2020-03-13 Method and device for controlling write-in of shared directory by using quota of distributed file storage directory

Country Status (1)

Country Link
CN (1) CN111459897A (en)

Cited By (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112000618A (en) * 2020-08-07 2020-11-27 北京浪潮数据技术有限公司 File change management method, device, equipment and storage medium for cluster nodes
CN113377454A (en) * 2021-06-23 2021-09-10 浪潮云信息技术股份公司 Method for realizing Flink dynamic connection Kerberos authentication component
CN113992657A (en) * 2021-10-26 2022-01-28 超越科技股份有限公司 Shared storage building method, device and medium based on cloud platform

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112000618A (en) * 2020-08-07 2020-11-27 北京浪潮数据技术有限公司 File change management method, device, equipment and storage medium for cluster nodes
CN112000618B (en) * 2020-08-07 2022-06-07 北京浪潮数据技术有限公司 File change management method, device, equipment and storage medium for cluster nodes
CN113377454A (en) * 2021-06-23 2021-09-10 浪潮云信息技术股份公司 Method for realizing Flink dynamic connection Kerberos authentication component
CN113992657A (en) * 2021-10-26 2022-01-28 超越科技股份有限公司 Shared storage building method, device and medium based on cloud platform
CN113992657B (en) * 2021-10-26 2024-04-12 超越科技股份有限公司 Cloud platform-based shared storage construction method, equipment and medium

Similar Documents

Publication Publication Date Title
CN111459897A (en) Method and device for controlling write-in of shared directory by using quota of distributed file storage directory
JP3062070B2 (en) System and method for multi-level token management for a distributed file system
US8069144B2 (en) System and methods for asynchronous synchronization
US8458127B1 (en) Application data synchronization
US7017105B2 (en) Deleting objects from a store of a device
JP4558945B2 (en) Database system having at least two host databases and a remote database and method for synchronizing such databases
US8812451B2 (en) Programming model for synchronizing browser caches across devices and web services
HU219996B (en) Client computer, as well as method for operating it
US20150199414A1 (en) Locally cached file system
CN102541984B (en) File system of distributed type file system client side
US20190347167A1 (en) Primary Node-Standby Node Data Transmission Method, Control Node, and Database System
CN111290826A (en) Distributed file system, computer system, and medium
US20190220442A1 (en) Architecture for management of digital files across distributed network
US10152493B1 (en) Dynamic ephemeral point-in-time snapshots for consistent reads to HDFS clients
CN113626286A (en) Multi-cluster instance processing method and device, electronic equipment and storage medium
CN109165078B (en) Virtual distributed server and access method thereof
EP2402861A1 (en) Storage system
CN111881103B (en) LDAP domain user ACL authority control method and device based on NFS sharing
JP2001312422A (en) Method and device for document batch management and recording medium
CN113961536A (en) Method for dynamically calculating MD5 value in storage device
CN112463879B (en) Data volume synchronization method and equipment
US10887429B1 (en) Processing multi-protocol redirection links
CN116010364B (en) Method and device for updating network disk file state, network disk and storage medium
CN117931731A (en) Data management method, platform, electronic equipment and storage medium
WO2023246442A1 (en) Pooling desktop startup method based on personalized roaming data, and cloud desktop system

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
WW01 Invention patent application withdrawn after publication

Application publication date: 20200728

WW01 Invention patent application withdrawn after publication