- Manuals
- Brands
- CVS Manuals
- Cables and connectors
- DA-2000
- Instruction manual
-
Bookmarks
Quick Links
DA-2000
2×1 B&W Screen Splitter
Instruction Manual
Thank you for purchasing one of our products. Please read this manual before using this
product. When using this product, always follow the instructions contained in this manual,
and pay attention to the safety information.
Related Manuals for CVS DA-2000
Summary of Contents for CVS DA-2000
-
Page 1
DA-2000 2×1 B&W Screen Splitter Instruction Manual Thank you for purchasing one of our products. Please read this manual before using this product. When using this product, always follow the instructions contained in this manual, and pay attention to the safety information. -
Page 2
Do not expose this product to water, rain or moisture. Doing this can result in electric shock or fire. Never take this product apart or try to modify it. Doing so is very dangerous and could result in electric shock. Do not store this product near open flame. -
Page 3
The DSP-2000 is a 2 camera video screen splitter that does not require any genlock feeds for the cameras. By using digital technology CVS is able to capture and synchronize one camera to another so that the pictures can be split. The size, type and position of the split (Fig. -
Page 4
Camera Requirements: The DSP-2000 will work with 1 Color or B&W camera for input 1 and only a B&W camera for input 2 which is the digitized input. Both cameras must conform with RS-170A sync timing standards. This means they must also be interlaced with the proper pulse widths and sync frequencies. -
Page 5
For units with serial numbers before 201225 the vertical delay can be disable: The units are shipped with the variable vertical delay activated. If you are going to use a vertical split (2 pictures, side by side) you need to disable the vertical delay. For newer units simply turn the “Camera 2 Vertical Delay”… -
Page 6
·Set the front panel switch to the center split position. ·It is recommended that you center the controls and vary each one while observing the picture. This will give you a feel for the way each control effects the picture. ·Begin by adjusting the start of the split with the Height Start Control. -
Page 7
Fig. 6 Diagram P.O. Box 749 Peekskill, NY 10566 Tel: (845) 737-7009 Fax: (845) 737-0426 Web: www.compuvideosystems.com… -
Page 8
KEY FEATURES: ·High resolution: 910×525 memory ·TBC feature, mix DC and LL Cameras ·Industrial grade specifications ·Color or B&W master camera ·Electronic positioning of B camera ·UL listed Power Supply ·Made in the USA P.O. Box 749 Peekskill, NY 10566 Tel: (845) 737-7009 Fax: (845) 737-0426 Web: www.compuvideosystems.com… -
Page 9
P.O. Box 749 Peekskill, NY 10566 Tel: (845) 737-7009 Fax: (845) 737-0426 Web: www.compuvideosystems.com… -
Page 10
NOTES: P.O. Box 749 Peekskill, NY 10566 Tel: (845) 737-7009 Fax: (845) 737-0426 Web: www.compuvideosystems.com… -
Page 11: Limited Warranty
Compu-Video Systems Inc. to the user is free of charge. How To Get Service Please contact CVS by phone for return authorization number and then return the defective unit, transportation prepaid and a dated proof of purchase to: Compu-Video Systems Inc.
date_spec . date_spec — ������������ ��������, ��������� ���� �
�������.
������������ �������� ��������������, ����� �� ����������� �� ���
�������� ������ ����� ����� ��������� ������; �.�. ����� ��
��������� ������� ����, ��������� `-D’, CVS ���������� ����
����������������� ����, ��� ��� ���������� ���������� � ��� ��
���������� ����� ������������ �� �� ���� (���� �� �� ������������ ��
����).
��������� �������� ��� �������������� ����������� ���������� RCS,
��������� ��������� � co(1), �� �� ����� ������ ��. date_spec
���������������� ��� ����������� � ������� ������� �����, ���� ��
��������������� ������. ������� �������� ������������ ��� ��������:
1 month ago
2 hours ago
400000 seconds ago
last year
last Monday
yesterday
a fortnight ago
3/31/92 10:00:07 PST
January 23, 1987 10:05pm
22:00 GMT
`-D’ �������� � ��������� checkout.diff.export.history.rdiff.rtag �
update. (������� history ���������� ��� ����� ��������� ��������
��������;). �� ��������� ��������� � �������
�������� ����� `-D’, ����� ��� ��������� ���� �� ���������������
������� ��� ����������� ����������. ������� � �������������� �����
`-D’ ����� ��������� �������� ���:
$ cvs diff -D «1 hour ago» cvs.texinfo
� ����� ���������� �����, ������� �� �������� ���� ���������� (���
�� ������������ �� ���� ����). ����������� ����� `-f’, ���� ��
������ ������ �����, ���� ����� ��� ������������ ��� ����������� ���
����. (����� ������������ ����� ��������� ����������� �����). `-f’
�������� � ������ ���������: checkout, export, rdiff, rtag � update.
��������������: ������� commit ����� ����� ����� `-f’, �� ��� �����
������ ��������� ��� ���� �������.
������������ �����, �������������� ��� ���� ������ CVS.
�������� ��������� �������� ���� � RCS �� ���������. ���� ������������ kflag ��������
��������������, ����� �� ����������� �� ��� �������� ������ �����
����� �������� �������; �.�. ����� �� ����������� ��� ����� �
��������� checkout ��� update, CVS ����������� ��� ��������� kflag �
������ � ���������� ������������ ��� � �������� ��������� ����������
� ��� �� �����, ���� �� �� �������������� ������. ����� `-k’
�������� � ��������� add, checkout, diff � update.
�������� �� ��������������. ��������������: ��� �� �� �� �����, ���
����� ����� `cvs -l’, ������� �� �������������� ����� �� �������
CVS! �������� �� ���������� ���������: checkout, commit, diff,
export, log, remove, rdiff, rtag, status � update.
������ ���������.
�������� �� ���������� ���������: add, commit � import.
���� ��������������� ��� ������� ������ �� ���� ��������������
������ � ��������� ���� ������; �� ��� �����
������� ��). ��������������: ��� �� �� �� �����, ��� ����� �����
`cvs -n’, ������� �� ������ ��������������� ����� �� ������� CVS!
�������� � ��������� checkout, commit, export � rtag.
���������� ��������� checkout ��� update.� ����� ������ ����������
(��� ������ � ������������ �������������) ��������
«��������».������������ `-P’ «����» ������� ��� ���������� �� �����
���������� ���������� �������� �������. ��� �� ������� ���������� ��
�����������, � ������ �� ����� ���������� ���������� �����. �������,
��� ��� ����� ��������������� ��� ������������� ����� `-r’ ��� `-D’
������ checkout � export.
����������� �����, � �� �� ������ � ������� ����������. �������� �
��������� checkout � update.
����� ����� ������������ ��������. ������������� ����� ���� �������
����� ����� ���� �� ����, ������� �� ������ ��������������� � �����
`.cvswrappers’.
�������� � ��������� import � update.
��� ������������� �����������, ����������������� ���������� tag ,
������ �������� (�� ���������) �����������. ��� �� ��� �����
�����������, ������������ ��������� tag � rtag, ��� �����������
����������� ������ ��������: `HEAD’ ��������� �� ����� ���������
������, ��������� � �����������, � `BASE’ ��������� �� �����������,
������� �� ���������� ������ ��������� � ������� ������� ����������.
������������ ����������� �������� ��������������, ����� ��
����������� ��� ����� ��� checkout ��� update ��� �������� �����
����������� ����� �����: CVS ������ ���������� � ����������
������������ ��� � ������� �������� ����������, ���� �� ��
�������������� ������. ���������� ����� ���� ���������� ���
���������.
���������������� ���������� ����� `-q’ � ��������� ������ `-r’ �����
������� ��� ���������� ��������������, ����� ���� ������� RCS ��
�������� ������������������ ���� �����������.
��������������: ��� �� �� �� �����, ��� ����� ����� `cvs -r’,
������� �� �������������� ����� �� ������� CVS! `-r’ �������� �
��������� checkout, commit, diff, history, export, rdiff, rtag �
update.
Содержание
- 1 Глоссарий
- 2 Структура информации под CVS
- 3 Основной цикл работы с CVS
- 3.1 checkout
- 3.2 commit
- 3.3 update
- 3.4 add
- 3.5 remove
- 3.6 release
- 4 Правила работы с CVS
- 5 Расширенные возможности CVS
- 5.1 log
- 5.2 update
- 5.3 липкие метки
- 5.4 diff
- 5.5 annotate
- 6 Управление ветками под CVS
- 7 Администрирование репозитария
- 8 Тесты
Глоссарий
- CVS-модуль
- Модуль с точки зрения CVS — это отдельный блок информации, который весь целиком может быть запрошен пользователем. Также можно устраивать ссылки из одного модуля на другие. Обычно для каждого проекта или группы проектов заводится свой CVS-модуль.
- конфликт
- Если два пользователя одновременно изменяют один и тот же файл, то возникает конфликт — изменения обоих пользователей должны быть отражены на сервере. Тот, кто первым закрепил файл на сервере — у него все проходит как обычно. Когда второй пытается свои изменения пронести на сервер, то ему сообщается о конфликте и производится попытка автоматического слития исправлений. Если исправления были в разных местах, то автоматика работает верно. Если же исправления попали в одно место, то необходимо вручную разобрать данный конфликт и собрать верную версию. Это возлагается на плечи второго, кто закрепляет изменения.
- Sticky tag
- Таг, который показывает номер замороженной версии файла на локальном месте. Если он был установлен, то это означает, что пользователь загружал старую версию данного файла. Также этот таг используется при регистрации веток. Если мы создаем ветку и помечаем ее тагом, то когда мы выдергиваем эту ветку, этот таг на локальном месте будет установлен в таг этой ветки, что позволит в дальнейшем вести работу только с выдернутой веткой.
Структура информации под CVS
Система контроля версий позволяет вести конкурентную работу с набором текстовых файлов.
Все файлы расположены в специальном хранилище — Репозитории CVS, который может размещаться на отдельном выделенном сервере (предпочтительный вариант работы), но может размещаться и на локальном компьютере пользователя (учет версий может быть удобен и в случае однопользовательской работы.
К файлам из Репозитория, возможен доступ только через интерфейс системы CVS:
- запрос текущей версии (или любой другой) файла на локальный диск;
- внесения изменений в файл;
- записи измененного файла обратно на сервер как новой версии.
При этом системой обеспечивается хранение всех версий файла, регистрация изменений от лица конкретного пользователя с точностью до строки, а также отслеживание возникших конфликтов.
CVS эффективно работает с текстовыми файлами, позволяя делать построчное сравнение версий, может также использоваться для хранения двоичных файлов, но, естественно, без сервиса по сравнению версий. Кроме того, если текстовые файлы хранятся довольно эффективно, то есть, фактически, имеется одна версия и журнал изменений, то двоичный файл при каждой правке запоминается целиком.
После получения последней версии файлов проекта с сервера большая часть работы сводится к следующим основным действиям:
- внесение изменений в файл каким-либо редактором;
- проверка, что изменения не привели проект в негодность (например, что при компиляции не происходит ошибок);
- закрепление изменений (пронесение изменений в репозитарий на сервере).
Помимо простейшего цикла работы у CVS есть множество дополнительных возможностей.
Основной цикл работы с CVS
Под основным циклом работы понимается использование стандартных команд CVS, позволяющих читать файлы, изменять их и записывать изменения.
Каждый CVS-модуль (полное дерево каталогов), помещенный под контроль CVS, хранится в центральном репозитарии. Вся работа выполняется с локальной копией CVS-модуля изменения из которой переносятся в репозитарий по готовности. Для этого используется несколько основных команд.
checkout
Для создания локальной копии CVS-проекта необходимо выбрать каталог для проектов на локальном диске (напр. D:\projects), в котором будет создан подкаталог данного проекта. В этом каталоге выполнить команду
cvs checkout имя_проекта
После этого в каталоге D:\projects\имя_проекта появляется локальная копия всего дерева последней версии указанного проекта.
Возможные значения параметра имя_проекта можно увидеть простым просмотром файла CVSROOT/modules, который можно запросить командой:
cvs checkout CVSROOT
commit
После того, как проверено, что внесенные Вами изменения оставили проект в рабочем (по крайней мере, в компилируемом) состоянии, следует закрепить изменения в репозитарии. В принципе, можно использовать разную политику закрепления изменений (как можно чаще, как можно реже, только после успешной компиляции и т. д.). Выбор конкретной политики не влияет на работу самого CVS и обусловлен требованиями проекта. Закрепление изменений производится командой:
cvs commit -m "[Комментарий]" [file]
либо не указывая имя файла, что закрепляет все изменения в выбранной директории.
Если не указан комментарий, то CVS запускает редактор для ввода пояснений в журнал версий.
Возможно, что изменения вносились в старую версию файла и с тех пор файл был поправлен.
Об этом cvs commit выдаст сообщение:
cvs server: Up-to-date check failed for `file' cvs [server aborted]: correct above errors first!
и надо будет выполнить cvs update для конфликтного файла, а затем, возможно, разрешить конфликт (процедура описана ниже). Если одновременно закрепляются изменения в нескольких файлах, то если конфликт был в одном из них, то все закрепление сделано не будет.
update
Синхронизация с репозитарием может быть выполнена в любой момент командой
cvs update [-dP] [file]
Ключ -d используется для проноса новых директорий, появившихся в проекте. Ключ -P удаляет пустые директории.
Дело в том, что в CVS нельзя удалить директорию. Можно лишь убрать все файлы из директории, тогда по команде cvs update -P она будет стерта с локальной машины.
Данная команда является одной из самых безопасных, так как ничего не меняет на сервере. Отметим также, что если файл на локальном компьютере был испорчен по каким-либо причинам, например неверно отредактирован, то его можно восстановить удалив его на локальной машине и заново считав с сервера командой cvs update [file].
При работе команда cvs update выдает протокол действий в виде списка имен файлов, предваряемых одной буквой — статусом файла. Значения букв:
- U,P
- В файл внесены изменения из репозитария.
- M
- Локальный файл модифицирован относительно репозитария.
- C
- Изменения локального файла конфликтуют с правками в репозитарии.
- ?
- Файл не помещен под CVS.
- А
- Файл локально добавлен, а в репозитарий не помещен.
- R
- Файл удален, но изменения в репозитарий не пронесены.
Проект может содержать директории, которые образованы специальным образом ссылкой на директории со стандартными файлами. Команда cvs update не копирует такие директории в вашу локальную копию проекта. Такие директории копируются командой
cvs checkout имя_проекта
то есть той же командой, которая используется для создании копии проекта.
Если в директории завести файл с именем .cvsignore и поместить в него список шаблонов файлов, которые не должны помещаться под CVS, то на них «?» выдаваться не будет.
Если было внесено много исправлений и команда выдала большой список, ее можно запустить повторно — она выдаст только файлы с модификациями и конфликтами. Конфликт означает, что правки файла, сделанные пользователем локально конфликтуют с правками, внесенными в репозитарий кем-то еще. Соответствующие места в файле будут помечены:
<<<<<<< filename Текст из локального файла ======= Текст из репозитария >>>>>>> version
Перед закреплением изменений необходимо эти конфликты разрешить.
add
Добавление директории или файла выполняется командой
cvs add file.txt
Для файла необходимо затем выполнить cvs commit.
Под CVS можно хранить также бинарные файлы, хотя и не так эффективно, как текстовые, т. к. в этом случае, CVS будет полностью хранить каждую версию файла. Бинарные файлы добавляются с опцией «-kb»:
cvs add -kb file.jpg
remove
Для удаления файла выполняются команды:
cvs remove -f file cvs commit -m "[комментарий]" file
Заметим, что команда cvs remove
требует, чтобы либо файл был сначала удален из локального каталога, либо была вызвана с опциями, форсирующими удаление локального файла, т.е. cvs remove -f code.sql
.
release
Если вдруг возникла необходимость убрать файлы из локальной CVS директории, то необходимо делать это командой:
cvs release -d имя_проекта
в основном каталоге проекта. При этом производится проверка соответствия локальной директории и состояния репозитария. Если есть конфликтующие или расходящиеся файлы, то будет выдана диагностика о их наличии. Все расхождения нужно проанализировать и устранить. После этого необходимо повторно выполнить ту же команду, проверить, что измененных файлов нет, и ответить на задаваемый вопрос «Y». После этого все файлы проекта будут удалены.
Правила работы с CVS
При использовании CVS нужно придерживаться нижеописанных правил:
- Рекомендуется с утра делать cvs update на всю директорию с проектами, чтобы не пропускать новые версии.
- Все полезные изменения вечером должны быть отражены в репозитарии. Исключением являются программные тексты, которые не были до конца исправлены (не компилируются, ошибки при тестировании).
- При выполнении cvs commit нужно всегда вводить комментарии. Если есть система регистрации ошибок или заданий (например Bugzilla или Jira), то качестве комментария при cvs commit удобно использовать не текстовое описание проблемы и исправлений, а код ошибки или задания, типа «Bug 1234».
- Обязательно нужно просматривать результат cvs commit, чтобы не пропустить сообщение о конфликте.
- Нельзя получать новые версии файлов другим путем, кроме как выполнением команд update или checkout. Копирование новых версий файлов с другого компьютера может привести к потере данных!
Расширенные возможности CVS
Рассмотрим функции и команды CVS, хотя и относительно редко используемые, но полезные во многих специальных случаях.
log
Для того, чтобы получить историю работы с файлом, нужно использовать команду
cvs log [file]
Результат работы рекомендуется перенаправлять в отдельный файл, который потом смотреть в произвольной кодировке. Выдается история изменений данного файла с номерами версий и пользователями, которые закрепляли данные версии.
update
Для того, чтобы получить конкретную версию файла, необходимо набрать команду
cvs update -r номер_версии file
Из репозитария будет загружена версия с данным номером. Если в файле на локальном компьютере производились изменения, то они будут слиты с версией с запрашиваемым номером, что может привести к странным результатам и, обычно, после этого требуется устранить конфликт.
липкие метки
Локальный файл, который был получен путем считывания предыдущей версии считается замороженным (имеющим «sticky tag») и изменения в нем не будут закрепляться в репозитарии. Проверить наличие этого тага можно путем вызова команды для получения статуса файла
cvs status [file]
В результате исполнения выдается полная информация о версиях данного файла.
Для того, чтобы вернуться к последней версии файла, необходимо набрать команду
cvs update -A file
Команда обеспечивает снятие всех «sticky tag» с выбранного файла, она также синхронизирует файл с последней версией с сервера. Если мы вдруг произвели изменения в файле с установленным «sticky tag», то изменения не будут потеряны — они будут пронесены в последнюю версию файла, при этом естественно возникнет конфликт.
diff
Для просмотра изменений файла от версии к версии нужно вызвать команду
cvs diff -r версия_1 [-r версия_2] file
Вторую версию можно не указывать, тогда будет взят текущий файл. Результат следует перенаправлять в отдельный файл. В файле будет приведен список отличий между версиями.
annotate
Для того, чтобы посмотреть, кто что написал в файле, необходимо использовать команду
cvs annotate file
Результат надо направлять в файл. В результате, для каждой строки исходного файла будет выведено имя пользователя и версия, в которой появилась данная строка.
Управление ветками под CVS
Для поддержки нескольких версий описаний библиотек, либо стандартов на разработку, необходимо использовать наиболее сложные возможности CVS — систему веток.
Путь развития каждого файла под CVS может представлять собой дерево (вообще говоря, даже многопотоковый граф). От основного ствола — основного пути изменения файла можно отщепить произвольное количество веток. На определенном этапе развития ветки могут быть снова слиты в одну ветку.
Для отщепления ветки используется механизм пометки тагами. Версия файла может быть помечена произвольным количеством тагов, таг — строка произвольного вида. Для данного файла существует одна и только одна версия помеченная конкретным тагом. Если мы хотим пометить тагом другую версию, то мы должны снять этот таг с предыдущей версии.
Для проекта таги используются для пометки определенных срезов информации. Эти срезы могут перемещаться и изменяться со временем.
Помимо обычных тагов бывают таги веток. Если мы хотим завести новую ветку у файла, то мы обязаны пометить ее веточным тагом. Отметим, что при поиске файла с тагом неважно, ищем мы файл по веточному тагу, либо по обычному.
Когда ветка выделена — она продолжает развиваться независимо, при этом последняя версия файла ветки помечена тагом этой ветки.
Для пометки файла тагом нужно использовать команду
cvs tag -F таг
Она пометит все файлы в директории и поддиректориях указанным тагом. Использование -F позволяет сдвигать таг, если он раньше был установлен.
Для того, чтобы создать ветку, нужно вызвать нижеследующие команды. Сначала нужно считать версию файла помеченную данным тагом — для проверки.
cvs update -r таг_ветки file
Далее следует проверить таг и признак тага — может быть ветка уже была создана. Также нужно проверить номер версии файла — отсюда ли мы хотим делать ветку. Вызвав команду
cvs status file
произведем проверку. Если мы хотим делать ветку из другого места, то мы должны считать нужную версию файла и сделать веткой при помощи команды
cvs tag -F -b таг_ветки file
Команда создает ветку этого файла для стандарта с данным номером. Опция -F означает, что старый таг с этим именем будет удален.
Для того, чтобы считать ветку файла, необходимо вызвать команду
cvs update -r таг_ветки
При этом на локальную машину будет помещены файлы из этой ветки, а за отсутствием файла в этой ветке — из основного ствола.
После этого локальная машина начинает работать с данной веткой. Команда update будут считывать более новые файлы этой ветки.
Для взятия последней версии основного ствола нужно использовать команду
cvs update -A file
Администрирование репозитария
Под администрированием репозитария понимается действия по созданию, удалению и импорту репозитария и отдельных CVS-модулей.
Создание CVS-модуля:
- Создать директорию с названием проекта (CVS-модуля). Директорию можно создавать в любом месте локальной машины.
- Внутри директории выполнить команду
cvs import custis/path vendortag releasetag
где
- path
- место CVS-модуля внутри репозитория, например, для модулей документации — docs/projects/имя_проекта;
- vendortag
- создатель модуля. ;releasetag: идентификатор, определяющий версию проекта. Идентификатор должен начинаться с буквы и не должен содержать символов @,$,-.
Пример такой команды
cvs import custis/projects/adb CUSTIS ADB_0_0
- Удалить на локальной машине созданную директорию.
- Создать локальную копию CVS-проекта CVSROOT/modules, для чего в корневой директории выполнить команду
cvs checkout CVSROOT/modules
- В файле projects/CVSROOT/modules в нужное место вставить название модуля и его место в репозитории, используя имеющиеся там примеры. Место в репозитории должно совпадать с путем, указанным в команде import.
- Записать изменения файла projects/CVSROOT/modules в репозиторий с помощью команды cvs commit.
- Удалить модуль CVSROOT с локальной машины командой
cvs release -d CVSROOT
- Создать локальную копию проекта командой checkout, убедиться, что все правильно.
Тесты
Можете проверить свои знания CVS интерактивной системой тестирования:
- Тест «CVS-базовый уровень»;
- Тест «CVS-advanced».
Внимание! Эта статья была создана путем автоматического реплицирования из внутренней базы знаний компании Заказные Информ Системы. Любые правки этой статьи могут быть перезаписаны при следующем сеансе репликации. Если у вас есть серьезное замечание по тексту статьи, запишите его в раздел «discussion».
В этом приложении описывается общая структура команд CVS, а некоторые команды описываются детально; краткий справочник по командам CVS находится в see section Краткий справочник по командам CVS.
Общий формат всех команд CVS таков:
cvs [ опции_cvs ] команда_cvs [ опции_команды ] [ аргументы_команды ]
cvs
- Имя исполняемого файла CVS.
cvs_options
- Некоторые ключи командной строки влияют на все подкоманды CVS. Такие ключи описаны ниже.
cvs_command
- Одна из нескольких подкоманд. Некоторые команды имеют синонимы, которые указываются в справочнике по этой команде. Есть только две ситуации, в которых вы можете пропустить `команду_cvs’: `cvs -H’ выдает список доступных команд, а `cvs -v’ отображает версию CVS.
command_options
- Ключи командной строки, специфичные для каждой команды.
command_args
- Аргументы команд.
К сожалению, есть небольшая путаница между опциями_cvs
и опциями_команды
. Ключ `-l’, когда он используется в качестве опции CVS, воздействует только на некоторые команды. Когда этот ключ используется как опция команды, у него появляется другое значение, и он используется с большим количеством команд. Другими словами, не придавайте вышеописанной категоризации слишком большого значения, а обращайтесь вместо этого к документации.
Код выхода CVS
CVS может сообщить вызывающей программе, успешно ли завершилась операция или нет, возвращая тот или иной код выхода. Точный способ проверки кода выхода зависит от операционной системы. Например, в скриптах оболочки UNIX переменная `$?’ содержит ноль, если последняя команда возвратила код успешного выхода, или же больше нуля, если выполнение программы завершилось с ошибкой.
Если CVS выполняется успешно, то возвращает код успешного завершения; в случае ошибки программа печатает сообщение об ошибке и возвращает код неуспешного завершения. Исключением является команда cvs diff
. Она возвращает код успешного завершения, если не обнаружила различий, или же код неудачного завершения, если были обнаружены различия или произошла ошибка. Так как такое поведение не обеспечивает простого способа обнаружения ошибок, в будущем, вероятно, команда cvs diff
будет изменена, чтобы вести себя подобно прочим командам CVS.
Ключи по умолчанию и файл ~/.cvsrc
Имеются определённые ключи команд CVS, которые используются столь часто, что вы захотите настроить для них что-то типа синонима. Основным примером (именно он и привел к поддержке файла `~/.cvsrc’) является то, что многим не нравится стандартная форма выдачи изменений, которая используется в команде `diff’, и они предпочитают контекстную или унифицированную выдачу изменений, которые выглядят значительно лучше.
Файл `~/.cvsrc’ — это способ установить ключи по умолчанию для команд CVS, не используя синонимов, скриптов оболочки и т. п.
Формат файла `~/.cvsrc’ прост. В нем ищется строка, чье начало совпадает с именем выполняемой команды CVS. Если совпадающая строка найдена, то остаток строки расщепляется на ключи командной строки и добавляется к командной строке перед ключами из настоящей командной строки.
Если у команды есть два имени (например, checkout
и co
), то для поиска используется официальное имя, не обязательно совпадающее с тем, что использовалось при вызове CVS. Таким образом, если содержимое файла `~/.cvsrc’ таково:
log -N diff -u update -P checkout -P
то к аргументам команды `cvs checkout foo’ добавится ключ `-P’, и точно то же самое произойдет с командой `cvs co foo’.
При использовании вышеприведенного файла команда `cvs diff foobar’ будет выдавать изменения в унифицированном формате. `cvs diff -c foobar’ будет, как обычно, выдавать контекстные изменения. Получение изменений в «старом» формате чуть более сложно, потому что у команды diff
нет способа задать выдачу в «старом» формате, поэтому вам потребуется использовать `cvs -f diff foobar’.
Вместо имени команды вы можете использовать cvs
, чтобы задать глобальные ключи (see section Глобальные ключи командной строки). Например, такая строка в файле `~/.cvsrc’ включит использование шестого уровня компрессии:
cvs -z6
Глобальные ключи командной строки
Вот список имеющихся ключей командной строки CVS (те из них, что задаются слева от имени команды):
--allow-root=rootdir
- Задает разрешенный каталог
CVSROOT
. См. section Настройка сервера для парольной аутентификации. -a
- Аутентифицировать всё общение между клиентом и сервером. Влияеттолько на клиента. В настоящее время это реализуется только при использовании соединения GSSAPI (see section Прямое соединение с использованием GSSAPI). Аутентификация предотвращает определённые виды атак, использующих перехват TCP-соединения. Включение аутентификации не включает шифрование.
-b bindir
- В @cvsver{1.9.18} и более старых версиях этот ключ задавал каталог, в котором находятся программы RCS. Текущие версии CVS не выполняют программ RCS; этот ключ оставлен только для обратной совместимости.
-T tempdir
- Использовать tempdir в качестве каталога, в котором расположены временные файлы. Переопределяет содержимое переменной среды
$TMPDIR
и каталог, заданный при компиляции. Этот параметр должен задавать полный путь. -d cvs_root_directory
- Использовать cvs_root_directory в качестве корневого каталога репозитория. Переопределяет содержимое переменной окружения
$CVSROOT
. See section Репозиторий. -e editor
- Использовать editor, чтобы ввести журнальное сообщение. Переопределяет содержимое переменных окружения
$CVSEDITOR
и$EDITOR
. За дальнейшей информацией обращайтесь к section Фиксирование изменений. -f
- Не читать файл `~/.cvsrc’. Этот ключ чаще всего используется из-за неортогональности набора ключей CVS. Например, команда `cvs log’ имеет ключ `-N’ (отключить отображение имен меток), но не имеет соответствующего ключа, чтобы включить такое отображение. Поэтому если у вас в файле `~/.cvsrc’ для команды `log’ имеется ключ `-N’, вам может потребоваться `-f’, чтобы отобразить имена меток.
-H
--help
- Выдать информацию об указанной команде CVS (но не выполнять её). Если вы не укажете имя команды, то `cvs -H’ выдаёт общую информацию об использовании CVS, включая список других ключей помощи.
-l
- Выполнить команду, не журналируя её в файле истории команд. See section Команда history: показать состояние файлов и пользователей.
-n
- Не изменять ничего на диске. Попытаться выполнить команду CVS, но только выдавать отчёт; не удалять, обновлять или объединять существующие файлы, не создавать новых. Заметьте, что CVS не обязательно выдаст те же самые сообщения, что и без использования `-n’, потому что в некоторых случаях CVS пропустит часть работы.
-Q
- Команда вообще не будет выдавать сообщений, за исключением сообщений о серьезных проблемах.
-q
- Команда будет выдавать только некоторые сообщения; например, информация о продвижении по дереву каталогов выдаваться не будет.
-r
- Делать новые рабочие файлы доступными только для чтения. Тот же самый эффект достигается установкой переменной окружения
$CVSREAD
(see section Все переменные окружения, используемые в CVS). По умолчанию рабочие файлы создаются доступными для записи, если только не включено слежение (see section Слежение за чужими исходными текстами). -s variable=value
- Установить переменную пользователя (see section Подстановки в административных файлах).
-t
- Отслеживать выполнение программы; отображать сообщения, сопровождающие различные шаги CVS. Особенно полезно совместно с `-n’, чтобы изучить работу незнакомой команды.
-v
--version
- Отображает версию CVS и информацию об авторских правах.
-w
- Делает новые рабочие файлы доступными для чтения и записи. Переопределяет содержимое переменной окружения
$CVSREAD
. Файлы по умолчанию создаются для чтения и записи, если только не был установлен$CVSREAD
или же не использовался ключ `-r’. -x
- Шифровать всё взаимодействие между клиентом и сервером. Воздействует только на клиента CVS. В текущей версии реализовано только при использовании соединения с GSSAPI (see section Прямое соединение с использованием GSSAPI) или соединения с Kerberos (see section Прямое соединение с помощью Kerberos). Включение шифрования подразумевает, что в канале связи будет также включена аутентификация. Поддержка шифрования по умолчанию недоступна; при компиляции CVS используйте специальный ключ командной строки к
./configure --enable-encryption
. -z gzip-level
- Установить уровень компрессии. Влияет только на клиента CVS.
Стандартные ключи командной строки
В этой главе описываются `ключи_команды’, доступные для использования с несколькими командами CVS. Эти ключи всегда задаются справа от имени `команды_CVS’. Не все команды поддерживают эти ключи, но лишь те, для которых ключ имеет смысл. Однако, если команда имеет один из этих ключей, вы можете быть уверены в одинаковом поведении этих ключей с разными командами. (Другие ключи команд, описанные вместе с отдельными командами, могут иметь различное поведение с разными командами CVS).
Предупреждение: команда `history’ является исключением, она поддерживает различные ключи, конфликтующие даже со стандартными ключами.
@macro std-option-f
-D дата
- Использовать самую свежую ревизию, сделанную не позже чем дата. В данном случае дата — это одиночный аргумент, являющийся описанием прошедшей даты. Указанная дата становится липкой, когда вы используете её, чтобы сделать копию файла с исходным текстом, то есть, когда вы извлекаете рабочий файл, используя `-D’, то CVS запоминает указанную дату, так что последующие команды обновления, выполненные в том же каталоге, будут использовать ту же дату (дальнейшая информация по липким меткам и датам находится в see section Липкие метки). Ключ `-D’ доступен совместно с командами
checkout
,diff
,export
,history
,rdiff
,rtag
иupdate
. (Командаhistory
использует этот ключ немного отличающимся способом; see section Ключи команды history). CVS поддерживает большое множество форматов даты. Самыми стандартными являются ISO-8601 (от Международной Организации по Стандартизации) и стандарт электронной почты (описанные в RFC822, с поправками в RFC1123). Даты в формате ISO-8601 имеют множество вариантов, но вот несколько примеров:1972-09-24 1972-09-24 20:05
Вероятно, вы совсем не желаете увидеть перечисление полного списка форматов, описанных в ISO8601 :-). Вдобавок к датам, разрешенным в электронной почте в Интернет, CVS также позволяет пропускать некоторые поля. Например:
24 Sep 1972 20:05 24 Sep
Считается, что дата находится в местной временн’ой зоне, если только таковая не задана явно. Предпочтительными являются два формата представления данных. Однако же, CVS в настоящее время поддерживает широкий диапазон других форматов представления даты. Они нарочно не документируются здесь, а будущие версии CVS могут уже не поддерживать их. Одним из таких форматов является
месяц/день/год
. Такой взаимный порядок дня и месяца может смутить некоторых, например, `1/4/96′ — это четвертое января, а не первое апреля. Не забудьте написать аргумент команды `-D’ в кавычках, чтобы ваша оболочка не посчитала пробелы разделителями аргументов. Команда, использующая ключ `-D’, может выглядеть так:$ cvs diff -D "1 hour ago" cvs.texinfo
-f
- Когда вы задаёте команде CVS конкретную дату или метку, то эта команда обычно игнорирует файлы, не содержащие заданной метки (или не существовавшие на указанный момент времени). Используйте ключ `-f’, если вы хотите, чтобы файлы извлекались, даже если они не совпадают с меткой или со временем, в этом случае будет использована самая свежая ревизия файла. `-f’ доступна с командами
annotate
,checkout
,export
,rdiff
,rtag
, иupdate
. Предупреждение: Командыcommit
иremove
также имеют ключ `-f’, но он имеет другое поведение. See section Ключи команды commit, а также section Удаление файлов. -k kflag
- Изменить обработку ключевых слов по умолчанию. See section Подстановка ключевых слов, о значении kflag. Указанное значение kflag становится липким, когда вы создаёте личную копию файла. Это означает, что когда вы используете этот ключ вместе с командами
checkout
илиupdate
, то CVS связывает значение kflag с файлом, и использует это значение при последующих командах обновления этого файла, если вы не укажете обратного. Ключ `-k’ доступен с командамиadd
,checkout
,diff
,import
иupdate
. @std-option-l Предупреждение: это не тот глобальный ключ `-l’, который вы указываете слева от команды CVS! Доступен с командамиannotate
,checkout
,commit
,diff
,edit
,editors
,export
,log
,rdiff
,remove
,rtag
,status
,tag
,unedit
,update
,watch
, иwatchers
. -m "сообщение"
- Использовать «сообщение» в качестве журнальной записи, вместо того, чтобы запустить редактор. Флаг доступен с командами
add
,commit
иimport
. -n
- Не выполнять соответствующие программы при выполнении команд `checkout’, `commit’ и `tag’. (В базе данных модулей могут быть указаны программы, которые нужно выполнить при выполнении одной из этих команд, а этот ключ используется для того, чтобы избежать этого). Предупреждение: этот флаг — не тот глобальный флаг `cvs -n’, который задаётся слева от команды CVS! Флаг доступен с командами
checkout
,commit
,export
иrtag
. -P
- Удалять пустые каталоги. См. section Удаление каталогов.
-p
- Выдать файлы, извлеченные из репозитория, на стандартный вывод, а не записывать их в текущем каталоге. Флаг доступен с командами
checkout
иupdate
. -R
- Рекурсивно обрабатывать каталоги. Включено по умолчанию. Доступно с командами
annotate
,checkout
,commit
,diff
,edit
,editors
,export
,rdiff
,remove
,rtag
,status
,tag
,unedit
,update
,watch
иwatchers
. -r метка
- Использовать ревизию, указанную в параметре метка, вместо головной ревизии (
HEAD
) по умолчанию. Помимо меток, созданных с помощью командtag
иrtag
, всегда доступны две специальные метки: `HEAD’ ссылается на самую свежую ревизию, находящуюся в репозитории, а `BASE’ ссылается на ревизию, которую вы извлекли в текущий рабочий каталог. Указанная метка становится липкой, если вы используетеcheckout
илиupdate
, чтобы создать собственную копию файла: CVS запоминает метку и продолжает использовать её при дальнейших командах обновления, пока вы не укажете обратного (See section Липкие метки, где можно найти дополнительную информацию о о липких метках/датах). Метка может быть номером ревизии или именем. See section Метки ревизий. Задание глобального ключа `-q’ вместе с ключом `-r’ часто бывает полезным, чтобы избежать предупреждающих сообщений о том, что RCS-файл не содержит указанной метки. Предупреждение: не перепутайте этот ключ с глобальным ключом `cvs -r’, который вы пишете слева от команды CVS! Ключ `-r’ доступен с командамиcheckout
,commit
,diff
,history
,export
,rdiff
,rtag
иupdate
. -W spec
- Задаёт имена файлов, которые нужно отфильтровать. Этот ключ можно использовать в командной строке несколько раз. spec может быть шаблоном имени файла, таким же, который можно использовать в файле `.cvswrappers’. Ключ доступен с командами
import
иupdate
.
Команда admin: администрирование
- Требует: репозиторий, рабочего каталога.
- Изменяет: репозиторий.
- Синоним:
rcs
Эта команда — интерфейс к разнообразным административным возможностям CVS. Некоторые из них имеют сомнительную ценность для CVS и существуют по историческим причинам. Некоторые из таких возможностей, скорее всего, исчезнут когда-либо. Эта команда работает рекурсивно, поэтому нужно соблюдать крайнюю осторожность.
Если на машине под UNIX существует группа cvsadmin
, то команду cvs admin
могут выполнять только члены этой группы. Эта группа должна существовать на сервере или на любой машине, на которой используется не-клиент-серверная версия CVS. Чтобы запретить всем пользователям выполнение команды cvs admin
, создайте соответствующую группу и никого в неё не помещайте. Под NT группы cvsadmin
не поддерживается, поэтому все пользователи могут выполнять cvs admin
.
Ключи команды admin
Некоторые ключи имеют сомнительную полезность для CVS, но существуют по историческим причинам. Некоторые даже приводят к невозможности использования CVS, пока вы не отмените их действие!
-Aстарый_файл
- Может не работать совместно с CVS. Добавляет список доступа старого_файла к списку доступа RCS-файла.
-aимена
- Может не работать совместно с CVS. имена перечисляются через запятую. Добавляет имена к списку доступа RCS-файла.
-b[ревизия]
- Устанавливает ветку по умолчанию& В CVS вы обычно не манипулируете ветками по умолчанию, вместо этого используются липкие метки (see section Липкие метки). Есть одна причина использовать
cvs admin -b
: вернуть обратно версию от поставщика при использовании веток поставщика (see section Возврат к последней версии от поставщика). Между `-b’ и аргументом не должно быть пробела. -cстрока
- Делает строку префиксом комментария. Этот префикс не используется ни в текущей версии CVS, ни в RCS 5.7, таким образом, о нём можно не беспокоиться. See section Подстановка ключевых слов.
-e[имена]
- Может не работать совместно с CVS. имена перечисляются через запятую. Удаляет имена из списка доступа RCS-файла. Если имена не заданы, очищает весь список доступа.
-I
- Выполняется интерактивно, даже если стандартный ввод не является терминалом. Этот ключ не работает с сетевой версией CVS и, скорее всего, исчезнет в будущих версиях CVS.
-i
- Бесполезный ключ. Создает новый RCS-файл, не создавая новой ревизии. Файлы можно добавлять в репозиторий с помощью команды
cvs add
(see section Добавление файлов в каталог). -ksubst
- Устанавливает режим подстановки ключевых слов по умолчанию. See section Подстановка ключевых слов. Явное указание режима подстановки при использовании команд
cvs update
,cvs export
иcvs checkout
переопределяет этот режим по умолчанию. -l[rev]
- Блокировать ревизию с номером rev. Если указан номер ветки, заблокировать самую последнюю ревизию на ветке. Если rev опущено, заблокировать последнюю ревизию на ветке по умолчанию. Между `-l’ и аргументом не может быть пробела. Этот ключ можно использовать в сочетании со скриптом `rcslock.pl’, находящимся в каталоге `contrib/’ в дистрибутиве CVS, для того, чтобы пользоваться блокированными извлечениями (когда только один пользователь в каждый момент времени может редактировать данный файл). Смотрите комментарии в этом файле за дальнейшей информацией (а также файл `README’ в каталоге `contrib/’, где содержится уведомление об отсутствующей поддержке для содержимого этого каталога.) В соответствии с вышеупомянутыми комментариями следует установить жесткий режим блокировки (по умолчанию это именно так).
-L
- Установить жесткий режим блокировки. Это означает, что владелец RCS-файла наравне со всеми прочими должен блокировать файл перед внесением в него изменений. Для работы с CVS жесткий режим блокировки должен быть установлен; смотри обсуждение этого вопроса в описании ключа `-l’.
-mrev:msg
- Заменить журнальное сообщение ревизии rev на msg.
-Nимя[:[rev]]
- Действует так же, как `-n’, переопределяя уже существующее имя. Об использовании с волшебными ветками смотри section Волшебные номера веток.
-nимя[:[rev]]
- Связывает алфавитное имя с веткой или ревизией rev. Обычно вместо этого ключа лучше использовать `cvs tag’ и `cvs rtag’. Если двоеточие и rev опущены, удаляет имя; в противном случае сообщает об ошибке, если имя уже связано с каким-либо номером. Если rev является алфавитным именем, то оно перед связыванием заменяется на соответствующий номер. Если rev состоит из номера ветви, за которым следует точка, то это означает самую свежую ревизию на ветке. Двоеточие с отсутствующим rev означает самую свежую ревизию на ветке по умолчанию, или на стволе. Например, `cvs admin -nname‘ связывает name с последней ревизией всех RCS-файлов; подобно этому `cvs admin -nname:$’ связывает name с номерами ревизий, извлеченных из содержимого ключевых слов в соответствующих рабочих файлах.
-oдиапазон
- Удаляет (делает устаревшими) ревизии, заданные диапазоном. Заметьте, что эта команда может быть весьма опасна, если только вы не знаете точно, что именно вы делаете (например, смотрите предупреждения о возможной путанице в синтаксисе rev1:rev2). Если вам не хватает дискового пространства, то эта команда может вам помочь. Подумайте дважды перед её использованием: отменить действие этой команды нельзя никак, кроме восстановления с резервных копий. Вероятно, неплохо будет сначала поэкспериментировать на копии репозитория. диапазон задаётся одним из нескольких способов:
rev1::rev2
- Уничтожить ревизии между rev1 и rev2, так что CVS будет хранить только изменения между rev1 и rev2, но не промежуточные изменения. Например, после выполнения команды `-o 1.3::1.5′ можно извлечь ревизию 1.3, ревизию 1.5, разницу между 1.3 и 1.5, но не ревизию 1.4 или разницу между 1.3 и 1.4. Другой пример: `-o 1.3::1.4′ и `-o 1.3::1.3′ не совершат никакого действия, потому что удалять в данных случаях нечего.
::rev
- Удаляет ревизии между началом ветки, содержащей rev, и самой rev. Точка начала ветки и rev остаются нетронутыми. Например, `-o ::1.3.2.6′ удаляет ревизию 1.3.2.1, ревизию 1.3.2.5 и все ревизии в промежутке между ними, но не трогает 1.3 и 1.3.2.6.
rev::
- Удаляет ревизии между rev и концом ветки, содержащей rev. Ревизия rev остается нетронутой, но головная ревизия (
HEAD
) удаляется. rev
- Удаляет ревизию rev. Например, `-o 1.3′ эквивалентно `-o 1.2::1.4′.
rev1:rev2
- Удаляет ревизии от rev1, включительно, до rev2, включительно, находящиеся на одной ветке. После выполнения команды нельзя будет извлечь ревизии rev1, rev2, а также все ревизии в промежутке между ними. Например, команда `cvs admin -oR_1_01:R_1_02 .’ редко бывает полезна. Она означает «удалить ревизии вплоть до метки `R_1_02′, включительно». Осторожно! Если есть файл, которые изменились между `R_1_02′ и `R_1_03′, то в файле соответствующим меткам будут присвоены одинаковые номера ревизии. Из-за этого не только нельзя будет извлечь `R_1_02′, но и `R_1_03′ потребуется восстанавливать с резервных копий. В большинстве случаев следует использовать вариант `rev1::rev2‘.
:rev
- Удалить ревизии с начала ветки, содержащей rev, вплоть до самой rev, включительно.
rev:
- Удалить ревизии от rev, включительно, до конца ветки, содержащей rev.
Ревизии не могут быть удалены, если они заблокированы или с них начинаются ветви. Если ревизии имеют алфавитные имена и вы используете эти имена в сочетании с синтаксисом `::’, то CVS выдаст сообщение об ошибке и не будет удалять такие ревизии. Если вы действительно хотите удалить алфавитные имена и ревизии, то сначала удалите имена с помощью
cvs tag -d
, затем выполнитеcvs admin -o
. Если вы не используете синтаксис `::’, то CVS удалит ревизии, но оставит алфавитные имена, которые ссылаются на несуществующие ревизии. Такое поведение оставлено для совместимости с предыдущими версиями CVS, но так как оно не очень полезно, то в будущем может измениться, чтобы совпадать со случаем `::’. Из-за способа, которым CVS обрабатывает ветви, rev нельзя задавать в виде алфавитного имени, если эта ревизия находится на ветке. See section Волшебные номера веток, где объясняется, почему это так. Убедитесь, что никто не извлёк копию ревизии, которую вы делаете устаревшей. Могут произойти странные вещи, если кто-то редактирует эту ревизию и пытается зафиксировать её. Из-за этого ключ `-o’ не следует использовать для отмены ошибочного фиксирования, вместо этого фиксируйте ещё одну ревизию, исправляющую ошибочное изменение (see section Слияние изменений между двумя ревизиями). -q
- Работать тихо, не выдавать сопроводительных сообщений.
-sstate[:rev]
- Полезно использовать вместе с CVS. Устанавливает атрибут состояния ревизии rev в state. Если rev — это номер ветви, то использовать последнюю ревизию на этой ветви. Если rev опущена, использовать последнюю ревизию на ветви по умолчанию. В качестве state можно использовать любой идентификатор. Полезным набором является `Exp’ (экспериментальный), `Stab’ (стабильный) и `Rel’ (вошедший в конечный продукт). По умолчанию состояние новой ревизии при создании устанавливается в `Exp’. Состояние сообщается командой `cvs log’ (see section Команда log: напечатать информацию о файлах) и в ключевых словах `$’Log$ и `$’State$ (see section Подстановка ключевых слов). Заметьте, что CVS использует состояние
dead
для своих внутренних нужд; для того, чтобы поместить файл в состояниеdead
или восстановить его из этого состояния, используйте командыcvs remove
иcvs add
, а неcvs admin -s
. -t[файл]
- Полезно при использовании вместе с CVS. Берёт из файла описание указанного RCS-файла, удаляя его старое описание. Имя файла не должно начинаться с минуса. Описание файла можно увидеть в выдаче команды `cvs log’ (see section Команда log: напечатать информацию о файлах). Между `-t’ и его аргументом не должно быть пробела. Если файл опущен, то описание берётся со стандартного ввода, завершённое символом конца файла или строчкой, состоящей из единственного символа «точка». При работе с терминала текст описания запрашивается у пользователя, смотри `-I’. Чтение со стандартного ввода не работает в клиент-серверной CVS и может измениться в будущей версии CVS.
-t-строка
- Похоже на `-tфайл‘. Текст описания берётся из строки, заменяя уже существующее описание. Между `-t’ и его аргументом не должно быть пробелов.
-U
- Устанавливает мягкий режим блокировок. Это означает, что владелец файла не обязан блокировать ревизию перед фиксированием. Для использования в CVS должен быть установлен жёсткий режим блокировок; смотри выше обсуждение ключа `-l’.
-u[rev]
- Смотри выше описание ключа `-l’, где обсуждается использование этого ключа в CVS. Разблокировать ревизию rev. Если дан номер ветки, разблокировать последнюю ревизию на этой ветке. Если rev опущена, удалить последнюю блокировку, сделанную пользователем в этом файле. Обычно только тот, кто сделал блокировку, может снять её. Если это делает кто-то другой, то это называется взломом блокировки. В этом случае владельцу блокировки отсылается уведомление по электронной почте. Почтовое сообщение может содержать комментарий, предоставленный тем, кто взломал блокировку. Комментарий завершается концом файла или строкой, состоящей из единственной точки. Между ключом `-u’ и его аргументом не должно быть пробела.
-Vn
- В предыдущей версии CVS этот ключ означал, что RCS-файл нужно создавать в формате, понимаемой программой RCS версии n. В настоящий момент этот ключ устарел и его использование приводит к сообщению об ошибке.
-xsuffixes
- В предыдущих версиях CVS этот ключ можно было использовать, чтобы задать имена RCS-файлов. Однако, CVS требует, чтобы имена RCS-файлов оканчивались на `,v’, поэтому этот ключ никогда не был полезен.
Команда checkout: извлечение исходных текстов для редактирования
- Краткое описание: `checkout [ключи] модули…’
- Требует: репозиторий
- Изменяет: рабочий каталог
- Синонимы:
co
,get
Создаёт или обновляет рабочий каталог, содержащий копии файлов с исходными текстами, заданных с помощью параметра модули. Команду checkout
обычно следует использовать перед использованием всех прочих команд CVS, так как большинство их них требует наличия рабочего каталога.
модули — это либо алфавитные имена коллекции каталогов и файлов с исходными текстами, или пути к каталогам и файлам в репозитории. Алфавитные имена описываются в файле `modules’. See section Файл `modules’.
В зависимости от модуля, который вы задали, команда checkout
может рекурсивно создавать каталоги и заполнять их соответствующими файлами. Теперь вы можете редактировать эти файлы когда угодно, независимо от того, что кто-то ещё редактирует копии тех же самых файлов); затем обновите их, чтобы получить изменения, помещённые другими в репозиторий; зафиксируйте результаты вашей работы в репозиторий.
Заметьте, что checkout
сам создаёт каталоги. В текущем каталоге при выполнении команды checkout
образуется каталог верхнего уровня, чьё имя обычно совпадает с именем указанного модуля. В случае псевдонима модуля созданный подкаталог может иметь другое имя, но можно быть уверенным, что это будет именно подкаталог, и что checkout
покажет относительный путь, ведущий к каждому файлу, который извлекается в ваш рабочий каталог (если вы не укажете глобальный ключ `-Q’).
Команда checkout
создаёт файлы с правами на чтение и запись, если не задан глобальный ключ `-r’ (see section Глобальные ключи командной строки), не установлена переменная окружения CVSREAD
, и за этим файлом не установлено слежение (see section Слежение за чужими исходными текстами).
Заметьте, что допускается также выполнение checkout
в каталоге, который был создан другой командой checkout
. Это похоже на выполнение команды update
с ключом `-d’, в том смысле, что в вашем рабочем каталоге появятся новые каталоги, которые были созданы в репозитории. Однако же, команда checkout
требует имени модуля, тогда как команда update
— имени каталога. Для использования checkout
таким способом её нужно выполнять из каталога верхнего уровня, поэтому прежде чем использовать checkout
, чтобы обновить существующий каталог, не забудьте перейти в каталог верхнего уровня.
Сообщения, которые выдаются командой checkout
, описаны в section Сообщения команды update.
Ключи команды checkout
Команда checkout
поддерживает стандартные ключи, описанные в (See section Стандартные ключи командной строки.):
-D date
- Использовать самую свежую ревизию, созданную не позднее date. Этот ключ является липким, и подразумевает использование ключа `-P’. See section Липкие метки, где находится дополнительная информация о липких метках и датах.
-f
- Полезен только при использовании совместно с ключами `-D date‘ или `-r tag‘. Если не найдено подходящей ревизии, извлечь самую свежую ревизию, а не игнорировать файл.
-k kflag
- Обрабатывать ключевые слова в соответствии с kflag. См. section Подстановка ключевых слов. Этот ключ является липким: дальнейшие обновления этого рабочего каталога будут использовать тот же самый kflag. Для того, чтобы увидеть липкие ключи, используйте команду
status
. See section Краткий справочник по командам CVS, где находится дополнительная информация о командеstatus
. @std-option-l -n
- Не выполнять программ при извлечении (тех, что указаны в файле `modules’ с помощью ключа `-o’). see section Файл `modules’).
-P
- Удалять пустые каталоги. См. section Перемещение и переименование каталогов.
-p
- Выдавать содержимое файлов на стандартный вывод. @std-option-R{Извлекать}
-r tag
- Использовать ревизию tag. Этот ключ является липким и подразумевает использование `-P’. See section Липкие метки, где можно найти дополнительную информацию о липких метках и датах.
Вдобавок к этому, можно использовать следующие ключи команды checkout
:
- @std-option-A
-c
- Копировать отсортированное содержимое файла `modules’ на стандартный вывод, вместо того, чтобы создавать или изменять файлы или каталоги в рабочем каталоге.
-d dir
- Создать каталог с рабочими файлами, который называется dir, а не использовать имя модуля. Вообще использование этого флага эквивалентно использованию `mkdir dir; cd dir‘, за которым следует команда извлечения без ключа `-d’. Однако же, существует важное исключение из этого правила. При извлечении одиночного файла очень удобно, чтобы файл создавались в каталоге, не содержащем пустых промежуточных каталогов. В этом, и только в этом случае CVS пытается «укоротить» пути к файлам, чтобы избежать подобных пустых каталогов. Например, если имеется модуль `foo’, содержащий файл `bar.c’, то команда `cvs co -d dir foo’ создаст каталог `dir/’ и поместит внутрь файл `bar.c’. Аналогично, если есть модуль `bar’, в котором есть подкаталог `baz/’, в котором есть файл `quux.c’, то команда `cvs -d dir co bar/baz’ создаст каталог `dir/’ и поместит туда файл `quux.c’. Использование флага `-N’ запретит такое поведение. В случае вышеописанной структуры модулей `cvs co -N -d dir foo’ создаст каталоги `dir/foo’ и поместит туда файл `bar.c’, а команда `cvs co -N -d dir bar/baz’ создаст каталоги `dir/bar/baz/’ и поместит туда файл `quux.c’.
-j tag
- Если используются два ключа `-j’, то изменения, сделанные в ревизии, указанной в первом ключе, будут объединены с ревизией, указанной во втором ключе, и помещены в рабочий каталог. With one `-j’ option, merge changes from the ancestor revision to the revision specified with the `-j’ option, into the working directory. The ancestor revision is the common ancestor of the revision which the working directory is based on, and the revision specified in the `-j’ option. Вдобавок каждый ключ `-j’ может задавать дату, которая, если используется вместе с ветвями, может ограничить выбор ревизий только подпадающими под эту дату. Дата задаётся с помощью двоеточия: `-jАлфавитная_Метка:Указание_Даты‘. See section Создание ветвей и слияние.
-N
- Полезен только с `-d dir‘. При задании этого ключа CVS не будет «укорачивать» пути к модулям в вашем рабочем каталоге, когда вы извлекаете одиночный модуль. См. описание флага `-d’, где обсуждается этот вопрос и даются примеры.
-s
- Похоже на `-c’, но выдает также статус модулей и сортирует их в соответствии с этим статусом. See section Файл `modules’, за информацией о том, как ключ `-s’ используется для задания в файле `modules’ статуса модуля.
Пример использования команды `checkout’
Получить копию модуля `tc’:
$ cvs checkout tc
Получить копию модуля `tc’ в том виде, в котором он находился вчера:
$ cvs checkout -D yesterday tc
Команды commit: поместить файлы в репозиторий
- Краткое описание:
commit [-lnRf] [-m 'журнальное_сообщение' | -F файл] [-r ревизия] [файлы...]
- Требует: рабочий каталог, репозиторий.
- Изменяет: репозиторий.
- Синоним: `ci’
Используйте commit
, если вы хотите поместить в репозиторий изменения, сделанные в вашей рабочей копии.
Если вы не укажете, какие файлы следует зафиксировать, то команда проверит все файлы в рабочем каталоге. commit
тщательно следит за тем, чтобы помещать в репозиторий только те файл, которые действительно изменились. По умолчанию (или если явно задать ключ `-R’) файлы в подкаталогах также обрабатываются и фиксируются, если они были изменены; можно использовать ключ `-l’, чтобы ограничить команду commit
только текущим каталогом.
commit
проверяет, что указанные файлы свежее, чем текущие ревизии в репозитории; если это не так, то команда выдаст предупреждение о необходимости выполнить команду update
(see section Команда update: обновить рабочий каталог из репозитория) и завершится, ничего более не делая. commit
не станет выполнять за вас команду update
, предоставляя вам сделать это в удобное время.
Если все нормально, будет вызван текстовый редактор, в котором можно будет ввести журнальное сообщение, которое будет передано программам журналирования (see section Файл `modules’ и see section Файл loginfo), а также помещено в RCS-файл в репозитории. Это журнальное сообщение можно извлечь с помощью команды log
, см. section Команда log: напечатать информацию о файлах. Можно задать журнальное сообщение в командной строке с помощью ключа `-m журнальное_сообщение‘, при этом редактор не будет вызван, или использовать ключ `-F файл‘, чтобы задать файл, содержащий журнальное сообщение.
Ключи команды commit
Следующие стандартные ключи (see section Стандартные ключи командной строки, где можно найти их полное описание) поддерживаются командой commit
:
-l
- @std-option-l
-n
- Не выполнять программ, относящихся к модулю. @std-option-R{Фиксировать}
-r рев
- Фиксировать с номером ревизии рев: это либо номер ветки, либо номер ревизии на основном стволе, больший, чем все существующие номера ревизии (see section Назначение номеров ревизий). Нельзя помещать изменения в ревизию, находящуюся на ветке.
Команда commit
также поддерживает следующие ключи:
-F file
- Прочесть журнальное сообщение из файла файл, не запускать редактор для ввода этого сообщения.
-f
- Заметьте, что поведение ключа `-f’ в этой команде отличается от стандартного, которое описано в section Стандартные ключи командной строки. Заставляет CVS зафиксировать новую ревизию, даже если вы не сделали никаких изменений в файле. Если текущая ревизия файла имеет номер 1.7, то следующие две команды эквивалентны:
$ cvs commit -f file $ cvs commit -r 1.8 file
Ключ `-f’ запрещает рекурсию (то есть подразумевает использование `-l’). Для того, чтобы заставить CVS зафиксировать новую ревизию для всех файлов во всех подкаталогах, используйте `-f -R’.
-m сообщение
- Использовать сообщение в качестве журнального сообщения, не вызывать редактор.
Пример использования команды commit
Помещение изменений на ветку
Вы можете зафиксировать изменения в ревизию, находящуюся на ветке (в её номере четное количество точек) с помощью ключа `-r’. Для того, чтобы создать ревизию на ветке, используйте ключ `-b’ команд rtag
и tag
(see section Создание ветвей и слияние). Затем используйте checkout
или update
, чтобы ваши исходные тексты стали основаны на этой свежесозданной ветке. Начиная с этого момента все изменения в этом рабочем каталоге автоматически добавляются в ревизию на ветке, никак не мешая разработке в основном стволе. Например, если вам потребовалось создать исправление к версии 1.2 вашего продукта, несмотря на то, что уже разрабатывается версия 2.0, вы можете:
$ cvs rtag -b -r FCS1_2 FCS1_2_Patch product_module $ cvs checkout -r FCS1_2_Patch product_module $ cd product_module [[ hack away ]] $ cvs commit
Все это будет работать автоматически, потому что ключ `-r’ является липким.
Создание ветки после редактирования
Предположим, вы работали над каким-то крайне экспериментальным продуктом, основанным на какой-то ревизии, извлеченной из репозитория неделю назад. Если кто-либо еще в вашей группе захочет вместе с вами работать над этим продуктом, не мешая при этом основному направлению разработки, то вы можете зафиксировать изменения в новую ветку. Другие смогут извлечь результаты вашего эксперимента и воспользоваться автоматическим исправлением конфликтов с помощью CVS. Сценарий таков:
[[ hacked sources are present ]] $ cvs tag -b EXPR1 $ cvs update -r EXPR1 $ cvs commit
После команды update
ключ `-r EXPR1′ прилипнет ко всем файлам. Заметьте, что ваши изменения в файлах никогда не будут удалены командой update
. Команда commit
автоматически поместит изменения на правильную ветку, потому что ключ `-r’ является липким. Вы также можете сделать так:
[[ hacked sources are present ]] $ cvs tag -b EXPR1 $ cvs commit -r EXPR1
но в этом случае только те файлы, которые вы изменили, будут иметь прилепленный флаг `-r EXPR1′. Если вы поредактируете еще какие-либо файлы и зафиксируете их без указания флага `-r EXPR1′, то эти файлы могут случайно оказаться в главном стволе.
Для того, чтобы работать вместе с вами над экспериментальной версией, другие могут просто сказать:
$ cvs checkout -r EXPR1 whatever_module
Команда diff: показать различия между ревизиями
- Краткая сводка:
diff [-lR] [format_options] [[-r rev1 | -D date1] [-r rev2 | -D date2]] [files...]
- Требует: рабочий каталог, репозиторий.
- Ничего не изменяет.
Команда diff
используется для сравнения различных ревизий файлов. Действие по умолчанию — сравнить ваши рабочие копии файлов с ревизиями, на которых эти файлы основаны, и сообщить о всех обнаруженных различиях.
Если заданы какие-либо файлы, то сравниваются только они. Если заданы имена каталогов, то сравниваются файлы в этих каталогах.
Смысл кода завершения для команды diff
отличается от всех прочих команд; детали описаны в section Код выхода CVS.
Ключи команды diff
Команда checkout
поддерживает стандартные ключи, описанные в See section Стандартные ключи командной строки.
-D дата
- Использовать самую свежую ревизию, созданную не позже чем дата. См. описание `-r’, где описывается, как это влияет на результаты сравнения.
-k kflag
- Обрабатывать ключевые слова в соответствии с kflag. См. section Подстановка ключевых слов. @std-option-l @std-option-R{Обрабатывать}
-r tag
- Сравнивать с ревизией метка. Можно задать от нуля до двух ключей `-r’. Без ключа `-r’ рабочий файл будет сравниваться с ревизией, на которой он основан. С одним ключом `-r’ указанная ревизия будет сравниваться с вашим рабочим файлом. С двумя ключами `-r’ указанные две ревизии будут сравниваться друг с другом (а содержимое рабочих файлов не будет влиять на выдачу команды). Один или оба ключа `-r’ можно заменить на ключ `-D дата‘, описанный выше.
Нижеследующие ключи задают формат выдачи. Они имеют то же значение, что и в программе GNU diff.
-0 -1 -2 -3 -4 -5 -6 -7 -8 -9 --binary --brief --changed-group-format=arg -c -C nlines --context[=lines] -e --ed -t --expand-tabs -f --forward-ed --horizon-lines=arg --ifdef=arg -w --ignore-all-space -B --ignore-blank-lines -i --ignore-case -I regexp --ignore-matching-lines=regexp -h -b --ignore-space-change -T --initial-tab -L label --label=label --left-column -d --minimal -N --new-file --new-line-format=arg --old-line-format=arg --paginate -n --rcs -s --report-identical-files -p --show-c-function -y --side-by-side -F regexp --show-function-line=regexp -H --speed-large-files --suppress-common-lines -a --text --unchanged-group-format=arg -u -U nlines --unified[=lines] -V arg -W columns --width=columns
Примеры использования команды diff
Нижеследующая строка выдает унифицированную (с ключом `-u’) разницу между ревизиями 1.14 и 1.19 файла `backend.c’. Из-за наличия флага `-kk’ ключевые слова не подставляются, поэтому различия внутри ключевых слов игнорируются.
$ cvs diff -kk -u -r 1.14 -r 1.19 backend.c
Предположим, что экспериментальная ветка `EXPR1′ была основана на наборе файлов, помеченных как `RELEASE_1_0′. Чтобы увидеть, что произошло на этой ветке, используйте команду
$ cvs diff -r RELEASE_1_0 -r EXPR1
Такая команда может использоваться, чтобы показать контекстную разницу между двумя версиями программного продукта:
$ cvs diff -c -r RELEASE_1_0 -r RELEASE_1_1 > diffs
Если вы пользуетесь файлами `ChangeLog’, то команда типа нижеуказанной поможет придумать подходящий текст для журнальной записи. Все изменения, которые вы сделали, будут продемонстрированы вам в удобном виде.
$ cvs diff -u | less
Команда export: экспортировать исходные тексты
- Краткая сводка: export [-flNnR] [-r rev|-D дата] [-k subst] [-d dir] модуль…
- Требует: репозиторий.
- Изменяет: текущий каталог.
Эта команда похожа на команду checkout
; её нужно использовать, если вы хотите получить копию исходных текстов модуля без служебных каталогов CVS. Например, команду export
можно использовать, чтобы подготовить исходные тексты для передачи вовне. Эта команда требует указания даты или метки (с помощью ключей `-D’ или `-r’), чтобы вы могли воспроизвести те же самые файлы, которые вы отдаете.
Часто при использовании cvs export
приходится указывать флаг `-kv’. При этом ключевые слова будут развернуты так, чтобы при импорте в другом месте не потерялась информация о ревизиях. Помните, что в этом случае бинарные файлы не будут корректно обрабатываться. Также помните, что после использования флага `-kv’ больше нельзя будет использовать команду ident
(являющуюся частью пакета RCS), которая ищет строки с ключевыми словами (см. ident(1)
). Если вы хотите использовать ident
, то не используйте `-kv’.
Ключи команды export
Команда export
поддерживает стандартные ключи, описанные в See section Стандартные ключи командной строки.
-D date
- Использовать саму свежую ревизию не позже чем date. @std-option-f @std-option-l
-n
- Не выполнять программ при извлечении. @std-option-R
-r метка
- Использовать ревизию метка.
Вдобавок поддерживаются следующие ключи (общие для checkout
и export
):
-d dir
- Создать для рабочих файлов каталог dir, а не использовать имя модуля. See section Ключи команды checkout, где полностью описаны детали обработки этого флага.
-k subst
- Установить режим подстановки ключевых слов (see section Режимы подстановки).
-N
- Полезно только при использовании вместе с `-d dir‘. See section Ключи команды checkout, где полностью описаны детали обработки этого флага.
Команда history: показать состояние файлов и пользователей
- Краткая сводка: history [-report] [-flags] [-options args] [files…]
- Требует: файл `$CVSROOT/CVSROOT/history’, иногда репозиторий.
- Ничего не изменяет.
CVS может вести файл истории, отслеживающий каждое использование команд checkout
, commit
, rtag
, update
и release
. Для того, чтобы отображать эту информацию в разных форматах, используется команда history
.
Журналирование должно быть включено путем создания файла `$CVSROOT/CVSROOT/history’.
Предупреждение:history
использует ключи `-f’, `-l’, `-n’ и `-p’ не так, как они обычно используются с командами CVS (see section Стандартные ключи командной строки).
Ключи команды history
Несколько флагов, показанных выше в качестве параметра `-report’, задают вид генерируемого отчета:
-c
- Сообщить о всех командах
commit
(то есть о каждом изменении репозитория). -e
- Сообщить обо всем (все виды записей). Эквивалентно заданию `-x’ со всеми типами записей. Конечно, `-e’ будет также включать все типы записей, которые будут добавлены в будущих выпусках CVS; если вы пишете скрипт, которые может обрабатывать только определенные типы записей, используйте `-x’.
-m module
- Сообщать об изменениях конкретного модуля (Можно использовать `-m’ несколько раз в одной командной строке.)
-o
- Сообщать об извлеченных модулях.
-T
- Сообщать обо всех метках.
-x type
- Извлекать указанный набор типов записей type из истории CVS. Типы задаются одиночными буквами, которые можно использовать в комбинациях. Некоторые команды имеют единственный тип записи:
F
- release
O
- checkout
E
- export
T
- rtag
После выполнения команды
update
могут появиться одна из четырех типов записей:C
- A merge was necessary but collisions were detected (requiring manual merging).
G
- A merge was necessary and it succeeded.
U
- A working file was copied from the repository.
W
- The working copy of a file was deleted during update (because it was gone from the repository).
После выполнения команды
commit
могут возникнуть одна из трех типов записей:A
- A file was added for the first time.
M
- A file was modified.
R
- A file was removed.
Ключи, показанные в виде параметра `-flags’, задают дополнительные ограничения или, наоборот, добавляют дополнительную информацию к отчету, не требуя дополнительных параметров:
-a
- Показать данные обо всех пользователях (по умолчанию выдается только информация о пользователе, выполняющем команду
history
). -l
- Показать только последнее изменение.
-w
- Показать только записи об изменениях, выполненных из того же рабочего каталога, где выполняется команда
history
.
Ключи, показанные в виде параметра `-options args‘, задают дополнительные ограничения, используя аргументы:
-b str
- Показывать данные от конца вплоть до последней строки str, встреченной в имени модуля, имени файла или пути к репозиторию.
-D дата
- Показывать данные с даты. Это немного отличается от обычного использования `-D дата‘, при котором извлекаются самые свежие ревизии, старше чем дата.
-f file
- Показывать данные для конкретного файла (можно использовать несколько ключей `-f’ на одной командной строке). Это эквивалентно указанию файла в командной строке.
-n module
- Показывать данные для конкретного модуля (можно использовать несколько ключей `-n’ на одной командной строке).
-p repository
- Показывать данные, относящиеся к конкретному репозиторию (вы можете задать в командной строке больше одного ключа `-p’.)
-r rev
- Показывать записи, относящиеся к ревизиям, появившимся после появления ревизии или метки rev. Соответствующие ревизии или метки ищутся в каждом RCS-файле.
-t tag
- Показывать записи, сделанные с тех пор, как в файле истории появилась запись о метке tag. Это отличается от ключа `-r’ тем, что читается только файл истории, а не RCS-файлы, что гораздо быстрее.
-u name
- Показывать записи о пользователе name.
Команда import: импортировать исходные тексты
- Краткая сводка: import [-options] repository vendortag releasetag…
- Требует: репозиторий, каталог с исходными текстами.
- Изменяет: репозиторий.
Используйте import
для помещения в ваш репозиторий целого дерева каталогов, полученного из внешнего источника (например, поставщика исходных текстов). Эту команду можно использовать как для начального импорта, так и для глобального обновления модуля из внешнего источника. See section Слежение за чужими исходными текстами, где обсуждается этот вопрос.
Параметр repository задает имя каталога (или путь к каталогу) в корневом каталоге CVS-репозитория; если этот каталог не существует, то CVS создаст его.
Когда вы импортируете с целью обновления дерева каталогов, которое было изменено в вашем репозитории с момента последнего импорта, вас уведомят обо всех файлах, конфликтующих в двух ветвях разработки; как советует import
, используйте `checkout -j’, чтобы согласовать изменения.
Если CVS решает, что файл нужно игнорировать (see section Игнорирование файлов с помощью cvsignore), то она не импортирует этот файл и печатает `I имя-файла‘ (see section Сообщения команды output, где полностью описаны сообщения).
Если существует файл `$CVSROOT/CVSROOT/cvswrappers’, то файлы, чьи имена совпадают со спецификациями в этом файле, будут считаться packages и над ними перед импортом будут произведены указанные действия. See section Файл `cvswrappers’.
Чужие исходные тексты хранятся на ветке первого уровня, по умолчанию имеющей номер 1.1.1. Обновления являются листьями на этой ветке; например, файлы из первой импортированной коллекции исходников будут иметь ревизию 1.1.1.1, файлы из первого импортированного обновления этой коллекции будут иметь ревизию 1.1.1.2 и т. д.
Команде требуется по крайней мере три параметра. repository требуется, чтобы задать коллекцию исходников. vendortag — это метка целой ветви (например, 1.1.1). Для того, чтобы идентифицировать файлы, находящиеся на листьях, образующихся при каждом импорте, требуется указать releasetag.
Заметьте, что import
не изменяет каталог, в котором вы выполнили эту команду. В частности, этот каталог не становится рабочим каталогом CVS; если вы хотите работать с исходными текстами — сначала импортируйте их, а затем извлеките в другой каталог (see section Получение исходного кода).
Ключи команды import
Команда import
поддерживает стандартный ключ, описанный в see section Стандартные ключи командной строки:
-m сообщение
- Использовать сообщение в качестве журнальной записи, а не вызывать редактор.
Есть также нижеследующие специальные ключи:
-b branch
- См. section Несколько веток поставщика.
-k subst
- Задает желаемый режим подстановки ключевых слов. Этот параметр будет влиять на все файлы, созданные во время импорта, но не на те, что уже существовали в репозитории. См. section Режимы подстановки, где описываются разрешенные параметры ключа `-k’.
-I name
- Задает имена файлов, которые следует игнорировать при импорте. Этот ключ можно использовать несколько раз. Чтобы не игнорировать ни один файл, задайте `-I !’. name может быть шаблоном имен файлов, типа тех, что можно задать в файле `.cvsignore’. See section Игнорирование файлов с помощью cvsignore.
-W spec
- Задает имена файлов, которые следует профильтровать перед импортом. Этот ключ можно использовать несколько раз. spec может быть шаблоном имен файлов, типа тех, что можно задать в файле `.cvswrappers’. See section Файл `cvswrappers’.
Сообщения команды output
Команда import
сообщает вам о своей деятельности, печатая строку на каждый файл, в начале которой находится один символ, сообщающий о статусе файла:
U file
- Файл уже существует в репозитории и не был локально изменен; будет создана новая ревизия, если нужно.
N file
- Это новый файл и теперь он добавлен в репозиторий.
C file
- Файл уже существует в репозитории, но был изменен локально, поэтому вам потребуется объединить изменения.
I file
- Файл игнорируется (see section Игнорирование файлов с помощью cvsignore).
L file
- Файл является символической ссылкой;
cvs import
игнорирует символические ссылки. Периодически предлагается изменить это поведение, но нет четкого соглашения, как именно. (Различные ключ в файле `modules’ могут использоваться для воссоздания символических ссылок при извлечении, обновлении и т. п.; see section Файл `modules’).
Примеры использования команды import
См. section Слежение за чужими исходными текстами, а также section Создание дерева каталогов из нескольких файлов.
Команда log: напечатать информацию о файлах
- Краткая сводка: log [options] [files…]
- Требует: репозиторий, рабочий каталог.
- Ничего не изменяет.
Отображает журнальную информацию о файлах. log
используется, чтобы вызвать утилиту rlog
из комплекта RCS. Although this is no longer true in the current sources, this history determines the format of the output and the options, which are not quite in the style of the other CVS commands.
Команда сообщает о местонахождении RCS-файла, головной ревизии (HEAD
) (последней ревизии на стволе, обо всех алфавитных именах меток, а также некоторую другую информацию. Для каждой ревизии печатается её номер, автор, количество удаленных и добавленных строк и журнальное сообщение. Все метки времени отображаются по Гринвичу (в UTC). (Другие части CVS печатают время в местной временн’ой зоне).
Предупреждение: log
использует ключ `-R’ не так, как это обычно делается в CVS (see section Стандартные ключи командной строки).
Ключи команды log
По умолчанию команда log
сообщает всю доступную информацию. Ключи предназначены для ограничения выдачи.
-b
- Печатает информацию о ревизиях на ветке по умолчанию, обычно это самая верхняя ветка на стволе.
-d dates
- Печатает информацию о ревизиях, помещенных в репозиторий в промежутке времени, заданном списком дат через точку с запятой. Форматы дат те же, что используются вместе с ключом `-D’ (see section Стандартные ключи командной строки). Даты можно комбинировать следующим образом:
d1<d2
d2>d1
- Выбрать ревизии, которые были помещены в репозиторий между датой d1 и датой d2.
<d
d>
- Выбрать все ревизии, датированные d или раньше.
d<
>d
- Выбрать все ревизии, датированные d или позже.
d
- Выбрать последнюю ревизию, датированную d или раньше.
Вместо символов `>’ и `<‘ можно использовать `<=’ и `>=’, чтобы задать диапазон включительно, а не исключительно. Между ключом `-d’ и его аргументом не должно быть пробела. Заметьте также, что разделителем является точка с запятой (`;’).
-h
- Печатает только имя RCS-файла, имя файла в рабочем каталоге, головную ревизию, ревизию по умолчанию, список прав доступа, блокировки, алфавитные имена и суффикс. @std-option-l
-N
- Не выдает список меток для этого файла. Этот ключ полезен, если вы используете много меток, чтобы избежать просматривания трех экранов информации о метках.
-R
- Печатает только имя RCS-файла.
-rrevisions
- Печатает информацию о ревизиях, перечисленных в списке ревизий и их диапазонов, разделенных запятыми. В этой таблице приведены все доступные форматы диапазонов:
rev1:rev2
- Ревизии от rev1 до rev2 (должны находиться на одной ветке).
:rev
- Ревизии с начала ветки вплоть до rev включительно.
rev:
- Ревизии, начиная с rev до конца ветки, содержащей rev.
branch
- Аргумент, являющийся веткой означает все ревизии на этой ветке.
branch1:branch2
- Диапазон ветвей означает все ревизии на ветках в этом диапазоне.
branch.
- Последнюю ревизию на ветке branch.
Пустой ключ `-r’, без списка ревизий, означает использование последней ревизии на ветке по умолчанию, обычно на стволе. Между ключом `-r’ и его параметром не должно быть пробела.
-s states
- Печатает информацию о ревизиях, чей атрибут состояния совпадает с состоянием из разделенного запятыми списка states.
-t
- Печатает то же самое, что и `-h’, плюс текст описания.
-wlogins
- Печатает информацию о ревизиях, созданных пользователями, перечисленными через запятую в списке logins. Если список опущен, используется имя текущего пользователя. Между ключом `-w’ и его аргументом не должно быть пробела.
log
печатает информацию о ревизиях удовлетворяющих ключам `-d’, `-s’, `-w’ и совокупности ключей `-b’ и `-r’.
Примеры использования команды log
Примеры будут с благодарностью приняты.
Команда rdiff: выдать изменения между версиями в формате patch
- Краткая сводка: rdiff [-flags] [-V vn] [-r t|-D d [-r t2|-D d2]] modules…
- Требует: репозиторий.
- Ничего не изменяет.
- Синоним:
patch
.
Создает файл изменений между двумя версиями продукта в формате программы patch(1)
, написанной Ларри Воллом. Этот файл можно скормить программе patch
, чтобы обновить старую версию до новой. (Это одна из немногих команд CVS, которые работают напрямую с репозиторием и не требуют предварительного извлечения исходных текстов.) Результат выдается на стандартный вывод.
Вы можете задать (используя стандартные ключи `-r’ и `-D’) любую комбинацию двух ревизий или дат. Если указана только одна ревизия или дата, то результат содержит изменения в промежутке между этой ревизией или датой и текущей головной ревизией в RCS-файле.
Заметьте, что если соответствующая версия продукта находится в нескольких каталогах, то может потребоваться указать команде patch
при обновлении старых исходников ключ `-p’, чтобы patch
смогла найти файлы, находящиеся в других каталогах.
Ключи команды rdiff
Команда rdiff
поддерживает стандартные ключи, описанные в see section Стандартные ключи командной строки:
-D date
- Использовать саму свежую ревизию, сделанную не позже date. @std-option-f @std-option-l @std-option-R
-r tag
- Использовать ревизию tag.
Вдобавок доступны следующие ключи:
-c
- Использовать контекстный формат. По умолчанию это именно так.
-s
- Создать вместо файла с исправлениями краткий отчет об изменениях. Отчет содержит информацию о файлах, которые были изменены или добавлены в промежутке между версиями. Этот отчет выдается на стандартный вывод. Это полезно, например, для выяснения, какие именно файлы изменились между двумя датами или ревизиями.
-t
- Изменения между двумя последними ревизиями выдаются на стандартный вывод. Это особенно полезно для выяснения, в чем заключалось последнее изменение файла.
-u
- Использовать унифицированный формат файла изменений. Учтите, что старые версии программы
patch
не могли обрабатывать этот формат, поэтому если вы планируете опубликовать изменения в сети, то вам, скорее всего, не следует использовать ключ `-u’. -V vn
- Раскрывать ключевые слова в соответствии с правилами, принятыми в RCS версии vn (формат подстановки изменился в RCS версии 5). Заметьте, что этот ключ больше не обрабатывается. CVS всегда будет раскрывать ключевые слова так, как этот делает RCS версии 5.
Примеры использования команды rdiff
Предположим, вы получаете письмо от foo@example.net, который просит вас прислать обновление с версии 1.2 до версии 1.4 компилятора tc
. У вас нету под рукой такого обновления, но с помощью CVS вы можете легко сделать так:
$ cvs rdiff -c -r FOO1_2 -r FOO1_4 tc | $$ Mail -s 'Исправления, которые Вы запрашивали' foo@example.net
Предположим, что вы сделали версию 1.3 и ветку `R_1_3fix’ для исправлений этой версии. `R_1_3_1′ соответствует версии 1.3.1, которая была сделана некоторое время назад. Теперь вы хотите узнать, что именно было сделано на этой ветке. Можно использовать такую команду:
$ cvs patch -s -r R_1_3_1 -r R_1_3fix module-name cvs rdiff: Diffing module-name File ChangeLog,v changed from revision 1.52.2.5 to 1.52.2.6 File foo.c,v changed from revision 1.52.2.3 to 1.52.2.4 File bar.h,v changed from revision 1.29.2.1 to 1.2
Команда release: сообщить, что модуль более не используется
- Краткая сводка: release [-d] directories…
- Требует: рабочий каталог.
- Изменяет: рабочий каталог, журнал истории.
Эту команду можно использовать, чтобы безопасным образом отменить `cvs checkout’. Так как CVS не блокирует файлы, то использовать эту команду необязательно. Вы всегда можете просто удалить рабочий каталог, если желаете; правда, в этом случае вы рискуете потерять изменения, о которых забыли, а в файле истории (see section Файл history) не остается никаких следов того, что вы отбросили извлеченные исходники.
Команда `cvs release’ позволяет избежать этой проблемы. Она проверяет, что в рабочем каталоге нет незафиксированных изменений; что вы выполняете эту команду из каталога, в котором находится рабочий каталог; что репозиторий, из которого был извлечен рабочий каталог, совпадает с репозиторием, описанным вбазе данных модулей.
Если все эти условия выполняются, `cvs release’ оставляет запись о своем выполнении в журнал истории (удостоверяя, что вы сознательно отложили извлеченные тексты).
Ключи команды release
Команда release
поддерживает единственный ключ:
-d
- Удалить рабочую копию файлов, если все нормально. Если этот флаг не указан, то ваши файлы останутся в вашем рабочем каталоге. Предупреждение: Команда
release
рекурсивно удаляет все каталоги и файлы. Это имеет очень важный побочный эффект: все каталоги, которые вы создали в извлеченном дереве исходников, но не добавили в репозиторий (используя командуadd
; see section Добавление файлов в каталог) будут бесшумно удалены — даже если эти каталоги непусты!
Сообщения команды release
Перед тем, как release
освободит ваши исходные тексты, эта команда печатает однострочное сообщение для каждого файла, который не соответствует содержимому репозитория.
Предупреждение: Все каталоги, которые вы создали, но не добавили в репозиторий с помощью команды add
(see section Добавление файлов в каталог), будут бесшумно проигнорированы (и удалены, если был указан флаг `-d’), даже если эти каталоги содержат файлы.
U file
P file
- В репозитории существует новая ревизия этого файла, а вы изменили его рабочую копию (`U’ и `P’ означают одно и то же).
A file
- Файл был добавлен в ваш рабочий каталог, но еще не был помещен в репозиторий. Если вы удаляете вашу копию исходных текстов, то этот файл будет потерян.
R file
- Файл был удален из вашего рабочего каталога, но еще не был удален из репозитория, потому что вы еще не зафиксировали удаление. See section Команды commit: поместить файлы в репозиторий.
M file
- Файл изменен в рабочем каталоге. В репозитории также может быть более новая ревизия.
? file
- file находится в рабочем каталоге, но не соответствует ни одному файлу в репозитории, и не находится в списке файлов, которые нужно игнорировать (см. описание ключа `-I’ и see section Игнорирование файлов с помощью cvsignore). Если вы удалите рабочий каталог, изменения будут потеряны.
Примеры использования команды release
Освободить каталог `tc’ и удалить рабочие копии файлов:
$ cd .. # Вам нужно находиться в каталоге, содержащем # ваш каталог с исходными текстами, перед тем, # как вы выполните команду `cvs release'. $ cvs release -d tc You have [0] altered files in this repository. Are you sure you want to release (and delete) directory `tc': y $
Команда update: обновить рабочий каталог из репозитория
- Краткая сводка: update [-AdflPpR] [-d] [-r tag|-D date] files…
- Требует: репозиторий, рабочий каталог.
- Изменяет: рабочий каталог.
После того, как вы извлечете из общего репозитория рабочую копию исходных текстов, другие разработчики продолжат вносить изменения в этот репозиторий. Время от времени, в удобное для вас время можно использовать команду update
в вашем рабочем каталоге, чтобы увязать вашу работу с ревизиями, помещенными врепозиторий после того, как вы извлекли или последний раз обновляли ваш рабочий каталог.
Ключи команды update
Команда update
поддерживает стандартные ключи, которые полностью описаны в see section Стандартные ключи командной строки:
-D date
- Использовать самую свежую ревизию, созданную не позже date. Этот ключ является липким, и подразумевает использование ключа `-P’. См. section Липкие метки, где полностью описаны липкие метки и даты.
-f
- Полезно только при использовании вместе с ключами `-D дата‘ или `-r метка‘. Если не найдено совпадающей ревизии, извлечь самую свежую ревизию, а не игнорировать файл.
-k kflag
- Обрабатывать ключевые слова в соответствии с kflag. См. section Подстановка ключевых слов. Этот ключ является липким; дальнейшие обновления этого файла в рабочем каталоге будут использовать тот же самый kflag. Команду
status
можно использовать для просмотра липких ключей. См. section Краткий справочник по командам CVS, где описана командаstatus
. @std-option-l -P
- Удалять пустые каталоги. См. section Перемещение и переименование каталогов.
-p
- Писать файлы в стандартный вывод. @std-option-R{Обрабатывать}
-r rev
- Извлечь ревизию/метку rev. Этот ключ является липким и подразумевает использование `-P’. См. section Липкие метки, где полностью описаны липкие метки и даты.
Команду update
можно также использовать с такими ключами:
-
@std-option-A
-d
- Создавать каталоги, существующие в репозитории, если они отсутствуют в рабочем каталоге. Обычно
update
работает только с файлами и каталогами, которые уже были созданы в рабочем каталоге. Этот ключ полезен при обновлении каталогов, которые были созданы в репозитории уже после извлечения вашей рабочей копии, но у него есть неприятный побочный эффект: если вы специально избегали определенных каталогов в репозитории, когда создавали рабочий каталог (используя имена модулей или явно перечисляя в командной строке требуемые файлы и каталоги), то обновление с ключом `-d’ создаст эти нежелаемые каталоги. -I name
- Во время обновления игнорировать файлы в вашем рабочем каталоге, чьи имена совпадают с name. Можно использовать этот ключ несколько раз, чтобы задать несколько файлов, которые нужно игнорировать. Используйте `-I !’, чтобы не игнорировать ни один файл. See section Игнорирование файлов с помощью cvsignore, где описаны другие способы игнорирования файлов.
-Wspec
- Задает имена файлов, которые следует фильтровать во время обновления. Этот ключ можно использовать несколько раз. spec — это шаблон имен файлов типа тех, что можно использовать в файле `.cvswrappers’. See section Файл `cvswrappers’.
-jrevision
- При использовании двух ключей `-j’ в рабочем каталоге происходит объединение изменений между ревизией, заданной первым ключом, и ревизией, заданной вторым ключом. При использовании одного ключа `-j’ в рабочем каталоге происходит слияние изменений между ревизией-предком и ревизией, заданной ключом `-j’. Ревизия-предок — это общий предок ревизии, на основе которой создан рабочий каталог, и ревизии, заданной ключом `-j’. Вдобавок, каждый ключ `-j’ может содержать необязательное указание даты, которая, при использовании вместе с ветвями, может дополнительно ограничить выбор ревизий. Необязательная дата задается добавлением двоеточия (`:’) к метке: `-jSymbolic_Tag:Date_Specifier‘. See section Создание ветвей и слияние.
Сообщения команды update
Команды update
и checkout
информируют о своей деятельности, печатая строчку на каждый обработанный файл. Первый символ означает статус этого файла:
U file
- Файл был обновлен из репозитория. Обновление производится: для файлов, существующих в репозитории, но не в вашем рабочем каталоге; для файлов, которые вы не изменяли, и для которых в репозитории существует более свежая ревизия.
P file
- Похоже на `U’, но для этого файла CVS-сервер посылает файл с исправлениями вместо целого файла. Результирующий файл оказывается тем же самым.
A file
- Файл был добавлен в вашем рабочем каталоге, и будет помещен в репозиторий, когда вы выполните команду
commit
. Это сообщение — напоминание о том, что файл требуется зафиксировать. R file
- Файл был удален из вашей личной копии исходников, и будет удален из репозитория, когда вы выполните команду
commit
. Это сообщение — напоминание о том, что файл требуется зафиксировать. M file
- Файл был изменен в вашем рабочем каталоге. `M’ может означать одно из двух состояний файла, над которым вы работаете: либо этот файл не менялся в репозитории, и поэтому остался неизменным в результате выполнения команды
update
, либо же файл изменился как в рабочем каталоге, так и в репозитории, но слияние изменений в ваш рабочий файл прошло успешно, без конфликтов. CVS выдает некоторые сообщения, когда сливает изменения, и оставляет резервную копию рабочего файла (как он выглядел перед выполнениемupdate
). Точное имя этого файла печатается во время работыupdate
. C file
- При попытке объединить изменения из репозитория в вашу рабочую копию файла был обнаружен конфликт. file (ваша рабочая копия) теперь является результатом попытки объединить две ревизии; неизмененная копия файла также находится в рабочем каталоге, с именем `.#file.revision‘, где revision — это ревизия, на которой был основан измененный вами файл. Разрешение конфликтов описано в section Пример конфликта. (Заметьте, что некоторые системы автоматически удаляют файлы, начинающиеся с `.#’, если к этим файлам не было обращений в течение нескольких дней. Если вы хотите сохранить копию исходного файла, переименуйте его.) Под VMS имя файла начинается с `__’, а не с `.#’.
? file
- file находится в вашем рабочем каталоге, но не соответствует ни одному файлу в репозитории, и не находится в списке файлов, которые нужно игнорировать (см. описание ключа `-I’ и see section Игнорирование файлов с помощью cvsignore).
Содержание
- 1 Глоссарий
- 2 Структура информации под CVS
- 3 Основной цикл работы с CVS
- 3.1 checkout
- 3.2 commit
- 3.3 update
- 3.4 add
- 3.5 remove
- 3.6 release
- 4 Правила работы с CVS
- 5 Расширенные возможности CVS
- 5.1 log
- 5.2 update
- 5.3 липкие метки
- 5.4 diff
- 5.5 annotate
- 6 Управление ветками под CVS
- 7 Администрирование репозитария
- 8 Тесты
Глоссарий
- CVS-модуль
- Модуль с точки зрения CVS — это отдельный блок информации, который весь целиком может быть запрошен пользователем. Также можно устраивать ссылки из одного модуля на другие. Обычно для каждого проекта или группы проектов заводится свой CVS-модуль.
- конфликт
- Если два пользователя одновременно изменяют один и тот же файл, то возникает конфликт — изменения обоих пользователей должны быть отражены на сервере. Тот, кто первым закрепил файл на сервере — у него все проходит как обычно. Когда второй пытается свои изменения пронести на сервер, то ему сообщается о конфликте и производится попытка автоматического слития исправлений. Если исправления были в разных местах, то автоматика работает верно. Если же исправления попали в одно место, то необходимо вручную разобрать данный конфликт и собрать верную версию. Это возлагается на плечи второго, кто закрепляет изменения.
- Sticky tag
- Таг, который показывает номер замороженной версии файла на локальном месте. Если он был установлен, то это означает, что пользователь загружал старую версию данного файла. Также этот таг используется при регистрации веток. Если мы создаем ветку и помечаем ее тагом, то когда мы выдергиваем эту ветку, этот таг на локальном месте будет установлен в таг этой ветки, что позволит в дальнейшем вести работу только с выдернутой веткой.
Структура информации под CVS
Система контроля версий позволяет вести конкурентную работу с набором текстовых файлов.
Все файлы расположены в специальном хранилище — Репозитории CVS, который может размещаться на отдельном выделенном сервере (предпочтительный вариант работы), но может размещаться и на локальном компьютере пользователя (учет версий может быть удобен и в случае однопользовательской работы.
К файлам из Репозитория, возможен доступ только через интерфейс системы CVS:
- запрос текущей версии (или любой другой) файла на локальный диск;
- внесения изменений в файл;
- записи измененного файла обратно на сервер как новой версии.
При этом системой обеспечивается хранение всех версий файла, регистрация изменений от лица конкретного пользователя с точностью до строки, а также отслеживание возникших конфликтов.
CVS эффективно работает с текстовыми файлами, позволяя делать построчное сравнение версий, может также использоваться для хранения двоичных файлов, но, естественно, без сервиса по сравнению версий. Кроме того, если текстовые файлы хранятся довольно эффективно, то есть, фактически, имеется одна версия и журнал изменений, то двоичный файл при каждой правке запоминается целиком.
После получения последней версии файлов проекта с сервера большая часть работы сводится к следующим основным действиям:
- внесение изменений в файл каким-либо редактором;
- проверка, что изменения не привели проект в негодность (например, что при компиляции не происходит ошибок);
- закрепление изменений (пронесение изменений в репозитарий на сервере).
Помимо простейшего цикла работы у CVS есть множество дополнительных возможностей.
Основной цикл работы с CVS
Под основным циклом работы понимается использование стандартных команд CVS, позволяющих читать файлы, изменять их и записывать изменения.
Каждый CVS-модуль (полное дерево каталогов), помещенный под контроль CVS, хранится в центральном репозитарии. Вся работа выполняется с локальной копией CVS-модуля изменения из которой переносятся в репозитарий по готовности. Для этого используется несколько основных команд.
checkout
Для создания локальной копии CVS-проекта необходимо выбрать каталог для проектов на локальном диске (напр. D:projects), в котором будет создан подкаталог данного проекта. В этом каталоге выполнить команду
cvs checkout имя_проекта
После этого в каталоге D:projectsимя_проекта появляется локальная копия всего дерева последней версии указанного проекта.
Возможные значения параметра имя_проекта можно увидеть простым просмотром файла CVSROOT/modules, который можно запросить командой:
cvs checkout CVSROOT
commit
После того, как проверено, что внесенные Вами изменения оставили проект в рабочем (по крайней мере, в компилируемом) состоянии, следует закрепить изменения в репозитарии. В принципе, можно использовать разную политику закрепления изменений (как можно чаще, как можно реже, только после успешной компиляции и т. д.). Выбор конкретной политики не влияет на работу самого CVS и обусловлен требованиями проекта. Закрепление изменений производится командой:
cvs commit -m "[Комментарий]" [file]
либо не указывая имя файла, что закрепляет все изменения в выбранной директории.
Если не указан комментарий, то CVS запускает редактор для ввода пояснений в журнал версий.
Возможно, что изменения вносились в старую версию файла и с тех пор файл был поправлен.
Об этом cvs commit выдаст сообщение:
cvs server: Up-to-date check failed for `file' cvs [server aborted]: correct above errors first!
и надо будет выполнить cvs update для конфликтного файла, а затем, возможно, разрешить конфликт (процедура описана ниже). Если одновременно закрепляются изменения в нескольких файлах, то если конфликт был в одном из них, то все закрепление сделано не будет.
update
Синхронизация с репозитарием может быть выполнена в любой момент командой
cvs update [-dP] [file]
Ключ -d используется для проноса новых директорий, появившихся в проекте. Ключ -P удаляет пустые директории.
Дело в том, что в CVS нельзя удалить директорию. Можно лишь убрать все файлы из директории, тогда по команде cvs update -P она будет стерта с локальной машины.
Данная команда является одной из самых безопасных, так как ничего не меняет на сервере. Отметим также, что если файл на локальном компьютере был испорчен по каким-либо причинам, например неверно отредактирован, то его можно восстановить удалив его на локальной машине и заново считав с сервера командой cvs update [file].
При работе команда cvs update выдает протокол действий в виде списка имен файлов, предваряемых одной буквой — статусом файла. Значения букв:
- U,P
- В файл внесены изменения из репозитария.
- M
- Локальный файл модифицирован относительно репозитария.
- C
- Изменения локального файла конфликтуют с правками в репозитарии.
- ?
- Файл не помещен под CVS.
- А
- Файл локально добавлен, а в репозитарий не помещен.
- R
- Файл удален, но изменения в репозитарий не пронесены.
Проект может содержать директории, которые образованы специальным образом ссылкой на директории со стандартными файлами. Команда cvs update не копирует такие директории в вашу локальную копию проекта. Такие директории копируются командой
cvs checkout имя_проекта
то есть той же командой, которая используется для создании копии проекта.
Если в директории завести файл с именем .cvsignore и поместить в него список шаблонов файлов, которые не должны помещаться под CVS, то на них «?» выдаваться не будет.
Если было внесено много исправлений и команда выдала большой список, ее можно запустить повторно — она выдаст только файлы с модификациями и конфликтами. Конфликт означает, что правки файла, сделанные пользователем локально конфликтуют с правками, внесенными в репозитарий кем-то еще. Соответствующие места в файле будут помечены:
<<<<<<< filename Текст из локального файла ======= Текст из репозитария >>>>>>> version
Перед закреплением изменений необходимо эти конфликты разрешить.
add
Добавление директории или файла выполняется командой
cvs add file.txt
Для файла необходимо затем выполнить cvs commit.
Под CVS можно хранить также бинарные файлы, хотя и не так эффективно, как текстовые, т. к. в этом случае, CVS будет полностью хранить каждую версию файла. Бинарные файлы добавляются с опцией «-kb»:
cvs add -kb file.jpg
remove
Для удаления файла выполняются команды:
cvs remove -f file cvs commit -m "[комментарий]" file
Заметим, что команда cvs remove
требует, чтобы либо файл был сначала удален из локального каталога, либо была вызвана с опциями, форсирующими удаление локального файла, т.е. cvs remove -f code.sql
.
release
Если вдруг возникла необходимость убрать файлы из локальной CVS директории, то необходимо делать это командой:
cvs release -d имя_проекта
в основном каталоге проекта. При этом производится проверка соответствия локальной директории и состояния репозитария. Если есть конфликтующие или расходящиеся файлы, то будет выдана диагностика о их наличии. Все расхождения нужно проанализировать и устранить. После этого необходимо повторно выполнить ту же команду, проверить, что измененных файлов нет, и ответить на задаваемый вопрос «Y». После этого все файлы проекта будут удалены.
Правила работы с CVS
При использовании CVS нужно придерживаться нижеописанных правил:
- Рекомендуется с утра делать cvs update на всю директорию с проектами, чтобы не пропускать новые версии.
- Все полезные изменения вечером должны быть отражены в репозитарии. Исключением являются программные тексты, которые не были до конца исправлены (не компилируются, ошибки при тестировании).
- При выполнении cvs commit нужно всегда вводить комментарии. Если есть система регистрации ошибок или заданий (например Bugzilla или Jira), то качестве комментария при cvs commit удобно использовать не текстовое описание проблемы и исправлений, а код ошибки или задания, типа «Bug 1234».
- Обязательно нужно просматривать результат cvs commit, чтобы не пропустить сообщение о конфликте.
- Нельзя получать новые версии файлов другим путем, кроме как выполнением команд update или checkout. Копирование новых версий файлов с другого компьютера может привести к потере данных!
Расширенные возможности CVS
Рассмотрим функции и команды CVS, хотя и относительно редко используемые, но полезные во многих специальных случаях.
log
Для того, чтобы получить историю работы с файлом, нужно использовать команду
cvs log [file]
Результат работы рекомендуется перенаправлять в отдельный файл, который потом смотреть в произвольной кодировке. Выдается история изменений данного файла с номерами версий и пользователями, которые закрепляли данные версии.
update
Для того, чтобы получить конкретную версию файла, необходимо набрать команду
cvs update -r номер_версии file
Из репозитария будет загружена версия с данным номером. Если в файле на локальном компьютере производились изменения, то они будут слиты с версией с запрашиваемым номером, что может привести к странным результатам и, обычно, после этого требуется устранить конфликт.
липкие метки
Локальный файл, который был получен путем считывания предыдущей версии считается замороженным (имеющим «sticky tag») и изменения в нем не будут закрепляться в репозитарии. Проверить наличие этого тага можно путем вызова команды для получения статуса файла
cvs status [file]
В результате исполнения выдается полная информация о версиях данного файла.
Для того, чтобы вернуться к последней версии файла, необходимо набрать команду
cvs update -A file
Команда обеспечивает снятие всех «sticky tag» с выбранного файла, она также синхронизирует файл с последней версией с сервера. Если мы вдруг произвели изменения в файле с установленным «sticky tag», то изменения не будут потеряны — они будут пронесены в последнюю версию файла, при этом естественно возникнет конфликт.
diff
Для просмотра изменений файла от версии к версии нужно вызвать команду
cvs diff -r версия_1 [-r версия_2] file
Вторую версию можно не указывать, тогда будет взят текущий файл. Результат следует перенаправлять в отдельный файл. В файле будет приведен список отличий между версиями.
annotate
Для того, чтобы посмотреть, кто что написал в файле, необходимо использовать команду
cvs annotate file
Результат надо направлять в файл. В результате, для каждой строки исходного файла будет выведено имя пользователя и версия, в которой появилась данная строка.
Управление ветками под CVS
Для поддержки нескольких версий описаний библиотек, либо стандартов на разработку, необходимо использовать наиболее сложные возможности CVS — систему веток.
Путь развития каждого файла под CVS может представлять собой дерево (вообще говоря, даже многопотоковый граф). От основного ствола — основного пути изменения файла можно отщепить произвольное количество веток. На определенном этапе развития ветки могут быть снова слиты в одну ветку.
Для отщепления ветки используется механизм пометки тагами. Версия файла может быть помечена произвольным количеством тагов, таг — строка произвольного вида. Для данного файла существует одна и только одна версия помеченная конкретным тагом. Если мы хотим пометить тагом другую версию, то мы должны снять этот таг с предыдущей версии.
Для проекта таги используются для пометки определенных срезов информации. Эти срезы могут перемещаться и изменяться со временем.
Помимо обычных тагов бывают таги веток. Если мы хотим завести новую ветку у файла, то мы обязаны пометить ее веточным тагом. Отметим, что при поиске файла с тагом неважно, ищем мы файл по веточному тагу, либо по обычному.
Когда ветка выделена — она продолжает развиваться независимо, при этом последняя версия файла ветки помечена тагом этой ветки.
Для пометки файла тагом нужно использовать команду
cvs tag -F таг
Она пометит все файлы в директории и поддиректориях указанным тагом. Использование -F позволяет сдвигать таг, если он раньше был установлен.
Для того, чтобы создать ветку, нужно вызвать нижеследующие команды. Сначала нужно считать версию файла помеченную данным тагом — для проверки.
cvs update -r таг_ветки file
Далее следует проверить таг и признак тага — может быть ветка уже была создана. Также нужно проверить номер версии файла — отсюда ли мы хотим делать ветку. Вызвав команду
cvs status file
произведем проверку. Если мы хотим делать ветку из другого места, то мы должны считать нужную версию файла и сделать веткой при помощи команды
cvs tag -F -b таг_ветки file
Команда создает ветку этого файла для стандарта с данным номером. Опция -F означает, что старый таг с этим именем будет удален.
Для того, чтобы считать ветку файла, необходимо вызвать команду
cvs update -r таг_ветки
При этом на локальную машину будет помещены файлы из этой ветки, а за отсутствием файла в этой ветке — из основного ствола.
После этого локальная машина начинает работать с данной веткой. Команда update будут считывать более новые файлы этой ветки.
Для взятия последней версии основного ствола нужно использовать команду
cvs update -A file
Администрирование репозитария
Под администрированием репозитария понимается действия по созданию, удалению и импорту репозитария и отдельных CVS-модулей.
Создание CVS-модуля:
- Создать директорию с названием проекта (CVS-модуля). Директорию можно создавать в любом месте локальной машины.
- Внутри директории выполнить команду
cvs import custis/path vendortag releasetag
где
- path
- место CVS-модуля внутри репозитория, например, для модулей документации — docs/projects/имя_проекта;
- vendortag
- создатель модуля. ;releasetag: идентификатор, определяющий версию проекта. Идентификатор должен начинаться с буквы и не должен содержать символов @,$,-.
Пример такой команды
cvs import custis/projects/adb CUSTIS ADB_0_0
- Удалить на локальной машине созданную директорию.
- Создать локальную копию CVS-проекта CVSROOT/modules, для чего в корневой директории выполнить команду
cvs checkout CVSROOT/modules
- В файле projects/CVSROOT/modules в нужное место вставить название модуля и его место в репозитории, используя имеющиеся там примеры. Место в репозитории должно совпадать с путем, указанным в команде import.
- Записать изменения файла projects/CVSROOT/modules в репозиторий с помощью команды cvs commit.
- Удалить модуль CVSROOT с локальной машины командой
cvs release -d CVSROOT
- Создать локальную копию проекта командой checkout, убедиться, что все правильно.
Тесты
Можете проверить свои знания CVS интерактивной системой тестирования:
- Тест «CVS-базовый уровень»;
- Тест «CVS-advanced».
CVS поддерживает историю дерева каталогов с исходным кодом, работая с последовательностью изменений. CVS маркирует каждое изменение моментом времени, когда оно было сделано, и именем пользователя, совершившим изменение. Обычно человек, совершивший изменение, также предоставляет текстовое описание причины, по которой произошло изменение. Вооружившись всей этой информацией, CVS может отвечать на такие вопросы, как
Перед обсуждением множества разнобразных терминов и идей, давайте взглянем на основные команды CVS.
CVS хранит все изменения в данном проекте в дереве каталогов, называемом «репозиторием» (repository). Перед тем, как начать использовать CVS, вам необходимо настроить переменную среды CVSROOT так, чтобы она указывала на каталог репозитория. Тот, кто ответственен за управление конфигурацией вашего проекта, вероятно, знает, что именно должна содержать в себе эта переменная; возможно даже, что переменная CVSROOT уже установлена глобально.
В любом случае, на нашей системе репозиторий находится в `/usr/src/master’. В этом случае вам следует ввести команды
если это Bash или какой-либой другой вариант Bourne shell.
CVS не может работать в обычном дереве каталогов; наоборот, вы должны работать в каталоге, который CVS создаст для вас. Точно так же, как вы выписываете книгу из библиотеки перед тем, как забрать ее с собой, вам следует использовать команду `cvs checkout’, чтобы получить от CVS рабочее дерево каталогов. Предположим, например, что вы работаете над проектом, называемым `httpc’, тривиальным HTTP клиентом:
Команда `cvs checkout httpc’ означает «Извлечь дерево исходных текстов с именем `httpc’ из репозитория, указанного в переменной окружения `CVSROOT’.»
Большинство этих файлов — рабочие копии исходных текстов `httpc’. Однако, подкаталог с именем `CVS’ (самый первый) имеет другое назначение. CVS использует его для хранения дополнительной информации о каждом файле в этом каталоге, чтобы определять, какие изменения вы внесли в них с тех пор, как извлекли их из репозитория.
После того, как CVS создал рабочее дерево каталогов, вы можете обычным образом редактировать, компилировать и проверять находящиеся в нем файлы — это просто файлы.
Например, предположим, что мы хотим скомпилировать проект, который мы только что извлекли:
Кажется, `httpc.c’ еще не был перенесен на эту операционную систему. Нам нужно сделать приведение типов для одного из аргументов функции connect. Чтобы сделать это, надо изменить строку 48, заменив
gcc -g -Wall -lnsl -lsocket httpc.c -o httpc
$ httpc GET http://www.cyclic.com
…здесь находится текст HTML с домашней страницы Cyclic Software …
$
Объединение изменений
Так как каждый разработчик использует свой собственный рабочий каталог, изменения, которые вы делаете в своем каталоги, не становятся автоматически видимыми всем остальным в вашей команде. CVS не публикует изменений, пока они не закончены. Когда вы протестируете изменения, вы должны «зафиксировать» (commit) их в репозитории и сделать их доступными остальным. Мы опишем команду cvs commit далее.
Однако, что если другой разработчик изменил тот же файл, что и вы, и, может быть, даже изменил те же самые строки? Чьи изменения будет использованы? Обычно ответить на этот вопрос автоматически невозможно, и CVS совершенно точно некомпетентен, чтобы принимать такие решения.
Поэтому перед тем, как фиксировать ваши изменения, CVS требует, чтобы исходные тексты были синхронизированы со всеми изменениями, которые сделали остальные члены группы. Команда cvs update позаботится об этом:
$ cvs update cvs update: Updating . U Makefile RCS file: /u/src/master/httpc/httpc.c,v retrieving revision 1.6 retrieving revision 1.7 Merging differences between 1.6 and 1.7 into httpc.c M httpc.c $
Рассмотрим пример строка за строкой:
`U Makefile'
Строка вида `U файл’ означает, что файл просто был обновлен; кто-то еще внес в этот файл изменения, и CVS скопировал измененный файл в ваш рабочий каталог.
`RCS file:... retrieving revision 1.6 retrieving revision 1.7 Merging differences between 1.6 and 1.7 into httpc.c'
Это сообщение означает, что кто-то еще изменил `httpc.c’; CVS объединила их изменения с вашими и не обнаружила текстуальных конфликтов. Цифры `1.6′ и `1.7′ — это номера редакции (revision numbers), используемые для обозначения определенных точек истории файла. Заметьте, что CVS объединяет изменения только в вашей рабочей копии; репозиторий и рабочие каталоги других разработчиков остаются нетронутыми. От вас требуется протестировать объединенный текст и убедиться, что он верен.
`M httpc.c'
Строка вида `M файл’ означает, что файл был модифицирован вами и содержит изменения, которые еще не стали видны другим разработчикам. Это — изменения, которые вам следует зафиксировать.
Так как CVS объединила чьи-то еще изменения с вашими исходными текстами, следует убедиться, что они все еще работают:
$ make gcc -g -Wall -lnsl -lsocket httpc.c -o httpc $ httpc GET http://www.cyclic.com ...HTML text for Cyclic Software's home page follows... $
Фиксирование изменений
Теперь, когда вы синхронизировали свои исходники с коллегами и протестировали их, вы готовы поместить свои изменения в репозиторий и сделать их видимыми остальным разработчикам. Единственный файл, который вы изменили — это `httpc.c’, но в любом случае можно без опаски запустить cvs update, чтобы получить от CVS список модифицированных файлов:
$ cvs update cvs update: Updating . M httpc.c $
Как и ожидалось, единственный файл, который упоминает CVS — это `httpc.c’; CVS говорит, что этот файл содержит изменения, которые еще не были зафиксированы. Вы можете зафиксировать их так:
$cvs commit httpc.c
В этом месте CVS запустит ваш любимый текстовый редактори попросит вас ввести описание изменений. После того, как вы выйдете из редактора, CVS зафиксирует ваши изменения:
Checking in httpc.c; /u/src/master/httpc/httpc.c,v <-- httpc.c new revision: 1.8; previous revision: 1.7 $
Заметьте, что теперь вы зафиксировали ваши изменения и они видны всем остальным членам группы. Когда другой разработчик исполняет cvs update, CVS внесет ваши изменения в файлы в его рабочем каталоге.
Отслеживание изменений
Теперь вы, возможно, захотите узнать, какие именно изменения внес другой разработчик в файл `httpc.c’. Чтобы увидеть журнальные записи для данного файла, можно использовать команду cvs log:
$ cvs log httpc.c RCS file: /usr/src/master/httpc/httpc.c,v Working file: httpc.c head: 1.8 branch: locks: strict access list: symbolic names: keyword substitution: kv total revisions: 8; selected revisions: 8 description: The one and only source file for trivial HTTP client ---------------------------- revision 1.8 date: 1996/10/31 20:11:14; author: jimb; state: Exp; lines: +1 -1 (tcp_connection): Cast address stucture when calling connect. ---------------------------- revision 1.7 date: 1996/10/31 19:18:45; author: fred; state: Exp; lines: +6 -2 (match_header): Make this test case-insensitive. ---------------------------- revision 1.6 date: 1996/10/31 19:15:23; author: jimb; state: Exp; lines: +2 -6 ... $
Большую часть текста здесь вы можете игнорировать; следует только обратить внимание на серию журнальных записей после первой строки черточек. Журнальные записи выводятся на экран в обратном хронологическом порядке, исходя из предположения, что недавние изменения обычно более интересны. Каждая запись описывает одно изменение в файле, и может быть разобрано на составные части так:
`revision 1.8'
Каждая версия файла имеет уникальный «номер редакции». Номера ревизии выглядят как `1.1′, `1.2′, `1.3.2.2′ или даже `1.3.2.2.4.5′. По умолчанию номер 1.1 — это первая редакция файла. Каждое следующее редактирование увеличивает последнюю цифру на единицу.
`date: 1996/10/31 20:11:14; author: jimb; ...'
В этой строке находится дата изменения и имя пользователя, зафиксировавшего это изменение; остаток строки не очень интересен.
`(tcp_connection: Cast...'
Это, очевидно, описание изменения.
Команда cvs log может выбирать журнальные записи по дате или по номеру редакции; за описанием деталей обращайтесь к руководству.
Если вы хотите взглянуть на соответствующее изменение, то можете использовать команду cvs diff. Например, если вы хотите увидеть, какие изменения Фред зафиксировал в качестве редакции 1.7, используйте такую команду:
$ cvs diff -c -r 1.6 -r 1.7 httpc.c
Перед рассмотрением того, что нам выдала эта команда, опишем, что означает каждая ее часть.
-c | Задает использование удобочитаемого формата выдачи изменений. (Интересно, почему это не так по умолчанию). (1) |
-r 1.6 -r 1.7 | Указывает CVS, что необходимо выдать изменения, необходимые, чтобы превратить редакцию 1.6 в редакцию 1.7. Вы можете запросить более широкий диапазон изменений; например, -r 1.6 -r 1.8 отобразит изменение, сделанные Фредом, и изменения, сделанные вами чуть позже. (Вы также можете заказать выдачу изменений в обратном порядке — как будто бы они были отменены — указав номера редакций в обратном порядке: -r 1.7 -r 1.6. Это звучит странно, но иногда полезно.) |
httpc.c | Имя файла для обработки. Если вы не укажете его, CVS выдаст отчет обо всем каталоге. |
Вот что выдаст эта команда:
Index: httpc.c ================================================================= RCS file: /u/src/master/httpc/httcp.c,v retrieving revision 1.6 retrieving revision 1.7 diff -c -r1.6 -r1.7 *** httpc.c 1996/10/31 19:15:23 1.6 --- httpc.c 1996/10/31 19:18:45 1.7 *************** *** 62,68 **** } ! /* Return non-zero iff HEADER is a prefix of TEXT. HEADER should be null-terminated; LEN is the length of TEXT. */ static int match_header (char *header, char *text, size_t len) --- 62,69 ---- } ! /* Return non-zero iff HEADER is a prefix of TEXT, ignoring ! differences in case. HEADER should be lower-case, and null-terminated; LEN is the length of TEXT. */ static int match_header (char *header, char *text, size_t len) *************** *** 76,81 **** --- 77,84 ---- for (i = 0; i < header_len; i++) { char t = text[i]; + if ('A' <= t && t <= 'Z') + t += 'a' - 'A'; if (header[i] != t) return 0; } $
Требуются некоторые усилия, чтобы привыкнуть к такой подаче информации, но это определенно стоит того.(2)
Интересная часть информации начинается с первых двух строк, начинающихся с *** и —; они описывают старый и новый файлы, подлежащие сравнению. Остальное состоит из двух «ломтей» (hunk), каждый из которых начинается со строки из звездочек. Вот первый «ломоть»:
*************** *** 62,68 **** } ! /* Return non-zero iff HEADER is a prefix of TEXT. HEADER should be null-terminated; LEN is the length of TEXT. */ static int match_header (char *header, char *text, size_t len) --- 62,69 ---- } ! /* Return non-zero iff HEADER is a prefix of TEXT, ignoring ! differences in case. HEADER should be lower-case, and null-terminated; LEN is the length of TEXT. */ static int match_header (char *header, char *text, size_t len)
Текст из более старой редакции находится после строки *** 62,68 ***; текст новой редакции находится после строки — 62,69 —. Пара цифр означает показанный промежуток строк. CVS показывает контекст вокруг изменений и отмечает измененные строки символами `!’. Таким образом вы видите, что одна строка из верхней половины была заменена на две строки из нижней.
Вот второй «ломоть»:
*************** *** 76,81 **** --- 77,84 ---- for (i = 0; i < header_len; i++) { char t = text[i]; + if ('A' <= t && t <= 'Z') + t += 'a' - 'A'; if (header[i] != t) return 0; }
Здесь описывается добавление двух строк, что обозначается символами `+’. CVS не выводит старый текст — это было бы избыточно. Для описания удаленных строк используется подобный формат.
Как и выход команды diff, выход команды cvs diff обычно называется «заплатой» (patch), потому что разработчики традиционно использовали этот формат для распространения исправлений и небольших новый возможностей. Достаточно читабельна, заплата содержит достаточно информации, чтобы применить изменения, которые она содержит, к текстовому файлу. В действительности, команда patch в среде UNIX делает с заплатами именно это.
Добавление и удаление файлов
CVS обращается с добавлением и удалением файлов так же, как и с прочими изменениями, записывая такие события в истории файлов. Можно смотреть на это так, как будто CVS сохраняет историю каталогов вместе с историей файлов.
CVS не считает, что созданные файлы должны оказаться под его контролем; это не так во многих случаях. Например, не требуется записывать историю изменений объектных и выполняемых файлов, потому что их содержимое всегда может быть воссоздано из исходных файлов (надо надеяться). Вместо этого, когда вы создадите новый файл, cvs update маркирует этот файл флагом `?’, пока вы не скажете CVS, что именно вы намереваетесь сделать с этим файлом.
Чтобы добавить файл в проект, сначала вы должны создать его, затем использовать команду cvs add, чтобы маркировать его как добавленный. Затем при следующем выполнении команды cvs commit CVS добавит этот файл в репозиторий. Например, вот так можно добавить файл README в проект httpc:
$ ls CVS Makefile httpc.c poll-server $ vi README ...введите описание httpc... $ ls CVS Makefile README httpc.c poll-server $ cvs update cvs update: Updating . ? README --- CVS еще не знает об этом файле $ cvs add README cvs add: scheduling file `README' for addition cvs add: use 'cvs commit' to add this file permanently $ cvs update --- что же теперь думает CVS? cvs update: Updating . A README --- Файл помечен как добавленный $ cvs commit README ... CVS просит вас ввести журнальную запись... RCS file: /u/jimb/cvs-class/rep/httpc/README,v done Checking in README; /u/src/master/httpc/README,v <-- README initial revision: 1.1 done $
CVS обращается с удаленными файлами почти так же. Если вы удалите файл и выполните `cvs update’, CVS не считает, что вы намереваетесь удалить файл из проекта. Вместо этого он поступает милосерднее — он восстанавливает последнюю сохраненную в репозитории версию файла и маркирует его флагом U, точно так же, как и любой другое обновление. (Это означает, что если вы хотите отменить изменения файла в рабочем каталоге, вы можете просто удалить его и позволить команде `cvs update’ создать его заново.)
Чтобы удалить файл из проекта, вы должны сначала удалить его,а потом использовать команду `cvs rm’, чтобы пометить его для удаления. При следующем запуске команда `cvs commit’ удалит файл из репозитория.
Фиксирование файла, маркированного с помощью `cvs rm’ не уничтожает историю этого файла — к ней просто добавляется еще одна редакция — «не существует». В репозитории по прежнему хранятся все записи об этом файле, и к ним можно обращаться по желанию — например, с помощью `cvs diff’ или `cvs log’.
Для переименования файла существует несколько стратегий; самая простая — переименовать файл в рабочем каталоге, затем выполнить `cvs rm’ со старым именем и `cvs add’ с новым. Недостаток этого подхода в том, что журнальные записи о содержимом старого файла не переносятся в новый файл. Другие стратегии позволяют избежать этого, но зато доставляют другие, более странные проблемы.
Вы можете добавлять каталоги точно также, как и обычные файлы.
Написание хороших журнальных записей
Если можно использовать `cvs diff’, чтобы получить точное содержание любого изменения, то зачем тогда придумывать еще журнальную запись о нем? Очевидно, что журнальные записи короче, чем тексты изменений, и позволяют читателю получить общее понимание изменения без необходимости углубляться в детали.
Однако же, хорошая запись в журнале описывает причину, по которой было сделано изменение. Например, плохая журнальная запись для редакции 1.7 может звучать как «Преобразовать `t’ к нижнему регистру». Это правильно, но бесполезно — `cvs diff’ предоставляет точно ту же информацию, и гораздо яснее. Гораздо лучшей журнальной записью было бы «Сделать эту проверку независящей от регистра», потому что это гораздо яснее описывает причину любому, кто понимает, что происходит в коде — клиенты HTTP должны игнорировать регистр букв при анализе заголовков ответа от сервера.
Обработка конфликтов
Как уже упоминалось, команда `cvs update’ объединяет изменения, сделанные другими разработчиками, с исходными текстами в вашем рабочем каталоге. Если вы отредактировали файл одновременно с кем-то другим, CVS объединит ваши изменения.
Довольно легко представить себе, как работает объединение, если изменения были совершены в разных участках файла, но что если вы оба изменили одну и ту же строку? CVS называет эту ситуацию конфликт и предоставляет вам самому разобраться с ним.
Например, предположим, что вы добавили некую проверку на ошибки в код, определяющий адрес сервера. Перед фиксированием изменений вы должны запустить `cvs update’, чтобы синхронизировать ваш рабочий каталог с репозиторием:
$ cvs update cvs update: Updating . RCS file: /u/src/master/httpc/httpc.c,v retrieving revision 1.8 retrieving revision 1.9 Merging differences between 1.8 and 1.9 into httpc.c rcsmerge: warning: conflicts during merge cvs update: conflicts found in httpc.c C httpc.c $
В этом случае другой разработчик изменил тот же участок файла, что и вы, поэтому CVS жалуется на конфликт. Вместо того, чтобы напечатать M httpc.c, как это обычно происходит, CVS печатает C httpc.c, что означает наличие конфликта в этом файле.
Чтобы справиться с конфликтом, откройте этот файл в редакторе. CVS обозначает конфликтующий текст так:
/* Look up the IP address of the host. */ host_info = gethostbyname (hostname); <<<<<<< httpc.c if (! host_info) { fprintf(stderr, "%s: host not found: %s\n", progname, hostname); exit(1); } ======= if (! host_info) { printf("httpc: no host"); exit(1); } >>>>>>> 1.9 sock = socket (PF_INET, SOCK_STREAM, 0);
Текст вашего рабочего файла появляется сверху, после символов <<<. Внизу находится конфликтующий код другого разработчика. Номер редакции 1.9 указывает, что конфликтующее изменение было внесено в версии 1.9 этого файла, упрощая проверку журнальных записей или просто выяснение изменений с помощью `cvs diff’.
Когда вы решите, как именно справиться с конфликтом, уберите маркеры из кода и отредактируйте его. В этом случае, так как ваша обработка ошибок определенно лучше, то просто отбросьте чужой вариант, оставив такой код:
/* Look up the IP address of the host. */ host_info = gethostbyname (hostname); if (! host_info) { fprintf(stderr, "%s: host not found: %s\n", progname, hostname); exit(1); } sock = socket (PF_INET, SOCK_STREAM, 0);
Теперь протестируйте изменения и зафиксируйте их:
$ make gcc -g -Wall -Wmissing-prototypes -lnsl -lsocket httpc.c -o httpc $ httpc GET http://www.cyclic.com HTTP/1.0 200 Document follows Date: Thu, 31 Oct 1996 23:04:06 GMT ... $ httpc GET http://www.frobnitz.com httpc: host not found: www.frobnitz.com $ cvs commit httpc.c
Важно понимать, что именно CVS считает конфликтом. CVS не понимает семантики вашей программы, он обращается с исходным кодом просто как с деревом текстовых файлов. Если один разработчик добавляет новый аргумент в функцию и исправляет все ее вызовы, пока другой разработчик одновременно добавляет новый вызов этой функции, и не передает ей этот новый аргумент, что определенно является конфликтом — два изменения несовместимы — но CVS не сообщит об этом. Его понимание конфликтов строго текстуально.
На практике, однако, конфликты случаются редко. Обычно они происходят потому, что два человека пытаются справиться с одной и той же проблемой, от недостатка взаимодействия между разработчиками, или от разногласий по поводу архитектуры программы. Правильной распределение задач между разработчиками уменьшает вероятность конфликтов.
Многие системы контроля версий позволяют разработчику блокировать файл, предотвращая внесение в него изменений до тех пор, пока его собственные изменения не будут зафиксированы. Несмотря на то, что блокировки уместны в некоторых ситуациях, это не всегда подход лучше, чем подход CVS. Изменения обычно объединяются без проблем, а разработчики иногда забывают убрать блокировку, в обоих случаях явное блокирование приводит к ненужным задержкам. Более того, блокировки предотвращают только текстуальные конфликты — они ничего не могут поделать с семантическими конфликтами типа вышеописанного — когда два разработчика редактируют разные файлы.
Footnotes
(1) Интересно, почему это вообще не -u? Прим. перев.
(2) Все же лучше использовать -u. Прим. перев.