Памятка для тех, кто не хочет платить за отсутствие маски

А за что, собственно, на нас составляют протоколы?

По словам известного медицинского адвоката Дмитрия Айвазяна, фундаментальные – значит, основные – права и обязанности граждан указаны в соответствующем разделе Конституции и в декларации, ратифицированной нашей страной, по правам человека.

И, к удивлению некоторых, понятий «маски» и «перчатки» там нет.

Проще говоря, отсутствует обязанность изолироваться в ситуации, когда ты здоров.

Другое дело, когда имеются очевидные признаки заболевания, которое может потенциально быть опасным или вредным для окружающих. Эти положения прописаны и в санитарно-эпидемиологическом законодательстве, и в соответствующих нормативных актах, регламентирующих порядок поведения лиц, имеющих определённые заболевания: туберкулёз, сифилис, ВИЧ. То есть за заведомое нарушение правил грозит административная или даже уголовная ответственность,

– объясняет эксперт.

И вот, если принимать во внимание законодательство местного самоуправления и регионов, вводящих подобные понятия, то они вступают в противоречие с федеральным законодательством: всё потому же – ввиду отсутствия там подобных норм.

«И если суд принимает к производству соответствующее административное дело, то там тоже есть разные обстоятельства: к примеру, лицо находилось без маски в месте скученности людей, и на него составили протокол в административном порядке. Что, по правилам, должно быть?

А теперь просто рассуждаем логически.

Представляем себе теоретическую ситуацию: экспертиза всё-таки проводится и указывает, что человек, на которого составили протокол, был здоров. Соответственно, в этой ситуации не возникает никаких обстоятельств, когда его можно обвинить в нарушении закона!

Сам по себе масочный режим, надо понимать, он носит рекомендательный характер. У нас же, в силу правового нигилизма – незнания законов со стороны населения, всё это перевёрнуто, и вменяется в обязанность. Значит – очевидное и явное нарушение и ущемление основных прав и свобод: передвигаться свободно, не причиняя при этом ни реальный, ни потенциальный вред окружающим,

– констатирует адвокат.

К сожалению, пока что нет официального обзора судебной практики по применению этих норм со стороны Верховного суда – иначе, считает Дмитрий Айвазян, это был бы нонсенс, если бы ВС или КС утвердили подобные «нарушения», поскольку разрушатся основы права.

В свою очередь, юристы коллегии адвокатов «Право вето» отмечают, что суды при рассмотрении административных дел за «нарушение масочного режима», например, в Ростовской области опираются на нормативно-правовой акт субъекта Федерации о «введении режима повышенной готовности», но такой режим и не предполагает обязательного ношения масок и перчаток.

Почему надо бить тревогу

Для начала, давайте разберемся, что же такое представляет собой ошибка «В данной транзакции уже происходили ошибки». Это, на самом деле, предельно простая штука: вы пытаетесь работать с базой данных внутри уже откаченной (отмененной) транзакции. Например, где-то был вызван метод ОтменитьТранзакцию, а вы пытаетесь ее зафиксировать.

Почему это плохо? Потому что данная ошибка ничего не говорит вам о том, где на самом деле случилась проблема. Когда в саппорт от пользователя приходит скриншот с таким текстом, а в особенности для серверного кода, с которым интерактивно не работает человек — это… Хотел написать «критичная ошибка», но подумал, что это buzzword, на который уже никто не обращает внимания…. Это задница.

Это ошибка программирования. Это не случайный сбой. Это косяк, который надо немедленно переделывать. Потому что, когда у вас фоновые процессы сервера встанут ночью и компания начнет стремительно терять деньги, то «В данной транзакции уже происходили ошибки» это последнее, что вы захотите увидеть в диагностических логах.

Есть, конечно, вероятность, что технологический журнал сервера (он ведь у вас включен в продакшене, да?) как-то поможет диагностировать проблему, но я сейчас навскидку не могу придумать вариант — как именно в нем найти реальную причину указанной ошибки. А реальная причина одна — программист Вася получил исключение внутри транзакции и решил, что

один раз — не карабас

«подумаешь, ошибка, пойдем дальше».

Это может быть опасно — убедитесь, что у вас есть локальная копия ветки, которую нужно повторно отправить.

Также обратите внимание: вы не хотите этого делать, если над веткой может работать кто-то другой.

git push --delete (branch_name) ## remove public version of branch 

Очистите ветку локально, а затем заново …

git push origin (branch_name) 

В нормальном случае вам, вероятно, не нужно беспокоиться о том, что история коммитов вашей частной ветки будет нетронутой. Просто нажмите последующую фиксацию (см. «Как отменить публичную фиксацию» выше), а затем выполните сквош-слияние, чтобы скрыть историю.

• 11 gitk --all $(git reflog | cut -c1-7)& может быть полезно для поиска предыдущей ревизии, если вы хотите отменить фиксацию ‘—amend’.
• 6 Следует отметить, что если вы пытаетесь удалить секретную информацию перед отправкой в ​​общий репозиторий, выполнение отката вам не поможет, потому что информация все еще будет в истории в предыдущем коммите. Если вы хотите, чтобы изменение никогда не было видно другим, вам нужно использовать git reset
• Я думаю, что «частный» / «общедоступный» правильнее было бы быть «локальным» / «удаленным».
• Исправить частную ветку в удаленном репозитории также можно, просто git push origin (branch_name) --force

Если вы хотите отменить его навсегда и клонировали какой-то репозиторий

Идентификатор фиксации можно увидеть

git log 

Тогда вы можете сделать —

git reset --hard git push origin -f 

• Что делать, если вы не используете «»и просто использовать» git reset —hard «? Обычно я просто хочу избавиться от моих последних обновлений, которые я еще не зафиксировал, и вернуться к последней сделанной мной фиксации, и я всегда использую» git reset —hard » .
• 6 @JaimeMontoya Чтобы отменить последние изменения, вы можете использовать git reset --hard , но если вам нужно жестко удалить последние «n» коммитов, вы указываете SHA

Если вы совершили мусор, но не подтолкнули,

git reset --soft HEAD~1 

ГОЛОВА ~ 1 это сокращение от коммита перед головой. В качестве альтернативы вы можете обратиться к SHA-1 хеша, если вы хотите выполнить сброс. —мягкий опция удалит фиксацию, но оставит все ваши измененные файлы «Изменения для фиксации», как сказал бы git status.

Если вы хотите избавиться от любых изменений в отслеживаемых файлах в рабочем дереве с момента фиксации перед заголовком, используйте «—жесткий«вместо этого.

ИЛИ ЖЕ

Если вы уже нажали, а кто-то потянул, что обычно бывает в моем случае, вы не можете использовать git сбросить. Однако вы можете сделать git revert,

git revert HEAD 

Это создаст новую фиксацию, которая отменяет все, что было внесено случайной фиксацией.

• У меня второй случай, но когда я делаю «git revert HEAD», он говорит: «Ошибка: фиксация [ID] — это слияние, но не задана опция -m. Fatal: revert failed». Какие-либо предложения?
• 4 Наверное, стоит упомянуть, что вместо HEAD~1 вы можете использовать фактический хеш, отображаемый git log --stat или по git reflog — полезно, когда вам нужно «отменить» более одной фиксации.

В SourceTree (графический интерфейс для GitHub) вы можете щелкнуть фиксацию правой кнопкой мыши и выполнить «Обратную фиксацию». Это должно отменить ваши изменения.

На терминале:

В качестве альтернативы вы можете использовать:

git revert 

Или же:

git reset --soft HEAD^ # Use --soft if you want to keep your changes. git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes. 

Одна команда:

git reset --soft 'HEAD^' 

Отлично работает, чтобы отменить последнюю локальную фиксацию!

• 15 Мне нужно было написать git reset —soft «HEAD ^» в двойных кавычках, потому что я пишу это из командной строки Windows.

Просто сбросьте его, выполнив команду ниже, используя git:

git reset --soft HEAD~1 

Объясните: какие git reset делает, это в основном reset к любой фиксации, к которой вы хотите вернуться, а затем, если вы объедините ее с —soft key, он вернется, но сохранит изменения в вашем файле (ах), чтобы вы вернулись на этап, на котором файл был только что добавлен, HEAD является главой филиала, и если совместить с ~1 (в этом случае вы также используете HEAD^), он вернется только к одной фиксации, которую вы хотите …

Я создаю шаги на изображении ниже более подробно для вас, включая все шаги, которые могут произойти в реальных ситуациях, и фиксацию кода:

Как отменить последний коммит Git?

Чтобы восстановить все, как было до последней фиксации, нам нужно выполнить сброс до фиксации перед HEAD.

1. Если вы не хотите сохранять внесенные вами изменения:

   git reset --hard HEAD^ 

2. Если вы хотите сохранить изменения:

   git reset --soft HEAD^ 

Теперь проверьте свой журнал git. Это покажет, что наша последняя фиксация была удалена.

«Сбросить рабочее дерево до последней фиксации»

git reset --hard HEAD^ 

«Очистить неизвестные файлы из рабочего дерева»

git clean 

см. — Краткий справочник Git

ЗАМЕТКА: Эта команда удалит вашу предыдущую фиксацию, поэтому используйте ее с осторожностью! git reset —hard безопаснее.

Используйте reflog, чтобы найти правильное состояние

git reflog 

РЕФЛОГ ПЕРЕД СБРОСОМ

Выберите правильный журнал ссылок (в моем случае — f3cb6e2) и введите

git reset --hard f3cb6e2 

После этого HEAD репо будет сброшен на этот HEADid

ЖУРНАЛ ПОСЛЕ СБРОСА

Наконец, рефлог выглядит как на картинке ниже

РЕФЛОГ ФИНАЛ

Первый забег:

git reflog 

Он покажет вам все возможные действия, которые вы выполнили в своем репозитории, например, фиксацию, слияние, извлечение и т. Д.

Затем сделайте:

git reset --hard ActionIdFromRefLog 

Что такое транзакции в 1с

Неловко писать про азбучные истины, но, видимо, немножго придется. Транзакции в 1С — это то же самое, что транзакции в СУБД. Это не какие-то особенные «1С-ные» транзакции, это и есть транзакции в СУБД. Согласно общей идее транзакций, они могут либо выполниться целиком, либо не выполниться совсем. Все изменения в таблицах базы данных, выполненные внутри транзакции, могут быть разом отменены, как будто ничего не было.

Далее, нужно понимать, что в 1С не поддерживаются вложенные транзакции. Собственно говоря, они не поддерживаются не «в 1С», а вообще не поддерживаются. По-крайней мере, теми СУБД, с которыми умеет работать 1С. Вложенных транзакций, например, нет в MS SQL и Postgres.

Каждый «вложенный» вызов НачатьТранзакцию просто увеличивает счетчик транзакций, а каждый вызов «ЗафиксироватьТранзакцию» — уменьшает этот счетчик. Данное поведение описано в множестве книжек и статей, но выводы из этого поведения, видимо, разобраны недостаточно. Строго говоря, в SQL есть т.н. SAVEPOINT, но 1С их не использует, да и вещь это достаточно специфичная.

Здесь и далее, специально для Воинов Истинной Веры, считающих, что код должен писаться только на английском, под спойлерами будет приведен аналог кода в англоязычном синтаксисе 1С.

Процедура ОченьПолезныйИВажныйКод(СписокСсылокСправочника) НачатьТранзакцию(); Для Каждого Ссылка Из СписокСсылокСправочника Цикл ОбъектСправочника = Ссылка.ПолучитьОбъект(); ОбъектСправочника.КакоеТоПоле = "Я изменен из программного кода"; ОбъектСправочника.Записать(); КонецЦикла; ЗафиксироватьТранзакцию();
КонецПроцедуры

Вы же наверняка пишете такой код, да? Приведенный пример кода содержит ошибки. Как минимум, три. Знаете какие? Про первую я скажу сразу, она связана с объектными блокировками и не имеет отношения непосредственно к транзакциям. Про вторую — чуть позже.

Третья ошибка — это deadlock, который возникнет при параллельном исполнении этого кода, но это тема для отдельной статьи, ее рассматривать сейчас не будем, дабы не усложнять код. Ключевое слово для гугления: deadlock управляемые блокировки.

Обратите внимание, простой ведь код. Такого в ваших 1С-системах просто вагон. И он содержит сразу, как минимум, 3 ошибки. Задумайтесь на досуге, сколько ошибок есть в более сложных сценариях работы с транзакциями, написанных вашими программистами 1С 🙂

Reflog

Если вы ошиблись, вы всегда можете использовать журнал ссылок, чтобы найти упавшие коммиты:

$ git reset @~ $ git reflog c4f708b [email protected]{0}: reset: moving to @~ 2c52489 [email protected]{1}: commit: added some .class files $ git reset 2c52489 ... and you're back where you started 

• 3 Для тех, кто читает в будущем — обратите внимание, что git revert это отдельная команда, которая по сути «сбрасывает» один коммит.

Использовать git revert .

Чтобы получить идентификатор фиксации, просто используйте git log.

• 18 Что это значит, вишенка выбирает коммит? В моем случае я был не на той ветке, когда редактировал файл. Я совершил это, а затем понял, что попал не в ту ветку. Использование «git reset —soft HEAD ~ 1» вернуло меня к состоянию непосредственно перед фиксацией, но теперь, если я проверю правильную ветку, как мне отменить изменения в файле в неправильной ветке, а вместо этого сделать их (в том же названии файл) в правильную ветку?
• Я просто использовал git revert commit-id работал как шарм. Конечно, тогда вам нужно будет продвигать свои изменения.
• 9 Я считаю, что это было бы git cherry-pick <<erroneous-commit-sha>> @astronomerdave. От, мистер Почти-2-летнего опоздания на вечеринку.
• @Kris: Вместо вишневого выбора используйте rebase. Потому что это расширенный сбор вишни
• Я бы использовал возврат только в том случае, если я уже отправил свою фиксацию. В противном случае сброс — лучший вариант. Не забывайте, что откат создает новую фиксацию, и обычно это не цель.

Если вы планируете полностью отменить локальную фиксацию, все, что вы изменили, вы сделали в фиксации, и если вас это не беспокоит, просто выполните следующую команду.

git reset --hard HEAD^1 

(Эта команда проигнорирует всю вашу фиксацию, и ваши изменения будут полностью потеряны из вашего локального рабочего дерева). Если вы хотите отменить фиксацию, но хотите, чтобы ваши изменения находились в промежуточной области (перед фиксацией, как и после git add) затем выполните следующую команду.

git reset --soft HEAD^1 

Теперь ваши зафиксированные файлы попадают в промежуточную область. Предположим, если вы хотите отложить файлы, потому что вам нужно отредактировать какой-то неправильный контент, выполните следующую команду

git reset HEAD 

Теперь зафиксированные файлы должны поступать из подготовленной области в неустановленную. Теперь файлы готовы к редактированию, поэтому все, что вы меняете, вы хотите отредактировать, добавить и сделать новую / новую фиксацию.

Подробнее (ссылка не работает) (Архивная версия)

• 14 @SMR, в вашем примере все указывают только на текущую HEAD. ГОЛОВА ^ = ГОЛОВА ^ 1. А также HEAD ^ 1 = HEAD ~ 1. Когда вы используете HEAD ~ 2, есть разница между символами ~ и ^. Если вы используете ~ 2, это означает, что первый родитель первого родителя, или дедушка или бабушка .

Если у вас установлен Git Extras, вы можете запустить git undo чтобы отменить последнюю фиксацию. git undo 3 отменит последние три фиксации.

Я хотел отменить последние пять коммитов в нашем общем репозитории. Я нашел идентификатор ревизии, к которой хотел откатиться. Затем я ввел следующее.

prompt> git reset --hard 5a7404742c85 HEAD is now at 5a74047 Added one more page to catalogue prompt> git push origin master --force Total 0 (delta 0), reused 0 (delta 0) remote: bb/acl: neoneye is allowed. accepted payload. To [email protected]:thecompany/prometheus.git 09a6480...5a74047 master -> master (forced update) prompt> 

А теперь про транзакции

С первой ошибкой разобрались, давайте перейдем ко второй.

Если не предусмотреть проверку исключения в этом методе, то исключение (например, весьма вероятное на методе «Записать()») выбросит вас из данного метода без завершения транзакции. Исключение из метода «Записать» может быть выброшено по самым разным причинам, например, сработают какие-то прикладные проверки в бизнес-логике, или возникнет упомянутая выше объектная блокировка. Так или иначе, вторая ошибка гласит: код, начавший транзакцию, не несет ответственность за ее завершение.

Именно так я бы назвал эту проблему. В нашем статическом анализаторе кода 1С на базе SonarQube мы даже отдельно встроили такую диагностику. Сейчас я работаю над ее развитием, и фантазия программистов 1С, чей код попадает ко мне на анализ, порой приводит меня в шок и трепет…

Почему? Потому что выброшенное наверх исключение внутри транзакции в 90% случаев не даст эту транзакцию зафиксировать и приведет к ошибке. Следует понимать, что 1С автоматически откатывает незавершенную транзакцию только после возвращения из скриптового кода на уровень кода платформы. До тех пор, пока вы находитесь на уровне кода 1С, транзакция остается активной.

Поднимемся на уровень выше по стеку вызовов:

Процедура ВажныйКод() СписокСсылок = ПолучитьГдеТоСписокСсылок(); ОченьПолезныйИВажныйКод(СписокСсылок);
КонецПроцедуры

Смотрите, что получается. Наш проблемный метод вызывается откуда-то извне, выше по стеку. На уровне этого метода разработчик понятия не имеет — будут ли какие-то транзакции внутри метода ОченьПолезныйИВажныйКод или их не будет. А если будут — то будут ли они все завершены… Мы же все тут за мир и инкапсуляцию, верно?

Автор метода «ВажныйКод» не должен думать про то, что именно происходит внутри вызываемого им метода. Того самого, в котором некорректно обрабатывается транзакция. В итоге, попытка поработать с базой данных после выброса исключения изнутри транзакции, с высокой вероятностью приведет к тому, что «В данной транзакции бла-бла…»

Вариант 4: вы сделали git reset —hard и нужно вернуть этот код

Еще кое-что: Предположим, вы уничтожили фиксацию как в первом примере, но потом обнаруживаешь, что тебе это все-таки нужно? Не повезло, правда?

Нет, есть Все еще способ вернуть его. Тип git reflog и вы увидите список (частичных) shas фиксации (то есть хэшей), в которые вы переместились. Найдите уничтоженную фиксацию и сделайте следующее:

git checkout -b someNewBranchName shaYouDestroyed 

Теперь вы воскресили этот коммит. На самом деле коммиты не уничтожаются в Git в течение примерно 90 дней, поэтому вы обычно можете вернуться и спасти тот, от которого не собирались избавляться.

• 31 ОСТОРОЖНО! Это могло бы не сработать, если бы ваша ошибочная фиксация была слиянием (перемоткой вперед)! Если ваша голова находится в фиксации слияния (например, функция слияния ветки в мастер), git reset --hard~1 укажет главной веткой на последний коммит внутри функциональной ветки. В этом случае следует использовать конкретный идентификатор фиксации вместо относительной команды.
• 6 Учтите, что число в HEAD~1 можно заменить на любое положительное целое число, например HEAD~3. Это может показаться очевидным, но новички (такие как я) очень осторожны при запуске команд git, поэтому они могут не захотеть рискнуть что-то испортить, тестируя эти вещи самостоятельно.
• 123 Отсутствует важный момент: если упомянутая фиксация была ранее «отправлена» на удаленный компьютер, любая операция «отмены», какой бы простой она ни была, вызовет огромную боль и страдания для остальных пользователей, у которых есть эта фиксация в их локальной копии. , когда они в будущем сделают «git pull». Итак, если фиксация уже была отправлена, сделайте это: git revert git push origin:
• 20 @FractalSpace, это не вызовет «огромной боли и страданий». Я сделал несколько принудительных толчков при использовании Git в команде. Все, что нужно, — это общение.
• 20 @Kyralessa На моем рабочем месте испорченный рабочий процесс всей команды, а затем рассказ им, как исправить дерьмо, не называется «общением». git history re-write — это деструктивная операция, которая приводит к удалению частей репо. Настаивать на его использовании при наличии ясных и безопасных альтернатив просто безответственно.

Есть два способа «отменить» вашу последнюю фиксацию, в зависимости от того, сделали ли вы уже свою фиксацию общедоступной (отправленной в удаленный репозиторий):

Заменить последнюю фиксацию на новую:

git commit --amend -m 'message' 

Он заменит последнюю фиксацию на новую.

По-другому:

Проверьте ветку, которую вы хотите вернуть, затем сбросьте локальную рабочую копию обратно на фиксацию, которую вы хотите сделать последней на удаленном сервере (все, что после нее, будет до свидания). Для этого в SourceTree я щелкнул правой кнопкой мыши и выбрал «Reset BRANCHNAME to this commit».

Затем перейдите в локальный каталог вашего репозитория и выполните эту команду:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME 

Это сотрет все коммиты после текущего в вашем локальном репозитории, но только для этой одной ветки.

Тип git log и найдите последний хэш-код фиксации, а затем введите:

git reset 

В моем случае я случайно зафиксировал некоторые файлы, которые не хотел. Итак, я сделал следующее, и это сработало:

git reset --soft HEAD^ git rm --cached [files you do not need] git add [files you need] git commit -c ORIG_HEAD 

Проверьте результаты с помощью gitk или git log —stat

Просто запустите это в командной строке:

git reset --soft HEAD~ 

Есть два основных сценария

Вы еще не нажали коммит

Если проблема заключалась в добавленных вами дополнительных файлах (и они не нужны вам в репозитории), вы можете удалить их, используя git rm а затем совершая с —amend

git rm 

Вы также можете удалить целые каталоги с помощью -rили даже в сочетании с другими командами Bash

git rm -r git rm $(find -name '*.class') 

После удаления файлов вы можете выполнить фиксацию с помощью — изменить вариант

git commit --amend -C HEAD # the -C option is to use the same commit message 

Это перепишет вашу недавнюю локальную фиксацию, удалив лишние файлы, поэтому эти файлы никогда не будут отправлены на push, а также будут удалены GC из вашего локального репозитория .git.

Вы уже нажали коммит

Вы можете применить то же решение из другого сценария, а затем выполнить git push с -f вариант, но это не рекомендуется так как он перезаписывает удаленную историю с другим изменением (это может испортить ваш репозиторий).

Вместо этого вы должны выполнить фиксацию без —amend (помните об -amend`: эта опция переписывает историю последней фиксации).

Как отменить публичную фиксацию

Если вы уже сделали свои коммиты общедоступными, вы захотите создать новый коммит, который «отменит» изменения, сделанные вами в предыдущем коммите (текущая HEAD).

git revert HEAD 

Теперь ваши изменения будут отменены и готовы к фиксации:

git commit -m 'restoring the file I removed by accident' git log commit 102: restoring the file I removed by accident commit 101: removing a file we don't need commit 100: adding a file that we need 

Для получения дополнительной информации ознакомьтесь с Основы Git — Отмена вещей.

Добавляйте / удаляйте файлы, чтобы добиться желаемого результата:

git rm classdir git add sourcedir 

Затем измените фиксацию:

git commit --amend 

Предыдущая ошибочная фиксация будет отредактирована, чтобы отразить новое состояние индекса — другими словами, это будет похоже на то, что вы вообще не совершали ошибки.

Обратите внимание, что вы должны делать это только в том случае, если вы еще не нажали. Если вы нажали, вам просто нужно зафиксировать исправление в обычном режиме.

• 4 FYI: это удаляет все мои файлы, и я потерял изменения.
• UPD: Однако я восстановил его с помощью reflog. Но квитанция не сработала для первоначального коммита.
• 3 Использование git rm --cached чтобы файлы оставались в файловой системе и удалялись только из индекса git!

git rm yourfiles/*.class git commit -a -m 'deleted all class files in folder 'yourfiles'' 

или же

git reset --hard HEAD~1 

Предупреждение: указанная выше команда навсегда удалит изменения в .java файлы (и любые другие файлы), которые вы хотели зафиксировать.

В hard reset к HEAD-1 установит вашу рабочую копию в состояние фиксации перед ошибкой фиксации.

• 22 git commit -a -m '' или же git commit -am '' естественно! :]
• Еще одно «сокращенное» использование тайника; если вы хотите отключить все (отменить git add), просто git stash, тогда git stash pop

Методы работы с транзакциями в 1с

Не будет лишним напомнить, что вообще 1С предоставляет нам для работы с транзакциями. Это всем известные методы:

Первые 3 метода очевидны и делают то, что написано в их названии. Последний метод — возвращает Истину, если счетчик транзакций больше нуля.

И есть интересная особенность. Методы выхода из транзакции (Зафиксировать и Отменить) выбрасывают исключения, если счетчик транзакций равен нулю. То есть, если вызвать один из них вне транзакции, то возникнет ошибка.

Как правильно пользоваться этими методами? Очень просто: надо прочитать сформулированное выше правило: код, начавший транзакцию, должен нести ответственность за ее завершение.

Как же соблюсти это правило? Давайте попробуем:

НачатьТранзакцию();
ДелаемЧтоТо();
ЗафиксироватьТранзакцию();

Выше мы уже поняли, что метод ДелаемЧтоТо — потенциально опасен. Он может выдать какое-то исключение, и транзакция «вылезет» наружу из нашего метода. Окей, добавим обработчик возможного исключения:

НачатьТранзакцию();
Попытка ДелаемЧтоТо();
Исключение // а что же написать тут?
КонецПопытки;
ЗафиксироватьТранзакцию();

Отлично, мы поймали возникающую ошибку, но что с ней делать? Записать сообщение в лог? Ну, может быть, если код логирования ошибок должен быть именно на этом уровне и ошибку мы тут ждем. А если нет? Если мы не ожидали тут никаких ошибок? Тогда мы должны просто передать это исключение выше, пусть с ними разбирается другой слой архитектуры.

НачатьТранзакцию();
Попытка ДелаемЧтоТо();
Исключение ВызватьИсключение;
КонецПопытки;
ЗафиксироватьТранзакцию();

Так, стоп… Если мы просто прокидываем исключение дальше, то зачем тут вообще нужна Попытка? А вот зачем: правило заставляет нас обеспечить завершение начатой нами транзакции.

НачатьТранзакцию();
Попытка ДелаемЧтоТо();
Исключение ОтменитьТранзакцию(); ВызватьИсключение;
КонецПопытки;
ЗафиксироватьТранзакцию();

Теперь, вроде бы, красиво. Однако, мы ведь помним, что не доверяем коду ДелаемЧтоТо(). Вдруг там внутри его автор не читал этой статьи, и не умеет работать с транзакциями? Вдруг он там взял, да и вызвал метод ОтменитьТранзакцию или наоборот, зафиксировал ее?

Нам очень важно, чтобы обработчик исключения не породил нового исключения, иначе исходная ошибка будет потеряна и расследование проблем станет невозможным. А мы помним, что методы Зафиксировать и Отменить могут выдать исключение, если транзакция не существует. Здесь-то и пригождается метод ТранзакцияАктивна.

Мне пришел штраф через приложение «социальный мониторинг», но я не нарушал режим самоизоляции. как быть?

Объектные блокировки

Итак, первая ошибка. В 1С существуют объектные блокировки, так называемые «оптимистические» и «пессимистические». Кто придумал термин, не знаю, убил бы :). Совершенно невозможно запомнить, какая из них за что отвечает. Подробно про них написано здесь и здесь, а также в прочей IT-литературе общего назначения.

Суть проблемы в том, что в указанном примере кода изменяется объект базы данных, но в другом сеансе может сидеть интерактивный пользователь (или соседний фоновый поток), который тоже будет менять этот объект. Здесь один из вас может получить ошибку «запись была изменена или удалена».

Если это произойдет в интерактивном сеансе, то пользователь почешет репу, ругнется и попробует переоткрыть форму. Если это произойдет в фоновом потоке, то вам придется искать это в логах. А журнал регистрации, как вы знаете, медленный, а ELK-стек для журналов 1С у нас в отрасли настраивают единицы… (мы, к слову, входим в число тех, кто настраивает и другим помогает настраивать :))

Короче говоря, это досадная ошибка и лучше, чтобы ее не было. Поэтому, в стандартах разработки четко написано, что перед изменением объектов необходимо ставить на них объектную блокировку методом «ОбъектСправочника.Заблокировать()». Тогда параллельный сеанс (который тоже должен так поступить) не сможет начать операцию изменения и получит ожидаемый, управляемый отказ.

Первый подход типичного 1с-ника

Обычно программисты 1С знают, что при записи может быть выдано исключение. А еще они боятся исключений, поэтому стараются их все перехватывать. Например, вот так:

Процедура ОченьПолезныйИВажныйКод(СписокСсылокСправочника) НачатьТранзакцию(); Для Каждого Ссылка Из СписокСсылокСправочника Цикл ОбъектСправочника = Ссылка.ПолучитьОбъект(); ОбъектСправочника.КакоеТоПоле = "Я изменен из программного кода"; Попытка ОбъектСправочника.Записать(); Исключение Лог.Ошибка("Не удалось записать элемент %1", Ссылка); Продолжить; КонецПопытки; КонецЦикла; ЗафиксироватьТранзакцию();
КонецПроцедуры

Ну как, стало лучше, да? Ведь теперь, возможные ошибки записи обрабатываются и даже логируются. Исключения больше не возникнут при записи объекта. И в логе даже видно — на каком объекте, не поленился, вывел в сообщение ссылку вместо лаконичного «Ошибка записи справочника», как это часто любят писать вечно торопящиеся разработчики. Иными словами, налицо забота о пользователе и рост компетенций.

Однако, опытный 1С-ник здесь скажет, что нет, лучше не стало. По сути ничего не поменялось, а может даже стало и хуже. В методе «Записать()» платформа 1С сама начнет транзакцию записи, и эта транзакция будет уже вложенной по отношению к нашей. И если в момент работы с базой данных 1С свою транзакцию откатит (например, будет выдано исключение бизнес-логики), то наша транзакция верхнего уровня все равно будет помечена как «испорченная» и ее нельзя будет зафиксировать. В итоге этот код так и останется проблемным, и при попытке фиксации выдаст «уже происходили ошибки».

А теперь представьте, что речь идет не о маленьком методе, а о глубоком стеке вызовов, где в самом низу кто-то взял и «выпустил» начатую транзакцию из своего метода. Верхнеуровневые процедуры могут и понятия не иметь, что кто-то там внизу начинал транзакции. В итоге, весь код валится с невнятной ошибкой, которую расследовать невозможно в принципе.

Код, который начинает транзакцию, обязан завершить или откатить ее. Не взирая ни на какие исключения. Каждая ветка кода должна быть исследована на предмет выхода из метода без фиксации или отмены транзакции.

Размазывание транзакций по методам

Второе правило «транзакционно-безопасного» кода: счетчик ссылок транзакций в начале метода и в его конце должен иметь одно и то же значение. Нельзя начинать транзакцию в одном методе и завершать ее в другом. Из этого правила, наверное, можно найти исключения, но это будет какой-то низкоуровневый код, который пишут более компетентные люди. В общем случае так писать нельзя.

Например:

Процедура ВажныйКод() СписокСсылок = ПолучитьГдеТоСписокСсылок(); ОченьПолезныйИВажныйКод(СписокСсылок); ЗафиксироватьТранзакцию(); // Путевка в ад, серьезный разговор с автором о наших сложных трудовых отношениях.
КонецПроцедуры

Выше — неприемлемый говнокод. Нельзя писать методы так, чтобы вызывающая сторона помнила и следила за возможными (или вероятными — как знать) транзакциями внутри других методов, которые она вызывает. Это нарушение инкапсуляции и разрастание спагетти-кода, который невозможно трассировать, сохраняя рассудок.

Особенно весело вспомнить, что реальный код намного больше синтетических примеров из 3-х строчек. Выискивать начинающиеся и завершающиеся транзакции по шести уровням вложенности — это прям мотивирует на задушевные беседы с авторами.

Решили пополнить казну за счёт «безмасочников»

На конец ноября МВД, которое, несмотря на наделение соответствующими полномочиями инспектором Роспотребнадзора, выписывает львиную долю административных протоколов, отчитывалось, что всего по стране за нарушение режимов повышенной готовности, карантина и самоизоляции (если кто позабыл, такое было – и сохраняется сейчас для людей старшего возраста, а также имеющих хронические заболевания), к ответственности привлекли свыше миллиона (!) человек.

И оштрафовали их в совокупности примерно на 1,7 млрд рублей: получается, в среднем назначали 1700 рублей на каждого нарушителя.

При этом ещё в середине октября власти Москвы сообщали, что за пять месяцев действия перчаточно-масочного режима (на тот момент, соответственно) оформили без малого сто тысяч протоколов непосредственно в столичном мегаполисе – на общую сумму в 480 млн рублей.

Как вам такое?

Экономика просела, бизнес вопит о том, что еле выживает, масса людей осталась без работы, а городская казна зарабатывает – по-московски, цинично и жёстко, не обращая внимания ни на что. Полмиллиарда – будьте любезны!

Но – спокойно, граждане, спокойно.

Называя эти цифры, власти, мягко говоря, лукавят – точнее, весьма основательно вводят в заблуждение.

В реальности речь идёт не о назначенных судами штрафах (это и по всей стране, и по Москве в частности), а только о составленных полицией (инспекторами) административных протоколах – зачастую со скандалами, закручиванием рук и препровождением «особо опасных преступников» в участки.

Судебная практика говорит о другом.

В своё время, на заре пандемии, когда суды в регионах начали было штамповать штрафы по ч. 2 статьи 6.3 КоАП России («Нарушение законодательства в области обеспечения санитарно-эпидемиологического благополучия населения»), предусматривающей наказание от 15 до 40 тысяч рублей, Верховный суд вынужден был давать разъяснения – о том, что речь в этом нормативном акте идёт именно о тех, кто потенциально опасен для окружающих. То есть, получив, например, положительный тест на ковид, отправился «гулять».

К остальным рекомендовалось применять более мягкую статью 20.6.1 («Невыполнение правил поведения при чрезвычайной ситуации или угрозе её возникновения»), в которой штраф начинается от тысячи рублей, а то и вовсе грозит только предупреждение.

И – да, важный момент: ВС предписывает соблюдать принцип соразмерности, пропорциональности и справедливости наказания.

Но Москва, например, посчитала, что федерального Кодекса об административных правонарушениях для жителей столицы маловато, и ввела собственную норму, в КоАП Москвы – ст. 3.18.1, предусматривающей наказание для «нарушителей режима повышенной готовности», введённое мэром Сергеем Собяниным.

И там штраф уже больше – 4 тысячи рублей.

Суды отменяют наказания

Вот только есть, что называется, нюансы. Во-первых, из почти 60 тысяч обжалованных москвичами административных протоколов (данные на середину октября, общая сумма требований – на 270 млн рублей) в 90 процентах рассмотренных случаев суд встал на сторону людей.

Причём, как следует из исследования Forbes, практически все отменённые наказания были назначены по московскому (привет мэрии!), а не по российскому законодательству.

А вот – аналитика сервиса DestraLegal, запустившего онлайн-услугу составления жалоб на подобные штрафы.

Мы собрали такую статистику. Половина получила предупреждения вместо штрафа в 5000 рублей, двадцати процентам штраф был снижен до 1000 рублей, остальным штраф оставили без изменений. В основном отменяют штрафы в случаях, когда человек только зашёл в метро и ещё не успел надеть маску или перчатки, но его уже сфотографировал сотрудник. Даже так бывало: люди засыпали в метро, и маска сползла, вследствие чего они получали штраф. Мы понимаем, что маски – это важно, но везде должны быть разумные пределы. Такие штрафы суды в Москве часто отменяют,

– констатируют аналитики.

Во-вторых, статья 20.6.1 КоАП РФ указывает, что наказание следует за действия (или бездействие), «повлекшие причинение вреда здоровью человека или имуществу». Но кто, простите, фиксирует, повлекло ли, скажем, отсутствие маски или перчаток то самое «причинение вреда» кому-либо?

Однако мэрия столицы, видимо, понимая как раз этот момент, руководствуясь указом Собянина от 25 сентября, указывает, что в Москве продолжают действовать «ограничения, установленные ранее», в том числе – обязательность «использования средств индивидуальной защиты органов дыхания (маски, респираторы)», по сути, повсеместно.

И вот здесь – уже третий любопытнейший момент.

Расшифровка, данная в скобочках (касательно СИЗов для органов дыхания), фактически… «дополняет» установленный государством ГОСТ 12.4.011-89, где (п. 2.2.) чётко прописано, что относится к перечню защитных средств: противогаз, респиратор, самоспасатель, пневмошлем, пневмомаска, пневмокуртка.

Иными словами, никаких масок там попросту нет! Совсем. И, к слову, производители масок указывают сами, что они не являются медицинскими и не предназначены для защиты от вирусов. Вот так-то.

А заставить восемь с лишним миллионов населения Москвы покупать респираторы… до этого, пожалуй, хватит прозорливости не дойти даже столичным властям.

Финальный вариант

Наконец, мы можем написать правильный, «транзакционно-безопасный» вариант кода. Вот он:

**UPD: в комментариях предложен более безопасный вариант, когда ЗафиксироватьТранзакцию расположен внутри блока Попытка. Здесь приведен именно этот вариант, ранее Фиксация располагалась после блока Попытка-Исключение.

НачатьТранзакцию();
Попытка ДелаемЧтоТо(); ЗафиксироватьТранзакцию();
Исключение Если ТранзакцияАктивна() Тогда ОтменитьТранзакцию(); КонецЕсли; ВызватьИсключение;
КонецПопытки;

Постойте, но ведь не только «ОтменитьТранзакцию» может выдавать ошибки. Почему же тогда «ЗафиксироватьТранзакцию» не обернут в такое же условие с «ТранзакцияАктивна»? Опять же, по тому же самому правилу: код, начавший транзакцию, должен нести ответственность за ее завершение.

Наша транзакция необязательно самая первая, она может быть вложенной. На нашем уровне абстракции мы обязаны заботиться только о нашей транзакции. Все прочие должны быть нам неинтересны. Они чужие, мы не должны нести за них ответственность. Именно НЕ ДОЛЖНЫ.

Нельзя предпринимать попыток выяснения реального уровня счетчика транзакций. Это опять нарушит инкапсуляцию и приведет к «размазыванию» логики управления транзакциями. Мы проверили активность только в обработчике исключения и только для того, чтобы убедиться, что наш обработчик не породит нового исключения, «прячущего» старое.

Чек-лист рефакторинга

Давайте рассмотрим несколько наиболее распространенных ситуаций, требующих вмешательства в код.

Паттерн:

НачатьТранзакцию();
ДелаемЧтоТо();
ЗафиксироватьТранзакцию();

Обернуть в «безопасную» конструкцию с Попыткой, Проверкой активности и пробросом исключения.

Паттерн:

Если Не ТранзакцияАктивна() Тогда НачатьТранзакцию()
КонецЕсли

Анализ и Рефакторинг. Автор не понимал, что делает. Начинать вложенные транзакции можно безопасно. Не нужно проверять условие, нужно просто начать вложенную транзакцию. Ниже по модулю он наверняка еще там извращается с их фиксацией. Это гарантированный геморрой.

Примерно похожий вариант:

Если ТранзакцияАктивна() Тогда ЗафиксироватьТранзакцию()
КонецЕсли

аналогично: фиксация транзакции по условию — это странно. Почему тут условие? Что, кто-то иной мог уже зафиксировать эту транзакцию? Повод для разбирательства.

Паттерн:

НачатьТранзакцию()
Пока Выборка.Следующий() Цикл // чтение объекта по ссылке // запись объекта
КонецЦикла;
ЗафиксироватьТранзакцию();

1. ввести управляемую блокировку во избежание deadlock
2. ввести вызов метода Заблокировать
3. обернуть в «попытку», как показано выше

Паттерн:

НачатьТранзакцию()
Пока Выборка.Следующий() Цикл Попытка Объект.Записать(); Исключение Сообщить("Не получилось записать"); КонецПопытки;
КонецЦикла;
ЗафиксироватьТранзакцию();

Данная транзакция уже не завершится в случае исключения. Нет смысла продолжать цикл. Код требуется переписать, сверяясь с исходной задачей. Дополнительно обеспечить более информативное сообщение об ошибке.

В заключение

Я, как вы уже, наверное, догадались, отношусь к людям, любящим платформу 1С и разработку на ней. К платформе, разумеется, есть претензии, особенно в среде Highload, но в общем и целом, она позволяет недорого и быстро разрабатывать очень качественные корпоративные приложения.

Давая из коробки и ORM, и GUI, и веб-интерфейс, и Reporting, и много чего еще. В комментариях на Хабре обычно пишут всякое высокомерное, так вот, ребята — основная проблема 1С, как экосистемы — это не платформа и не вендор. Это слишком низкий порог вхождения, который позволяет попадать в отрасль людям, не понимающим, что такое компьютер, база данных, клиент-сервер, сеть и всякое такое.

1С сделала разработку корпоративных приложений слишком легкой. Я за 20 минут могу написать на ней учетную систему для закупок/продаж с гибкими отчетами и веб-клиентом. После этого, мне несложно подумать о себе, что и на больших масштабах можно писать примерно так же. Как-то там 1С сама все внутри сделает, не знаю как, но наверное сделает. Напишу-ка я «НачатьТранзакцию()»….

И знаете — самое главное, что это прекрасно. Простота разработки в 1С позволяет моментально реализовывать бизнес-идеи и встраивать их в процессы компании. Потом всегда можно отрефакторить, главное понимать как. И если вдруг вам нужна помощь в аудите вашей «медленной 1С» — обращайтесь к специалистам по оптимизации. Она совсем не медленная.