Gestion des tâches planifiées des bases de données 1C depuis l'updater

2018-11-20T15:18:30+00:00

Dans cette note, examinons les capacités du programme de mise à jour pour gérer les tâches planifiées dans les bases de données.

Tout d'abord, dans la rubrique "Plus" -> "Gérer les tâches planifiées...":

À menu contextuel base dédiée (ou groupe de bases) :

Et, enfin, dans les modèles pour les scripts batch (cela vous permet d'effectuer des opérations sur des tâches planifiées à partir d'un script sur un calendrier) :

Voici à quoi ressemble la boîte de dialogue de gestion des tâches planifiées dans les bases de données :

Quelles tâches permet-il de résoudre dans le groupe de bases souhaité (ou une base) ?

Sélection des tâches planifiées

Faites attention à la possibilité de sélectionner une liste de tâches planifiées dans de nombreuses opérations ci-dessous :

Mais dans la boîte de dialogue de sélection, il se peut qu'il n'y ait pas de tâches planifiées spécifiquement pour votre base :

Dans ce cas, vous pouvez spécifier les noms des tâches planifiées dont vous avez besoin dans la section "Tâches personnelles ...", par exemple, comme ceci :

Les noms de ces tâches planifiées peuvent être tirés directement du rapport sur toutes les tâches planifiées (il est décrit).

Affichage de l'état actuel des travaux

Pour cela, rendez-vous dans l'onglet "Retirer" et appuyez sur le bouton "Retirer...":

Dans les résultats, nous pouvons voir:

1. Activé ou désactivé le lancement de nouvelles tâches planifiées sur le serveur 1C.
2. Liste des tâches planifiées dans la base de données.
3. Leur emploi du temps.
4. Travaux activés ou désactivés.
5. Si la dernière exécution de la tâche comportait une erreur, cette erreur s'affiche en rouge à côté de la tâche.

Si nécessaire, dans les paramètres des fonctionnalités, nous pouvons réduire la liste des tâches planifiées, ainsi que n'afficher que les tâches activées :

Désactiver tout ou partie des tâches

Pour cela, rendez-vous dans l'onglet "Désactiver":

Toutes les tâches planifiées ou certaines d'entre elles décocheront la case Utilisation.

Voici le résultat pour une base (cliquez pour agrandir)

Inclure tout ou partie des tâches

Pour cela, rendez-vous dans l'onglet "Activer":

Toutes les tâches planifiées ou certaines d'entre elles auront la case Utilisation cochée.

Veuillez noter que dans cet onglet le drapeau "Make sauvegarde base" dans le coin inférieur gauche.

Voici le résultat pour une base (cliquez pour agrandir)

Nous gérons le lancement des tâches planifiées sur le serveur 1C

Pour cela, rendez-vous dans l'onglet "Serveur 1C":

Sélectionnez "bloquer" ou "débloquer" et cliquez sur le bouton "Exécuter".

Mise en place d'un planning de tâches

Mais que se passe-t-il si nous devons établir un calendrier pour lancer une tâche (ou un groupe de tâches) dans plusieurs bases de données à la fois ?

Pour cela, rendez-vous dans l'onglet "Configurer le planning" :

Nous configurons le calendrier (la boîte de dialogue et ses capacités sont complètement les mêmes que celles habituelles dans 1C lui-même) et cliquons sur "Configurer ...".

Lancer des tâches pour exécution

Pour cela, rendez-vous dans l'onglet "Démarrer":

Sélectionnez les tâches souhaitées et cliquez sur le bouton "Démarrer":

Enregistrement des paramètres du travail dans un fichier externe

Supposons que nous ayons idéalement configuré des tâches planifiées dans l'une des bases de données et que nous souhaitions transférer ces paramètres vers toutes les autres bases de données.

Pour ce faire, nous téléchargeons d'abord tous les paramètres de travail de la base de données idéale dans un fichier externe :

Restauration des paramètres du travail à partir d'un fichier externe

Et puis nous chargeons ce fichier avec les paramètres du travail dans toutes les autres bases de données :

Notez simplement que pour cette tâche (transférer les paramètres d'un travail d'une base de données à d'autres), j'ai choisi la méthode de correspondance par nom de travail et non par identifiant interne.

mot d'adieu

En général, c'est tout ce que je voulais dire. Je vois moi-même de nombreux scénarios d'utilisation de nouvelles fonctionnalités, mais ici, je viens de survoler les points principaux.

Plateformes: 1C : Entreprise 8.3, 1C : Entreprise 8.2, 1C : Entreprise 8.1
Configurations: Toutes configurations

2012-11-13
53989

Dans le flux de travail, certaines tâches nécessitent une exécution périodique - par exemple, le vingtième ou quotidiennement. En règle générale, dans les entreprises spécifiquement pour cela, certaines règles sont créées qui indiquent quand et comment la tâche nécessaire doit être effectuée, et qui doit contrôler le processus. Ces tâches sont effectuées conformément à la réglementation et sont dites réglementées.

Très souvent, l'informatique suit les règles de surveillance. Cette méthode est bien connue des administrateurs, car il existe programmes spéciaux utilisé pour vérifier périodiquement la santé de l'infrastructure réseau et des serveurs. Ils informent l'administrateur des problèmes détectés par SMS ou e-mail.

Un système similaire est valable pour les webmasters, tandis que la disponibilité du site est vérifiée dans les 24 heures. À l'aide du mécanisme "Tâches régulières" en 1C, des tâches de surveillance sont effectuées, ainsi que des tâches périodiques qui sont effectuées selon un calendrier en mode automatique au 1C. Considérons ce sujet plus en détail.

Tâches planifiées 1C

L'objet 1C, appelé "Tâches régulières", permet de traiter les informations non pas après qu'un problème se soit produit, mais selon un calendrier. Dans le configurateur tâche routinière est un moyen de définir des préférences et de définir un calendrier. De plus, il est possible de modifier ultérieurement le calendrier en mode 1C Enterprise.

Lors de l'utilisation d'une base de données de fichiers, les travaux ne sont pas exécutés automatiquement. Pour démarrer le processus, vous devez démarrer une session 1C en mode 1C Enterprise et démarrer l'exécution d'une tâche planifiée dans celle-ci.

Toutes les configurations typiques ont un paramètre utilisateur qui vous permet de préciser que lorsque 1C est en cours d'exécution, les tâches de routine seront effectuées automatiquement.

L'utilisation de la version client-serveur de 1C permet d'effectuer automatiquement des tâches sur le serveur. À l'heure prévue - une tâche en arrière-plan est lancée, qui effectue les actions nécessaires. Pour le calcul parallèle sur le serveur, une tâche en arrière-plan peut être créée à partir du texte du programme en utilisant le langage 1C, sans utiliser de tâche 1C planifiée. L'action d'une tâche planifiée peut être temporairement désactivée à l'aide de la console de gestion du serveur 1C pour cela.

Ajout d'une tâche planifiée

Les tâches planifiées se trouvent dans — Configurateur — Général — Tâches planifiées. Ajoutez une nouvelle "tâche" et indiquez un nom. Ensuite, vous devez vous rendre dans les propriétés des "Tâches". Et choisissez le nom de la méthode. Ici, vous devez spécifier la fonction de gestionnaire, comme cela se produit dans l'abonnement à l'événement. Cette fonction sera située dans le module général et marquée d'un serveur "oiseau" dans les propriétés. Cela signifie que le module nécessaire doit être ajouté à l'avance.

Le nom de la tâche dans les Propriétés de la tâche planifiée permet de définir son nom, qui apparaîtra ultérieurement dans les outils de gestion des tâches. La fonction Propriétés des travaux planifiés est une clé qui permet de regrouper plusieurs travaux planifiés différents. Dans ce cas, une seule tâche peut être lancée à la fois avec la même valeur clé. Ici, la valeur peut être arbitraire, mais il est obligatoire de la renseigner car la valeur vide n'est pas prise en compte par le système.

Dans l'édition Comptabilité 2.0, qui est une configuration typique, les tâches planifiées telles que : "Recalcul des totaux" et "Mise à jour de la configuration" sont prédéfinies, et telles que "Mouvements différés" et "Échange de données" ne sont pas prédéfinies.

Crash Retry - Redémarre une tâche en cours d'exécution. Prévu pour un lancement qui n'a pas réussi la première fois. Ici, il est indiqué combien de fois vous pouvez redémarrer et combien de temps après le crash.

Outils de suivi et de gestion de la tâche planifiée 1C

Le traitement standard "Job Console", qui se trouve sur les disques ITS, est responsable de la gestion de la tâche planifiée. Ce traitement est un traitement standard externe universel 1C. En règle générale, il n'est pas inclus dans la configuration, mais est acheté séparément.

Avec son aide, vous pouvez effectuer les actions suivantes :

Activer et désactiver la tâche planifiée ;

Attribuer et modifier l'horaire ;

Indiquez le nom de l'utilisateur avec lequel la tâche planifiée sera effectuée ;

Voir les tâches terminées (quand et avec quel résultat), ainsi que les erreurs de tâche ;

Tâche planifiée et copies de base de données

Lors de l'utilisation du serveur 1C, le moment suivant peut survenir :

Pour la programmation, vous devez faire une copie de la base de données de travail ;

La nécessité de travailler dans des copies de la base de données (tests) ;

Pour une raison quelconque, la tâche planifiée n'est pas activée dans la base de données de test.

Si l'une de ces situations survenait lors de l'exécution de tâches par une tâche planifiée qui n'est associée qu'à sa propre base de données, cela n'entraîne pas de conséquences négatives. Mais, souvent, une tâche planifiée peut enregistrer des fichiers ou d'autres données, envoyer des e-mails et échanger. Dans ce cas, il peut y avoir confusion entre les résultats du "travail" et les copies. Pour éviter que cela ne se produise, vous devez désactiver les "tâches" dans la console de gestion du serveur.

Tâches de routine terminées et non terminées

Lors de la création de tâches planifiées, il est important de vérifier si la tâche peut être exécutée en tant que tâche planifiée. Il est important de savoir que le module serveur ne fournit pas beaucoup de choses possibles sur le client. Ensuite, une tâche qui traite de quelque chose qui est en dehors de la base - les droits jouent un rôle important à cet égard. Utilisateur Windows, sous lequel la tâche est exécutée.

Le dernier facteur est particulièrement important, car si le module n'est pas exécuté sur le serveur, la tâche ne peut en principe pas être exécutée. Pour vérifier, vous devez exécuter une tâche et évaluer le résultat.

Concept de programmation asynchrone

Le concept asynchrone de la programmation est que le résultat de l'exécution de la fonction n'est pas disponible immédiatement, mais après un certain temps sous la forme d'un appel asynchrone (violant l'ordre normal d'exécution).

Ceux. L'idée principale de la programmation asynchrone est de démarrer des appels de méthode individuels et de continuer à faire d'autres travaux en parallèle sans attendre la fin des appels.

Certaines méthodes, dont la probabilité d'exception est minimisée, n'ont pas besoin d'une approche asynchrone, mais d'autres l'exigent au tout début du développement.

Comme on peut le voir sur les graphiques, il n'y a pas de coefficient d'actions utilisateur interactives utiles dans le modèle de programmation synchrone, puisque le système bloque l'interface utilisateur, tandis que dans le modèle asynchrone, l'utilisateur continue à travailler activement dans le système.

Lors d'une exécution synchrone, une application n'a qu'un seul thread. Avec le modèle de programmation asynchrone, vous pouvez exécuter de nombreux threads parallèles et répondre aux nouvelles actions de l'utilisateur au fur et à mesure de leur exécution. Une fois le n-thread terminé, vous affichez le résultat à l'écran.

Tâches en arrière-plan dans 1C:Enterprise 8

Dans "1C:Entreprise 8" travaux d'arrière-plan conçu pour effectuer des tâches d'application de manière asynchrone. Ils peuvent générer des travaux d'arrière-plan enfants, par exemple, pour paralléliser des calculs complexes sur différents serveurs de travail du cluster dans un mode de fonctionnement client-serveur.

Il est possible de limiter l'exécution des jobs d'arrière-plan qui ont les mêmes méthodes, selon un certain attribut d'application. La création et la gestion par programmation des tâches d'arrière-plan sont possibles à partir de n'importe quelle connexion utilisateur avec base d'informations systèmes. La tâche d'arrière-plan s'exécute en tant qu'utilisateur qui l'a créée.

Le mécanisme de tâche fonctionne à la fois dans les versions client-serveur et fichier de work, mais les possibilités d'administration et d'exécution des tâches dans les deux versions sont quelque peu différentes.

Option client-serveur

Dans la version client-serveur, les tâches sont planifiées par le planificateur de tâches, qui est physiquement situé dans le gestionnaire de cluster.

Le planificateur vérifie périodiquement les demandes d'exécution de tâches en arrière-plan. S'il y a des travaux qui doivent être exécutés, le planificateur détermine les processus de travail du cluster les moins chargés et affecte séquentiellement une tâche à exécuter à chacun d'eux. Ainsi, le même flux de travail peut potentiellement exécuter plusieurs tâches en parallèle. Une fois la tâche reçue par le flux de travail, le flux de travail établit une connexion à l'infobase et exécute la tâche dans cette connexion. Une fois la tâche exécutée, le workflow informe le planificateur de la réussite ou de l'échec de la tâche.

Options de fichier

À partir de la version 8.3.3.641 de la plate-forme, les développeurs ont grandement simplifié le travail avec des tâches en arrière-plan dans la version fichier.

Auparavant, l'exécution automatique des tâches nécessitait le lancement d'une session 1C:Enterprise supplémentaire distincte utilisée comme planificateur de tâches. Et dans cette session, il était nécessaire d'exécuter périodiquement la méthode du langage intégré ExécutezProcessingJobs(). Cette approche était plutôt lourde, peu pratique et limitait considérablement l'utilisation des tâches en arrière-plan et planifiées dans la version fichier de work.

Maintenant, tout est devenu beaucoup plus facile. Si un client léger ou lourd démarre, ou si le serveur Web dispose de connexions client, alors chacune de ces applications démarre automatiquement un autre thread avec une connexion à la base de données. Ces threads sont engagés dans le fait qu'ils exécutent des tâches en arrière-plan et planifiées.

Chacune de ces applications exécute ses propres tâches d'arrière-plan. Si une application a initié plusieurs jobs d'arrière-plan, alors ils sont exécutés séquentiellement, dans l'ordre dans lequel ils sont reçus.

Emplois d'arrière-plan évidents moins 1C: puisqu'elles sont effectuées côté serveur, il n'y a aucune possibilité de travail interactif avec l'utilisateur (par exemple, vous ne pouvez pas afficher un message ou toute autre information ; toutes ces données doivent être stockées dans l'infobase et traitées ultérieurement d'une manière ou d'une autre) .

Il convient de noter que les travaux d'arrière-plan sont des objets purement programmatiques et ne peuvent pas être stockés dans la base de données. Autrement dit, nous ne pouvons que créer une instance de la classe, initialiser ses propriétés et l'exécuter pour l'exécution.

Un exemple d'exécution de code asynchrone dans 1C:Enterprise 8

« Écrire des programmes dans lesquels le résultat d'un appel de fonction arrive à une heure inconnue est beaucoup plus difficile que des programmes ordinaires. Appels imbriqués, gestion des erreurs, contrôle sur ce qui se passe - tout devient plus compliqué », seuls ceux qui ne savent pas utiliser correctement les capacités de la plateforme le diront, mais pas nous !

Démontrons toute la simplicité et l'élégance de l'exécution de code asynchrone dans 1C:Enterprise 8 !

Étape 1. Créons un nouvel IB pour le développement de la configuration

Étape 2 Dans la configuration, ajouter le module général "AsynchronousHandlers"

Pourquoi avons-nous ajouté un module commun ? Tout est simple ici: pour effectuer des opérations asynchrones dans 1C: Enterprise 8, des tâches d'arrière-plan sont utilisées, qui ont leur propre gestionnaire - «BackgroundTask Manager». Cet objet a une méthode "Run", à l'aide de laquelle la tâche en arrière-plan est lancée.

Passons à l'assistant de syntaxe.

Ainsi, nous aurons besoin d'un module commun.

Étape 3 Dans le module général "AsynchronousHandlers" ajoutons la procédure d'export OurDurationOperation()

Procedure OurDurationOperation(Duration) Export // Simulation d'une action continue (Duration sec.). OperationStartDate = CurrentDate(); Tandis que CurrentDate() - OperationStartDate< Длительность Цикл КонецЦикла; КонецПроцедуры

Étape 4 Nous ajoutons le traitement "AsynchronousProgrammingConcept" à la configuration (vous pouvez créer un traitement externe)

Ajoutez un attribut au formulaire :

Durée (Nombre)

et deux équipes

Effectuez une opération longue ;

Exécutez une Long-runningOperation de manière asynchrone.

Étape 5 Selon l'assistant de syntaxe, remplissez le module de formulaire

&AtClient Procédure PerformLongOperation(Commande) PerformLongOperationOnServer(); EndProcedure & Procédure OnServer PerformLongOperationOnServer() AsynchronousHandlers.OurLongOperation(Duration); EndProcedure &OnClient Procedure ExecuteLong-runningOperationAsynchronously(Command) ExecuteLong-runningOperationAsynchronouslyOnServer(); EndProcedure &AtServer Procedure PerformLong-runningOperation AsynchronouslyAtServer() Parameters = New Array; Paramètres.Ajouter(Durée); BackgroundJobs.Run("AsynchronousHandlers.Our LongOperation", Parameters, New UniqueIdentifier, "Exemple de concept de programmation asynchrone"); FinProcédure

Étape 6 Nous lançons et vérifions !

Résultat:

Si nous cliquons sur le bouton "Effectuer une opération longue", alors l'interface utilisateur est bloquée pendant "Durée" secondes ;

Si nous cliquons sur le bouton "Exécuter une opération de longue durée de manière asynchrone", l'interface utilisateur n'est pas bloquée et le code du programme est exécuté en parallèle.

Nous pouvons vérifier que le code du programme s'exécute de manière asynchrone en consultant le journal.

Nous pouvons déboguer le code du programme qui s'exécute en "arrière-plan" si nous définissons la propriété appropriée dans les options de débogage.

Un exemple d'exécution de code asynchrone dans 1C:Enterprise 8 à l'aide de BSP

Considérons un exemple de mise en œuvre du concept de programmation asynchrone dans 1C: Enterprise 8 dans BSP en utilisant l'exemple du traitement des affaires courantes.

La logique est la suivante : lors du lancement du programme, l'espace de travail de la page d'accueil est initialisé, où vous pouvez afficher le formulaire de traitement « Affaires courantes ». Ce formulaire est rempli avec les affaires courantes de l'utilisateur, et il faut du temps pour le remplir. Si les développeurs n'avaient pas la possibilité d'exécuter du code de manière asynchrone, alors l'interface utilisateur serait bloquée pendant la durée de remplissage du formulaire de traitement !

Analysons le code programme du formulaire.

L'événement de formulaire "OnCreateOnServer" appelle la procédure "RunBackgroundJob" - c'est ce dont nous avons besoin.

Sans nous laisser distraire par les nuances, nous analysons cette procédure

Et ici, nous voyons que le gestionnaire de tâches en arrière-plan et sa méthode Execute sont utilisés. Notez que les développeurs conservent un ID de tâche d'arrière-plan unique.

Pour ce faire, les développeurs utilisent la méthode ConnectWaitingHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>).

Dans une procédure de hook Pluggable_CheckJobExecution() les développeurs appellent une fonction Travail terminé (ID de travail)

Cette fonction vérifie l'exécution d'un job d'arrière-plan par ID.

Il convient de noter que le BSP a développé modules communs prise en charge des opérations de serveur de longue durée.

Ainsi, le concept asynchrone de programmation dans 1C:Enterprise 8 augmente légèrement la complexité de la résolution de problèmes pour le développeur, mais améliore considérablement la fonctionnalité du programme du point de vue de l'utilisateur.

Lorsque vous travaillez dans 1C, de nombreuses opérations de routine doivent être lancées ou formées selon un calendrier en effectuant l'une ou l'autre action, par exemple : publier des documents ou télécharger des données sur 1C à partir d'un site.

J'ai récemment posté un article : il est temps d'automatiser cela :

Tâches planifiées et en arrière-plan

Le mécanisme de travail est conçu pour exécuter n'importe quelle application ou fonctionnalité selon un calendrier ou de manière asynchrone.

Le mécanisme de travail effectue les tâches suivantes :

• Capacité à déterminer les procédures de routine au stade de la configuration du système ;
• Exécution des actions spécifiées selon le calendrier ;
• L'exécution d'un appel à une procédure ou une fonction donnée est asynchrone, c'est-à-dire sans attendre son achèvement ;
• Suivre la progression d'un travail spécifique et obtenir son état d'achèvement (une valeur indiquant le succès ou l'échec de son exécution) ;
• Obtenir une liste des tâches en cours ;
• Capacité d'attendre la réalisation d'une ou plusieurs tâches;
• Gestion des jobs (possibilité d'annulation, blocage d'exécution, etc.).

Le moteur de tâche comprend les composants suivants :

• Métadonnées des tâches planifiées ;
• Missions programmées ;
• Travaux d'arrière-plan ;
• Planificateur de tâches.

Les travaux d'arrière-plan et sont conçus pour exécuter des tâches d'application de manière asynchrone. Les travaux d'arrière-plan sont implémentés à l'aide du langage intégré.

Les tâches planifiées et sont conçues pour effectuer des tâches planifiées. Les tâches planifiées sont stockées dans l'infobase et sont créées en fonction des métadonnées définies dans la configuration. Les métadonnées de la tâche planifiée contiennent des informations telles que le nom, la méthode, l'utilisation, etc.

Une tâche planifiée a une planification qui détermine à quel moment la méthode associée à la tâche planifiée doit être exécutée. Le calendrier, en règle générale, est défini dans l'infobase, mais peut également être défini au stade de la configuration (par exemple, pour des tâches planifiées prédéfinies).

Le planificateur de tâches est utilisé pour planifier l'exécution des tâches planifiées. Pour chaque travail planifié, le planificateur vérifie périodiquement si le La date actuelle et le calendrier de la tâche planifiée. S'il correspond, le planificateur planifie l'exécution de ce travail. Pour ce faire, en fonction de cette tâche planifiée, le planificateur crée une tâche en arrière-plan qui effectue le traitement proprement dit.

Avec la description, je pense que c'est suffisant - passons à la mise en œuvre :

Création d'une tâche planifiée

Nom de la méthode– chemin vers la procédure qui sera exécutée en tâche de fond selon le planning spécifié. La procédure doit être dans un module partagé. Il est recommandé de ne pas utiliser de modules communs typiques, mais de créer les vôtres. N'oubliez pas que les tâches en arrière-plan s'exécutent sur le serveur !

Usage- un signe de l'utilisation d'une tâche planifiée.

prédéterminé– indique si la tâche planifiée est prédéfinie.

Si vous souhaitez que la tâche planifiée fonctionne immédiatement après avoir été placée dans la base de données, spécifiez le signe prédéterminé. Sinon, vous devrez utiliser le traitement "Job Console" ou appeler le travail pour qu'il s'exécute par programmation.

Nombre de tentatives lorsqu'une tâche plante– combien de fois le travail d'arrière-plan a été redémarré s'il a été exécuté avec une erreur.

Intervalle entre les tentatives d'abandon de tâche– la fréquence à laquelle la tâche d'arrière-plan sera redémarrée si elle a été exécutée avec une erreur.

Réglage du calendrier

Programme exécution de la tâche :

Chaque heure, juste un jour	Retry PeriodDays = 0, Retry PeriodDuringDay = 3600
Tous les jours une fois par jour	Retry PeriodDays = 1, Retry PeriodDuringDay = 0
Un jour, une fois	Jours de période de nouvelle tentative = 0
Tous les deux jours une fois par jour	Jours de période de nouvelle tentative = 2
Toutes les heures de 01h00 à 07h00 tous les jours	RetryPeriodDays = 1RepeatPeriodDay = 3600StartTime = 01.00 Heure de fin = 07h00
Tous les samedis et dimanches à 09h00	Répéter la période de jours = 1Jours de la semaine = 6, 7StartTime = 09.00
Tous les jours une semaine, pass semaine	Période de répétition de jours = 1 Période de semaines = 2
À 01h00 une fois	Heure de début = 01.00
Dernier jour de chaque mois à 9h00.	Répéter la période de jours = 1DayInMonth = -1StartTime = 09.00
Le cinquième de chaque mois à 9h00	Répéter la période de jours = 1DayInMonth = 5StartTime = 09.00
Le deuxième mercredi de chaque mois à 9h00	Période de répétitionJours = 1JourSemaineDansMois = 2JourSemaine = 3 Heure de début = 09h00

Particularités de l'exécution de tâches en arrière-plan dans les versions fichier et client-serveur

Les mécanismes d'exécution des tâches en arrière-plan dans les versions fichier et client-serveur sont différents.

Au format fichier vous devez créer un processus client dédié qui effectuera des tâches en arrière-plan. Pour ce faire, la fonction contextuelle globale ExecuteJobProcessing doit être appelée périodiquement dans le processus client. Un seul processus client par infobase doit traiter les travaux d'arrière-plan (et donc appeler cette fonction). Si aucun processus client n'a été créé pour traiter les tâches en arrière-plan, lors de l'accès par programmation au moteur de tâches, l'erreur "Le gestionnaire de tâches n'est pas actif" sera générée. Il n'est pas recommandé d'utiliser le processus client qui traite les travaux d'arrière-plan pour d'autres fonctions.

Une fois que le processus client qui gère les travaux d'arrière-plan est en cours d'exécution, d'autres processus clients ont la possibilité de accès au programme au mécanisme de tâche d'arrière-plan, c'est-à-dire peut exécuter et gérer des tâches en arrière-plan.

En version client-serveur Pour exécuter des tâches en arrière-plan, le planificateur de tâches est utilisé, qui est physiquement situé dans le gestionnaire de cluster. Le planificateur de toutes les tâches d'arrière-plan mises en file d'attente obtient le processus de travail le moins chargé et l'utilise pour exécuter la tâche d'arrière-plan correspondante. Le processus de travail exécute le travail et informe le planificateur des résultats de l'exécution.

Dans la version client-serveur, il est possible de bloquer l'exécution des tâches planifiées. Le blocage de l'exécution des tâches planifiées se produit dans les cas suivants :

• Un blocage explicite des tâches planifiées a été défini sur l'infobase. Le verrou peut être défini via la console du cluster ;
• Un blocage de connexion a été défini sur l'infobase. Le verrou peut être défini via la console du cluster ;
• La méthode SetExclusiveMode() a été appelée à partir du langage intégré avec le paramètre True ;
• Dans certains autres cas (par exemple, lors de la mise à jour de la configuration de la base de données).

Traitement du lancement et de la visualisation des travaux planifiés vous pouvez télécharger ici.

Certaines tâches de gestion de documents et de comptabilité peuvent devoir être effectuées périodiquement. Par exemple, sur les vingtièmes numéros. Ou quotidiennement.

Habituellement, l'entreprise essaie de créer des règles sur la mise en œuvre de telles tâches - qui, quand et comment doit effectuer la tâche, qui doit la contrôler.

Ces tâches sont appelées - réglementées, c'est-à-dire exécutées conformément à la réglementation.

En informatique, la surveillance est souvent routinière.

Ceci est bien connu de l'administrateur système - il existe des programmes spéciaux qui vérifient périodiquement la santé des serveurs et de l'infrastructure réseau et signalent des SMS ou des e-mails à l'administrateur.

Des choses similaires existent pour les webmasters - pour vérifier la disponibilité du site pendant la journée.

Dans 1C, les tâches de surveillance et toutes les autres tâches périodiques qui doivent être exécutées automatiquement selon un calendrier sont effectuées à l'aide du mécanisme de tâches planifiées 1C.

Parlons d'eux aujourd'hui.

Tâches planifiées 1C

Les tâches planifiées 1C sont celles qui vous permettent d'effectuer comme elles le font, mais dans les délais.

La tâche de routine 1C elle-même dans le configurateur est un moyen de spécifier les paramètres et de définir un calendrier. À propos, le calendrier peut être modifié dynamiquement plus tard en mode 1C Enterprise.

Des tâches en arrière-plan peuvent être créées arbitrairement à partir du texte du programme dans le langage 1C sans tâche planifiée 1C - pour le calcul parallèle sur le serveur.

L'exécution des tâches de routine 1C peut être temporairement désactivée - in.

Ajouter une tâche planifiée 1C

Les tâches planifiées 1C sont dans la configuration dans la branche Général / Tâches planifiées 1C. Ajoutons une nouvelle tâche planifiée 1C, spécifions son nom.

Dans la propriété de la tâche planifiée 1C, le nom de la méthode est indiqué, ainsi que dans. La fonction sera située dans un module commun avec la case Serveur cochée dans les propriétés, c'est-à-dire que le module doit être ajouté au préalable.

La propriété de la tâche planifiée 1C - Nom de la tâche - détermine le nom sous lequel la tâche apparaîtra dans les outils de gestion des tâches.

La propriété de la tâche planifiée 1C - Clé - permet de regrouper plusieurs tâches planifiées différentes 1C. Une seule tâche avec la même valeur de clé peut être exécutée en même temps. La valeur elle-même peut être arbitraire. Une valeur vide n'est pas prise en compte lors du contrôle (c'est-à-dire qu'elle est considérée comme non remplie).

La propriété de la tâche planifiée 1C - Prédéfinie - détermine qu'au démarrage de 1C Enterprise, une telle tâche sera créée et en un seul exemplaire avec le calendrier spécifié dans le configurateur. Les tâches non prédéfinies apparaissent par programmation lorsque le planning arrive.

Dans les configurations typiques, par exemple, Comptabilité 2.0, des tâches de routine 1C telles que la mise à jour de la configuration et le recalcul des totaux sont prédéfinies, et telles que l'échange de données ou les mouvements différés ne sont pas prédéfinis.

Utilisation - inclut la tâche (c'est-à-dire qu'elle ne sera exécutée que si la case Utilisation est cochée).

Crash retry - comme vous pouvez facilement le deviner, signifie redémarrer le travail s'il n'a pas pu être terminé avec succès la première fois - il est indiqué combien de fois redémarrer et après combien de temps après le crash.

1C gestion et surveillance des tâches planifiées

Pour gérer les tâches planifiées 1C, il existe un traitement typique spécial de la console de tâches. Il peut également être trouvé sur .

Ce traitement appartient à la soi-disant externe universelle traitements standards 1C, qui ne sont souvent pas inclus dans la configuration, mais sont distribués séparément, par exemple sur des disques ITS.

Avec Job Console Processing, vous pouvez :

• Activer / désactiver l'exécution de la tâche planifiée 1C
• Attribuer / modifier le calendrier de la tâche planifiée 1C (et d'autres paramètres)
• Spécifiez l'utilisateur 1C pour le compte duquel la tâche planifiée 1C sera exécutée
• Afficher - quelles tâches ont été accomplies quand et avec quel résultat, erreurs dans l'accomplissement des tâches 1C
• Exécuter une tâche.

Copies des bases de données et des tâches de routine 1C

Si le serveur 1C est utilisé, la situation suivante se produit :

• Pour leurs propres besoins (par exemple, pour la programmation), une copie de la base de données de travail est faite
• Dans une copie de la base de données, il est travaillé, testé, etc.
• On oublie de désactiver les tâches de routine 1C dans une telle base de test.

Alors que les tâches de routine 1C exécutent des tâches liées uniquement à leur infobase, il n'y a rien là-dedans.

Cependant, les tâches de routine 1C peuvent souvent enregistrer toutes les données de fichiers dans d'autres bases de données, échanger, envoyer des e-mails.

Dans ce cas, un mélange intéressant peut se produire entre le résultat de l'exécution de tâches de routine 1C dans la base de données de travail et les copies.

Les tâches de routine 1C pour les copies de la base de travail doivent être désactivées dans.

Accomplissement et non-accomplissement des tâches de routine 1C

Lors de la création de tâches planifiées 1C, vous devez vous rappeler :

• Tâches exécutées par elles-mêmes - elles doivent être surveillées
• Tâches exécutées dans un module sur le serveur
• Les tâches sont exécutées sous un utilisateur Windows différent, avec des droits différents.

Tout d'abord, vous devez vérifier que la tâche est en cours d'exécution et peut être exécutée en tant que tâche 1C planifiée.

Deuxièmement, le module serveur signifie que de nombreuses choses qui sont disponibles sur le client ne sont pas disponibles. Par exemple, parfois, tous les documents ne peuvent pas être affichés uniquement sur le serveur, car leur algorithme peut prévoir que l'affichage est lancé manuellement par l'utilisateur et que des fonctions non serveur peuvent être utilisées, par exemple
Alerte ("Salut !")

Troisièmement, si la tâche traite de quelque chose en dehors de la base 1C, les droits de l'utilisateur Windows sous lequel la tâche est effectuée deviennent importants.

Le troisième point est particulièrement important dans le développement. Si le module ne peut pas être exécuté sur le serveur, la tâche ne sera en principe pas exécutée. Pour vérifier, vous devez exécuter la tâche au moins une fois et voir le résultat "Tâche terminée" dans le traitement de la console des tâches.