company_banner
21 октября 2014 в 14:38

Git as Subversion

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

Почесав репу и содрогнувшись от связанных с Subversion воспоминаний мужики решили: «А что, мы же программисты!» и запилили свой Subversion с Git-ом и печеньками. Так родился проект git-as-svn.

Теперь мы можем использовать и Git, и Subversion с одним и тем же репозиторием. Причем доступ через Subversion напрямую использует данные Git-репозитория, в отличие, скажем, от SubGit, где для Subversion используется отдельный репозиторий.

Зачем понадобился еще один велосипед?

Справедливости ради надо отметить, что оба лагеря были по-своему правы. В пользу Git можно сказать следующее:
  1. У Git-а можно делать по ветке на задачу и спокойно коммитить промежуточные результаты без риска все разломать.
  2. Git, по сравнению с Subversion, нереально быстрый.

Против Git:
  1. Более высокий порог вхождения:
    • Git объективно сложнее, чем Subversion;
    • TortoiseGit далеко не такой удобный как TortoiseSvn;
    • многие вещи надо делать через консоль;
    • много больше способов отстрелить себе ногу.
  2. У Git не очень хорошо с клиентами под Windows.
  3. Для работы в Subversion-стиле (обновил → поработал → залил → поработал → залил...) нужно много больше телодвижений.
  4. Нет разделения прав внутри репозитория.
  5. При большом количестве постоянно заливающего народу, люди начинают биться головами (между pull и push успевает кто-то вклиниться).

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

Когда стало ясно, что эксперимент по замене Subversion на Git провалился, начали поиск решения из сложившейся ситуации. В процессе поиска были обнаружены:
  • Поддержка Subversion на GitHub.
    Можно приобрести в комплекте с GitHub Enterprise за сотни нефти.
  • Стремный проект SubGit.
    SubGit пытается через хуки поддерживать в синхронном состоянии Git и Subversion репозитории. Это архитектурное решение выглядит очень шатким, хотя, надо отметить, что реализация кажется рабочей.
  • Люто тормозящая python-реализация Subversion-фронтэнда для Git-репозитория.
    Самое главное в этом проекте — его небольшой объем. После этого задача реализации Subversion-фронтенда для Git-репозитория стала казаться просто безумной, а не абсолютно безумной, как было ранее. :)

Что это и как оно работает

Данный проект представляет собой реализацию Subversion-фронтэнда для Git-репозитория. Он позволяет работать с репозиторием при помощи, как минимум:
  • консольного Subversion-клиента;
  • TortoiseSVN;
  • SvnKit.

На данный момент поддерживается:
  • svn checkout, update, switch, diff
  • svn commit (!)
  • svn log
  • svn cat, ls
  • svn replay (svnsync)
  • partial checkout
  • sparse working copy (svn --depth/--set-depth)
  • git submodules
  • аутентификация через LDAP

По производительности работа не просто сопоставима, но местами даже превосходит родной Subversion-сервер.

Как работает коммит?


Одна из самых важных деталей системы — сохранение изменений. В общих чертах, идея следующая:
  1. В момент команды svn commit клиент отправляет на сервер свои изменения. Сервер при этом запоминает их. В этот же момент происходит первая проверка на актуальность клиентских данных.
  2. Сервер берет голову ветки и начинает формировать новый коммит на базе полученных от клиента данных. В этот момент происходит ещё одна проверка на актуальность клиентских данных.
  3. Проверяется целостность svn properties для заливаемых данных.
  4. Сервер пытается консольным Git-клиентом сделать push нового коммита в текущую ветку этого же репозитория. Далее по результату push-а:
    — если все хорошо — загружаем последние изменения из git-коммитов и радуемся;
    — если не fast forward — загружаем последние изменения из git-коммитов и идём к шагу 2;
    — если отбили хуки — сообщаем клиенту;
    — если другая ошибка — сообщаем клиенту.

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

Где хранятся svn-данные репозитория?


Для представления Subversion репозитория нужен ряд данных, которые в Git либо отсутствуют (например, данные о том, откуда скопирован файл), либо очень дорого получить (например, номер ревизии, когда файл менялся в последний раз). Чтобы не заниматься их расчетом каждый запуск, они кэшируются в ветках refs/git-as-svn/*. Этот же кэш позволяет не ломаться соответствии Git-коммитов Subversion-ревизиям из-за операций force push. ;-)

Известные проблемы и ограничения

На данный момент приходится мириться со следующими ограничениями:
  1. нельзя средствами Subversion менять svn properties;
  2. не сохраняется история копирования файлов.

Svn properties


Основная беда svn properties в том, что некоторые свойства надо поддерживать в синхронном состоянии между Git и Subversion. Чтобы эти данные не расходились, svn properties генерируются на базе содержимого файлов из Git-репозитория (например, svn:ignore генерируется на основании .gitignore). При коммите же происходит проверка сохраняемых свойств данным репозитория. Это накладывает важное ограничение: нужно корректно формировать svn:auto-props, иначе при добавлении файлов пользователю придётся приводить их руками к виду, который ожидает сервер.

Самое злобное свойство: svn:eol-style. Основная беда в том, что поведение Git-а по умолчанию в контексте eol-ов сломано и соответствует файлу .gitattributes с содержимым:
* text=auto eol=native 

То есть, с настройками по-умолчанию Git меняет содержимое текстовых файлов.

После долгих страданий было найдено решение проблемы eol-ов: в корень Git-репозитория нужно добавить файл .gitattributes, начинающийся со строки:
* -text

Это потребует от Git не трогать окончания строк у файлов до тех пор, пока его об этом явно не попросят.

И что в итоге?

На данный момент проект находится в неторопливой разработке и эксплуатируется в одной из команд Mail.Ru Group. В результате, люди вольны использовать подходящий для их нужд инструмент: дизайнеры используют TortoiseSvn и заливают им изменения напрямую в master, а программисты пользуются Git-ом и живут в своих уютненьких веточках. Обстановка в целом стала здоровее, и у коллег перестали сжимать кулаки, когда кто-то рядом произносит слова Git или Subversion.

Что нужно сделать, чтобы потыкать в проект палочкой?

Чтобы запустить git-as-svn нужно:
  1. Установить Java 8.
  2. Скачать последнюю сборку с github.com/bozaro/git-as-svn/releases/latest.
  3. Распаковать архив.
  4. Запустить сервер.
    java -jar git-as-svn.jar --config config.example --show-config

В результате будет создан Git репозиторий с одним тестовым коммитом, доступный по URL svn://localhost/example/ из под пользователя test с паролем test. В качестве клиента настоятельно рекомендуется использовать клиент для Subversion 1.8+.
Автор: @Bozaro
Похожие публикации

Комментарии (168)

  • +16
    TortoiseGit далеко не такой удобный как TortoiseSvn;

    У Git не очень хорошо с клиентами под Windows.

    С данными пунктами не согласен. На своих проектах использую SourceTree который мне субъективно кажется удобнее чем TortoiseGit/TortoiseSvn. По поводу остальных клиентов под Windows, есть достаточно приличный выбор.

    По поводу первого, я не согласен с тем, что клиенты git менее удобны, а не с тем, что TortoiseGit удобнее чем TortoiseSvn. Я имел ввиду что придерживаюсь мнения, что клиенты для git удобнее чем для SVN.
    • 0
      SourceTree появился всего пару лет назад, и то только для макоси. Под винду он вышел попозже. А под линукс до сих пор не вышел.
      • +5
        Да, согласен, но:
        1. Для Windows он все таки уже вышел, следовательно нельзя не учитывать его
        2. Если не ошибаюсь TortoiseGit для Linux/MacOS тоже еще не вышел
        • 0
          Хм… я почему-то думал, что этот проект (git-as-svn) был сделан уже давно. А оказалось, совсем недавно.
          • +2
            Вы не с `git-svn` путаете?
    • +2
      У Git нет официального консольного клиента для 64-х битной платформы.
      Мне известен только один свежий 64-х битный клиент: github.com/slonopotamus/wingit/releases

      Так как Git использует паки через отображение файла на память, использование 32-х битной сборки накладывает серьезное ограничение на размер репозитория.
    • +5
      После перехода с SVN по привычки пытались использовать TortoiseGit, но он оказался не удобен.

      В итоге остановились на Git Extensions, он оказался как раз тем что нужно. После этого (уже как пару лет) я стал одним из авторов проекта :-).

      Интерфейс
      image
      • +1
        Большое спасибо! Git extensions — очень хороший клиент.
      • 0
        Аналогично. И тоже остановился на GE, хотя перепробовал кучу разных и некоторые были довольно достойны, но мне нравится его простота и отсутствие дизайна.
      • 0
        Примерно таже ситуация, тоже сначала по привычки пыталась использовать TortoiseGit, пока мне не посоветовали Git Extensions. Правда немного тормозит, когда просматриваешь DIff комита с большим количеством файлов.
    • +1
      Под маком SourceTree хорош, а вот под винду пока так себе (видимо ввиду молодости). Так и не смог привыкнуть, вернулся к SmartGit.
  • +16
    Чтобы запустить git-as-svn нужно:
    Установить Java 8.
    Thanks, but no thanks.

    Оставлю здесь Visualizing Git Concepts из последнего дайджеста, очень рекомендую покликать если вы начинаете разбираться с Git.
  • 0
    Почесав репу и содрогнувшись от связанных с Subversion воспоминаний

    Что за воспоминания? Т.е. какая причина при переходе весомее: недовольство svn или преимущества git?
    • +3
      Основную боль в Subversion вызывает то, что нельзя сохранить в системе контроля версий какой-либо промежуточный результат крупных изменений (к примеру: я поменял 100500 файлов, починил компиляцию, но не починил тесты) без разламывания общей версии.
      Так же при обновлении нельзя откатиться до состояния «до обновления», т.к. надо разрешить все конфликты любой ценой — обратной дороги нет.
      Теоретически это должно решаться ветками, но в Subversion это крайне неудобный механизм.
      • –2
        А в чём проблема с ветками? Если делаешь что-то большое, создал ветку, переключился на неё, довёл до ума, потом слил в основу, разрешил конфликты, зафиксил — и вуаля.
      • –1
        Так же при обновлении нельзя откатиться до состояния «до обновления», т.к. надо разрешить все конфликты любой ценой — обратной дороги нет.


        Просто получите ещё одну рабочкую копию с помощью `svn checkout` и обновите её до любой ревизии которую хотите просмотреть.

        Теоретически это должно решаться ветками, но в Subversion это крайне неудобный механизм.


        Чем именно-то неудобный?
        • 0
          1) Конфликты, если файл менялся одинаково сразу в двух ветках
          2) Слабее чем в git инструментарий для мерджа
          3) История в ветке не своя а как бы референс на родительскую ветку. И то только в новом SVN в старом — никакой истории
        • +3
          Просто получите ещё одну рабочкую копию с помощью `svn checkout` и обновите её до любой ревизии которую хотите просмотреть.

          Допустим:
          1. я обновился
          2. поменял 100500 файлов
          3. попытся закоммитить, но не смог — меня кто-то опередил
          4. обновился
          5. мерж 100500 файлов
          6. запутался и накосячил при мерже

          В этой ситуации Subversion не позволяет откатиться к состоянию до начала мержа.
          svn checkout даст мне возможность откатиться до начала изменения 100500 файлов, но от этого, обычно, не легче.
          • 0
            Вот как раз поэтому для доработок, затрагивающих 100500 файлов и создают ветки. В отдельной можно спокойно зафиксировать все изменения, а потом уже разбираться с конфликтами с основой, откатываясь сколько угодно. Благо в SVN ветка — это просто пометка в дереве ревизий, не занимающая ни дополнительного места, ни времени.
            • 0
              Благо в SVN ветка — это просто пометка в дереве ревизий, не занимающая ни дополнительного места, ни времени.


              Wrong. В SVN ветка — это штуковина, для переключения working copy на которую требуется по меньшей мере O(кол-во файлов) времени. В ситуациях, когда количество файлов в working copy идёт на сотни тысяч или даже миллионы, этот процесс становится неюзабельно медленным.
              • –1
                При переключении между ветками основное время занимает не сравнение, а перекачка изменений. Переключение между ветками с небольшими различиями происходит с вполне вменяемой скоростью. Если же приходится вести параллельно сильно различающиеся ветки, их можно отдельными копиями хранить.

                Сколько я ни видел аргументов в пользу Git — все они касаются весьма спорных и практически не встречающихся на практике ситуаций. При правильно организованной работе с SVN Git не даёт сколь-либо весомых преимуществ для того, чтобы переходить на него.
                • +1
                  Как долго вы проработали с Git?
                  • –3
                    Я не работал с Git вообще. Я прочитал несколько статей про него, но не смог найти в них сколь-либо убедительных аргументов в пользу того, чтобы перевести хранилище рабочих проектов с SVN на него.
                    • +2
                      Предлагаю на этом и закончить.
                      • 0
                        Вот во всех статьях на этом и заканчивают =).

                        Мы переходит на Git! А зачем?

                        Я вполне понимаю людей, которые начинают новый проект на нём. Но за довольно долгое время не встретил ни одного вменяемого аргумента в пользу миграции достаточно большого проекта. И ваш пример в этой статье, к сожалению, исключением не стал.
                        • 0
                          Для ответа на этот вопрос нужно попробовать поработать с DVCS (Git, Mercurial и т.п.). После этого возникает понимание чем оно лучше/хуже и когда оно уместно.

                          Для меня толчком для «попробовать Mercurial» стала ситуация когда я писал код без интернета в общественном транспорте.

                          Первое время оно непривычно и несколько раздражает, потом легче. Git я стал понимать где-то через месяц использования.
                    • 0
                      Всё-таки работа над большими изменениями в DVCS и в VCS сильно отличается. В VCS я не могу сохранить текущий стейт локально, иначе как сделав патч. Чтобы продолжить с ним работу после правки какого-нибудь важного бага, например.
                      Так же в VCS намного сложнее организовать красивый пайплан: отдельные ветки для фичей. Это не невозможно, но это просто сложнее сделать.

                      Лично мой опыт показывает, что работать с DVCS командой проще, быстрее, эффективнее.
  • +2
    У Git нет официального консольного клиента для 64-х битной платформы.
    Мне известен только один свежий 64-х битный клиент: github.com/slonopotamus/wingit/releases

    Так как Git использует паки через отображение файла на память, использование 32-х битной сборки накладывает серьезное ограничение на размер репозитория.
  • +1
    Не могу представить себе случая, когда дизайнерам и программистам необходимо держать код в одном репозитории.
    • +3
      Стоит уточнить, что в нашем случае речь идет об игровых дизайнерах.
      Отвечая на вопрос. По нашему процессу код определяет схему данных (за которые отвечают дизайнеры). Поэтому целостность версии — достаточно ценная штука сама по себе. Ультимативной необходимости это не рождает, но это очень удобно.
    • +1
      Дизайнеры не работают с кодом, они работают с данными.
      Данные и код сильно взаимосвязаны. Из-за этого желательно держать их в одном репозитории.

      Пример из жизни:
      • программисты пишут блоки для игровой логики;
      • дизайнеры составляют используют эти блоки для описания поведения игровых предметов.
      • 0
        Понял, спасибо.
        Хотя я сам учил нескольких дизайнеров работе с git. Нормально получалось, были довольны. Использовали smartgit, терпеть не могу черепаху.
  • –1
    image
    • +9
      Не знаю, работали ли вы в команде с большим количеством не только программистов, но и дизайнеров, и художников. Наша необходимость родилась из опыта. У нас есть крупные проекты на svn, мы пробовали git на более маленьком проекте. Краткие выводы такие: программисты любят git и связанный с ним пайплайн, контент-мейкерам он не подходит (по крайней мере нам не удалось научить их любить git). Это ответ на ваш вопрос.

      Зачем мы это опубликовали? Есть мнение, что наша ситуация неуникальна, возможно, кому-то еще пригодится эта разработка. Я не сомневаюсь, что у большинства таких проблем нет, иначе готовых решений было уже достаточно (ибо сама по себе задача не архисложна). Однако кому-то это может помочь.
      • +1
        По опыту контентщики нормально вписываются в гит. Просто нужно через «не хочу».
        Это не рокетсайнс, это всего-лишь система контроля версий.
        • +1
          Этот разговор можно продолжать бесконечно. У нас есть один опыт (достаточно продолжительный, чтобы считать его валидным), у вас другой. Давайте на этом и закончим.
        • +1
          Если данные нельзя мержить, то Git лишь добавит им проблем без какой-либо выгоды.
          Хуже того: же они будут лишены механизма блокировок, который ранее снижал вероятность получения конфликтов.
        • 0
          Вы что бинарники в гите храните?
          • +1
            Например в юнити ассеты — бинарники. Мне их на фтп хранить? )
          • 0
            • 0
              Вдогонку blogs.atlassian.com/2014/05/handle-big-repositories-git/


              Я эту статью читаю как
              «Git не поддерживает версионирование больших бинарников, но с помощью зубной щётки, проволоки и пары гвоздей вы всё же можете попробовать...».
              • 0
                Ну у меня там в пределах сотни метров. Не сказал бы что испытываю какие-то проблемы.
          • +1
            Художники могут хранить svg в гите, хоть и не бинарник, но дифф svg вам не даст вообще ничего.
        • 0
          У нас постоянная проблема с тем, что не программисты не понимают, что такое гит, зачем он им нужен, и почему там все так сложно. С Subversion особых проблем не было, они тыкали себе пару кнопок в клиенте, и жили счастливо. С гитом же начались траблы, уже описанные выше.
          Да, конечно, можно их палками научить работать с гитом, но вопрос зачем? Им не нужна полноценная работа с системой контроля версий, зачастую им не нужны ветки и прочие прелести. Им просто нужно находиться в единой инфраструктуре, имея возможность доносить свою работу до остальных участников проекта.
          Мы с этой проблемой пока еще не справились.
          • 0
            зачастую им не нужны ветки и прочие прелести.


            Такая прелесть как branching & merging (т.е. ветки и их слияние) работает в Subversion вполне хорошо и улучшается от релиза к релизу.
  • 0
    На Mac использую SourceTree, на Windows — GIT Extensions

    Субъективно GIT Extensions гораздо мощнее.
    • 0
      На osx попробуйте tower2. Я попробовал и через месяц купил — ни разу не жалею, отличная штука, гораздо удобнее запутанного source tree, с бОльшим функционалом, чем у GitHub.app.
      • 0
        на самом деле в 90% случаев мне хватает command line, а эти тулы больше для визуального просмотра.

        Tower попробую, спасибо.
        • 0
          Из того, что очень прям понравилось:
          — мощный механизм выбора чего коммитить
          — возможность раскидать по папкам внутри программы
          — раскладывает ветки в стиле gitflow по папкам, такого пока нигде не видел (ну и поддержка gitflow)
          — ну и главное — при мерже/ребейзе бекапит состояние и если что — легко откатывает.
          Единственное — merge тулза нужна внешняя, если у кого-то есть вменяемый вариант, буду рад услышать.
          • 0
            при мерже/ребейзе бекапит состояние и если что — легко откатывает

            строго говоря, это стандартный функционал гита. git rebase --abort в середине процесса вернёт репозиторий в состояние до ребейза, например.
          • 0
            meld
    • 0
      Git Extensions прикольный. Но не все люди видят профит от гит-пайплайна разработки, не всем он нужен. А если преимуществами не пользоваться, то гит вносит оверхед просто своим существованием, тут дело даже не столько в интерфейсе. Цель была в том, чтобы для таких людей оставить простой цикл change-commit.
    • +1
      А для Линукс есть что-нибудь приличное? После TortoiseHg линуксовые git gui теплых чувств не вызывают.
  • 0
    При большом количестве постоянно заливающего народу, люди начинают биться головами (между pull и push успевает кто-то вклиниться).

    А вот это как раз привет логика svn. В git для этого офигенный механизм веток, а не всем в trunk master вместе пушить.
    • 0
      Согласен.
      В Git и Subversion разный workflow. И нашей целью было совместить оба варианта.
      • 0
        А почему нельзя было дизайнерам отвести по ветке, а конечным разработчикам мержить в свои ветки дизайнерские наработки? Это позволит дизайнеру коммитить без напряга, а разработчику удобно подтягивать нужную версию.
        • 0
          Дизайнерские данные непригодны к мержу, увы. Реинтеграция дизайнерских веток превратится в ад для релиз-менеджеров.
          • 0
            Почему в ад? У дизайнера линейная история. Разработчик время от времени мержит себе дизайнерскую ветку.
            • 0
              У одного дизайнера да, но если дизайнеров много, растет вероятность того, что несколько человек потрогает одни и те же бинарники.
              Последующий мерж веток этих дизайнеров будет достаточно сложен, если возможен в принципе. Хорошо, если выяснится, что одно изменение из двух было паразитным(сплошь и рядом), куда хуже, если все они — осмысленные.
              Разрезолвить такое без потери изменений возможно далеко не всегда.
    • 0
      Контент-мейкеры значительно реже пересекаются по данным, для них пайплайн «всем в trunk коммитить» вполне подходит.
  • +1
    mercurial смотрели? Contra ##1,2,3 (и с оговорками — 5) оно вполне себе решает. плюс искаробочное прозрачное версионирование бинарников
    • 0
      Основная проблема: «Git не даёт никаких преимуществ и создаёт дополнительные проблемы, если файлы не поддаются мержу» свойственна всем распределенным системам контроля версий, в том числе и Mercurial-у.
      • 0
        файлы не поддаются мержу
        имеются в виду конкретно бинарные ассеты или что-то ещё?
        • +2
          Да, бинарные ассеты.
          Это боль, страдание и унижение.
          • +2
            ну так искаробочное mercurial.selenic.com/wiki/LargefilesExtension же. Ассеты кладутся отдельно от сырцов, мерж для них не работает и диффы не вычисляются. В Unity3D им, говорят, успешно пользуются.
            • 0
              Речь не про то, чтобы использовать версионирование. Если бинарные файлы (с которыми в основном работают дизайнеры) не поддаются мержу (не версионированию, а мержу, то есть, например, они бинарные или, например, даже xml-ные, но с таким хаосом в чейнджах, что мержить нереально), то смысла в гите нет, так как нет веток, которые можно потом мержить, и всего прочего, что оставляет дизайнера с линейной историей вполне достаточного svn-а.
  • +2
    Что-то вы по-моему совсем какого-то франкенштейна породили. А нельзя было просто научить дизайнеров использовать гит? Мне кажется это быстрее чем писать такой кастом
    • 0
      Кастом написать один раз, а дизайнеров много. При чем с дизайнерами еще не так страшно, куда сложнее обучить художников.
    • +1
      А какие есть альтернативы?

      Мы рассматривали варианты:
      • Использовать всем Subversion.
        Разработчки могут использовать git svn или аналоги, но он не дает возможности работать вдвоём над одной фиче-веткой. Плюс боль и страдание с ветками стабильных версий
      • Использовать всем Git.
        Не вышло. Производительность падает, а недовольство растёт.
      • Использовать SubGit.
        Есть опасение, что мастер-мастер связка репозиториев развалится в самый неподходящий момент.
      • Переезд на GitHub.
        Не подходит, т.к. репозиторий должен быть внутри компании.
      • Переезд на GitHub Enterprice.
        Дорого.
      • Распилить на два репозитория.
        Нужны дополнительные телодвижения для того, чтобы поддерживать соответствие между ними. Особенно тяжело будет при работе со стабильными ветками для боевого кода.
      • Написать git-as-svn.
        Нужно время на разработку и поддержку.


      Все варианты — дрянь. Приходилось выбирать меньшее зло.
      • 0
        GitLab.
        • 0
          GitLab, в отличие от GitHub, не позволяет работать с Git-репозиторием через Subversion-клиент.
          • 0
            Зато позволяет работать с репозиторием через веб-морду для тех, кто не умеет в гит.
            • +1
              WEB-морда красивая, но наших проблем она не решает.
              В конечном счете, git-as-svn крутится на машине с gitlab-ом и все счастливы.
              • –1
                Вместо доработки существующего продукта и/или обучения пользователей вы решили сделать костыль, стимулирующий пользоваться устаревшим ПО. Очень ок.
                • +1
                  Я сомневаюсь, что дизайнерам и художникам так уж важно уметь работать с git. Им это скорее совсем не нужно, потому что они пользуються только одной из всех его возможностей.
                  И использование устаревшего по — не всегда зло. ПО должно максимально эффективно решать задачи, а не быть самым новеньким и клевеньким.
                  • 0
                    Я с этим и не спорю.
                    И про устаревание я имел ввиду лишь то, что ваша контора, вроде как, решила перейти на Git.
                    Сам SVN я не считаю устаревшим в общем смысле этого слова.
                    Подход, когда часть усилий тратится на поддержку костыля — врядли можно называть «максимально эффективным решением задач», проще уж тогда было на SVN остаться.
                    • +1
                      На SVN сложнее делать фичи разработчикам.
                      На Git — дизайнерам.
                      А так, ценой некоторых усилий, счастливы все.
                      • 0
                        Ок, пусть будет так.
                    • 0
                      Вопрос на самом деле, можете ли вы сделать этот костыль, и что будет выгодней — сделать костыль и поддерживать его, или переучить персонал. Все просто.
                      • 0
                        Де-факто мы его уже сделали. В данный момент не видно ничего, что может вызвать проблемы с поддержкой или требует крупных усилий для реализации. Все, что нам нужно — уже работает.
                        Сравнение с переучиванием же несколько не корректно — дело не в том, что они не хотят переучиваться, а в том, что для их работы Subversion объективно лучше подходит.
      • 0
        Perforce? мощная система, отлично работает с большими объемами, отличный GUI клиент. Помнится у гита были проблемы с большими репами, размером в 4 гига. Плюс с бинарными данными тоже не все гладко было.
        Да, Entreprise solution
        Да, за деньги
        • 0
          Помнится у гита были проблемы с большими репами, размером в 4 гига.


          Репозиторий в 4гб — маленький репозиторий. Вот у Apache Software Foundation относительно большой репозиторий — 65гб с 1.5 лямом ревизий.
          • 0
            есть сомнения, что там самый обычный гит сервер. но спорить не буду.
            • 0
              У ASF-то? Я указывал Subversion репозиторий ASF: svn.apache.org/repos/asf/
              • 0
                но разговор был про гит у ASF (http://git.apache.org/)
        • 0
          Для того, чтобы Perforce попал в список рассматриваемых вариантов, кто-то должен был его предложить и объяснить, почему он лучше. Таких людей не оказалось.

          Беглый взгляд на Perfoce не выявил никаких преимуществ. К тому же очень настораживает тот факт, что данные о рабочей копии лежат на сервере. То есть для нормальной работы требуется подключение к серверу, причем быстрое.
          • 0
            метаданные да, все на сервере живут, это как раз удобно, если много разработчиков, сразу видно, что ктото зачекаутил конкретный файл. вполне хватает впн подключения в другой конец мира. так же есть perforce proxy сервис.
            • +1
              Я допускаю, что Perforce — хороший инструмент.

              Но, такова жизнь: пока не появится в команде хоть кто-то, кто с ним работал ранее, вероятность его использования минимальна.

              Буду очень признателен, если предоставите хоть какой-то внятный обзор на тему «почему Perforce — хорошо».
              • +1
                --почему Perforce — хорошо
                много лет пользуюсь Perforce, им чаше пользуются гиганты софтиндустрии потому что он платный был практически, а сейчас 20 лицензий бесплатно.

                По сравнению с svn — быстрее, интерфейс намного интуитивнее, и может куда больше чем svn.

                Примерное дерево с последней работы (50,000 аккаунтов):

                — future version 6
                — Accepted
                — main
                — — Accepted 5.0
                — — Released 5.0
                — — — Service Pack1
                — — — Service Pack2
                — — — — Walmart — тут патчи для отдельных клиентов
                — — — — BOA
                — — Accepted 4.6
                — — Released 4.6
                — — — Service Pack1
                — — Accepted 4.5
                — — Released 4.5
                — — — Service Pack1

                Кроме того каждый разработчик создает свои деревья и тока потом может заливать в нужную ветку. В отличии от svn — дерево версий соотвествует дереву на диске всегда.

                В отличии от git я никогда не видел чтобы ломался у perforce дипозиторий, может для open-source это некритично, но в любой серьезной организации после такого покажут на дверь.
                • +1
                  Я подозреваю, что гиганты софтоиндустрии им пользуются не от того, что он платный, а от того, что он появился до Subversion, Git, Mercurial и пр.
                  На момент его выхода, если не ошибаюсь, из систем контроля версий были только SourceSafe и CVS.

                  В любом случае, чтобы составить представление о системе контроля версий с ней нужно поработать хотя бы месяц :)
                  • 0
                    С svn я работаю уже пять лет. perforce лишь старше на пять лет чем svn.
                  • 0
                    Ну, всякие SourceSafe и CVS даже рядом не поставить с Perforce.

                    На счёт попробовать. Есть public depot. Попробуйте. Perforce — штука здоровская и это начинаешь понимать когда с ним поработаешь какое-то время.
        • +1
          4 Гб это смешной размер. Он даже много меньше моей рабочей копии.

          Лично у меня, git-репозиторий раздувался до ~250Гб (получен через git svn, рабочая копия ~30Гб). Git его вполне нормально переваривал. Mercurial, к слову, развалился на гораздо меньших объемах.

          Но нужно отметить, что 32-х битная сборка git-а не может с ним ничего сделать.
          • 0
            возможно как раз и с 32битной версией сталкивался, давно это было.
            • 0
              Под Windows нет официальной 64-х битной версии Git-а.
              Есть не официальная сборка: github.com/slonopotamus/wingit
          • 0
            git-репозиторий раздувался до ~250Гб (получен через git svn

            Если не нужна вся история, то можно указать с какой ревизии выкачивать.
            • +1
              Я знаю. Когда я его вытягивал, историю обрезал одним месяцем. Потом он по-тихоньку распухал.

              Аналогичный репозиторий со всей историей есть у коллеги: папочка .git занимает порядка 1.5Тб. При этом он на нем успешно работает.

              К слову, исходный Subversion-репозиторий занимает порядка 2Тб.
        • 0
          Perforce ужасен.
          • для любого взаимодействия нужно подключение к репе. Даже чтобы узнать, что изменилось в файле
          • ме-е-едленный
          • мердж — боль
          • 0
            на вкус и цвет…
            пришлось с ним работать постольку поскольку.
            Наличие постоянного подключения да, требуется, но как-то проблем с этим не возникало. Медленности тоже не замечал. очень непривычно было то, что чтобы отредачтировать файл надо сначала сделать Checkout… Но привык.
            • 0
              Checkout делать не обязательно, можно пользоваться Reconcile Offline Work.
          • 0
            Это Вы ещё StarTeam не щупали.
          • 0
            По первым двум пунктам можно в какой-то степени согласиться, а какие проблемы со слиянием? Есть даже Branch Mappings, упрощающие частое слияние, да и давненько уже появились Streams.

            • 0
              Самый главный минус — невозможность выполнить Resolve вручную, как, к примеру, позволяет тот же Subversion с Postpone Conflict. Из этого следуют следующие проблемы:
              — Perforce клиент — гуано (по крайней мере на OS X). И дело даже не юзабилити, а банально в том, что P4Merge постоянно падает, причем в некоторых ситуациях со 100% воспроизведением. Приходится идти в обход. Зачастую просто руками добавлять изменения.
              — ме-е-едленно составляется changelist с изменениями, ме-е-едленно, ресолвится каждый файл. Ну и остается проблема с тем, что кто-то уже успел залить новую ревизию, и резолв возобновляется.

              Сравните это все с тем же Subversion. Не говоря уже о Git.

              > Streams
              это хорошо, но в некоторых крупных компаниях до сих пор стоит pre-2011 Perforce без стримов. И обновлять его не собираются. Вопли разработчиков не слышат, утверждая «и так работает».
              • 0
                Насколько мне известно, в пользу Perforce постулируются три следующих тезиса:

                — Умеет мапить дерево на сервере в другое по структуре дерево в рабочей копии. Этим достигается воспроизводимость environment-а при изменении структуры репы, т.е. связанные проекты можно перемещать в репе относительно друг друга
                Лолшто? Хранить билд-конфигурацию в метаданных рабочей копии?
                Лолшто №2? Хранить все проекты в одной репе? Да, я знаю, что в Subversion так делали, но это все равно плохо. А в Perforce это поощряется.

                — Хорошо справляется с большими бинарниками.
                Лолшто? А Subversion плохо справляется? А Git (если его нормально настроить)?

                Ынтерпрайз, пыщ-пыщ Широкие возможности администрирования, в том числе раздача прав доступа
                No comments :facepalm:

                Итого получается, что Perforce ничем не лучше, но по ряду параметров откровенно всасывает.
      • 0
        Мне просто кажется что время на обучение дизайнеров\художников должно быть меньше чем на разработку и поддержку настолько кастомного решения. Кстати, как долго вы его разрабатывали?

        И еще, а что (если это не секрет, конечно) художники складывают в репозиторий?
        • 0
          Время на разработку ушло не большое — вся история есть на GitHub.
          • начало разработки: 11 августа 2014 года.
          • первая относительно рабочая сборка: 27 августа 2014 года (спустя 16 дней после старта).

          Разработка по остаточному принципу. Задействовано два человека.
          • 0
            Окей, спасибо
        • 0
          Исходные данные художников лежат в Subversion.
          Там безумные объемы и нет таких жестких требований к соответствию данных и кода.
      • +1
        git svn или аналоги, но он не дает возможности работать вдвоём над одной фиче-веткой.

        От чего ж не даёт? Вполне себе даёт. Он создаёт обычные svn-ветки, на которые могут переключиться другие пользователи git/svn.
        А вообще, вам не ужа с ежом надо было бы дружить, а воспользоваться меркуриалом.
      • 0
        Не рассматривали подключение svn репозитория как подмодуля? Распиливать, конечно, придётся, но зато синхронизировать можно через pull. Недавно распилил свой на 2 части — фронтендт для верстальщика и бэкенд. Все картинки, к примеру, только в первом, связь через симлинки.
        • 0
          Мысль о разделении на два репозитория рассматривалась, но у нас данные и код слишком сильно связаны и это порождает слишком много проблем. К тому же это потребовало бы частичного дублирования инфраструктуры с коммит-хуками. В результате этот вариант выглядел, как наихудший.

          Готовых технических средств для связи Git <-> Subversion я не знаю. То есть в конечном счете это потребовало бы нагромождение других костылей.

          В данном же случае получившееся решение выглядит достаточно целостным и устроило обе стороны (и сторонников Git-а, и сторонников Subversion-а).
      • +1
        Разработчки могут использовать git svn или аналоги, но он не дает возможности работать вдвоём над одной фиче-веткой. Плюс боль и страдание с ветками стабильных версий

        Для коллективной работы можно пушить ветку в отдельный git-репозиторий. А результат работы потом мержить в trunk svn-репозитория.
        • 0
          Для коллективной работы можно пушить ветку в отдельный git-репозиторий.

          В случае с git svn мы почему-то получали разные git-хэши для одних и тех же svn-коммитов на разных машинах. В причине этого явления не разбирались, но работу через отдельный репозиторий оно делает не возможным.
          • 0
            Причём тут хеши svn-коммитов? Один разработчик заводит git-ветку в git-репозитории, второй её стягивает. Далее работа происходит в чистейшем гите. По окончанию один из разработчиков делает merge или rebase (если нужна история) на мастера (коим является git-svn) и отправляет коммит в svn. Второй разработчик подтягивает коммиты уже из svn. И не важно какие хеши будут у каждого из разработчиков для коммитов из svn, потому что хранилищем у нас является svn, и ссылаться на коммиты нужно по номеру ревизии, а не хешу.
            • 0
              Для слияния веток крайне желательно, чтобы они имели хоть что-то общее. В случае несовпадения хэшей при импорте из svn это будет два независимых дерева.

              То есть работать вдвоем, конечно, можно, но для этого нужно, чтобы разработчики клонировали репозитории друг у друга, а не использовали ранее полученные через git svn clone.
              • 0
                Тут вы правы. Но есть выход — слияние делает тот, кто заводил ветку. Тогда будет всё ок.
  • +1
    У гитхаба прекрасные клиенты для мака и винды, которые нивелируют проблемы простых смертных. Клиенты вроде можно использовать и без привязки к сервису.
  • +1
    Стремный проект SubGit.

    Не могу согласиться с этим утверждением. Используем его уже больше года, проект зарекомендовал себя как надежный и стабильный.
    • +1
      Сама идеология мастер-мастер репликации порождает кучу вопросов:
      • как делать коммит-хуки?
      • какой репозиторий первичен?
      • как происходит одновременный коммит через Git и Subversion?
      • как делать резервную копию без остановки сервиса?
      • как восстановится соответствие репозиториев друг-другу, если в час X отключить питание?
      • что делать, если один из репозиториев умрет?

      Мы не знаем, на них ответов и это нас останавливает.

      Но, справедливости ради, пока мы тыкали в него палочкой, он вел себя стабильно.
      • 0
        То, что SubGit отвечает на некоторые из этих вопросов не так, как Вам нужно, не делает его «стремным». Например, он идеально ложится на наш случай, когда основным репозиторием выступает SVN, в то время как Ваш проект под нее ну совершенно не подходит. Однако это не делает Ваш проект «стремным» в моих глазах.
      • 0
        Мы используем SubGit в проекте без каких-то проблем год, называть его «стрёмным» я бы тоже не стал, свои задачи успешно решает. Заказчик работает с SVN, команда использует git. Не такие счастливые как в Mail.ru чтобы так отвлечься на свой велосипед.

        Опишу свой опыт не претендуя на полное знание:

        > какой репозиторий первичен?

        Это какой-то основной вопрос философии, на ваше усмотрение. У нас это svn, там вся история. В принципе в любой момент можно бросить любой репозиторий, и svn и git и продолжить работу дальше в каком-то одном.

        > как делать резервную копию без остановки сервиса?

        Резервную копию subgit? Мы не делаем так как потеря с сервера с subgit не приведет к потере данных, а лишь к некоторой потере времени на перенастройку (хотя я вспомнил что VM с subgit на самом деле бэкапится раз в неделю). Если бы требовалось и этот простой устранить, то я не думаю что были бы особые сложности. Не думаю что было бы критично остановить синхронизацию сделать копию и восстановить синхронизацию — все же коммиты в репозиторий это не критичная вещь чтобы несколько минут недоступности ночью коммитов кому-то помешает.

        Вообще надо сказать что у subgit есть два режима интеграции с svn (remote и local), мы используем remote.

        > что делать, если один из репозиториев умрет?

        Subgit создает git репозиторий на основе svn, можно например с какой-то определенной ревизии если вся история в git не нужна для работы. Если умрет git репозиторий, то мы заново пересоздадим его из svn. svn не должен умирать, в нашей среде он админами надежно настроен в плане бэкапов и аппаратного зеркалирования, чтобы не было downtime в случае поломки сервера.
        • 0
          Я допускаю, что у вас SubGit работает и работает хорошо.

          Но пока не понятно, по каким принципам он работает, я бы его использовать не рискнул.
          • 0
            Я не знаю точно вашего окружения, так что мне не очень понятно почему вы боитесь рисковать. Что вы теряете если инструмент например, сломается?

            Я подумал что мы в своем окружение ничего важного не теряем: svn репозиторий живет отдельной жизнью и хорошо защищен от сбоев и хранит все законченные задачи, git репозиторий внутри subgit потерять не страшно так как его копии обычно есть у всех разработчиков (+ на другом remote, есть у нас некоторые особенности настройки).

            С одновременными коммитами в svn и git мы сталкивались, система остается в разруливаемом состоянии (примерно как когда два человека нажимают git push, второй получает ошибку и ему обычно понятно что нужно делать).
            • +2
              Потеря одного репозитория это далеко не худший вариант.

              Самое страшное, что может произойти: расхождение содержимого репозиториев.

              Пока нет никаких объяснений почему это не может произойти, как это обнаружить и что в этой ситуации делать.
              • 0
                Обнаружить наличие расхождений наверное не очень сложно, просто сравнить рабочие копии.
                • 0
                  Опасность ошибок расхождения данных в том, что обычно они всплывают внезапно. При этом между появлением ошибки и её обнаружением проходит значительный временной промежуток.

                  В контексте того, что репозитории в разных VCS, сравнить их не так просто, как может показаться на первый взгляд. Сейчас я знаю, как это сделать эффективно, но на момент начала истории с написанием git-as-svn у меня этих знаний не было.

                  Кстати, именно требование отсутствия дублирования данных между Git и Subversion-представлениями явилось причиной нетривиального, с точки зрения реализации, механизма работы с Subversion Properties.
  • 0
    А у вас команда разработчиков находится в одном офисе или распределённая? Просто вы указывали в статье, что

    Git, по сравнению с Subversion, нереально быстрый.


    Это утверждение относительно верно если команды разрабочиков удалены от Subversion сервера, но Subversion в этом плане можно ЗНАЧИТЕЛЬНО ускорить!

    Вы можете настроить репликацию репозиториев и установить репозиторий-зеркало в каждом из офисов чтобы разработчики доступались до ближейшего сервера, а не ходили за океан.
    • +2
      Мой опыт показывает, что Git быстрее Subversion даже в пределах локальной сети. У меня есть подозрения о причинах этого явления, но это тема отдельной дискуссии.

      Хотя создание реплики Subversion через svnsync действительно снижает остроту проблемы.
  • +4
    Как разработчик SVNKit, я бы посоветовал вам взглянуть на реализацию SVN сервера на основе нашего DAV сервлета.

    Например, разработчики GitHub не скрывали, что посматривают в наши исходники, когда работают над поддержкой SVN на GitHub.

    А как разработчик SubGit, я недоумеваю, почему наш продукт стрёмный. SubGit в первую очередь решает задачу постепенной миграции с Subversion на Git, в этом его основное отличие от git as svn; при этом:

    — SubGit абсолютно прозрачен для пользователей Git и для пользователей Subversion — поддерживаются все функции обеих систем, то есть наличие SubGit неочевидно для пользователя;

    — SubGit'у достаточно обычного удалённого доступа к Subversion репозиторию, чтобы создать Git зеркало этого репозитория;

    — Такие компании как Comcast, CBS, Boeing, SpaceX, Cisco, etc. не считают SubGit стрёмным. Наоборот, они его используют в production успешно и не один год.

    — Некоторые задачи синхнронизации потребовали нетривиальных решений, и это было одной из самых интересных частей нашего проекта. Это и надёжная репликация, и трансляция информации о merge и поддержка eol-style свойств. Думаю многие из решений заслуживают отдельных постов;

    — И да, SubGit — это коммерческий продукт, к которому мы предоставляем не менее коммерческий саппорт, при этом SubGit бесплатен для небольших команд, academic и open source проектов.
    • 0
      SVNKit хороший продукт и его существование значительно сократило нам объем работы.

      Но SubGit использует потенциально опасную концепцию мастер-мастер репликации.
      Сама идеология мастер-мастер репликации порождает кучу вопросов:
      1. как делать коммит-хуки?
      2. какой репозиторий первичен?
      3. как происходит одновременный коммит через Git и Subversion?
      4. как делать резервную копию без остановки сервиса?
      5. как восстановится соответствие репозиториев друг-другу, если в час X отключить питание?
      6. что делать, если один из репозиториев умрет?

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

      Ощущение от работы с ним сложилось такое: оно работает, но как — не понятно.
      То есть для меня это магическая черная коробка, от которой не понятно, что ожидать в будущем.
    • +1
      Раз представилась такая возможность, хочу поблагодарить Вас за SubGit. Пользоваться им — сплошное удовольствие! Прямо как мостик в нормальный мир из SVN ада :)
  • +1
    Я использую Git Extensions и субъективно он на порядок удобнее любых других клиентов которыми я ранее пользовался. Единственные слабые места которые всплыли за годы работы — это работа с субмодулями и неудобный поиск коммитов по хэшу. Tortoise Git по сравнению — тихий ужас, имхо. Консоль — вообще непонятно зачем нужна при наличии позволяющего сделать все без нужды копать мануал Extensions.

    У нас конечно не очень большой коллектив (человек 20 работает с репозиторием), но работа там идет довольно активная и этого вполне достаточно чтобы часто столкнуться с тем что «делаешь Push а тебя уже опередили». Абсолютно никаких проблем в git это не создает. Работаешь себе спокойно в локальном репозитории сколько нужно, затем делаешь pull с одновременным merge или rebase. В 90% он происходит автоматически, в оставшихся 10% ручками правишь то что не смержилось. Дальше делаю push. Не прошло? Делаю снова pull + rebase / merge. Поскольку времени между соседними pull-ами прошло немного, то почти наверняка во второй раз все проходит автоматически, исключения встречаются буквально раз-два в год. Сразу после этого делаю push. Третьей итерации pull-push на моей памяти практически никогда не бывает. Очень легко, прозрачно и удобно все делается.

    Впрочем в Гите довольно глупо работать всем в одной ветке. Я все чаще создаю по новой ветке на каждую задачу над которой работаю и подмердживаю в неё правки из главной ветки по мере необходимости. При этом я никому заведомо не мешаю своим кодом, мне тоже никто не мешает, я держу весь код в репозитории на серваке, но при этом сам решаю когда мне мержиться и у меня НИКОГДА не возникает нужды делать повторный мердж потому что кто-то еще что закоммитил и я не могу запушить свои изменения. Каждый мерж конфликт в подавляющем большинстве случаев фиксится лишь один раз и дальше Git в подавляющем большинстве случаев к этому конфликту никогда не возвращается. Когда я достигаю в задаче определенного майлстоуна я мержу мастер в свою ветку в последний раз, правлю при необходимости конфликты, проверяю что все работает и мерджу свою ветку обратно в главную. При этом все мержи из моей ветки автоматически сливаются в единый большой осмысленный коммит и мерж проходит легко и безболезненно. При условии что каждый девелопер работает похожим образом число коммитов в главную ветку получается очень невелико и вероятность того что они произойдут одновременно очень мала; плюс в главной ветке в любой момент времени живет только протестированный и полностью сделанный код, а не некий «полуфабрикат» в котором часть ревизий указывает на плохие или недоделанные билды. Эта схема начинает давать сбои только в ситуации когда один код очень сильно в разные стороны правится двумя людьми и быстро расходится к двум совершенно разным версиям кода в разных ветках, но в такой ситуации по-любому будет тонна мерж конфликтов
    • +1
      Именно по этому программисты и любят Git.
      Выбор клиента тут имеет второстепенное значение.

      Проблема в другом: у дизайнеров файлы бинарные и слияние не возможно в принципе. Из-за этого все телодвижения с локальными ветками теряют смысл и превращаются в обузу. Локальные коммиты при этом становятся вредными, так как только увеличивают вероятность конфликта.
  • 0
    Мы для авторов статей сделали свой интерфейс, который в фоне на самом деле коммитит правки в git. По принципу — кто последний, тот и прав.

    И никаких проблем.

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

      Реализация своего интерфейса не рассматривалась по той причине, что у многих программ есть готовая интеграция с Perforce и Subversion, но нет интеграции с Git. Подменяя интерфейс на стороне сервера мы автоматически используем встроенную интеграцию без необходимости допиливать каждый инструмент для использования с Git-ом.
      • 0
        для контента подходит, благо история правок есть.
  • –3
    Простите, а вы ПРАВДА не смогли своих гениальных разработчиков перевести с тормозного SVN на скоростной GIT?
  • +1
    — если не fast forward — загружаем последние изменения из git-коммитов и идём к шагу 2;
    Вот этот шаг был сделан очень зря. Потому что Subversion в таких случаях выдавал ошибку — и не просто так…
    • 0
      Subversion не выдавал в таких случаях ошибку. Для коммита через Subversion достаточно, чтобы изменения коммита не пересекалось с другими изменениями. При этом не обязательно, чтобы рабочая копия была обновлена до последней версии.

      В нашем случае это поведение сохраняется.
      • 0
        Хм, не замечал. Наверное, у меня просто никогда не встречалось непересекающихся коммитов…
        • 0
          В Subversion это настолько естественно, что этого не замечаешь.
          Самый простой способ:
          • обновиться
          • поменять два файла
          • закоммитить первый файл
          • закоммитить второй файл — в этом месте рабочая копия уже не от последней ревизии


          Но по большому счету, повторная попытка заливки нужна из-за того, что кто-то может параллельно совершить git push в ту же ветку.

          Если бы мы просто вернули ошибку в случае «не fast forward», то при повторной попытке коммит мог бы пройти у пользователя, что выглядит странно. При текущем же поведении, если первая попытка закоммитить не прошла, то второй раз пытаться не имеет смысла — будет та же ошибка.
          • 0
            После коммита первого файла текущая ревизия обновится — и к моменту коммита второго файла рабочая копия все равно будет от последней ревизии.

            Извиняюсь, что так долго отвечал — под рукой не было SVN, чтобы проверить.
            • 0
              После коммита первого файла текущая ревизия обновится — и к моменту коммита второго файла рабочая копия все равно будет от последней ревизии.

              Это не так. Ревизия обновляется только у элементов, которые непосредственно участвуют в коммите. Данные о втором файле будут от предпоследней ревизии.
              Сама рабочая копия будет от смешанной ревизии (см. вывод svnversion).

              Мы, кстати, эту особенность используем при изменении svn properties: если закоммитить изменения .gitattibutes/.gitignore, то при следующем обновлении поменяются свойства всех файлов, которые «затронуты» его изменением.
  • –4
    Сделайте тогда лучше систему блокировки файлов и не морочьте людям голову. Когда-то в CVS была какая-то.
    • +1
      А какую проблему решит создание отдельной системы блокировки файлов?
  • 0
    В данной ситуации проще всего было использовать Mercurial.
    Там нормальный клиент под винду, более понятная для перехода от SVN система команд, а чтобы выстрелить себе в ногу надо-таки выстрелить себе в ногу, а не сделать что-то с виду безобидное. SVN-like процесс для дизайнеров можно добавить, дописав небольшое расширение.
    • 0
      Как я уже писал выше:
      Основная проблема: «Git не даёт никаких преимуществ и создаёт дополнительные проблемы, если файлы не поддаются мержу» свойственна всем распределенным системам контроля версий, в том числе и Mercurial-у.
      • 0
        Это не совсем так.
        Насколько я понял, вам нужен SVN-like update и SVN-like commit.
        Их на мерке организовать довольно-таки просто и без риска отстрела конечностей.
        В части скорости выполнения команд, логов, чекаутов и т.п. любая DVCS даст SVN сто очков вперед.
        В вашем же случае и разработка сложнее и абстракции дырявее, и родовые недостатки SVN у дизайнеров останутся.
        • +2
          SVN-like update и SVN-like commit это только макушка айсберга.

          Суть проблемы в том, что можно выделить два варианта работы с системой контроля версий:
          • Основанный на слияниях: взял версию -> начал править -> слил изменения -> залил
            Этот подход используется, как в DVCS, так и в Subversion.
          • Основанный на блокировках: взял блокировку -> начал править -> залил и снял блокировку
            Этот подход может использоваться в Subversion и Perforce.

          Внезапно выяснилось, что:
          • выбор подхода сильно зависит от инструментария и данных (у картинок, к примеру, нельзя совместить изменения);
          • оба подхода могут быть на одном проекте (дизайнеры vs программисты);
          • многий инструментарий, ориентированный на работу через блокировки, не имеет интеграции ни с одной DVCS системой;
          • дизайнеры очень не хотят терять результат дневной работы из-за отсутствия блокировок.

          Реализация Subversion-протокола на серверной стороне позволило совместить оба подхода и при этом:
          • держать данные проекта в одном репозитории;
          • избавиться от проблем, возникающих при разбивке на два разнотипных репозитория;
          • избавиться от необходимости впиливания интеграции с DVCS в используемом инструментарии.
          • 0
            Вы же в курсе, что в svn «блокировки» на самом деле ничего не блокируют, а только лишь ставят аттрибут read-only на файлах в рабочей копии? При этом узнаёшь о том, что стоит этот аттрибут, лишь когда пытаешься сохранить изменённый файл и тебе предлагают выбор между «выкинуть свою работу в корзину» и «сохранить всё-равно».
            • 0
              Боюсь, что вы что-то путаете: блокировки в Subversion живут на стороне сервера и учитываются при попытке закоммитить заблокированный файл. То есть это не просто «флажок read-only».

              Проблема со взятием блокировки в начале изменения данных до сохранения, к сожалению, решается только интеграцией инструментария с системой контроля версий.
              • +1
                Да, видимо спутал с атрибутом svn:needs-lock
            • 0
              Ну, надо просто чаще сохраняться (и чаще делать svn up). Все-таки между «не смог сохраниться и потерял полчаса работы» и «не смог смерджить изменения и потерял 2 дня работы» огромная разница.
          • 0
            Это все понятно, непонятно другое — почему для реализации блокировок обязательно надо эмулировать SVN?
            Я полагаю, что это связано не с DVCS вообще, а с гитом в частности.
            • +1
              А куда по-вашему в DVCS можно положить блокировки?
      • 0
        у вас дошли руки до посмотреть плагин largefiles и вы признали его непригодным?
        • +1
          Лично я этот плагин не смотрел, но отзывы о нем от коллеги не очень лестные.

          В целом, на этапе поиска решения Git и Mercurial рассматривались как примерно равные системы контроля версий. Git был предпочтительней из-за большего опыта работы с ним у большинства разработчиков команды.
    • 0
      Mercurial в данной ситуации ничем не лучше. При работе над немержабельными бинарниками все DVCS одинаково плохи. А так — мы и на Git'е организовали SVN-like процесс, дописав небольшое расширение (git-as-svn).
      • 0
        Не скажите. Гит очень уж по-челябински суров. Блокировки же к существующей DVCS можно приделать и без эмуляции SVN.
        • +5
          Блокировки не могут быть реализованы отдельно за дешево. Сферические блокировки в вакууме никому не нужны.

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

Только зарегистрированные пользователи могут оставлять комментарии. Войдите, пожалуйста.

Самое читаемое Разработка