la création de planification de tâche sans tâche Cron

Tâche planifiée doit être créé, mais il n'est pas possible d'utiliser Cron job (il y a un avertissement de fournisseur d'hébergement que "l'exécution de la Tâche cron plus d'une fois à l'intérieur de 45 minutes est une infraction des règles, et pourrait entraîner la fermeture du compte."

script php (qui d'insérer des données à partir de txt à la base de données mysql) doit être exécutée à chaque minute, c'est à dire ce lien doit être appelé http://www.myserver.com/ImportCumulusFile.php?type=dayfile&key=letmein&table=Dayfile&file=./data/Jan10log.txt

Est-il un autre moyen?

Vous pouvez soit utiliser une seule tâche cron toutes les 60 minutes et exécuter pendant 60 minutes, le déclenchement de votre demande, à chaque minute, ou vous prenez un coup d'oeil à la "pauvre mans cron" l'idée, si ce n'est pas fiable sur un faible volume de trafic de la page.

OriginalL'auteur Marko | 2014-04-12

  1. 6

    Il y a plusieurs façons de faire des tâches répétitives. Certains des moyens que je peux penser tout de suite sont les suivants:

    1. À l'aide de: https://www.setcronjob.com/

    Utiliser un site externe, comme cela se déclenche votre url à intervalles réguliers

    1. L'aide de meta refresh. Plus ici. Vous devez avoir à ouvrir la page et de le laisser tourner.

    2. Javascript/Ajax d'actualisation. Similaire à l'exemple ci-dessus.

    3. La configuration d'une tâche cron. La plupart d'hébergement mutualisé offrent un moyen de mettre en place des tâches cron. Regarder le cPanel de votre hébergement.

    Je sais que c'est d'un an, si votre'e toujours active, pouvez-vous répondre si l'actualisation des métafichiers et js/ajax actualiser les fichiers doivent être chargés afinde pour eux de travailler ou qu'ils travaillent sans que vous n'en appelant les fichiers (de façon indépendante)?
    vous avez besoin de charger la page, dans l'ordre, la meta/js/ajax pour être exécuté.
    Nous avons utilisé pour la définir comme page d'accueil du navigateur dans windows server. Vous avez l'idée - il est limité.

    OriginalL'auteur Santosh Achari

  2. 3

    si vous avez un accès shell vous pouvez exécuter un script php via le shell

    quelque chose qui serait une boucle sans fin, qui serait sleep 60 secondes exécuter, ramasser les ordures et répéter jusqu'à la fin des temps.

    while(true) {
    sleep(60);
    //script here


    //end your script
}

    ou vous pourriez faire un "pauvre mans cron" avec ajax ou meta refresh. je l'ai fait avant. fondamentalement, il vous suffit de placer une redirection avec javascript ou html meta refresh au début de votre script. l'accès à ce script à partir de votre navigateur, et il suffit de laisser ouvert. il va vous rafraichir toutes les 60 secondes, comme une tâche cron.

    encore une autre alternative à une tâche cron, serait un script bash tels que:

    #!/bin/bash
while :

do
sleep 60
 wget http://127.0.0.1/path/to/cronjob.php -O Temp --delete-after

done

    tout cela étant dit, vous aurez probablement se laisser prendre par l'hôte et être mis fin à toute façon.

    Donc votre meilleure solution:

    aller et inscrivez-vous pour un 5 à 10 dollars par mois vps, et de dire au revoir à l'hébergement mutualisé et bonjour à l'exploitation de votre propre petit serveur.

    si vous faites cela, vous pouvez même arrêter à l'aide de merde php et utiliser facebook de hhvm la place et de profiter de ses performances impressionnantes.

    OriginalL'auteur r3wt

  3. 1

    Je comprends que cette question est un peu vieux, mais je suis tombé sur elle il ya une semaine avec cette question et le meilleur et sûr option que nous avons trouvé a l'aide d'un Service Web.

    Notre contexte:

    Nous avons notre système à la fois l'hébergement mutualisé et les clouds privés.

    Nous avons besoin d'un script est activé qu'une seule fois en un mois (il y a des plans pour créer plus d'horaires et de permettre aux utilisateurs de créer des prédéterminé d'actions)

    Notre système permet d'accéder à de nombreux clients, de sorte que, lorsque quelqu'un utilise le système d'appels pour un Service Web via Ajax et ne se soucie pas de la réponse (après tout, tout est enregistré dans notre base de données et doit fonctionner sans intervention de l'utilisateur)

    Ce que nous avons fait, c'est:

    1 - Un appel ajax est appelé lors de l'accès dans tous les grands de l'écran.

    2 - Le Web Service lit un tableau horaire sur notre base de données et les appels de tout ce qui a besoin d'appeler

    3 - Pour éviter de nombreux empilées les appels de Service Web, nous vérifions datetime avec un intervalle de 10 minutes avant d'effectuer toutes les actions

    C'est aussi un moyen de répartir la charge sur l'équilibre et les horaires n'affecte pas le système avec de l'interaction de l'utilisateur.

    OriginalL'auteur Paulo Lima

  4. 0

    Il y a un service gratuit à la

    http://cron-job.org

    Qui vous permet de configurer une belle petite alternative.

    OriginalL'auteur Rolf Pedro Ernst

  5. 0

    Option Un

    Un moyen facile de le réaliser serait de créer un fichier/entrée de base de données contenant le temps d'exécution de votre script php:

    <?php
//crons.php
return [
    'executebackup.php' => 1507979485,
    'sendnewsletter.php' => 1507999485
];
?>

    Et à chaque demande faite par le biais de vos visiteurs vous vérifier l'heure actuelle et si sa vous permet d'inclure le script php:

    <?php
//cronpixel.php
$crons = @include 'cache/crons.php';
foreach ($crons as $script => $time) {
    if ($time < time()) {
        //create lock to avoid race conditions
        $lock = 'cache/' . md5($script) . '.lock';
        if (file_exists($lock) || !mkdir($lock)) {
            continue;
        }
        //start your php script
        include($script);
        //now update crons.php
        $crons[ $script ] += 86400; //tomorrow
        file_put_contents('cache/crons.php', '<?php return ' . var_export($crons, true) . '; ?' . '>')
        //finally delete lock
        rmdir($lock);
    }
}
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
//image data
$im = imagecreate(1, 1);
$blk = imagecolorallocate($im, 0, 0, 0);
imagecolortransparent($im, $blk);
//image output
header("Content-type: image/gif");
imagegif($im);
//free memory
imagedestroy($im);
?>

    Remarque: Il sera rarily appelé à la seconde près, parce que vous ne savez pas quand votre visiteur, vous ouvrez votre page (peut-être 2 secondes plus tard). Il est donc logique de définir le nouveau temps pour le lendemain non pas à travers l'ajout de 86400 secondes. Au lieu d'utiliser mktime.

    Option B

    C'est un projet un peu J'ai réalisé dans le passé, qui est similaire à @r3wt l'idée, mais couvre des conditions de course et travaille sur des horaires précis comme une tâche cron dans un planificateur sans heurter les max_execution_time. Et ça marche la plupart du temps sans la nécessité de ressusciter (comme le fait par les visiteurs dans l'Option A).

    Explication:
    Le script écrit un fichier de verrouillage (pour éviter des conditions de course) pour le 15e, 30e, 45e et 60e de seconde d'une minute:

    //cron monitoring
foreach ($allowed_crons as $cron_second) {
    $cron_filename = 'cache/' . $cron_second . '_crnsec_lock';
    //start missing cron requests
    if (!file_exists($cron_filename)) {
        cron_request($cron_second);
    }
    //restart interrupted cron requests
    else if (filemtime($cron_filename) + 90 < time()) {
        rmdir($cron_filename);
        cron_request($cron_second);
    }
}

    Chaque fois qu'un fichier de verrouillage est manquant, le script crée et utilise sleep() pour atteindre la seconde près:

    if (file_exists($cron_filename) || !mkdir($cron_filename)) {
    return;
}
//add one minute if necessary
$date = new DateTime();
$cron_date = new DateTime();
$cron_date->setTime($cron_date->format('H'), $cron_date->format('i'), $sec);
$diff = $date->diff($cron_date);
if ($diff->invert && $diff->s > 0) {
    $cron_date->setTime($cron_date->format('H'), $cron_date->format('i') + 1, $sec);
}
$diff = $date->diff($cron_date);
//we use sleep() as time_sleep_until() starts one second to early (https://bugs.php.net/bug.php?id=69044)
sleep($diff->s);

    Après le réveil, encore une fois, il envoie une requête à lui-même par le biais de fopen():

    //note: filter_input returns the unchanged SERVER var (http://php.net/manual/de/function.filter-input.php#99124)
//note: filter_var is unsecure (http://www.d-mueller.de/blog/why-url-validation-with-filter_var-might-not-be-a-good-idea/)
$url = 'http' . isSecure() . '://' . filter_input(INPUT_SERVER, 'HTTP_HOST', FILTER_SANITIZE_URL) . htmlspecialchars($request_uri, ENT_QUOTES, 'UTF-8');
$context = stream_context_create(array(
    'http' => array(
        'timeout' => 1.0
    )
));
//note: return "failed to open stream: HTTP request failed!" because timeout < time_sleep_until
if ($fp = @fopen($url, 'r', false, $context)) {
    fclose($fp);
}
rmdir($cron_filename);

    Par ce qu'il appelle lui-même à l'infini et vous êtes en mesure de définir les différents horaires de départ:

    if (isset($_GET['cron_second'])) {
    if ($cron_second === 0 && !(date('i') % 15)) {
        mycron('every 15 minutes');
    }
    if ($cron_second === 0 && !(date('i') % 60)) {
        mycron('every hour');
    }
}

    Remarque: Il produit 5760 demandes par jour (4 par minute). Pas beaucoup, mais un cronjob utilise beaucoup moins de ressources. Si votre max_execution_time est suffisamment élevée, vous pouvez le changer à l'appel de lui-même qu'une seule fois par minute (1440 demandes/jour).

    OriginalL'auteur mgutt