Git-Flow alternative to support multiple versions of a product

Git-Flow works very well for a scenario where devs mantain & evolve a software with a single instance on production (i.e. http://www.virgingames.com). git

But imagine a scenario where devs develop a software that has different versions installed in different clients and devs have to give some support to old versions. (i.e. Visual Studio) while evolving the latest. Devs have to:

  • Mantain version 1.0 of your software (critical bug fixing) [In our example VS 2013]
  • Mantain version 1.1 of your software (critical bug fixing) [In our example VS 2015]
  • Develop version 1.2 (new features) [In our example VS 2017]

Git-Flow doesn’t support that scenario. Here is my solution, a git flow variant with feature branches and multiple “Master” branches called Release Branches.

Git-flowAlternative

  • Feature Branches and Dev branch works like git-flow.
  • Version 1.0
    • First release (r1.0) is done by creating a branch.
    • Evolutive development continues in Dev branch (and feature branches)
    • It is critical that no evolutive development is done in Release Branch r1.0 so if user wants a new feature he has to wait to r1.1 version.
    • If a critical bug is found in r1.0 version it can be fixed there.
    • If the critical bug is affecting dev, bug fix must be merged to dev branch.
    • If the critical bug is complex a small hot-fix branch can be created (like a feature branch)
  • Version 1.1
    • When next version (r1.1) is ready a new branch is created [Same as previous version]
    • Old branch (r1.0) is kept while we have still users on that version.
    • Once version 1.0 (r1.0) is declared obsolete, users with bugs must install a higher version.
  • Version 1.2
    • Same as version 1.1
  • Etc.

Function to prepare Machine.config

This PowerShell script “prepare” machine.config by:

  • Create appSettings.config and link it in machine.config
  • Create connectionStrings.config and link it in machine.config
  • Add proxy settings

Code:

 

 

 

 

 

 

Main base Powershell script (with Azure)

Example of PowerShell Main base script with detection of PowerShell version and Azure PowerShell version.

 

 

PowerShell new features.

PowerShell 5.0 (Windows Management Framework 5.0)

  • By default in Windows 10 & Windows Server 2016 Technical Preview.
  • Remote Script Debugging in ISE 🙂
  • Transcription works in ISE by default
  • .NET enumerations.
  • Improved DSC.

PowerShell 4.0

  • By default in Windows 8.1 & Windows Server 2012 R2
  • DSC: Desired State Configuration
  • Remote Script Debugging in console (no ISE)
  • Improved Invoke-RestMethod and Invoke-WebRequest to specify headers.

PowerShell 3.0

  • By default in Windows 8 & Windows Server 2012
  • Improved ISE: IntelliSense
  • Improved remote PowerShell ( New-PSSession)
  • Module Auto-Load
  • Invoke-RestMethod and Invoke-WebRequest
  • Ordered Hashtables
  • Scheduled jobs

The James White Manifesto

Taken from websages blog.

    == Rules ==
On Infrastructure
– There is one system, not a collection of systems.
– The desired state of the system should be a known quantity.
– The “known quantity” must be machine parseable.
– The actual state of the system must self-correct to the desired state.
– The only authoritative source for the actual state of the system is the system.
– The entire system must be deployable using source media and text files.

On Buying Software
– Keep the components in the infrastructure simple so it will be better understood.
– All products must authenticate and authorize from external, configurable sources.
– Use small tools that interoperate well, not one “do everything poorly” product.
– Do not implement any product that no one in your organization has administered.
– “Administered” does not mean saw it in a rigged demo, online or otherwise.
– If you must deploy the product, hire someone who has implemented it before to do so.

On Automation
– Do not author any code you would not buy.
– Do not implement any product that does not provide an API.
– The provided API must have all functionality that the application provides.
– The provided API must be tailored to more than one language and platform.
– Source code counts as an API, and may be restricted to one language or platform.
– The API must include functional examples and not requre someone to be an expert on the product to use.
– Do not use any product with configurations that are not machine parseable and machine writeable.
– All data stored in the product must be machine readable and writeable by applications other than the product itself.
– Writing hacks around the deficiencies in a product should be less work than writing the product’s functionality.

In general
– Keep the disparity in your architecture to an absolute minimum.
– Use Set Theory to accomplish this.
– Do not improve manual processes if you can automate them instead.
– Do not buy software that requires bare-metal.
– Manual data transfers and datastores maintained manually are to be avoided.

My own basic Git cheat sheet

Git Cheat Sheet

  • Create
    • Clone Repository: git clone url
    • Create new local repository: git init
  • Local Changes
    • Detect pending changes: git status
    • Add files to commit: git add -p <filename> or git add .
    • Commit code: git commit -a -m “Comment”
    • Get code: git pull
    • Push changes: git push
    • View History: git log  / git log -p <filename>
    • History/Blame: git blame <filename>
  • Branches, Merge & Rebase
    • Detect current branch: git branch
    • List all branches: git branch -av
    • Merge branch into current head: git merge <branch>
    • Rebase current head onto <branch>: git rebase <branch>

Git workflow: https://www.atlassian.com/git/tutorials/comparing-workflows

git

PowerShell Modules: All you need to remember

 

Script Modules

A script module is a file (.psm1) that contains any valid Windows PowerShell code. Script developers and administrators can use this type of module to create modules whose members include functions, variables, and more.

Binary Modules

A binary module is a .NET Framework assembly (.dll) that contains compiled code. Cmdlet developers can use this type of module to create modules that contain cmdlets, providers, and more. (Existing snap-ins can also be used as binary modules.)

Manifest Modules

A manifest module is a module that includes a manifest (described later in this section) to describe its components, but that does not specify a root module in the manifest. A module manifest does not specify a root module when the ModuleToProcess key of the manifest is blank. In most cases, a manifest module also includes one or more nested modules using script modules or binary modules. A manifest module that does not include any nested modules can be used when you want a convenient way to load assemblies, types, or formats.

Dynamic Modules

A dynamic module is a module that does not persist to disk. This type of module enables a script to create a module on demand that does not need to be loaded or saved to persistent storage. By default, dynamic modules created with the New-Module cmdlet (described in the following sections) are intended to be short-lived and therefore cannot be accessed by the Get-Module cmdlet

Using Transfer utility in AWS SDK.NET

Useful Links

Upload files

Upload directory