Commit | Line | Data |
---|---|---|
3b8cae5a ERE |
1 | #!/usr/bin/env python3 |
2 | ||
b124086e VR |
3 | import argparse |
4 | import os | |
5 | import random | |
6 | import string | |
7 | from hashlib import sha512 as hashfunc | |
8 | ||
9 | ||
10 | def create_rand_name(size=None): | |
11 | """ Create rand name using alphanumeric char. | |
12 | Param size: size of str name. | |
13 | Type size: int. | |
14 | Return: random name. | |
15 | Rtype: str. | |
16 | """ | |
17 | if not size: | |
18 | size = random.randint(5, 15) | |
19 | name = '' | |
20 | for x in range(size): | |
21 | name += random.choice(string.hexdigits) | |
22 | return name | |
23 | ||
24 | ||
25 | def create_rand_folder(directory): | |
26 | """ Create rand folder in directory. | |
27 | Param directory: folder where create new rand folder. | |
28 | Type directory: str. | |
29 | Return: path with new directory. | |
30 | Rtype: str. | |
31 | """ | |
32 | new_dir = os.path.join(directory, create_rand_name()) | |
33 | if not os.path.exists(new_dir): | |
34 | os.makedirs(new_dir) | |
35 | else: | |
36 | new_dir = create_rand_folder(directory) | |
37 | return new_dir | |
38 | ||
39 | ||
40 | def create_rand_cad(size=1024): | |
41 | """ Create rand str using hexadecimal char and hash sha512. | |
42 | Param size: size in byte of str for generate. | |
43 | Type size: int. | |
44 | Return: random name. | |
45 | Rtype: str. | |
46 | """ | |
3b8cae5a | 47 | cads = [hashfunc(create_rand_name().encode('utf-8')).hexdigest()] |
b124086e | 48 | last = cads[0] |
3b8cae5a ERE |
49 | for i in range(int(size / 128)): |
50 | last = hashfunc(last[:8].encode('utf-8')).hexdigest() | |
b124086e VR |
51 | cads.append(last) |
52 | return ''.join(cads)[:size] | |
53 | ||
54 | ||
55 | def create_file(path, size): | |
56 | """ Get rand name using alphanumeric char. | |
57 | Param size: size of str name. | |
58 | Type size: int. | |
59 | Return: random name. | |
60 | Rtype: str. | |
61 | """ | |
62 | filename = create_rand_name() | |
63 | new_file = os.path.join(path, filename) | |
64 | if not os.path.exists(new_file): | |
65 | with open(new_file, 'w') as f: | |
66 | f.write(create_rand_cad(size)) | |
7b900c3e | 67 | return new_file |
b124086e | 68 | else: |
7b900c3e | 69 | return create_file(path, size) |
b124086e VR |
70 | |
71 | ||
72 | def generate_list_sizes(nfile, size, distribute_size): | |
73 | """ Generate list of size for use it with create_files. | |
74 | Param nfile: . | |
75 | Type nfile: . | |
76 | Param size: . | |
77 | Type size: . | |
78 | Param distribute_size: . | |
79 | Type distribute_size: . | |
80 | Return: . | |
81 | Rtype: . | |
82 | """ | |
83 | list_sizes = [] | |
84 | aux_size = size | |
85 | normal_size = int(size / nfile) | |
3b8cae5a | 86 | var = max(1, int(normal_size - normal_size * distribute_size / 100)) |
b124086e VR |
87 | for s in range(nfile): |
88 | if aux_size <= 0: | |
89 | list_sizes.append(0) | |
90 | continue | |
91 | tmp_size = random.randint(normal_size - var, normal_size + var) | |
92 | aux_size -= tmp_size | |
93 | if tmp_size < 0: | |
94 | list_sizes.append(tmp_size + aux_size) | |
95 | else: | |
96 | list_sizes.append(tmp_size) | |
97 | return list_sizes | |
98 | ||
99 | ||
100 | def get_files_per_folder(nfile, ndir, distribute_files): | |
101 | """ Get numbers of files for each folder. | |
102 | Param nfile: . | |
103 | Type nfile: . | |
104 | Param ndir: . | |
105 | Type ndir: . | |
106 | Param distribute_files: . | |
107 | Type distribute_files: . | |
108 | Return: List of numbers. | |
109 | Rtype: list(int). | |
110 | """ | |
111 | list_files = [] | |
112 | aux_files = nfile | |
113 | f_per_dir = int(nfile / ndir) | |
114 | f_remainder = int(nfile % ndir) | |
115 | for d in range(ndir): | |
116 | if (aux_files <= 0): | |
117 | list_files.append(0) | |
118 | continue | |
119 | files = 0 | |
120 | if (f_per_dir > 0): | |
3b8cae5a | 121 | var = max(1, int(f_per_dir - f_per_dir * distribute_files / 100)) |
b124086e | 122 | files += random.randint(f_per_dir - var, f_per_dir + var) |
b4e1cb72 | 123 | var = f_remainder - f_remainder * distribute_files // 100 |
b124086e VR |
124 | files += random.randint(f_remainder - var, f_remainder + var) |
125 | aux_files -= files | |
126 | if (aux_files <= 0): | |
127 | list_files.append(files + aux_files) | |
128 | continue | |
129 | list_files.append(files) | |
130 | if (aux_files > 0): | |
131 | list_files[-1] += aux_files | |
132 | return list_files | |
133 | ||
134 | ||
08bb4b4a ERE |
135 | def main(args = None): |
136 | parser = argparse.ArgumentParser(description='Wgeneration option. ') | |
137 | parser.add_argument('--seed', type=int, action='store', help='Seed. ') | |
138 | parser.add_argument('--ndir', type=int, action='store', | |
139 | help='Number of directories for create. ') | |
140 | parser.add_argument('--deep', type=int, action='store', | |
141 | help='Percent for distribute deep.') | |
142 | parser.add_argument('--nfile', type=int, action='store', | |
143 | help='Number of files for create. ') | |
144 | parser.add_argument('--size', type=int, action='store', | |
145 | help='Total size of files (MB) ') | |
146 | parser.add_argument('--distribute_files', type=int, action='store', | |
147 | help='Percent for distribute files. ') | |
148 | parser.add_argument('--distribute_size', type=int, action='store', | |
149 | help='Percent to distribute size of files. ') | |
150 | parser.add_argument('--path', action='store', help='Path to generate. ') | |
151 | ||
152 | if not args: | |
f0287fb7 | 153 | parsed_args = parser.parse_args() |
08bb4b4a | 154 | else: |
f0287fb7 | 155 | parsed_args = parser.parse_args(args) |
08bb4b4a | 156 | |
f0287fb7 CH |
157 | if parsed_args.seed is not None: |
158 | seed = parsed_args.seed | |
b124086e VR |
159 | else: |
160 | seed = random.randint(0, 1000000000) | |
161 | random.seed(seed) | |
f0287fb7 CH |
162 | if parsed_args.ndir is not None: |
163 | ndir = parsed_args.ndir | |
b124086e VR |
164 | else: |
165 | ndir = random.randint(0, 50000) | |
f0287fb7 CH |
166 | if parsed_args.deep is not None: |
167 | deep = parsed_args.deep | |
b124086e VR |
168 | else: |
169 | deep = random.randint(0, 100) | |
f0287fb7 CH |
170 | if parsed_args.nfile: |
171 | nfile = parsed_args.nfile | |
b124086e VR |
172 | else: |
173 | nfile = random.randint(1, 500000) | |
f0287fb7 CH |
174 | if parsed_args.size: |
175 | size = parsed_args.size * 1024 * 1024 # MB to byte | |
b124086e VR |
176 | else: |
177 | size = random.randint(1, 5000) | |
178 | size = size * 1024 * 1024 # MB to byte | |
f0287fb7 CH |
179 | if parsed_args.distribute_files is not None: |
180 | distribute_files = parsed_args.distribute_files | |
b124086e VR |
181 | else: |
182 | distribute_files = random.randint(0, 100) | |
f0287fb7 CH |
183 | if parsed_args.distribute_size is not None: |
184 | distribute_size = parsed_args.distribute_size | |
b124086e VR |
185 | else: |
186 | distribute_size = random.randint(0, 100) | |
f0287fb7 CH |
187 | if parsed_args.path: |
188 | path = os.path.abspath(parsed_args.path) | |
b124086e VR |
189 | if not os.path.exists(path): |
190 | os.makedirs(path) | |
191 | else: | |
192 | path = os.getcwd() | |
193 | ||
194 | print("Using seed %d: " % seed) | |
195 | print("Generate %d folders with %d%% of deep." % (ndir, deep)) | |
196 | print("Generate %d files with total size %d MB." % (nfile, | |
197 | size / 1024 / 1024)) | |
198 | print("\tDistribute (files, size): (%d%%, %d%%)." % (distribute_files, | |
199 | distribute_size)) | |
200 | ||
201 | list_dir = [[path, ndir, nfile]] | |
202 | list_sizes = generate_list_sizes(nfile, size, distribute_size) | |
203 | list_files = get_files_per_folder(nfile, ndir, distribute_files) | |
204 | ||
205 | while ndir > 0: | |
206 | new_dir = create_rand_folder(list_dir[0][0]) | |
207 | ndir -= 1 | |
208 | for i in range(list_files[0]): | |
209 | create_file(new_dir, list_sizes[i]) | |
210 | del list_sizes[:list_files[0]] | |
211 | del list_files[0] | |
212 | current_ndir = list_dir[0][1] - 1 | |
213 | if (current_ndir == 0): | |
214 | del list_dir[0] | |
215 | else: | |
216 | ndir_deep = current_ndir * deep / 100 | |
217 | ndir_path = current_ndir - ndir_deep | |
218 | if (ndir_deep > 0): | |
219 | list_dir.append([new_dir, ndir_deep]) | |
220 | if (ndir_path > 0): | |
221 | list_dir[0][1] = ndir_path | |
222 | else: | |
223 | del list_dir[0] | |
08bb4b4a | 224 | return seed |
b124086e VR |
225 | |
226 | ||
227 | if __name__ == "__main__": | |
08bb4b4a | 228 | main() |