aebb9315d2af49b8182b853c4405d087e43bac73
[splitter-ng] / Splitter-ng-test / src / SplitterTest.java
1 import java.io.IOException;
2 import java.nio.file.DirectoryStream;
3 import java.nio.file.Files;
4 import java.nio.file.Path;
5 import java.nio.file.Paths;
6 import java.util.Collection;
7 import java.util.HashMap;
8 import java.util.LinkedList;
9 import java.util.List;
10 import java.util.Map;
11 import java.util.Map.Entry;
12 import java.util.Scanner;
13 import java.util.TreeMap;
14
15 import splitterng.CodingTask;
16 import splitterng.DecodingTask;
17 import splitterng.EncodingTask;
18 import splitterng.Splitter;
19 import splitterng.SplitterCallback;
20 import splitterng.plugin.CodecDescription;
21 import splitterng.plugin.PluginDescription;
22
23 public class SplitterTest implements SplitterCallback {
24
25         private Collection<Splitter> splitters = new LinkedList<Splitter>();
26         private List<CodingTask> finished_encoding_task = new LinkedList<CodingTask>();
27         private List<CodingTask> finished_decoding_task = new LinkedList<CodingTask>();
28
29         // in der Map werden die Metadaten-vorlage für jeden Codec gespeichert
30         private Map<Splitter, Map<String, Object>> splitter_metadata_map = new HashMap<Splitter, Map<String, Object>>();
31
32         public static void main(String[] args) throws InterruptedException {
33                 SplitterTest splitterTest = new SplitterTest();
34                 splitterTest.run();
35
36                 // Thread.sleep(50000);
37                 // System.exit(0);
38         }
39
40         public void run() {
41
42                 System.out.println("Splitter Plugins");
43                 // Optional: Anfrage, welche Plugins geladen sind
44                 for (PluginDescription p : Splitter.getPluginDescriptions()) {
45                         System.out.println("---------------------------------------------\n" + p.getPluginID() + "\t"
46                                         + p.getPluginName());
47                         // Optional: Aus jeder Plugindescription die Verfügbaren Codecs
48                         // auslesen
49                         for (CodecDescription c : p.getCodecDescriptions()) {
50                                 System.out.println("\t|---------------------------------------------\n\t|" + c.getCodecID() + "\t"
51                                                 + c.getCodecDescriptionText());
52                                 Map<String, Integer[]> codecParameterMinMax = c
53                                                 .getCodecParameterMinMax();
54                                 for (Entry<String, Integer[]> e : codecParameterMinMax
55                                                 .entrySet()) {
56                                         System.out.println("\t|\t" + e.getKey() + "\tmin:"
57                                                         + e.getValue()[0] + "  max:" + e.getValue()[1] + " default: " + c.getCodecParameterDefaults().get(e.getKey()));
58                                 }
59                                 // Wenn hier eine Konfiguration für eine plugin-codec
60                                 // Kombination vorhanden ist, wird der Splitter initialisiert.
61                                 switch (p.getPluginID() + "/" + c.getCodecID()) {
62 ///-----------------------------------------------------------------------------------------------
63 ///-----------------------------------------------------------------------------------------------
64 ///-----------------------------------------------------------------------------------------------
65 ///-----------------------------------------------------------------------------------------------
66                                 case "jerasure/JerasureCauchyGood":
67                                         // Codecparameter Bauen
68                                         Map<String, Integer> codecParameter = new TreeMap<String, Integer>();
69                                         codecParameter.put("k", 2);
70                                         codecParameter.put("m", 2);
71                                         //codecParameter.put("w", 8);
72                                         //codecParameter.put("packetsize", 8);
73                                         System.out.println("\t\tinitialisiere mit" + " k="
74                                                         + codecParameter.get("k") + " m="
75                                                         + codecParameter.get("m") + " w="
76                                                         + codecParameter.get("w") + " packetsize="
77                                                         + codecParameter.get("packetsize"));
78                                         // Splitter mit Plugin-ID CodecID und codecparametern
79                                         // initialisieren
80                                         Splitter splitterjerasure = new Splitter(p.getPluginID(), c.getCodecID(),
81                                                         codecParameter);
82                                         splitters.add(splitterjerasure);
83                                         
84                                         // Metadaten bauen vorlage
85                                         Map<String, Object> metadatajerasure = new TreeMap<String, Object>();
86                                         metadatajerasure.put("fragmentsize", (int) 64);
87                                         // Beleiebige weitere Metadaten
88                                         
89                                         splitter_metadata_map.put(splitterjerasure, metadatajerasure);
90                                         break;
91 ///-----------------------------------------------------------------------------------------------
92                                 case "--jerasure/JerasureReedSolomon":
93                                         // Codecparameter Bauen
94                                         Map<String, Integer> codecParameter1 = new TreeMap<String, Integer>();
95                                         codecParameter1.put("k", 3);
96                                         codecParameter1.put("m", 3);
97                                         //codecParameter1.put("w", 16);
98                                         //codecParameter1.put("packetsize", 64);
99                                         System.out.println("\t\tinitialisiere mit" + " k="
100                                                         + codecParameter1.get("k") + " m="
101                                                         + codecParameter1.get("m") + " w="
102                                                         + codecParameter1.get("w") + " packetsize="
103                                                         + codecParameter1.get("packetsize"));
104                                         // Splitter mit Plugin-ID CodecID und codecparametern
105                                         // initialisieren
106                                         Splitter splitterjerasure1 = new Splitter(p.getPluginID(), c.getCodecID(),
107                                                         codecParameter1);
108                                         splitters.add(splitterjerasure1);
109                                         
110                                         // Metadaten bauen vorlage
111                                         Map<String, Object> metadatajerasure1 = new TreeMap<String, Object>();
112                                         metadatajerasure1.put("fragmentsize", (int) 40960);
113                                         // Beleiebige weitere Metadaten
114                                         
115                                         splitter_metadata_map.put(splitterjerasure1, metadatajerasure1);
116                                         break;
117 ///-----------------------------------------------------------------------------------------------
118                                 case "--jerasure/JerasureLiber8tion":
119                                         // Codecparameter Bauen
120                                         Map<String, Integer> codecParameter2 = new TreeMap<String, Integer>();
121                                         codecParameter2.put("k", 3);
122                                         codecParameter2.put("m", 2);
123                                         codecParameter2.put("packetsize", 64);
124                                         System.out.println("\t\tinitialisiere mit"
125                                                         + " k=" + codecParameter2.get("k") 
126                                                         + " m=" + codecParameter2.get("m")
127                                                         + " packetsize=" + codecParameter2.get("packetsize"));
128                                         // Splitter mit Plugin-ID CodecID und codecparametern
129                                         // initialisieren
130                                         Splitter splitterjerasure2 = new Splitter(p.getPluginID(), c.getCodecID(),
131                                                         codecParameter2);
132                                         splitters.add(splitterjerasure2);
133                                         
134                                         // Metadaten bauen vorlage
135                                         Map<String, Object> metadatajerasure2 = new TreeMap<String, Object>();
136                                         metadatajerasure2.put("fragmentsize", (int) 40960);
137                                         // Beleiebige weitere Metadaten
138                                         
139                                         splitter_metadata_map.put(splitterjerasure2, metadatajerasure2);
140                                         break;
141 ///-----------------------------------------------------------------------------------------------
142                                 case "Raid1Plugin/raid1codec":
143                                         // Codecparameter Bauen
144                                         Map<String, Integer> codecParameternoop = new TreeMap<String, Integer>();
145                                         codecParameternoop.put("k", 1);
146                                         codecParameternoop.put("m", 1);
147                                         System.out.println("\t\tinitialisiere mit"
148                                                         + " k=" + codecParameternoop.get("k")
149                                                         + " m=" + codecParameternoop.get("m")
150                                                         );
151                                         // Splitter mit Plugin-ID CodecID und codecparametern
152                                         // initialisieren
153                                         Splitter splitterraid1 = new Splitter(p.getPluginID(), c.getCodecID(),
154                                                         codecParameternoop);
155                                         splitters.add(splitterraid1);
156                                         
157                                         // Metadaten bauen vorlage
158                                         Map<String, Object> metadataraid1 = new TreeMap<String, Object>();
159                                         metadataraid1.put("fragmentsize", (int) 40960);
160                                         // Beleiebige weitere Metadaten
161                                         
162                                         splitter_metadata_map.put(splitterraid1, metadataraid1);
163                                         
164                                         break;
165 ///-----------------------------------------------------------------------------------------------
166                                 case "jsharing/shamir":
167                                         // Codecparameter Bauen
168                                         Map<String, Integer> codecParameterjsharing = new TreeMap<String, Integer>();
169                                         codecParameterjsharing.put("k", 2);
170                                         codecParameterjsharing.put("m", 1);
171                                         System.out.println("\t\tinitialisiere mit k="
172                                                         + codecParameterjsharing.get("k") + " m="
173                                                         + codecParameterjsharing.get("m"));
174
175                                         Splitter splittershamir= new Splitter(p.getPluginID(), c.getCodecID(),
176                                                         codecParameterjsharing);
177                                         splitters.add(splittershamir);
178                                         
179                                         // Metadaten bauen vorlage
180                                         Map<String, Object> metadatashamir = new TreeMap<String, Object>();
181                                         metadatashamir.put("fragmentsize", (int)8);
182                                         // Beleiebige weitere Metadaten
183                                         
184                                         splitter_metadata_map.put(splittershamir, metadatashamir);
185                                         
186                                         break;
187 ///-----------------------------------------------------------------------------------------------
188                                 case "jerasure-java/JerasureJavaCRS":
189                                         // Codecparameter Bauen
190                                         Map<String, Integer> codecParameter11 = new TreeMap<String, Integer>();
191                                         codecParameter11.put("k", 2);
192                                         codecParameter11.put("m", 2);
193                                         //codecParameter11.put("w", 8);
194                                         //codecParameter11.put("packetsize", 8);
195                                         System.out.println("\t\tinitialisiere mit"
196                                                         + " k=" + codecParameter11.get("k")
197                                                         + " m=" + codecParameter11.get("m") 
198                                                         + " w=" + codecParameter11.get("w")
199                                                         + " packetsize=" + codecParameter11.get("packetsize")
200                                                         );
201                                         // Splitter mit Plugin-ID CodecID und codecparametern
202                                         // initialisieren
203                                         Splitter splitterjerasure11 = new Splitter(p.getPluginID(), c.getCodecID(),
204                                                         codecParameter11);
205                                         splitters.add(splitterjerasure11);
206                                         
207                                         // Metadaten bauen vorlage
208                                         Map<String, Object> metadatajerasure11 = new TreeMap<String, Object>();
209                                         metadatajerasure11.put("fragmentsize", (int) 64);
210                                         // Beleiebige weitere Metadaten
211                                         
212                                         splitter_metadata_map.put(splitterjerasure11, metadatajerasure11);
213                                         break;
214 ///-----------------------------------------------------------------------------------------------
215                                         
216                                 case "JigDFS/crs":
217                                         // Codecparameter Bauen
218                                         Map<String, Integer> codecParameter111 = new TreeMap<String, Integer>();
219                                         codecParameter111.put("k", 2);
220                                         codecParameter111.put("m", 1);
221                                         //codecParameter111.put("chunksize", 16);
222                                         System.out.println("\t\tinitialisiere mit" + " k="
223                                                         + codecParameter111.get("k") + " m="
224                                                         + codecParameter111.get("m")
225                                                         + " chunksize=" + codecParameter111.get("chunksize")
226                                                         );
227                                         // Splitter mit Plugin-ID CodecID und codecparametern
228                                         // initialisieren
229                                         Splitter splitterjerasure111 = new Splitter(p.getPluginID(), c.getCodecID(),
230                                                         codecParameter111);
231                                         splitters.add(splitterjerasure111);
232                                         
233                                         // Metadaten bauen vorlage
234                                         Map<String, Object> metadatajerasure111 = new TreeMap<String, Object>();
235                                         metadatajerasure111.put("fragmentsize", (int) 64);
236                                         metadatajerasure111.put("digest", "SHA-256");
237                                         //metadatajerasure111.put("digest", "MD5");
238                                         // Beleiebige weitere Metadaten
239                                         splitter_metadata_map.put(splitterjerasure111, metadatajerasure111);
240                                         break;
241 ///-----------------------------------------------------------------------------------------------
242                                         
243                                 case "bitsplitter/bitsplitter":
244                                         // Codecparameter Bauen
245                                         Map<String, Integer> codecParameter1111 = new TreeMap<String, Integer>();
246                                         codecParameter1111.put("k", 4);
247                                         codecParameter1111.put("m", 0);
248                                         System.out.println("\t\tinitialisiere mit" + " k="
249                                                         + codecParameter1111.get("k") + " m="
250                                                         + codecParameter1111.get("m"));
251                                         // Splitter mit Plugin-ID CodecID und codecparametern
252                                         // initialisieren
253                                         Splitter splitter1111 = new Splitter(p.getPluginID(), c.getCodecID(),
254                                                         codecParameter1111);
255                                         splitters.add(splitter1111);
256                                         
257                                         // Metadaten bauen vorlage
258                                         Map<String, Object> metadata1111 = new TreeMap<String, Object>();
259                                         metadata1111.put("fragmentsize", (int) 409600);
260                                         // Beleiebige weitere Metadaten
261                                         
262                                         splitter_metadata_map.put(splitter1111, metadata1111);
263                                         break;
264 ///-----------------------------------------------------------------------------------------------
265 ///-----------------------------------------------------------------------------------------------
266 ///-----------------------------------------------------------------------------------------------
267 ///-----------------------------------------------------------------------------------------------
268 ///-----------------------------------------------------------------------------------------------
269                                 default:
270                                         System.out.println("\t\tNo Splitter created for: "
271                                                         + p.getPluginID() + "/" + c.getCodecID());
272                                         break;
273                                 }
274                         }
275                 }
276
277                 System.out.println("\nListe der Dateien");
278                 Path srcDir = Paths.get("srcDir");
279                 List<Path> srcFileList = getFileList(srcDir);
280                 for (Path entry : srcFileList) {
281                         System.out.println("- " + entry.toString());
282                 }
283
284                 // restoreDir anlegen bzw aufräumen
285                 Path splitDir = Paths.get("splitDir");
286                 checkDirectory(splitDir);
287                 for (Path entry : getFileList(splitDir)) {
288                         try {
289                                 Files.delete(entry);
290                         } catch (IOException e) {
291                                 // TODO Auto-generated catch block
292                                 e.printStackTrace();
293                         }
294                 }
295
296                 // restoreDir anlegen bzw aufräumen
297                 Path restoreDir = Paths.get("restoreDir");
298                 checkDirectory(restoreDir);
299                 for (Path entry : getFileList(restoreDir)) {
300                         try {
301                                 Files.delete(entry);
302                         } catch (IOException e) {
303                                 e.printStackTrace();
304                         }
305                 }
306                 // Jede Datei ...
307                 for (Path srcfile : srcFileList) {
308                         // ... mit jedem initialisierten Splitter bearbeiten
309                         for (Splitter splitter : splitters) {
310                                 System.out.println("Encoding: "
311                                                 + srcfile
312                                                 + "  with "
313                                                 + splitter.getCurrentPlugin().getPluginDescription()
314                                                                 .getPluginID() + "/"
315                                                 + splitter.getCurrentCodecDescription().getCodecID());
316                                 try {
317
318                                         Map<String, Object> metadata = new TreeMap<String, Object>();
319                                         
320                                         for (Entry<String, Object> e: splitter_metadata_map.get(splitter).entrySet()){
321                                                 metadata.put(e.getKey(), e.getValue());
322                                         }
323                                         
324                                         metadata.put("time_encoding_submitted",
325                                                         System.currentTimeMillis());
326                         
327
328                                         // Hier wird codiert. Der Encodingtask
329                                         splitter.encode(new EncodingTask(srcfile, Paths
330                                                         .get("splitDir"), this, metadata));
331                                 } catch (InterruptedException | IOException e) {
332                                         e.printStackTrace();
333                                 }
334
335                         }
336
337                 }
338
339                 System.out.println("-----");
340                 System.out.println("Alle Aufträge an die Splitter übermittelt");
341
342                 printUsage();
343
344                 
345                 // dateien zusammenbauen
346                 @SuppressWarnings("resource")
347                 Scanner in = new Scanner(System.in);
348                 while (true) {
349                         System.out.print(">>>");
350                         if (!in.hasNext()) System.exit(0);
351                         switch (in.next()) {
352                         case "EOF":
353                         case "q":
354                         case "quit":
355                         case "exit":
356                                         System.exit(0);
357                         case "h":
358                         case "help":
359                                 printUsage();
360                                 break;
361                         case "ls":
362                                 switch (in.next()){
363                                 case "enc":
364                                         for (CodingTask t : finished_encoding_task) {
365                                                 System.out.println(""
366                                                                 + finished_encoding_task.lastIndexOf(t) + "\t"
367                                                                 + t.getFilePath().getFileName());
368                                         }
369                                         break;
370                                 case "dec":
371                                         for (CodingTask t : finished_decoding_task) {
372                                                 System.out.println(""
373                                                                 + finished_decoding_task.lastIndexOf(t) + "\t"
374                                                                 + t.getFilePath().getFileName());
375                                         }
376                                         break;
377                                         
378                                 case "frag":
379                                         try {
380                                                 for (Entry<Integer, Path> e : finished_encoding_task
381                                                                 .get(Integer.parseInt(in.next()))
382                                                                 .getFragmentPaths().entrySet()) {
383                                                         System.out.format("\t %-5s %s %s\n", e.getKey(), e
384                                                                         .getValue().toString(), (Files.exists(e
385                                                                         .getValue()) ? "OK" : "Fehlt"));
386                                                         // System.out.println(++"\t"+e.getValue().toString());
387                                                 }
388                                         } catch (Exception e) {
389                                                 System.out.println("Index nicht gefunden");
390                                         }
391                                         break;
392                                         
393                                 case "src":
394                                         System.out.println("noch nicht implementiert");
395                                         break;
396                                         
397                                         
398                                 case "splitter":
399                                         System.out.println("noch nicht implementiert");
400                                         break;
401                                 
402                                 }
403                                 break;
404
405                         case "meta":
406                                 switch(in.next()){
407                                 case "enc":
408                                         try {
409                                                 for (Entry<String, Object> e : finished_encoding_task
410                                                                 .get(Integer.parseInt(in.next())).getMetadata()
411                                                                 .entrySet()) {
412                                                         System.out.format("\t %-25s %-25s %s\n", e.getKey(), e
413                                                                         .getValue().toString(), e.getValue().getClass()
414                                                                         .toString());
415                                                         // System.out.println(++"\t"+e.getValue().toString());
416                                                 }
417                                         } catch (Exception e) {
418                                                 System.out.println("Index nicht gefunden");
419                                         }
420                                         break;
421                                 
422                                 case "dec":
423                                         try {
424                                                 for (Entry<String, Object> e : finished_decoding_task
425                                                                 .get(Integer.parseInt(in.next())).getMetadata()
426                                                                 .entrySet()) {
427                                                         System.out.format("\t %-25s %s\n", e.getKey(), e
428                                                                         .getValue().toString());
429                                                         // System.out.println(++"\t"+e.getValue().toString());
430                                                 }
431                                         } catch (Exception e) {
432                                                 System.out.println("Index nicht gefunden");
433                                         }
434                                         break;
435                                 }
436                                 break;
437
438                         case "rm":
439                                 try {
440                                         int tasknr = Integer.parseInt(in.next());
441                                         int fragmentnr = Integer.parseInt(in.next());
442                                         Map<Integer, Path> fragmentPaths = finished_encoding_task
443                                                         .get(tasknr).getFragmentPaths();
444                                         Path path = fragmentPaths.get(fragmentnr);
445                                         try {
446                                                 Files.delete(path);
447                                         } catch (Exception e) {
448                                                 System.out.println("Konnte fragment nicht löschen "
449                                                                 + e.getMessage());
450
451                                         }
452
453                                 } catch (Exception e) {
454                                         System.out.println("Index nicht gefunden");
455                                 }
456                                 break;
457
458                         case "dec":
459                                 try {
460                                         int tasknr = Integer.parseInt(in.next());
461                                         CodingTask enctask = (CodingTask) finished_encoding_task
462                                                         .get(tasknr);
463                                         Path restorefile = restoreDir.resolve(""
464                                                         + System.currentTimeMillis()
465                                                         + enctask.getFilePath().getFileName());
466
467                                         Map<Integer, Path> fragmentPaths = enctask
468                                                         .getFragmentPaths();
469                                         for (int i = 0; i < fragmentPaths.size(); i++) {
470                                                 Path path = fragmentPaths.get(i);
471                                                 if (path == null || !Files.exists(path)) {
472                                                         fragmentPaths.put(i, null);
473                                                 }
474
475                                         }
476                                         DecodingTask dectask = new DecodingTask(fragmentPaths,
477                                                         restorefile, this, enctask.getMetadata());
478                                         for (Splitter spl : splitters) {
479                                                 if (spl.getCurrentPlugin().getPluginDescription()
480                                                                 .getPluginID() == (String) enctask
481                                                                 .getMetadata("pluginid")
482                                                                 && spl.getCurrentCodecDescription()
483                                                                                 .getCodecID() == (String) enctask
484                                                                                 .getMetadata("codecid")) {
485                                                         System.out.println("Auftrag angenommen..."
486                                                                         + restorefile);
487                                                         spl.decode(dectask);
488                                                 }
489                                         }
490
491                                 } catch (Exception e) {
492                                         e.printStackTrace();
493                                         System.out.println("Index nicht gefunden");
494                                 }
495                                 break;
496                         case "enc":
497                                 System.out.println("noch nicht implementiert");
498                                 break;
499                                 
500                         
501                         default:
502                                 printUsage();
503                         }
504
505                 }
506
507         }
508
509         private static List<Path> getFileList(Path path) {
510                 List<Path> files = new LinkedList<Path>();
511                 checkDirectory(path);
512                 try (DirectoryStream<Path> stream = Files.newDirectoryStream(path,
513                                 new DirectoryStream.Filter<Path>() {
514                                         @Override
515                                         public boolean accept(Path entry) throws IOException {
516                                                 return !Files.isDirectory(entry);
517                                         }
518                                 });) {
519                         for (Path entry : stream) {
520                                 files.add(entry);
521                         }
522                 } catch (IOException e) {
523                         e.printStackTrace();
524                 }
525                 return files;
526         }
527
528         private static void checkDirectory(Path path) {
529                 if (!Files.exists(path)) {
530                         try {
531                                 Files.createDirectory(path);
532                         } catch (IOException e) {
533                                 System.err.println("Verzeichnis kann nicht erstellt werden: "
534                                                 + path.toUri());
535                                 e.printStackTrace();
536                         }
537                 }
538         }
539
540         // private static void initSplitter(Splitter splitter) {
541         //
542         // System.out.println("Liste der Codecs:");
543         // Collection<String> codecids = splitter.getCodecIDs();
544         // Iterator<String> it = codecids.iterator();
545         // while (it.hasNext()){
546         // System.out.println("- " + it.next().toString());
547         // }
548         // if (codecids.contains("jerasureparity")){
549         // SplitterConfiguration config = new SplitterConfiguration();
550         // config.setCodecID("jerasureparity");
551         // splitter.setSplitterConfiguration(config);
552         // }
553         // System.out.println();
554         // }
555
556         @Override
557         public void codingFailed(CodingTask task, String reason) {
558                 synchronized (task) { // damit die Ausgabe nicht verwürfelt wird
559                         System.err.println("Coding Failed: "
560                                         + task.getFilePath().toString() + "  Reason:" + reason);
561                 }
562
563         }
564
565         @Override
566         public synchronized void codingSuccessfull(CodingTask task) {
567                 synchronized (task) { // damit die Ausgabe nicht verwürfelt wird
568                         long duration = 0;
569                         if (task instanceof EncodingTask) {
570                                 finished_encoding_task.add(task);
571                                 duration = (long) task.getMetadata("time_encode_end")
572                                                 - (long) task.getMetadata("time_encode_start");
573                         } else if (task instanceof DecodingTask) {
574                                 finished_decoding_task.add(task);
575                                 duration = (long) task.getMetadata("time_decode_end")
576                                                 - (long) task.getMetadata("time_decode_start");
577                         }
578
579                         System.err.println("Coding OK: " + task.getFilePath().toString()
580                                         + "  Codec: " + task.getMetadata("pluginid") + "/"
581                                         + task.getMetadata("codecid") + "  T(ms):" + duration);
582                 }
583         }
584
585         public void printUsage() {
586                 System.out.println("Bedienung:"
587                                 //+ "\nls splitter\tlistet alle initialisierten Splitter auf"
588                                 //+ "\nls src\t\tlistet alle Dateien in scrDir auf"
589                                 + "\nls enc\t\tlistet alle fertig encodierten Tasks auf"
590                                 + "\nls dec\t\tlistet alle fertig decodierten Tasks auf"
591                                 + "\nls frag <nr>\tlistet die Fragmentdateien zu Encoding-Task <nr> auf"
592                                 + "\nrm <nr> <frac_nr>\tlöscht aus Encoding-Task <nr> die Fragmentdatei <frac_nr>"
593                                 + "\ndec <nr>\twiederherstellen der Originaldatei aus Encoding-Task <nr> in das Verzeichnis restoreDir"
594                                 //+ "\nenc <scr_nr> <splitter_nr>\tencodieren von Datei <scr_nr> mit Splitter <split-ter_nr>"
595                                 + "\nmeta enc <nr>\tgibt metadaten zu encodingtask <nr> aus"
596                                 + "\nmeta dec <nr>\tgibt metadaten zu decodingtask <nr> aus"
597                                 + "\nq, quit oder exit\tbeenden das Programm"
598                                 //+" \nh oder help\tzeigt die Hilfe an"
599                                 + "");
600         }
601
602 }