Архив метки: git

Git, в примерах

Содержание
1. Введение
2. Запуск консоли для работы с Git
3. Git, простые примеры
3.1. Настройка Git-репозитория
3.1.1. Пример 1: создание репозитория и установка локальных настроек
3.1.2. Пример 2: то же что и пример1, но короче запись
3.1.3. Пример 3: установка пользовательских настроек
3.2. Простые операции с одним репозиторием
3.2.1. Пример 1: создать репозиторий, зафиксировать изменения
3.2.2. Пример 2: создать репозиторий, сделать 3 фиксации
3.2.3. Пример 3: работа с git checkout (возврат)
3.2.4. Пример 4: работа с git checkout и git branch (возврат и создание новой ветки)
3.2.5. Пример 5: работа с git branch (слияние двух веток)
3.3. Операции с двумя репозиториями
3.3.1. Пример 1: создать реп, отклонироваться, внести изменения в первый, обновиться во втором
3.3.2. Пример 2: создать два репозитория, внести изменения в оба, второй слить с первым
3.3.3. Пример 3: создать два репозитория, внести изменения в оба, второй слить с первым
3.3.4. Пример 4: втолкнуть данные в удалённый пустой репозиторий
3.3.5. Пример 5: втолкнуть данные в удалённый не пустой репозиторий
3.4. Заключение

Введение

В этой части мы рассмотрим работу с репозиторием git на примерах

Команды, которые будут использоваться здесь, кратко описаны в предыдущей части Git, краткий справочник команд.

Читать

Git, краткая теория

Введение

Git (произн. «гит») — это распределённая система управления версиями файлов. Проект был создан Линусом Торвальдсом для управления разработкой ядра Linux, первая версия выпущена 7 апреля 2005 года.

Git позволяет вести распределённую работу над одним проектом. Разработчики могут располагаться как на одном компьютере, так и в разных частях света.

Помимо Git есть много других систем управления версиями (VCS, Version Control System), одной из которых является свободная (и бесплатная) система Subversion (кратко SVN).

Subversion (также известная как «SVN») — свободная централизованная система управления версиями, официально выпущенная в 2004 году компанией CollabNet Inc.

Обо всём этом можно подробно прочитать в других источниках. Здесь же я опишу своё краткое представление о Git, которое у меня сложилось при работе с ним. Описание не претендует на полное и всеобъемлющее.

Описание будет в виде коротких тезисов и абзацев

Хотя местами указаны названия команд, они не будут выполняться, т.к. некоторые параметры для них опущены. Конкретные примеры применения команд git будут рассмотрены в следующей статье.

Git, описание

Общее

Git — это распределённая система управления версиями.

С git можно работать и локально и удалённо.

Репозиторий (хранилище) — это место, где хранится наши данные: история изменений нашего проекта

Репозиторий Git — это всегда локальный репозиторий

Данные репозитория git помещается в папку .git/ в папке, в которой вы создали репозиторий

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

О репозитории

В Git, в отличии от Subversion, есть два типа репозитория: «простой» и «голый»

Простой репозиторий — это основной репозиторий, с которым вам предстоит работать. В нём вы можете выполнять большинство команд git. Такой репозиторий содержит подпапку .git/

Голый репозиторий — этот репозиторий часто, применяемый для ведения разработки в централизованном стиле. Данные репозитория не помещаются в подпапку .git/, а размещаются непосредственно в корне папки репозитория

Настройки репозитория

Используйте команду git config для работы с настройками, или редактируйте файлы настроек вручную

Каждый репозиторий Git имеет свои собственные настройки, располагаемые в файле .git/config

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

  • Уровень 1. Локальные настройки репозитория, применяются только к одному конкретному репозиторию, располагаются в каждом отдельном репозитории в файле .git/config
  • Уровень 2. Пользовательские настройки репозитория, применяются ко всем репозиториям пользователя, и располагаются в домашней директории пользователя в файле ~/.gitconfig (Для Windows путь к домашней директории вы можете явно указать в переменной окружения HOME)
  • Уровень 3. Системные настройки, применяются ко всем репозиториям всех пользователей системы, располагаются обычно в файле /etc/gitconfig (для Windows это может быть файл «c:Program Files (x86)Gitetcgitconfig»)

Приоритетным уровнем является первый, поэтому в нём могут быть переопределены все настройки, которые были установлены с верхних уровней.

Отношения между репозиториями

Репозиторий Git — это всегда локальный репозиторий, располагающийся в своей папке

Для репозитория есть понятие «наблюдать за другим репозиторием» (это понятие я придумал сам), на практике выражается использованием команд git remote в консоли и секций [remote «имя_наблюдения»] в файле конфигураций репозитория

Один репозиторий может:

  • не наблюдать ни за кем
  • или наблюдать за любым кол-вом репозиториев

Репозиторий A может загрузить полное (или частичное) содержимое репозитория B, даже если A «не наблюдает» за B, и даже если A не имеет общей истории с B.

«Загрузить» (git fetch) внешний репозиторий и «слиться» (git merge) с репозиторием — разные вещи! Мы всегда можем загрузить содержимое внешнего репозитория, посмотреть его историю изменений, но не прибегать к слиянию с ним.

Допустим, в репозитории A вы создали наблюдение с именем seeB за репозиторием B (git remote add seeB path/to/B). Но важно помнить, что «наблюдение» не обновляется автоматически. Это значит, что спустя время, git не сообщит вам об изменениях в репозитории B. Узнавать об этом вам необходимо самим — просто загрузив свежую версию репозитория B командой git fetch seeB. «Наблюдение» — это не какая-то система слежения, а просто копия репозитория B в одной из падпапок .git/ репозитория A.

Одиночная работа

Создав репозиторий, в него можно фиксировать изменения (git commit), просматривать логи изменений (git log), загружать указанную или последнюю версию фиксации (git checkout)

Одиночная работа с репозиторием сводится к тому, что вы делаете некоторые изменения в файлах и фиксируете их (подробнее об этом написано в статье «Название статьи»)

Распределённая работа

Командная работа над проектом (репозиторием) начинается тогда, когда кто-то клонирует его.

Клонировать репозиторий — значит скопировать весь репозиторий полностью: вместе со всей его историей изменений.

Один репозиторий может быть клонирован любым кол-вом людей.

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

Когда разработчик 2 внёс изменения в склонированный ранее репозиторий, он сообщает об этом разработчику 1. И тот «забирает» его изменения от себя используя команду git pull (или две последовательные команды git fetch и git merge). После этого разработчик 1 сообщает разработчику 2, что он принял изменения, после этого 2-й разработчик обновляет свой склонированный репозиторий командой git pull, и продолжает разработку.

Разработчик 2 не смог бы «втолкнуть» (git push) свои изменения в репозиторий разработчика 1, т.к. по умолчанию это запрещено (для больших подробностей смотрите опцию receive.denyCurrentBranch настроек репозитория)

Втолкнуть изменения из репозитория B в репозиторий A, без его ведома A можно в том случае, если репозиторий A является «голым» (т.е. создан командой git init —bare).

Распределённая структура разработки

Есть группа разработчиков. Каждый имеет свой собственный «простой» (git init) репозиторий. У каждого настроены «наблюдения» за репозиториями соседей. Каждый разработчик сам загружает к себе чужие изменений. Никто из разработчиков не может ни кому «втолкнуть» свои изменения.

Централизованная структура разработки

Существует центральный «голый» (git init —bare) репозиторий. Все остальные разработчики отклонировались от центрального репозитория. Каждый разработчик сначала вносит изменения в свой локальный репозиторий-клон, а потом «вталкивает» (git push) свои изменения в центральный сервер.

Ветви в репозитории

Используйте команду git branch, чтобы просмотреть список существующих веток в репозитории и узнать какая ветка сейчас выбрана активной

Используйте
команду git branch -r, чтобы просмотреть список веток в существующих «наблюдениях» репозитория

Ветка в репозитории — это альтернативный путь развития проекта

Репозиторий может содержать любое кол-во веток

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

Две ветви одного репозитория могут быть слиты в одну ветку (git merge)

Создать новую ветку можно двумя способами:

  • создать явно командой git branch имя_ветки
  • или неявно: откотиться назад до любой фиксации, внести изменения и зафиксировать эти новые изменения.

Git защитит вас, если вы попытаетесь удалить ветку (git branch -d имя_ветви), изменения которой вы ещё не сливали в главной ветвь. Но если вы всё же хотите удалить ветвь без слияния с основной ветвью, используйте команду git branch -D имя_ветви

Общие понятия в репозитории

Репозиторий имеет несколько важных понятий, о которых важно знать, чтобы поняь принцип работы с репозиторием.

Working tree — рабочая папка «простого» репозитория, место, где хранятся файлы вашего проекта (папка .git не относится к этой области)

Index (staging area) — незримая область, в которой хранятся отметки о файлах, изменения в которых вы собираетесь зафиксировать

Local repo — ваш локальный репозиторий.

Remote repo — это удалённый репозиторий, который может находиться как в другой папке на вашем компьютере, так и на другой машине в сети.

Таким образом процесс работы с репозиторием сводится к следующей простой схеме:

  1. вы вносите изменения в working directory
  2. добавляете желаемые изменения в область staging area
  3. фиксируете изменения в репозиторий local repo

Также есть ещё несколько понятий, значение которых я ещё не уловил до конца:

  • HEAD — ссылка на текущее состояние репозитория
  • FETCH_HEAD — ссылка на состояние репозитория, загруженное в эту ссылку командой git fetch или git pull

Заключение

Более подробно о работе git я расскажу в следующей статье. Данная статья служит лишь общим каркасом для понимания общих идей и принципов работы git. Всё, о чём говорилось здесь, мы рассмотрим в следующей статье на примерах

Читать далее: Git, краткий справочник команд

Смотрите также:

Автор: galiego710

Git, установка

Git (произн. «гит») — распределённая система управления версиями файлов. Проект был создан Линусом Торвальдсом для управления разработкой ядра Linux, первая версия выпущена 7 апреля 2005 года.
В этой статье я кратко опишу как устанавливать git.

Если вы работаете в Windows, то взять git для установки можно по этой ссылке: Git-1.7.8-previewXXXXXXXX.exe.
Желающие также могут установить графический клиент TortoiseGit для работы с git, но все наши примеры будут для командной строки.

Установка Git в Windows

Запускаем Git-1.7.8-previewXXXXXXXX.exe, оставляем всё по умолчанию, дожидаемся завершения работы установщика. После инсталляции, вы можете запустить консоль для работы с git:

"ПускПрограммыGitGit bash"

Быстрый запуск консоли для git

Конечно, запускать консоль мышью через меню каждый раз — дело утомительное. Поэтому предлагаю немного оптимизировать этот процесс.
1. На основном диске создайте папку

C:bin

2. Создайте файл C:bingitbash.bat со следующим содержимым:

@%WINDIR%system32cmd.exe /c ""C:Program Files (x86)Gitbinsh.exe" --login -i"

Обратите внимание, что путь «»C:Program Files (x86)Gitbinsh.exe» у вас может быть другим. Всю эту строчку я взял из поля «Объект» свойства ярлыка «ПускПрограммыGitGit bash».

3. Добавьте путь C:bin в переменную PATH среды Windows.

Свойства «Мой компьютер» вкладка «Дополнительно» кнопка «Переменные среды…» блок «Системные переменные».
Найдите в списке переменную «Path», выберите её, нажмите «Изменить». Допишите в конец значения переменной следующую строку:

;C:bin

Нажмите Ок Ок Ок

Готово! Теперь, если у вас уже была открыта командная строка, её нужно закрыть и запустить снова. Теперь из любой папки мы можем написать gitbash для запуска командной строки для работы с git.

Читать далее: Git, краткая теория

Список сайтов:
Установка и настройка git и gitosis в Ubuntu
DVCS Git и TortoiseGit в картинках. Пособие для начинающих чайников.

Смотрите также:

Автор: galiego710

Deployment и Git

Сперва — что такое deployment?

Буквальный перевод — развертывание. Речь идет о том, чтобы заставить код, написанный разработчиком в своей песочнице, заставить работать в реальных условиях на «боевых серверах». И вот во что это выливается даже в случае с одним разработчиком:

Мой нынешний проект я разрабатываю/тестирую на своем домашнем сервере (dev-сервер, это называется). А недавно выложил на хостинг — это, так сказать, production-сервер (ну, на самом деле, это пока что разновидность тестирования). И тут появляются некоторые ньюансы: Читать

Системы контроля версий. Git.

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

Что такое управление версиями и зачем оно?

Итак, предположим, вы разрабатываете программу. Для простоты сначала предположим, что вы разрабатываете ее в одиночку и для собственного удовольствия. Как это выглядит?

Создаем директорию MyApplication, в ней — собственно файлы программы (скажем, *.c). Далее начинается итерационный процесс: написали некоторое количество кода → скомпилировали → запустили → обнаружили ошибки или недоработки → отредактировали исходники → … Всё просто, в целом. Но через некоторое время начинаются нетривиальные вещи. Например:

  • Последнее изменение сделало программу хуже, чем она была до того. Хочется вернуть всё «как было». Хорошо, если не успели закрыть редактор — делаем Undo. А если закрыли?

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

  • Если программа предназначена не только для вас лично, то вам придется делать»релизы», т.е. выпускать заведомо работающие версии программы. Для подготовки релиза вам придется фиксить некоторое количество багов. Это довольно скучный процесс, хочется разбавлять его добавлением новых возможностей в программу (это, как правило, интереснее). Но нельзя: добавление новых фич обязательно добавит багов, и вы никогда не доедете до релиза.

Первое, что приходит в голову для решения всех этих проблем — резервные копии. Скажем, каждую работающую версию программы упаковывать в MyApplication_v0.001.tar.gz, в случае чего — откатываться. Для подготовки к релизу — сделать копию директории MyApplication, в которой только фиксить баги, а в основной — добавлять функционал. При этом подходе через некоторое время разработки у вас появится куча *.tar.gz и не меньше копий рабочей директории. Очень быстро вы начнете путаться, где что.

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

  • Вы добавили в программу (в свою копию) возможность A, а ваш товарищ (в свою) — возможность B. Хотелось бы, чтобы у обоих была версия с обоими возможностями.

  • Вы добавили в программу некоторую функцию, ваш товарищ добавил ее же, но реализовал по-другому. Какую версию выпускать и поддерживать дальше?

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

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

Все эти проблемы призваны решить специальные программы — системы контроля версий (version control systems, vcs).

Общие свойства VCS

Если вы работаете с vcs, то у вас есть место, где хранится вся история изменений в программе — это место называется репозиторий (repository). Для внесения изменений в программу вам нужно получить копию текущей разрабатываемой версии — она называется вашей рабочей копией (working copy). Процесс получения рабочей копии традиционно называется словом «чекаут» (checkout). В случае коллективной разработки, вам придется поддерживать актуальность вашей рабочей копии (проверять, что там остальные наработали) — это обычно называется «апдейт» (update). Чтобы ваши изменения попали в репозиторий, вам нужно сделать коммит (commit) (еще это называется словом checkin). Ча
сто словом commit называют собственно сам набор изменений, зафиксированный этой операцией (более точный термин — changeset). Каждое зафиксированное изменение называют ревизией. Вы можете в любой момент откатить свою рабочую копию к любой предыдущей ревизии — это называется revert.

Для того, чтобы отслеживать такие вещи, как релизы, или варианты рефакторинга программы, или тестировать версии с новыми функциями — в репозитории создаются ветви разработки (branches). Для согласования хода разработки в разных ветках (она может вестись, и обычно ведется, параллельно) время от времени делают слияние веток (merge) — когда к одной ветке применяются те же изменения, что были проделаны в другой. Если какое-то место какого-то файла было по-разному изменено в разных ветках, при слиянии возникает конфликт (merge conflict) — его приходится решать вручную, выбирая один из вариантов или как-то логично их объединяя.

Так как ревизий в репозитории обычно довольно много, возникает необходимость некоторые из них как-то помечать (например, выпущенные релизы, или просто состояния программы, в которых она заведомо работала). Такие пометки называют тегами (tags). Таким образом, теги — это поименованные ревизии в репозитории.

Автоматизация всех перечисленных операций — дело VCS.

Централизованные vs распределенные VCS

Всё множество VCS можно разделить на два класса — централизованные и распределенные.

В случае с централизованной VCS репозиторий хранится на одном сервере, и все разработчики работают с ним. Очевидное преимущество: простое управление выпуском релизов и вообще ходом развития программы, раз весь код в одном месте. Очевидный недостаток: если с сервером что-то случится, работа всех разработчиков пропадет (даже в случае регулярных бэкапов — пропадет работа всех разработчиков, скажем, за последнюю неделю). Известные примеры централизованных vcs — CVS, Subversion, Perforce.

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

  • Раз у каждого есть полная копия репозитория, работа всех разработчиков пропасть не может вообще.

  • Часто выполняемые операции — прежде всего, commit — происходят почти мгновенно, т.к. не требуют соединения по сети.

  • Каждый разработчик может создавать в своем репозитории ветки для каких-то экспериментов, всем остальным даже не нужно знать об этом.

  • Т.к. в распределенных VCS предполагается регулярная синхронизация репозиториев, в них гораздо более эффективно реализована операция слияния веток (здесь это одна из базовых операций, в отличие от централизованных VCS, где это делается нечасто).

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

Git

Git — это одна из распределенных VCS (distributed version control system, dvcs). Другими примерами dvcs являются Mercurial, Bazaar, Monotone.

Git выделяется на их фоне главным образом из-за того, что он применяется для разработки ядра Linux (http://www.kernel.org). Собственно, именно для этого Git и разрабатывался. Ядро Linux — весьма немаленький проект, как по объему исходного кода, так и по числу участников, поэтому при его разработке большое внимание было уделено производительности и легкости слияния веток.

Далее я привожу часто используемые команды git. Я опускаю кучу тонкостей и многие возможности Git. Всё это можно посмотреть в документации (git help имя-команды, например git help commit). Здесь — скорее отправная точка, свод основных возможностей Git.

Для начала работы с Git вам понадобится репозиторий. Его можно либо создать с нуля, либо клонировать какой-нибудь существующий репозиторий.

$ cd project
$ git init

— создаем пустой репозиторий.

$ git clone git://remote.server/repo.git

— клонируем существующий репозиторий. Кроме собственного протокола, git поддерживает http://, ssh:// и пр.

При создании репозитория в его корневой директории появляется скрытая директория .git — она содержит собственно репозиторий, т.е. историю версий итп. Все остальное содерж