Updated documentation

joseramon.afonso · joseramon.afonso · commit 4f4b3d4de7cb · 2020-04-23T17:25:20.000+02:00
diff --git a/devoutils/faker/generators/template_parser.py b/devoutils/faker/generators/template_parser.py
@@ -20,13 +20,13 @@ def __init__(self, template=None, providers=None, date_generator=None):
         self.fake.add_provider(InternetProvider)
         self.template = template
         self.providers = {} if providers is None else providers
-        self.date_generator = TemplateParser.null_date_generator() \
+        self.date_generator = TemplateParser.null_date_generator \
             if date_generator is None else date_generator
 
     @staticmethod
     def null_date_generator():
         """Generate now date"""
-        yield str(datetime.now())
+        return str(datetime.now())
 
     def process(self, date_generator=None, **kwargs):
         """Procces template, parsing it"""
diff --git a/docs/faker/file.md b/docs/faker/file.md
@@ -5,3 +5,41 @@
 * [FileFakeGenerator](../../devoutils/faker/generators/file_fake_generator.py)
 
 ### Doc
+
+file_name
+
+This generator is mainly intended to create files with fake data.
+
+You have one example in simple_file_template, we explain here:
+
+Script:
+
+    from devoutils.faker import SyslogFakeGenerator
+    from devo.sender import Sender
+    
+    if __name__ == "__main__":
+        with open("./simple_syslog_template.jinja2", 'r') as myfile:
+            template = myfile.read()
+
+    con = Sender(config="./config.yaml")
+
+    f = SyslogFakeGenerator(engine=con,
+                            template=template,
+                            probability=100,
+                            frequency=(1, 1),
+                            tag="my.app.request.info",
+                            verbose=True)
+    f.start()
+
+
+With this code we create one Sender With this basic code we create a Sender with the devo-sdk to send data to 
+Devo, and we create a SyslogFakeGenerator to create the false data.
+
+You have to add the tag that you want to send in the creation of the SyslogFakeGenerator object, a
+nd the generator will be in charge of using the con.send function (tag = self.tag, msg = fake_data_line) to send the data
+
+Template:
+
+    {%- set type = fake.random_element(["post", "get"]) -%}
+    {{ next(date_generator) }} receiving {{ type }} request.
+    {%- set a = 3 -%}
diff --git a/docs/faker/realtime.md b/docs/faker/realtime.md
@@ -5,3 +5,25 @@
 * [RealtimeFakeGenerator](../../devoutils/faker/generators/realtime_fake_generator.py)
 
 ### Doc
+
+This generator is the parent class of several generators, but it is also useful for creating your own generators.
+
+Just create a class like the example below, and create your own run function. With this you can add your own functions.
+
+The important thing is, in the run function, call `self.realtime_iteration` sending your own write function in the 
+variable `write_function` (It can be a send, or a print, or your own function to send it by https or a socket, anything.
+
+    from .realtime_fake_generator import RealtimeFakeGenerator
+    
+    
+    class MyCustomGenerator(RealtimeFakeGenerator):
+        """Class to manage secure simulations of faker"""
+        def __init__(self, template=None, **kwargs):
+            RealtimeFakeGenerator.__init__(self, template=template, **kwargs)
+    
+        #You can override this function/Creat your own
+        def run(self):
+            """Run function for cli or call function"""
+            #This call is neccesary for write/send/whatever, yo need send your function
+            #in write_function. You receive in each call one text line
+            self.realtime_iteration(write_function=lambda x: x) 
diff --git a/docs/faker/shellcli.md b/docs/faker/shellcli.md
@@ -4,6 +4,12 @@ command, for example:
 ```
 devo-faker -t template --config config.json -i
 ```
+
+Or all in config file
+```
+devo-faker --config config.json
+```
+
 This command uses the template indicated with the configuration inside the
 config.json file and makes the process interactive.
 
@@ -26,27 +32,36 @@ Options:
                                will only store the events in a file. Can be
                                used with batch mode to set the file where
                                store the batch events
+
   --simulation                 Set as simulation. Shows the event in the
                                console, but do not send it
+
   -t, --template FILENAME      Template to send.  [required]
+  -p, --providers FILENAME     File with custom providers dict.
   -i, --interactive            Interactive mode.
   -raw, --raw_mode             Send raw mode.
-  --prob INTEGER               Probability (0-100).
-  --freq TEXT                  Frequency in seconds. Example:"1.0-5.0" =
+  --probability INTEGER        Probability (0-100).
+  --frequency TEXT             Frequency in seconds. Example: "1.0-5.0" =
                                random time between 1 sec. to 5secs.
+
   --batch_mode                 Enable blatch mode, a lot of events will be
                                generated as fast as possible and written to a
                                file. The events will be generated in thetime
                                range specified by the --date_range option
+
   --date_range <TEXT TEXT>...  batch mode: Date range where the logs will be
                                generated, default: the last 24 hours
+
   --date_format TEXT           (batch mode) Format of the generated dates.
                                default: "%Y-%m-%d %H:%M:%S.%f"
+
   --dont_remove_microseconds   (batch mode) By default the microseconds are
                                removed from the generated dates by doing
                                date[:-3] this flags prevents it
+
   --verbose                    Verbose mode shows the events created in the
                                console when sending dta into Devo.
+
   --help                       Show this message and exit.
 ```
 
@@ -60,20 +75,24 @@ The config.json file could be like this:
         "tag": "test.keep.free",
         "address": "eu.elb.relay.logtrust.net",
         "port": 443
-   }
+   },
+    "verbose": true,
+    "probability": 80,
+    "frequency": (2,4)
 }
 ```
 
 config.yaml its available too:
 ```
-{
-    "sender": {
-        "key": "<path_to_key>.key",
-        "cert": "<path_to_cert>.crt",
-        "chain": "<path_to_chain>.crt",
-        "tag": "test.keep.free",
-        "address": "eu.elb.relay.logtrust.net",
-        "port": 443
-   }
-}
+sender:
+    key: "<path_to_key>.key",
+    cert: "<path_to_cert>.crt",
+    chain: "<path_to_chain>.crt",
+    tag: "test.keep.free",
+    address: "eu.elb.relay.logtrust.net",
+    port: 443
+simulation: true
+probability: 50
+frequency: (1,3)
+providers: providers.py
 ```
diff --git a/docs/faker/simulation.md b/docs/faker/simulation.md
@@ -5,3 +5,9 @@
 * [SimulationFakeGenerator](../../devoutils/faker/generators/simulation_fake_generator.py)
 
 ### Doc
+
+This is a basic generator to create simulations on the screen, useful to see how a template 
+would work, etc., without risking sending data.
+
+In short, it is a generator to display the data on the screen, as if you activated the flag 
+`simulation` and` verbose` in any of the other generators
diff --git a/examples/simple_file_example.py b/examples/simple_file_example.py
@@ -0,0 +1,12 @@
+from devoutils.faker import FileFakeGenerator
+
+if __name__ == "__main__":
+    with open("./simple_syslog_template.jinja2", 'r') as myfile:
+        template = myfile.read()
+
+    f = FileFakeGenerator(template=template,
+                          probability=80,
+                          frequency=(1, 3),
+                          verbose=True,
+                          file_name="faker_file_example.log")
+    f.start()
diff --git a/examples/simple_syslog_template.jinja2 b/examples/simple_syslog_template.jinja2
@@ -1,3 +1,2 @@
 {%- set type = fake.random_element(["post", "get"]) -%}
-{{ next(date_generator) }} receiving {{ type }} request.
-{%- set a = 3 -%}
+{{ date_generator() }} receiving {{ type }} request.
