Aktionen zu zufälliger Zeit ausführen

werner_sg

Erfahrenes Mitglied
Hallo,

ich würde mich gerne an ein kleines Script ransetzen welches zu zufälliger Zeit eine Reaktion anfordert.

Im Prinzip wie eine Art Totmann Schalter, nur das hier nicht alle X Minuten eine Reaktion angefordert wird, sondern nur zu zufällig generierter Zeit.

Mir fehlt der Ansatz mit der Umsetzung der Zufallszeit, Zufallszahlen sind ja kein Problem.

Ich habe mir dazu überlegt eine Startzeit und eine Endzeit festzulegen, dann eventuell eine Zufallszahl zu generieren, welche dann die Zeit in Minuten nach der Startzeit zur Ausführung übergibt.

So wirklich gefällt mir das aber nicht, insbesondere da die Abfrage nur in dem festgelegten Zeitraum erfolgen soll und das 3 bis 4 mal am Tag.

Hat vieleicht jemand einen Ansatz direkt eine Zufalls Uhrzeit zu generieren?

Werner
 

Technipion

Erfahrenes Mitglied
Hallo werner_sg,
um Programme/Skripte zu bestimmten Zeitpunkten oder in bestimmten Zeitintervallen auszuführen, werden meist sogenannte cronjobs eingesetzt.
Der Service dahinter heißt Cron, und Einstellungen werden über $ crontab -e vorgenommen.

welches zu zufälliger Zeit eine Reaktion anfordert.

nur das hier nicht alle X Minuten eine Reaktion angefordert wird, sondern nur zu zufällig generierter Zeit.

Dein Fall scheint etwas speziell zu sein, da du zufällig generierte Zeitpunkte willst. Außerdem habe ich den Eindruck, du möchtest das ganze in C++ realisieren?

Gibt es einen guten Grund für die zufälligen Zeitpunkte? Würden es gleichmäßige Zeitintervalle (z.B. alle 6 Stunden) nicht auch tun? Und stimmt das mit C++?

Gruß Technipion
 

werner_sg

Erfahrenes Mitglied
Hallo werner_sg,
um Programme/Skripte zu bestimmten Zeitpunkten oder in bestimmten Zeitintervallen auszuführen, werden meist sogenannte cronjobs eingesetzt.
Der Service dahinter heißt Cron, und Einstellungen werden über $ crontab -e vorgenommen.





Dein Fall scheint etwas speziell zu sein, da du zufällig generierte Zeitpunkte willst. Außerdem habe ich den Eindruck, du möchtest das ganze in C++ realisieren?

Gibt es einen guten Grund für die zufälligen Zeitpunkte? Würden es gleichmäßige Zeitintervalle (z.B. alle 6 Stunden) nicht auch tun? Und stimmt das mit C++?

Gruß Technipion
Hallo Technipon

Mit der Sprache bin ich mir noch nicht ganz sicher eventuell auch in C# oder vb.net (was mir eigentlich mehr liegt)

Das es sehr speziell ist war mir klar, und ja es muss eine zufällige Zeit sein die nicht eingeplant werden kann, ein Zeitintervall wäre es.

Mit den Conjobs ist schon klar die Frage ist halt wie generiere ich eine zufällige Uhrzeit in einem bestimmten Zeitfenster, wobei dann auch noch die folgend generierten nicht vor dem davor erstellten liegen dürfen ;-)
 

Endurion

Erfahrenes Mitglied
Einfach eine Zufallszahl generieren (Anzahl Minuten), DateTime.Now nehmen und die Minuten draufaddieren sollte reichen

cronjobs gibt's unter Linux, unter Windows wäre das der Task Scheduler.


C# könnte so aussehen:

var random = new Random();
var randomMinutes = random.Next( <minimum Minuten>, <Maximum Minuten> );

var randomTimestamp = DateTime.Now.AddMinutes( randomMinutes );
 

ComFreek

Mod | @comfreek
Moderator
wobei dann auch noch die folgend generierten nicht vor dem davor erstellten liegen dürfen ;-)
Such dir feste Zeitintervalle und generiere nur in diesen zufällig. Beispiel:
  • 10:00 - 11:59
  • 12:00 - 13:59
  • 14:00 - 15:59
  • 16:00 - 17:59
Für all diese Zeitintervalle suchst du dir eine Zahl aus zwischen [0, (Ende - Start) in Minuten]. Beispiel:
  • 11:32
  • 12:43
  • 15:59
  • 16:00
Die letzten zwei Zeilen spiegeln Extremwerte wider. Das bedeutet insbesondere, dass wenn dein Programm länger als eine (halbe?) Minute laufen kann, du dafür Sorge tragen muss, dass überlappende Programmabläufe sich nicht stören.
(Ich habe "halbe" in Klammern geschrieben, weil auf general-purpose Betriebssystemen nicht davon ausgegangen werden kann, dass dein Programm genau zu dem geplanten Zeitpunkt startet. Je nach aktueller Auslastung können da schon Sekunden verstreichen.)
 

werner_sg

Erfahrenes Mitglied
Such dir feste Zeitintervalle und generiere nur in diesen zufällig. Beispiel:
  • 10:00 - 11:59
  • 12:00 - 13:59
  • 14:00 - 15:59
  • 16:00 - 17:59
Für all diese Zeitintervalle suchst du dir eine Zahl aus zwischen [0, (Ende - Start) in Minuten]. Beispiel:
  • 11:32
  • 12:43
  • 15:59
  • 16:00
Die letzten zwei Zeilen spiegeln Extremwerte wider. Das bedeutet insbesondere, dass wenn dein Programm länger als eine (halbe?) Minute laufen kann, du dafür Sorge tragen muss, dass überlappende Programmabläufe sich nicht stören.
(Ich habe "halbe" in Klammern geschrieben, weil auf general-purpose Betriebssystemen nicht davon ausgegangen werden kann, dass dein Programm genau zu dem geplanten Zeitpunkt startet. Je nach aktueller Auslastung können da schon Sekunden verstreichen.)

Nunja das Programm läuft eigentlich schon länger, die Aufteilung in Blöcke geht nicht da in dem Moment nach dem ersten Aufruf klar stehen würde wann frühestens der nächste kommen könnte.
 

Technipion

Erfahrenes Mitglied
Nunja das Programm läuft eigentlich schon länger, die Aufteilung in Blöcke geht nicht da in dem Moment nach dem ersten Aufruf klar stehen würde wann frühestens der nächste kommen könnte.
Das klingt jetzt wiederum so als würdest du gerne eine Art "spontan" einsetzenden Test laufen lassen, der sich nicht extern vorhersagen lässt. Damit bewegst du dich ja quasi schon im IT-Security und Kryptographie Bereich.
Hier ist ein Beispielprogramm in C++:
C++:
#include <random>
#include <chrono>
#include <thread>
#include <iostream>


int main()
{
    // random_device versucht nicht-deterministische
    // Zufallszahlen zu erzeugen
    std::random_device rd;
    
    // Wir benutzen random_device um den Seed des
    // Mersenne-Twisters mt19937 festzulegen.
    // Der Zufallsgenerator hat also nach jedem Start
    // einen anderen internen Zustand.
    std::mt19937 gen(rd());
    
    // Wir legen eine Transformationsfunktion an,
    // die unsere Zufallszahlen ins Ganzzahlintervall
    // [1, 12] abbildet.
    std::uniform_int_distribution<int> ud12(1, 12);
    
    // Generiere einen Zufallswert als int value
    int value = ud12(gen);
    
    if (value == 1) {
        // Ein Wert von 1 bedeutet, dass wir in diesem
        // 5-Minuten-Intervall einen Test durchführen
        // werden.
        
        // Legen wir eine neue Transformationsfunktion
        // an, die nach [0, 299] abbildet.
        std::uniform_int_distribution<int> ud300(0, 299);
        
        // Holen wir uns einen weiteren Zufallswert
        int delay = ud300(gen);
        
        // Und wandeln ihn in eine Zeitspanne (in s) um
        std::chrono::seconds timespan(delay);
        
        // Zum Verschleiern unseres 5-Minuten-Taktes wird
        // nun für eine zufällige Dauer gewartet.
        std::this_thread::sleep_for(timespan);
        
        
        // HIER wird der Test durchgeführt.
        std::cout << "PERFORMING TEST" << std::endl;
    }
}

Und das ganze funktioniert so: Du benutzt entweder Cron oder den Task Scheduler um das Programm alle 5 Minuten (= 300 s) auszuführen. Das Programm erzeugt eine Zufallszahl, die mit einer Wahrscheinlichkeit von 1 zu 12 den Wert 1 hat. In einer Stunde liegen genau 12 5-Minuten-Blöcke. Statistisch wird das Programm also 1 mal pro Stunde den Wert 1 "würfeln". Immer wenn das so ist geht's in die if-Abzweigung. Dort wird eine zufällige Verzögerung bis maximal 299 Sekunden bestimmt (das Programm würde dann 4min 59s warten). Das Programm wird für diese Zeitspanne angehalten, um zu verschleiern, dass wir eigentlich cronjobs im 5-Minuten-Takt laufen lassen (sonst könnte ein Angreifer unsere Tests vorhersagen).
Danach wird schließlich deine "Aktion ausgeführt", hier einfach per Ausgabe dargestellt.

Das Besondere hierbei: Niemand weiß im Voraus, wann das Programm einen Test ausführen wird. Ist ein bisschen wie mit radioaktivem Zerfall, es passiert plötzlich einfach.

Was wenn das Programm, sagen wir alle 4 Stunden, einen Test machen soll?
In dem Fall würden wir die Wahrscheinlichkeit am Anfang nicht auf 1 zu 12 setzen, sondern auf 1 zu 48, denn 4 Stunden enthalten 48 5-Minuten-Blöcke.

Die Frage ist natürlich: Hat die Methode jetzt so viele Vorteile gegenüber den anderen? Vor allem: Bietet es sich nicht eigentlich an die Zeitpunkte im Voraus zu berechnen?

Gruß Technipion
 

werner_sg

Erfahrenes Mitglied
Das klingt jetzt wiederum so als würdest du gerne eine Art "spontan" einsetzenden Test laufen lassen, der sich nicht extern vorhersagen lässt. Damit bewegst du dich ja quasi schon im IT-Security und Kryptographie Bereich.


Die Frage ist natürlich: Hat die Methode jetzt so viele Vorteile gegenüber den anderen? Vor allem: Bietet es sich nicht eigentlich an die Zeitpunkte im Voraus zu berechnen?

Gruß Technipion
Du hast den Nagel auf den Kopf getroffen, es soll absolut spontan erfolgen ;-)

Und daher hat die Methode einige Vorteile.

Habe mich zwar jetzt doch entschieden das ganze in C# umzusetzen, aber dein Beispiel ist eine Mega Hilfe
 

Neue Beiträge