In addition to cpharmston’s answer, it sounds like you need to do some refactoring to separate out what is truly custom for each client and what isn’t. Then you may consider adding additional repositories to track the customizations for each client (entirely new repos, not branches). Then your deployment can pull your “core” from your main repo, and the client-specific stuff from that repo.
I would not use branches to accomplish what you are trying to do.
In source control, branches are intended to be used for things that are meant to be merged back into trunk. For example, Alex Gaynor spent his summer of code working on a branch of Django that allows for support for multiple databases, with the goal of eventually merging it back into the Django trunk.
Checkouts (or clones, in Git’s case) might better suit what you are trying to do. You would create a repo containing all of the project’s base files (and .sample files, if you will), and clone the repo to all the various locations you wish to deploy the code. Then manually create the configuration and customization files at each deployment (take care not to add them to the repo). Whenever you update the code in the repo, run a pull on each deployment to update the code. Viola!
- Django runserver custom database
- Accessing form fields as properties in a django view
- Django template object type
Other answers are correct that you’ll be in the best shape for maintenance to the extent that you separate out your core code from the custom per-client code. However, I’ll break from the crowd and say that if you’re unable to do that (say because you need to add extra functionality to core code for a certain client), DVCS branches would work just fine for what you want to do. Though I’d probably recommend per-directory branches rather than in-repo branches for this purpose (git can do per-directory branches as well, it’s nothing but a cloned repo that diverges).
I use hg, not git, but all of my Django projects are cloned from the same base “project template” repo that has utility scripts, a basic common set of INSTALLED_APPS, etc. This means when I make changes to that project template, I can easily merge those common updates into existing projects. This isn’t exactly the same as what you’re planning, but is similar. You will occasionally have to deal with merge conflicts, if you modify the same area of code in the core that you’ve already customized for a specific client.
Matthew Talbert is correct, you really need to separate the custom stuff from non-custom stuff. If you can refactor all the core code to be contained in one directory, your clients can use it as a read-only git submodule. The added benefit is that you lock them into an explicit version of the core code. This means that they would have to consciously update to a newer revision, which is what you want for production code.
- Creating a Gin Index with Trigram (gin_trgm_ops) in Django model
- Have a url that accepts all characters
- Django QuerySet Custom Ordering by ID
After reading all your answers (thanks!) i decided to first refactor my django project structure to isolate the core and my differents apps in an apps subfolder. Doing this makes a cleaner project, and tweaking the .gitignore in the differents branches file makes it easy to use git branches to manage the differents customers and settings !
- How to output text from database with line breaks in a django template?
- ImportError: cannot import name "urandom"
- Django; AWS Elastic Beanstalk ERROR: Your WSGIPath refers to a file that does not exist
- Changing password in Django Admin