The signing process was interrupted by the user. Reasons for incorrect operation of electronic signatures and ways to resolve problems. COMET: frequent polling VS persistent connection

With the new storage format, a log file can reach hundreds of gigabytes. The sampling time for it will be very long, and a problem arises: the work of all users stops.

Signs of this problem are:

It is impossible to enter the information database.

Almost 100% activity of the disk on which the log file is located and active reading of the log file by the rmngr process.
This item can be checked using the resource monitor (Task Manager - Performance - Open Resource Monitor) on the “Disk” tab.
In the “Storage devices” group, you need to pay attention to the “Active time (%)” column.
In the “Disk Operation” group, you need to pay attention to the “Read” and “File” columns. You can sort by the “Reading” column. Among the first lines with the fastest reading speed will be the rmngr process. Next you need to look at the name readable file, it will correspond to the registration log of a certain infobase.

In the administration console of a 1C:Enterprise server cluster, in the list of sessions, almost all users will have a large and approximately the same value in the “DBMS Captured” column or in the “Call Time (current)” column.

If a problem is detected, you need to:

Remember the UID of the information security system that is being read by the rmngr process.

Start collecting the process log for EXCP events, if not already started.

Export all sessions on the problematic server OR on the problematic information security using the administration console of the 1C:Enterprise server cluster, in case additional data is needed for analysis.

Restart the 1C:Enterprise service.

Collect a technological log during the restart of the 1C:Enterprise server.

Analyze the technological log: search for the words “UnloadRegistrationLog” or “UnloadEventLog”.

Example:

29:40.069000-0,EXCP,4,process=rphost, p:processName=ib_accounting ,t:clientID=114396,t:applicationName=1CV8C, t:computerName=COMP ,t:connectID=109127,SessionID=1, Usr=IvanovII ,AppID=1CV8C,ClientID=114389,Exception=NetDataExchangeException,Descr=Data transfer was interrupted by the receiving party.,Context="Form.Call: ExternalReport.RegistrationLogAnalysis.Form.Module.BackgroundTaskRun

GeneralForm.ReportForm.Form: 1242: ReportOptions.GenerateReportInBackground(ReportGenerationParameters, BackgroundTaskResult.ResultAddress);

GeneralModule.ReportOptions.Module: 2544: Formation = GenerateReport(Parameters, False, False);

GeneralModule.Report Options.Module: 2060: ReportObject.AssembleResult(Result.TabularDocument, Result.Decryption);

ExternalReport.Analysis of the Registration Log.Object Module: 64:UploadJournalRegistration(TK, Selection, Columns);"

From this line you can tell who: Ivanov II, where (on which computer): COMP , in which information base: ib_accounting launched log analysis.

Many procurement participants, regardless of experience, are faced with the problem of correct operation on the electronic trading platform. These errors can be discovered at any time, including during electronic trading.

The consequences can be very different, namely:

• Application for participation in the competition not submitted on time
• Lost e-auction
• State contract not signed on time

The three most common problems when working with electronic signatures

1. The procurement participant certificate is not displayed on the electronic platform
2. Electronic signature does not sign documents

In fact, there may be many more errors, but we will analyze the main ones and their causes, and also indicate possible ways troubleshooting.

The most important thing is to remember that for the electronic signature to work correctly, you must use a browser Internet Explorer no lower than version 8 and, preferably, no higher than 11 (with version 11 there is no guarantee of stable operation of the signature).

The signing key certificate is not visible on the site when trying to log in to the system

In this case, the error is caused by several reasons, namely:

• Incorrect configuration of the signing key certificate
• Internet browser is not configured correctly
• The root certificate of the Certification Authority is missing

How to solve a problem?

First of all, you need to make sure that you have correctly installed the public part of the certificate into personal ones via CIPF (Crypto Pro). At the same time, the version installed program suitable for your operating system type.

Then, in settings Internet browser Explorer needs to add site addresses to Trusted Sites and enable all ActiveX controls.

Electronic signature gives an error when signing documents

Typically, this error occurs in a number of cases:

• The CryptoPro program license has expired
• Media with a different certificate is inserted

How to fix it?

To do this, you need to obtain a new license by contacting the Certification Center. After the license has been successfully obtained, you need to launch CryptoPro and enter serial number licenses.

In the second case, you need to check all closed containers (media) inserted into the computer’s USB connector and check that the correct certificate has been selected.

The system gives an error when logging into the electronic platform

This error may be caused by a combination of the reasons listed above. As practice shows, such an error primarily appears due to an incorrectly installed Capicom library. We recommend checking whether the library is installed on your computer and paying attention to the need for copying 2 system files with the .dll extension into one of Windows folders, when using a 64-bit system.

In order for you to avoid such mistakes, before installing an electronic signature, read about installing and setting up an electronic signature or order information about issuing and setting up an electronic signature from our company.

COMET technologies allow you to organize data updating on a page without user intervention.

Chats, Internet mail and multi-user admin panels are far from full list, where they apply.

In this series of articles, numerous subtle points and solutions to common problems are described in detail.

What is COMET?

COMET (or "server push") is a method of transferring data from the server to the client, at the initiative of the server.

For example, you have an electronic store, and the manager can track client transitions.
COMET allows the manager to immediately, online, ask the client about something and offer an interesting option.

"Server-initiated" means that the client itself does not request the server, it is simply on the page.

The oldest example of COMET is chat. A person simply stays on the page and receives new messages.

COMET is also used in admin panels to notify other visitors about changes, for joint editing of documents, etc.

Implementation methods

There are many ways to implement COMET. They have a variety of characteristics, advantages and disadvantages.
There are two main classes.

By message upon request

The browser receives each event on the server with a separate request. There are two main methods here.

1. Frequent polling
2. Long poll

To reduce the number of required connections and latency, event messages are packaged in special packets, “datagrams.”
For example, one XML message might look like:

Vasya Hello! processing Processing completed

The next time you connect, the browser immediately receives the entire package of events to date.

The browser maintains a constant connection to the server, the so-called “channel”, and receives events through it.

The communication channel breaks from time to time:

• so that the proxy doesn’t think that the connection has timed out and breaks it for us
• to clear memory from junk of old messages

In addition, to measure network delays and monitor connections, the server can periodically send ping packets over this channel.

Basic ways to maintain a persistent connection:

1. Infinite IFrame
2. XMLHTTPRequest, interactive
3. Multipart XMLHTTPRequest
4. Event-source

You will find them in other articles in this section.

Problems common to persistent connections

The HTTP protocol was originally designed so that one request would return one piece of information. But we want a lot, hence some difficulties...

Proxy buffering

This is rare, but a proxy can buffer a certain amount of data before transmission to the client. For example, receive and send responses in blocks of 2K. In this case, messages will remain on the proxy and wait until they reach 2K (or whatever the buffer size is) bytes, and only then will they be transmitted to the client.

The solution is to add 2K spaces to each message.

It is unknown whether this problem will affect you. Hope not, but keep in mind proxy buffering like possible reason User complaints are a must.

Can't GZIP

An IFrame that serves to pass messages should NOT be compressed with gzip/deflate. In other words, compression should be disabled for the service URL of messages.

Enabled compression means that the browser waits for the download to finish, and then decompresses and displays it to the user. In our case, this is strictly contraindicated, and you cannot compress pieces of a page (message) separately.

This is an unfortunate consequence of the iframe's hacker nature. For example, in long poll, compression goes well, because the events are not part of the same page.

Server page buffering

Don't forget to disable server buffering. In Apache/PHP - disable output buffering and enable ob_implicit_flush:

While (@ob_end_flush()) () ob_implicit_flush(1); // and of course, remove the limit on the script execution time set_time_limit(0);

COMET: frequent polling VS persistent connection

As always, when writing a web application, the question of choosing an architecture arises. On the one hand, solutions on long connections (all but frequent polling) provide fast notification. On the other hand... Is a long connection always better than frequent polling?
The solution with long connections is seemingly more optimal, but it is much more complicated and has a number of features.

1. Implementing a long connection, as a rule, complicates the architecture. Perhaps there is a simpler solution?
2. A number of web servers are poorly optimized for large numbers of long connections. For example, threads or processes are used that eat up a fixed amount of resources and do not release them until the end of the connection. At the OS level, the problem is solved by using kqueue (FreeBSD) or epoll (Linux). At the web server level, you can use
   1. Apache MPM event for apache 2.2 (experimental and limited MPM, special thread handles Listening and Keep-Alive sockets)
      doesn't work properly with mod_perl/mod_php
   2. Jetty (Java) / Twisted (Python), nginx and other specialized servers with one thread/process for many clients.

   Will the current one handle it? server architecture long connections? The answer is not obvious for hundreds/thousands of simultaneous connections, but up to, say, 100 connections in any architecture is fine.

3. How long do users stay on the same page? During transitions, the connection will most likely have to be reopened in any case.
4. If event delivery delays are acceptable, then perhaps frequent polling will suffice?

Classic (transport-independent) COMET model

Let's look at the client-server interaction "from a bird's eye view", above the details of data transfer, transports, etc. For example, this is done in the specialized server-push engine lightstreamer.

Connections to the server are divided into two types

1. Control connection - control connections, through which the client sends requests to the server. These are normal AJAX requests via XMLHTTPRequest.
2. Push connection(channel) - stream of events, connection through which the client receives events from the server

All events on the server have a type. The client can subscribe and unsubscribe to events of interest through control connections. For convenience, the types are organized into diagrams. For example, a chat schema might have a message type.

For example, the following diagram describes a typical sequence of actions:

1. The client opens a streaming connection to the server
2. The client subscribes to events of type Item1 in Schema1
3. Server sends events
4. The client unsubscribes from events via a new control connection
5. The client closes the connection

Or - here is a more complex diagram in which the client already subscribes to different types events:

Lightstreamer uses iframe as transport. From time to time it must be closed to clear the received objects. When the session is closed (the same happens when the page is refreshed in the browser), the server buffers new events until a certain timeout and sends them as soon as a new Stream Connection 2 session of the same user opens.

In general, event buffering is a general technique that allows you to smoothly survive the closure of a connection, and is needed for any transport.