1c routine tasks. Background tasks: features, capabilities, settings. – Accountant tasks update

How to speed up work in 1C: Accounting 8.3 (version 3.0) or disable routine and background tasks

Those of you who have already managed to switch to the new edition of 1C: Accounting 8.3 (revision 3.0) have noticed that it has become slower than the deuce. Some incomprehensible slowdowns, endless background tasks several times a day, which no one asked her to perform without our knowledge.

Immediately after the transition, my accountants told me that the new edition of 1C: Accounting 3.0 frankly slows down in comparison with the previous ones! And it's impossible to work.

I began to understand and very soon found out that the main cause of freezes and subsequent user dissatisfaction are routine and background tasks, many of which are enabled by default, although for the vast majority of accountants they are not necessary.

Well, for example, why do we need to run the "Text Extraction" task a hundred times a day if we do not perform a full-text (accountants, don't be scared) search across all the objects in our database.

Or why constantly download exchange rates if we do not have currency transactions or we do them occasionally (and before that we ourselves can click the download rates button).

The same applies to the constant attempt by 1C to connect to the site and check and update the bank classifiers. What for? I myself will press the button to update the classifiers if I do not find the right bank by its BIC.

About how to do it on the points below.

1. Go to the "Administration" section and select the "Maintenance" item in the action panel ():

2. In the window that opens, find and select the "Regular and background tasks" item:

3. Open each job that has the On column. worth a jackdaw.

4. Uncheck "Enabled" and click the "Save and Close" button.

5. Do this with each of the included tasks and enjoy the new edition. In general, in my opinion, it is much better than the deuce.

At the same time, the platform will still turn on some of the scheduled tasks that you have disabled.

When working in 1C, there are many routine operations that must be launched or formed on a schedule by performing one or another action, for example: posting documents or loading data into 1C from a site.

I recently posted an article: it's time to automate this:

Scheduled and background jobs

The job mechanism is designed to execute any application or functionality on a schedule or asynchronously.

The job mechanism performs the following tasks:

• Ability to determine routine procedures at the stage of system configuration;
• Execution of specified actions according to the schedule;
• The execution of a call to a given procedure or function is asynchronous, i.e. without waiting for its completion;
• Tracking the progress of a specific job and getting its completion status (a value indicating the success or failure of its execution);
• Getting a list of current tasks;
• Ability to wait for the completion of one or more tasks;
• Job management (possibility of cancellation, blocking of execution, etc.).

The job engine consists of the following components:

• Metadata of scheduled tasks;
• Scheduled assignments;
• Background jobs;
• Task Scheduler.

Background jobs & are designed to run application tasks asynchronously. Background jobs are implemented using the built-in language.

Scheduled tasks & are designed to perform scheduled tasks. Scheduled tasks are stored in the infobase and are created based on the metadata defined in the configuration. Scheduled job metadata contains information such as name, method, usage, and so on.

A scheduled job has a schedule that determines at what times the method associated with the scheduled job should be executed. The schedule, as a rule, is set in the infobase, but can also be set at the configuration stage (for example, for predefined scheduled tasks).

The task scheduler is used to schedule the execution of scheduled tasks. For each scheduled job, the scheduler periodically checks whether the current date and time matches the schedule of the scheduled job. If it matches, the scheduler schedules that job to run. To do this, according to this scheduled task, the scheduler creates a background task that performs the actual processing.

With the description, I think that's enough - let's proceed to the implementation:

Creating a Scheduled Job

Method name– path to the procedure that will be executed in the background task according to the specified schedule. The procedure must be in a shared module. It is recommended not to use typical common modules, but to create your own. Don't forget that background jobs run on the server!

Usage- a sign of the use of a scheduled task.

predetermined– indicates whether the scheduled job is predefined.

If you want the scheduled task to work immediately after being placed in the database, specify the sign predetermined. Otherwise, you will need to use the “Job Console” processing or call the job to run programmatically.

Number of retries when a job crashes– how many times the background job was restarted if it was executed with an error.

Job abort retry interval– how often the background task will be restarted if it was executed with an error.

Schedule setting

Schedule task completion:

Peculiarities of performing background tasks in file and client-server versions

Mechanisms for executing background jobs in the file and client-server versions are different.

In file format you need to create a dedicated client process that will perform background tasks. To do this, the global context function ExecuteJobProcessing must be called periodically in the client process. Only one client process per infobase should process background jobs (and therefore call this function). If no client process has been created to process background jobs, then when programmatically accessing the job engine, the error "Job manager is not active" will be generated. It is not recommended to use the client process that processes background jobs for other functions.

After the client process processing background jobs is started, other client processes can programmatically access the background job mechanism, i.e. can run and manage background jobs.

In client-server version To execute background jobs, the task scheduler is used, which is physically located in the cluster manager. The scheduler for all queued background jobs gets the least loaded worker process and uses it to run the corresponding background job. The worker process executes the job and notifies the scheduler of the execution results.

In the client-server version, it is possible to block the execution of scheduled tasks. Blocking the execution of scheduled tasks occurs in the following cases:

• An explicit blocking of scheduled tasks has been set on the infobase. The lock can be set via the cluster console;
• A connection block has been set on the infobase. The lock can be set via the cluster console;
• The SetExclusiveMode() method was called from the built-in language with the True parameter;
• In some other cases (for example, when updating the database configuration).

Processing the launch and viewing of scheduled jobs you can download here.

". In it, we will consider new features that do not relate to the system interface, but significantly expand the functionality of the 1C:Enterprise 8 platform.

Applicability

The article deals with the 1C:Enterprise platform version 8.3.4.437. All functionality described in the article has been updated to version 8.3.11.

Other innovations in 1C:Enterprise 8.3

Let's continue to get acquainted with the innovations of the 1C:Enterprise 8.3 platform.

Background and scheduled tasks in the file infobase

In many typical platform configurations 8.2 there was a constant that indicated the user under which the tasks were performed in the file version.

When the system started working under this user, a wait handler was connected, which at a certain frequency called the method of the built-in language ExecuteProcessingJobs().

This approach created additional difficulties and inconveniences for the use of scheduled tasks in the file base.

This could be especially critical when working with configurations such as “Comprehensive Automation” or "Manufacturing Enterprise Management" in which routine tasks play a rather important role.

If This isFileIB Then
=
Constants.UserForPerformingRegularTasksInFileVariant.Get();
If a glValueVariable(“gCurrentUser”) =
UserToPerformRegularJobs Then
// with an interval of seconds, we call the procedure for working with scheduled tasks
SupportRegularTaskForFileVersion();
IntervalFor Polling=
Constants.IntervalForPollingRegularTasksInFileVariant.Get();
If a IntervalFor Polling= Undefined
OR IntervalFor Polling= 0 Then
IntervalFor Polling= 60 ;
EndIf ;
ConnectHandlerWaiting(“SupportRegularAssignmentForFileVersion”,
IntervalFor Polling);
EndIf ;
EndIf ;

In the platform 8.3 Implemented the work of background and scheduled tasks in the file infobase without using the call of the global context method ExecuteProcessingJobs().

Background and scheduled tasks are executed directly in one of the client applications (thin, thick client) or by a web server extension.

A background job started by a session is executed by the same client application that initiated it.

Background jobs are executed sequentially, i.e. on one client application at a time, only one background task (including scheduled ones) can be executed.

Scheduled tasks are performed by only one client application. The command line key is used to control the launch of scheduled tasks. /AllowExecuteScheduledJobs.

Scheduled tasks are executed by the first client application in the order of launch, which is not prohibited from executing scheduled tasks (to disable the session, the session must be started with the command line parameter /AllowExecuteScheduledJobs -Off).

When this session terminates, execution jumps to any of the remaining running sessions.

If the launch line of the client application explicitly specifies the need to launch scheduled tasks (the command line specifies /AllowExecuteScheduledJobs -Force), then scheduled tasks begin to run on it, regardless of the presence of other sessions.

Scheduled tasks are processed once every 60 seconds.

Note that the scheduled tasks of the applied solution (in the file version) started to be executed no earlier than 1 minute after the client application was launched. Starting with version 8.3.8, this time has been doubled, and therefore scheduled tasks begin to run a maximum of 2 minutes after the client starts (in the file version).

This decision is due to a decrease in the delay at the start of the application. In addition, in release 8.3.7, the ability to quickly determine if the current session is a background job session was added. This is implemented through a new global context method GetCurrentInfobaseSession(), as well as a new method for an infobase session GetBackgroundTask().

Below is the code that illustrates the above:

Click on the image to enlarge.

Checksum calculation

The platform now has mechanisms for calculating data checksums.

Recall that a checksum (hash) is a value calculated from a data set by applying a certain algorithm and used to check the integrity of data during transmission or storage.

Hashes can be used to check the identity of data (for example, you need to make sure that the file was not damaged during the transfer; check whether changes were made to the file, and if so, upload it to the database again).

To do this, the platform implemented an object HashingData, available on the server, thick client, external connection, and mobile app server.

This object has two methods: Add() and To add a file(), which update the hash sum based on the data passed in the parameters.

Platform 8.3.4.437 supports the calculation of the following hash functions: CRC32, MD5, SHA1, SHA256. But the functions SHA1 and SHA256 not supported on the mobile platform.

Let's consider a simple example. It is assumed that on the server in the program directory there is a file “ agent.exe". Need to calculate MD5-sum for this file.

To do this, we will create an external processing, on the form of which we will place the command Calculate. The handler contains the following code:

&AtClient
Procedure Calculate (Command)
Result = CalculateOnServer();
Report(String(Result));
EndProcedure
&On server
Function CalculateOnServer()
Hash = New HashingData(HashFunction .MD5 );
Hash.AddFile(CatalogPrograms() + "ragent.exe" );
Return Hash.HashSum ;
EndFunctions

In platform revision 8.3.10+ in the method Add() object HashingData it became possible to use a stream of binary data, which greatly simplified their use in solving various applied problems of updating hash sums.

Working with secure versions of protocols SMTP/POP3

In the platform 8.3 it became possible to use secure versions of protocols SMTP/POP3(there are terms SMTPS/POP3S or SSLSMTP/SSLPOP3).

For object InternetPostalProfile new properties implemented:

• UseSSLSMTP;
• UseSSLPOP3;
• OnlySecuredAuthenticationSMTP;
• OnlySecuredAuthenticationPOP3.

Properties SMTP authentication and POP3 authentication object InternetPostalProfile, as well as enumerations SMT Authentication Method and POP3 Authentication Method use is deprecated - they are supported for compatibility.

Using a secure protocol SMTPS allows you to send mail from 1C using mailbox Google.

Consider an example. On the form, we will place fields for entering the subject of the letter and the address of the recipient, and for entering the text of the letter - a formatted document field.

Click on the image to enlarge.

By pressing the button Send the following code will be executed:

&AtClient
Procedure Send (Command) Mail = New InternetMail ; Profile = New InternetPostalProfile;
Profile.SMTPServerAddress= "smtp.googlemail.com" ;
Profile.SMTP User= “[email protected]” ;
Profile.SMTP Password= "PASSWORD" ;
Profile.UseSSLSMTP= true ;
Profile.SMTP Port = 465 ; Attempt
Mail.Connect(Profile );
Exception
Report(ErrorDescription());
Return ;
EndTry ; MailMessageText= “” ;
Attachments = New Structure ;
Text.GetHTML(MailMessageText, Attachments ); MailMessage= New InternetMailMessage;
MailMessage.Recipients.Add(To whom );
MailMessage.Subject= Subject ;
MailMessage.Texts.Add(MailMessageText,
MailMessageTextType.HTML); Mail.Send ( MailMessage); Mail.Disconnect();
EndProcedure

Note that in our example, if the SMTP server was unable to send an email message to the recipient(s), then the method Mail.Send(MailMessage) threw an exception. This caused some inconvenience for the developers, because. the reason for throwing the exception was not obvious.

In version 8.3.9, this behavior has changed, and now the Send() method returns a match, the key of which is the addressee, and the value is diagnostics from the mail server. This allows you to accurately determine the reasons for the unsuccessful sending of a mail message to each of the recipients. In version 8.3.8 compatibility mode, the behavior has not changed.

Two-sided printing

In the platform 8.2 The platform itself did not control duplex printing; it was only possible to control this function using the printer driver.

In the platform 8.3 it became possible to control duplex printing for a spreadsheet document, a graphic scheme (from the built-in language and interactively) and a text document (interactively only).

System enumerations appeared in the built-in language:

• TypeDouble SidedPrinting(None, FlipUp, FlipLeft);
• (Auto, MirrorUp, MirrorLeft, Do Not Use).

And the objects SpreadsheetDocument and GraphicScheme properties appeared Two-sided printing and InterleavingPage Arrangements, with which you can change the layout of printed pages.

In platform revision 8.3.9, the system enumeration DuplexType has a new value UsePrinter Settings. Selecting this value allowed the printer settings to be used when printing system documents. In version 8.3.8 compatibility mode, the behavior has not changed and the corresponding printer settings are ignored.

The infobase publishing dialog on the web server has been made more functional. Now publishing from the configurator allows you to set all file parameters default.vrd.

For the dialog for publishing the web client and Web services through the configurator, the following is implemented:

• the ability to control the availability of Web services by default (attribute pointEnableCommon element ws);
• the ability to control the execution of background jobs in the file version (attribute allowexecutescheduledjobs element ws).

If the checkbox “Publish Web Services by Default” on the bookmark “Basic” is set, then when the publication is updated, the selected Web services will be published automatically.

Otherwise, Web services will be marked as unpublished. This flag corresponds to the attribute pointEnableCommon element ws in file default.vrd for configuring the web client and web services.

Attribute pointEnableCommon ws element is responsible for the possibility of using Web services in this infobase that are published without explicitly specifying permission to use (attribute enable element point).

If the attribute has a value true, then all Web services for which the attribute value is not explicitly specified enable element point, will be allowed to use.

Otherwise, the use of such Web services will be prohibited.

Setting “Background jobs in file mode” matches attribute allowexecutescheduledjobs ws element in file default.vrd.

Attribute allowexecutescheduledjobs controls the ability to execute scheduled tasks by the web server extension for the infobase file version.

The attribute can take the following values:

• off– in this case, the web server extension will not perform scheduled tasks. Scheduled tasks will be performed by a client application (if one exists) that connects to the infobase directly, without using a web server.
• force– in this case, the web server extension will perform scheduled tasks.
  If the value of this attribute is not set, then scheduled tasks will be performed by the application that will be used for the first connection to the infobase.

The publishing window on a web service in the current release of the platform has become even more convenient and ergonomic. Now the parameters describing OpenID authentication are placed on a separate tab.

Numbering of infobase objects

In the platform 8.3 the mechanism for automatic numbering of infobase objects has been redesigned. The uniqueness of the number or code (including the one obtained as a result of automatic generation of the number or code) is always controlled during the recording of the object.

An indication of which number or code is not unique has been added to the text of the message about a violation of the uniqueness of a number or code.

The use of a vacated number or code has changed. A new number or code is assigned without using vacated numbers or codes, if there are already issued numbers or codes with a large (in order) number or code prefix.

Aggregate Functions of the Data Composition System Expression Language

New aggregate functions are implemented in the expression language of the data composition system:

• Each();
• Any();
• Standard Deviation of Population();
• Sample Standard Deviation();
• VarianceSampling();
• Population variance();
• Population Covariance();
• SampleCovariance();
• Correlation();
• RegressionSlope();
• RegressionSegment();
• RegressionCount();
• RegressionR2();
• RegressionMeanX();
• RegressionMeanY();
• RegressionMeanSXX();
• RegressionMeanSYY();
• RegressionMeanSXY().

As you can see from the names, these are statistical functions, which means that developers have the opportunity to create complex reports without resorting to the development of procedures for calculating statistical data.

Click on the image to enlarge.

As you can see from the figure, there are no new functions in the drop-down list, however, if you enter them manually, then there will be no error message, and the report will be generated:

Also of interest is the new function ClassificationABC(). The result of the function will be the class number, starting from 1 (1 corresponds to class A, 2 to class B, 3 to class C, etc.).

Let's demonstrate how this function works. Create a new external report “Classification of goods” based on request:

CHOOSE
ConsumptionGoodsGoods.Goods,
Consumption of Goods Goods. Quantity
FROM
Document.Expense of Goods.Goods HOW ConsumptionGoodsGoods

Define a new calculated field Class:

Click on the image to enlarge.

Let's configure the resources as follows:

Click on the image to enlarge.

In user mode, the report looks like this:

In conclusion, we note that from edition to edition in the 1C 8.3 platform, the ACS mechanism is constantly being improved and refined, and it is not possible to bring these changes in full within the framework of our “newbie” article. Yes, this seems redundant, because, working on the current version of the platform, you can always use various help systems to help with the analysis of one or another aspect of the operation of this mechanism.

In addition, do not forget about our separate course Professional development of reports in 1C 8.3 on the Data Composition System, which analyzes to the atom all the subtleties and pitfalls when working with this mechanism. See the demo for yourself.

So, let's sum up the intermediate results. Up to this point, we got acquainted with the new features of the Taxi interface and managed forms, as well as with some previously not provided features of the platform itself. Now it's time to see what convenient features have become available to the developer in the configurator.

Platforms: 1C:Enterprise 8.3, 1C:Enterprise 8.2, 1C:Enterprise 8.1
Configurations: All configurations

2012-11-13
53989

In the workflow, there are tasks that require periodic execution - for example, on the twentieth, or daily. As a rule, in companies specifically for this, certain rules are created that indicate when and how the necessary task should be performed, and who should control the process. Such tasks are performed according to the regulations and are called regulated.

Quite often, IT follows the rules for monitoring. This method is well known to administrators, since for this there are special programs used to periodically check the health of the network infrastructure and servers. They notify the administrator about detected problems via SMS or e-mail.

A similar system is valid for webmasters, while the availability of the site is checked within 24 hours. With the help of the "Regular Tasks" mechanism in 1C, monitoring tasks are carried out, as well as periodic tasks that are scheduled in automatic mode in 1C. Let's consider this topic in more detail.

Scheduled tasks 1C

Object 1C, which is called "Regular tasks" - makes it possible to process information not after a problem occurs, but according to a schedule. In the configurator, a scheduled job is a way to set up settings and set a schedule. In addition, it is possible to subsequently change the schedule in the 1C Enterprise mode.

When using a file database, jobs are not automatically executed. In order to start the process, you need to start the 1C session in the 1C Enterprise mode and start the execution of the scheduled task in it.

All typical configurations have a user setting that allows you to clarify that when 1C is running, routine tasks will be performed automatically.

Using the client-server version of 1C makes it possible to automatically perform tasks on the server. At the scheduled time - a background task is launched, which performs the necessary actions. For parallel computing on the server, a background task can be created from the program text, using the 1C language, without using a scheduled 1C task. The action of a scheduled task can be temporarily disabled using the 1C server management console for this.

Adding a Scheduled Job

Scheduled tasks are located in — Configurator — General — Scheduled tasks. Add a new "task" and provide a name. Next, you need to go to the properties of the "Tasks". And choose Method name. Here, you need to specify the handler function, just as it happens in the event subscription. This function will be located in the general module and marked with a "bird" Server in the properties. This means that the required module must be added in advance.

The name of the task in the Properties of the scheduled task allows you to define its name, which will later appear in the task management tools. The Scheduled job properties function is a key that allows you to group several different scheduled jobs. In this case, only one task with the same key value can be launched at the same time. Here, the value can be arbitrary, but it is mandatory to fill it in, since the empty value is not taken into account by the system.

In Accounting 2.0 edition, which is a typical configuration, scheduled tasks such as: "Recalculation of totals" and "Configuration update" are predefined, and such as, for example, "Delayed movements" and "Data exchange" are not predefined.

Crash Retry - Restarts a running job. Provided for a launch that was not successfully completed the first time. Here, it is indicated how many times you can restart and how long after the crash.

Monitoring and management tools for the scheduled task 1C

The standard processing "Job Console" is responsible for managing the scheduled task, which can be found on the ITS disks. This processing is a universal external standard processing 1C. As a rule, it is not included in the configuration, but is purchased separately.

With its help, you can perform the following actions:

Turn on and off the scheduled task;

Assign and change the schedule;

Indicate the name of the user with which the scheduled task will be performed;

See completed tasks (when and with what result), as well as task errors;

Scheduled task and database copies

When using server 1C, the following moment may arise:

For programming, you need to make a copy of the working database;

The need to work in copies of the database (testing);

For some reason, the scheduled task is not enabled in the test database.

If one of these situations arose during the execution of tasks by a scheduled task that is associated only with its own database, then this does not entail negative consequences. But, often, a scheduled task can save files or other data, send emails, and exchange. In this case, there may be confusion between the results of the "job" and copies. To prevent this from happening, you need to disable "tasks" in the server management console.

Completed and not completed routine tasks

When creating scheduled tasks, it is important to check if the task can be executed as a scheduled task. It's important to know that the server module doesn't provide many of the things that are possible on the client. Next, a task that deals with something that is outside the database - an important role in this is played by the rights of the Windows user under which the task is performed.

The last factor is especially important, since if the module is not executed on the server, then the task cannot be executed in principle. To check, you need to run one task and evaluate the result.

Often, when keeping records, it becomes necessary to periodically perform certain actions without user intervention. Scheduled and background tasks in 1C are the mechanisms that are provided for this purpose in the eighth version of the program and allow:

• Set up timely delivery of documents;
• Calculate balances and totals;
• Ensure regular posting;
• Check and delete irrelevant data.

Background and scheduled task - what is it and where is it configured

A scheduled task is a mechanism embedded in 1C that allows you to configure and, in accordance with the established schedule and frequency, perform a certain sequence of actions.

A background task is an action generated by a scheduled operation and does not require the direct participation of the user.

A scheduled task is created in the configurator mode:

• In the configuration tree window we find the corresponding branch (Fig. 1);

• Click the add button;
• In the window that opens, you must specify a name that allows you to identify the object in the configuration;

Fig.2

• Opposite the inscription "Schedule" (Fig. 2) there is an inscription "Open", clicking on which opens a window for setting the time and frequency of the handler execution (Fig. 3);

Fig.3

• It is also necessary to fill in the “Method name” (the name of the procedure called from the general module and describing the program behavior algorithm will be entered here);
• The fields "Name" and "Key" allow you to group objects;
• The checked box "Usage" indicates the activity of the scheduled operation;
• "Predefined" should be set if the handler should be launched immediately after it is added to the database, otherwise it can be launched from the corresponding processing (more on that below);
• The Retry Count and Retry Interval parameters describe the behavior of the program in the event of an exception occurring while executing a background job.

So, using the mechanism of scheduled operations, you can set the schedule and the main actions of background jobs. Let's now look at their features.

Features of background jobs

The main feature of this mechanism is that the background process runs asynchronously.

What does this mean. The fact is that with a synchronous model of work, in the case of the execution of any algorithm, the user interface is blocked. In our case, the user can continue to enter and edit data, even if the procedure is running. The asynchronous programming model involves the separation of computational threads.

Thus, background jobs in 1C can generate their own processes, distributing calculations across different servers that are part of the same cluster.

Features of working in client-server mode

• Execution scheduling and control is performed by the scheduler from the server cluster;
• If a request for execution appears, the scheduler looks for cluster worker processes with a minimum load and distributes tasks to them for execution;
• Each process can perform multiple parallel computations;
• After the task arrives, the process connects to the database and executes the algorithm in it;
• The process reports the results to the scheduler.

Background jobs in file mode

Prior to platform version 8.3.3.641, working with background jobs in the file version presented some difficulties:

1. It was necessary to launch a separate session that would work around the clock, replacing the scheduler;
2. This session should have periodically executed the ExecuteJobProcessing() method.

After the update, each start of the thick and thin clients, if the AllowExecuteScheduledJobs key is specified in the launch settings (Fig. 4) in the "Additional" field, initiates an additional connection thread to the database, which does not affect the user's work in any way, but only performs background tasks. operations.

Fig.4

It should be taken into account that even in the file version of operation, background processes do not allow interactive work with the user (service messages, warnings, questions will not be displayed). That is, they must be encoded as if they will be executed on the server side.

How to disable scheduled tasks

Unused tasks can be disabled by simply unchecking the "Use" checkbox in the object's properties.

If the administrator needs to prohibit the use of routine and background operations for the entire database as a whole (for example, several databases are stored on the server, of which only one is the main one, and the rest are used only for development), it is necessary to use the database administration utility. You can also check the "Set blocking of scheduled tasks" box in the database created on the server.

In addition, ITS disks have a special processing “Job Console”, which allows you to edit the schedule of background processes and change their activity.