Today we’re pleased to announce Stash 2.4, which offers the choice and flexibility enterprise teams need to manage their Git development workflows. This release introduces several key features to manage and collaborate on your Git repositories behind the firewall–forking, a distributed development workflow popularized in open source development, along with personal repositories and per-repository permissions. Choice, flexibility, control–that’s Stash 2.4.

Try Stash 2.4 Now

Collaborative Git Development with Forks

To fork simply means to create a clone of a repository, including previous history, on the server side. Forks in Stash provide developers with a workflow to contribute code back to a repository for which they do not have write access–adding a layer of control into your development process. In Stash, clicking the ‘Fork’ button on a repository creates a copy that is tracked by Stash and modified independently of the original repository, insulating code from the original repository to unwanted changes or errors. You can fork a repository into any other project in Stash for which you have admin access, or create personal forks and give other developers access. Stash lets you easily merge changes between forks through pull requests.

Why fork?

• Contractors – Allow external developers to contribute to a project while only core team members have write access to the repository. Contributors can simply fork a repository and contribute changes back via pull requests.
• Large teams – With hundreds of developers working on the same repository, the volume of branches and activity in the repository can turn into noise. Forks provide a way for teams to work separately while constantly syncing new additions from the core repository into their project.
• Experiments – Whether you’re participating in ShipIt, spiking a project, or simply prototyping a feature, experimenting on forks gives developers the option to trash changes without polluting the main repository with commits if the experiment goes nowhere.

For an in-depth look at why an enterprise would want to adopt forks see “Why Forks?“.

Contribute changes via pull requests

The beauty of forks is that changes being made on the forked repository will not affect the main code line. Once a fork is ready for primetime, a request can be made to merge it into the original repository. Stash and pull requests facilitate the process of merging those changes. This gives other developers an opportunity to review and discuss the changes before they become a part of the main codebase. From there the changes can be merged based on the pull request settings and branch permissions in the original repository.

Personal Repositories

In Stash 2.4 we’ve added a way to create personal repositories that are not related to other projects. This gives developers the freedom to innovate and store their private snippets of work, kick-start their own project, contribute a bug fix for a project they are not a member of, or add a feature to a common component maintained by a small group in an organization. Keep your personal repositories as open (or closed) as you want, then use repository permissions to collaborate with other users and groups if and when you are ready.

With the introduction of personal repositories and personal forks, we needed an easily accessible place to summarize the information. So we revamped user profiles, too.

Repository Permissions

Stash permissions aim to keep your code secure, and give you the confidence that the right developers have the right access. Early in Stash’s development we introduced two key permission sets: Global permissions to provide control or delegate user and group access to projects, and project permissions to control read and write access per-project. In Stash 2.0 we added a deeper level of access control–branch permissions–to enforce who can commit to specific branches in a repository. Stash 2.4 adds even more fine-grained access control to Stash; you can now set permissions at the repository level.

Administrators can keep projects as open or closed as they want. Grant access to individual repositories within a project without making the entire project available to the user. There are several scenarios where this can benefit your workflow:

• External developers – Opening up broad access to your repositories can be nerve-racking when working with external developers. For a given project, your core team should have access to all repositories, while only select repositories are available to contractors.
• Open up access – Many teams restrict write access to a small group of developers for specific projects. To foster collaboration you can open up view access to the rest of an organization so other non-core team members can fork and contribute.
• Delegate administration – Save valuable time by providing administration access for a repository to trusted team members, giving them the freedom to manage specific repositories.

Stash lets you choose how you and your teams work with distributed code, and that flexibility means you can work and ship faster.

Always Fork Before You Commit With Stash 2.4

New to Stash? Fork today with a free trial and get up and running in a matter of minutes.

Try Stash 2.4 Now

Already using Stash? Your upgrade to 2.4 is just a click away. Check out our full release notes to get started.

The Problem

I hate it when I make a trivial change, something like:

Then a few minutes later.. *BOOM*

What the heck? How did changing the capitalization of a letter break the database migration tests?

Hmm.. maybe they’re flakey. Let’s re-run the build. *BOOM*

Arggh!

Oh wait. Of course. I know what heinous crime I’ve committed!

Little did I know, one of my co-workers had broken master at some point in the past. My crime: branching from their broken commit. A simple merge from master at this point (providing it’s green) will remedy the situation, even if it does make the history a bit uglier.

Wouldn’t it be nice if we could avoid this whole situation altogether?

The Solution

What if git warned you when you switched to a dodgy ref? Something like:

Then you could easily switch back to a better ref for your branch point, or slap the build breaker until they fix it.

I’ve built a little client-side git hook that does exactly that. It will work work for any git repository built by Bamboo or hosted by Stash, and is super easy to install.

Just run this command from the root of your local clone:

You’ll be prompted for the url and credentials of either:

• the Bamboo server that builds your repository; or
• the Stash server that hosts your repository (if you’ve set up your CI server to notify Stash of build results).

It works by registering a post-checkout hook that hits a little known REST end-point in Bamboo that provides all build results for a particular SHA.

The project is up on Bitbucket and I’m very open to pull requests.

It was great to be one of the sponsors at the GOTO Chicago 2013 conference from Tuesday April, 23 – Wednesday, April 24th  It was awesome meeting a number of JIRA, Confluence, and Dev Tools customers  at the conference.  Herzum Consulting, one of our experts joined us at the booth as well.  Atlassian Experts help deliver an incredible experience with our products. If you need a plugin built, a deployment tuned, help with setup and configuration, or coaching on going agile, we’ve got the expert for the job.

Technology, Innovation, and Fun

We enjoyed two full days of technology, innovation, and fun with some amazingly bright minds.  We heard from Dan North sharing on how we tend to cling to structure.  He challenged us how to thrive in an uncertain world.  Mike Lee talked candidly about how innovation happens at the intersection of creativity and commerce. His take is that innovation, the hard core engineering, commands sacrifice.  Mike encourages developers to seek feedback from peers as well as end users on making their application better.

We also heard from Atlassian’s own Tim Pettersen.  Tim, originally based in Sydney, was one of the developers on the Stash team.  He now joins us in San Francisco as a developer advocate.   Stash is Atlassian’s on-premise, enterprise grade Git solution.  He shared with all of us how to use Git as a platform.  He used examples from tracking configuration changes in a Wi-Fi router to seeing change history in the German legislature.  Tim of course hosts his slides in Git!

New to Git?

For those of you who are new to Git, Atlassian has two Git solutions: Stash and Bitbucket.  Stash is enterprise Git for an on premise solution.  Bitbucket is all of the goodness of Git hosted in the cloud.

Want to learn more about Git? Check out our Git center on the web.

Git Tutorials and Training

And so what?

If you’re lucky enough to never have branched from a bad commit, let me share with you how ugly it can be. You have worked on this new feature, the code has been reviewed and you are ready to push it to master for the world to see, but you see on Stash that the builds are red on your branch. You start checking the builds wondering how your change could have broken all these tests. After a while you realize these tests were broken on master when you branched, but since master is green now everything should be ok. You push your change and move on. After a while build wallboards start getting red all over the office with your face on it. You did break some tests after all… But all that pain can be avoided if you take care to branch from a good commit in the first place.

Scenarios:

On the Confluence team, we don’t have a 1:1 mapping between commits and builds. So given that, the results need to be analysed a bit.

• Commit with failed builds : obviously you don’t want to branch from there
  • This doesn’t mean that this particular commit broke the build. It could be caused by a previous commit build in the same time.
• Commit with green builds 
  • The more CI builds are exercising that commit, and the more of them that are green, the more reliable the commit is.
  • For the Confluence team, 5 builds passed means all “A1. Master Baseline” builds passed, and you can branch

Thanks to the Stash-Bamboo plugin we can start your branch on the right foot, but it’s pretty much useless if you forget to check the build status before branching. One way to fix this problem for good is to use Bamboo Gatekeeper, letting Bamboo push branch changes to master once the tests are green. Or you could put a sticky note on your monitor to remind you… but I don’t recommend it.

Get the Stash-Bamboo Plugin

• Invite him to a screen sharing session
• Copy my code to a snippet hosting site and share the link via HipChat
• Commit the refactored code to my Stash repo and send him a pull request

Most developers would probably have been fine with any of those options, but none was satisfying to me. Bob and I were already engaged in a detailed discussion via HipChat about my refactoring, and being able to code collaboratively would have been ideal.

Bringing it to life

The situation above isn’t a first for me. In fact, it happens all the time – and I’m sure I’m not alone. For ages I’ve longed for a real-time collaborative editor where my code lives. Many have tried to create a solution like this, but none have proved useful for me.

So a few weeks back when my colleague Tim Pettersen and I were discussing what we should work on for our quarterly ShipIt project, I suggested that we solve this problem. One day of hacking later, we managed to produce a solution.

Introducing the Stash Realtime Editor Add-on

The Stash Realtime Editor makes it possible to edit files in real-time directly from the Stash interface – no cloning, no IDE, no local editor. Because it’s in real-time, you can share a link with your colleagues to collaboratively edit or review code together. Once you’re happy with your edits, you can commit them directly to Stash without the need to push your changes up to the repository. Your commit gets stored in a new branch and can be merged in with a simple pull request.

This add-on adds a real-time editor directly into Stash using the fabulous Firebase service and its awesome Firepad operational transform (OT) based editor. OT makes it possible to edit files in real-time with reliability and predictability, and allows users to see what other users are doing inside the editor (e.g., selecting, highlighting, typing, etc.).

The Stash Realtime Editor works even if you lose network connectivity. If you’re working on a file with someone and happen to suspend your laptop, resume your work on a train, and then come back online at home, your changes will sync up exactly as you would expect.

The Stash Realtime Editor is a free add-on for Stash. Look for it in the Atlassian Marketplace…

Learn more

Interested in the latest Stash release? Check out What’s New »

What do you get when you combine a razor-focused release cycle and implementing one of the highest voted Stash feature requests? It’s Stash 2.3, and it’s available today. Today’s release of Stash 2.3 introduces features for Enterprise teams (single sign-on), Git operations (submodule recognition and branch deletion) and making Stash even more scalable (the SCM Cache plugin).

Try Stash 2.3 Now

Crowd Single Sign-On Support

Many enterprise teams use Atlassian Crowd to integrate and deploy single sign-on (SSO) using popular directory servers such as Active Directory or OpenLDAP. In response to many votes from our users, Stash now supports Crowd SSO.

• IT administrators can centralize user management through Crowd and provide SSO for all Atlassian apps with minimal configuration.
• End-users enjoy the convenience of logging in once to any Atlassian application, avoiding the interruption of repeated authentication across other applications. Log in once, and you’re automatically logged into all applications connected to Crowd, including Stash.

Virtually everything in Stash is pluggable and authentication is no different. Our new plugin based authentication allows you to integrate Stash with other single sign-on solutions.

Even More Scalable

The Stash development team’s approach to Stash performance is simple: keep it scalable and speedy. Stash maintains fast response times and limits memory consumption by using streaming, paged APIs and fine tuning the many Git operations that we use to build the data displayed to the user. We use a mixture of automated performance tests and manual profiling to ensure every last drop of speed is squeezed out of our software. One of the recent results of our focus on performance is the Stash SCM Cache plugin.

Large instances with continuous integration (CI) or other automatic tooling set up to poll Stash for changes can end up with high load on their Stash servers. Consider for instance a CI server that has a number of builds set up for a given repository. Each of those builds polls Stash for changes and when it detects a change, it starts a new build. If your CI server supports parallel and/or chained build steps, each of these builds typically results in multiple clone operations of the same repository. The result: lots of polling for changes, and bursts of clones of a repository when a change is detected.

The SCM Cache plugin adds a caching layer that caches the pack files generated by Git during a clone operation on disk. This greatly reduces the CPU hit on your server and drastically improves response time when you experience repetitive requests from continuous integration. Check out some results from a recent test.

Read more about installing and configuring the Stash SCM Cache Plugin on your Stash server.

Delete Branch

Git, unlike some other SCM systems, makes branching and merging your codebase easy and cheap. However, one side effect is that you can often end up with large numbers of calcifying branches cluttering up your repository, long after they’ve been merged into master.

Up until now, deleting branches after they’ve been merged has been a manual process from the command line (read: it usually never gets done).

Stash 2.3 provides a simple way to delete the branch when you merge the pull request. As you might expect, Stash checks on a few things before allowing the deletion–the branch being merged will not be deleted if:

• The branch is the default repository branch.
• The user does not have permission to delete the branch.
• The branch is subject to an open pull request.

Save your team time; automate the process and keep your code organized with the simple click of a box.

Git Submodules Recognition

Git submodules allow you to nest external Git repositories within the directory structure of your own repository. Submodules are commonly used to embed external codebases–such as shared libraries–which are updated independently of the main project. For a more thorough introduction to submodules, along with some common usage patterns, check out our overview on Git submodules.

Stash 2.3 makes it easy to identify Git submodules through the Stash user interface:

If Stash recognizes the external resource hosting a particular submodule (Bitbucket or Github, for example) it will generate a link to the submodule’s home repository in the Stash UI, so you can easily click through to the relevant project.

Get More Out Of Your Git Repositories With Stash

New to Stash? Start a free trial today and get up and running in a matter of minutes.

Try Stash 2.3 Now

Already using Stash? Your upgrade to 2.3 is waiting for you. Check out our full release notes to get started.

Content Scheduler, our February winner!

We’re pleased to announce that Content Scheduler, a plugin for Confluence, is the winner of the $10,000 add-on of the month prize for February!

Built by bitvoodoo ag, Content Scheduler allows you to schedule dates and times for blog posts to be published, write the post ahead of time, and let Confluence automatically publish your post at the designated time. No need to remember to go to your drafts and publish the right one and the right moment, Content Scheduler creates a new “Schedule” button next to the publish button, just like WordPress.

But they didn’t stop there. You also get to customize a shortlink for your blog post and can see an overview of all your currently scheduled posts.

Runner up: Notifyr for Stash

Our runner up for the February prize is Notifyr, a plugin for Stash by Stefankohler.  With Notifyr, users can watch specific repositories, branches, or tags and get beautifully formatted email notifications whenever someone makes changes. This highly useful add-on makes staying on top of your Stash codebase so much easier.

Join me in contgratulating bitvoodoo, Stefankohler, and the other 21 fantastic entries we received for Codegeist during the month of February. We’ll be awarding a $10,000 prize for Content Scheduler, and they’ll be eligible to receive the $15,000 “Best Overall Add-on Prize”. Notifyr will be eligible for the $10,000 “Best Stash Add-on Prize”, both of which will be awarded after the contest ends on May 31.

Don’t forget about the Atlassian Marketplace

We saw great entries in February across the board, whether add-ons were free or paid. Don’t forget, if you build something that you believe is worth selling, you can easily sell it via the Atlassian Marketplace. To date, February Codegeist submissions have grossed almost $4,000 on the Atlassian Marketplace and have been evaluated more than 150 times. Your add-on could be next.

We’re excited to see what March brings! Start building your Codegeist add-on today.

Get Started!

SourceTree is a free Git desktop client for developers on Windows. Say goodbye to the command line and use the full capabilities of Git through SourceTree’s beautifully simple interface (and stop being jealous of what your Mac friends are using).

A simple, powerful Git client

SourceTree for Windows simplifies how you interact with Git repositories so you can focus on coding.

• Get your team up and running using common Git commands from a simple user interface
• Manage all your Git repositories, hosted or local, through a single client
• Put Git commands at your fingertips: commit, push, pull and merge with just one-click
• Use advanced features such as patch handling, rebase, shelve and cherry picking
• Connect to your repositories in Bitbucket, Stash, Microsoft TFS or GitHub

Perfect for Git newbies

SourceTree was built to make Git approachable for every developer – especially those new to Git. Every Git command is just a click away using the SourceTree interface.

• Create and clone repos from anywhere
• Commit, push, pull and merge
• Detect and resolve conflicts
• Search repository histories for changes

Visualize your repositories

SourceTree keeps track of code activity and provides an at-a-glance view of everything from projects to repositories to changesets.

Use SourceTree’s Bookmarks to get a real-time, aggregated view of all your projects and repositories. Jump directly to the changeset graph to visualize changesets across multiple branches and forks.

Powerful enough for Git veterans

SourceTree makes Git simple for everyone, but also makes Git experts faster and more productive. Review your outgoing and incoming changesets, cherry-pick between branches, create and apply patches, rebase, shelve changesets and more with lightning speed.

Git one-stop shop

Atlassian offers a full complement of tools that will help you and your dev team make the most of Git. Whether you’re working on Mac or Windows, behind the firewall or in the cloud, Atlassian’s family of Git tools will bring you the power of Git while making adoption a breeze.

Connect to the cloud or behind the firewall

Thanks to hosting services like Bitbucket, many small teams working with Git repositories begin coding in the cloud. Connect SourceTree to Bitbucket’s free unlimited private repositories to easily manage your Git repositories from the SourceTree interface.

Stash, Atlassian’s Git repository manager for Enterprises, makes it simple to manage your Git Server – behind the firewall. With powerful two-way integration, Stash and SourceTree make it easy for your team to develop with Git. SourceTree can discover and fetch your Stash repositories. And one-click clone operations get you the source you need fast.

If you don’t have Stash or Bitbucket yet, not a problem, SourceTree for WIndows works with any Git repository, including GitHub, Microsoft Team Foundation Server or your own Git server.

What’s coming next?

We received great feedback from the SourceTree for Windows private beta users (a huge thank you). We will continue to push frequent updates and features to SourceTree for Windows users. We plan to bring all the great features that are part of SourceTree for Mac to Windows as well. What can you expect in the near future:

• Mercurial support
• Git-flow support
• Custom actions
• JIRA integration
• and heaps more

Get SourceTree for Free!

If you’re new to Git, or just want a handy tool to make you even faster, download SourceTree – it’s free at our brand spankin’ new website.

Have you heard of Vagrant yet? It is awesome. Why? It automates much of the boilerplate work we developers have to endure while setting up our platforms and toolkits. So what does Vagrant do? In their words, it allows you to create and configure lightweight, reproducible, and portable development environments.

So what better testbed for this tool than the shiny new Stash 2.2 release?

Objective: provide me and fellow developers a (almost) one-click install for Stash.

Alright, I say almost because you need just a few dependencies if you want to use a configuration/provisioning framework, specifically a recent version of VirtualBox, Vagrant and of course git.

First try out this magic for yourself and then I’ll walk you through some interesting details of the setup:

1. Install VirtualBox and Vagrant and make sure you have git available.

2. Open your favorite terminal and add a base virtual machine or provide your own:

   
   1
   vagrant box add base http://files.vagrantup.com/precise32.box
   
   

3. Clone the stash-vagrant-install project by typing at your command line:

   
   1
   2
   3
   git clone https://bitbucket.org/durdn/stash-vagrant-install.git
   
   
   
   cd stash-vagrant-install
   
   

4. Start up and provision automatically all dependencies in the vm:

   
   1
   vagrant up
   
   

5. ??? There is no step 5. *** You’re DONE! ***

Note: be sure to let the process finish as it might take a while to download all the required packages.

After it finishes you will be able to access your brand new Stash installation with a browser at http://localhost:7990/setup.

If you need to access the vm you can ssh into the box, you will find the stash installation in the /vagrant folder:

1
2
3
    vagrant ssh



    cd /vagrant

And if you need to start Stash manually you can just type:

1
    STASH_HOME=/vagrant/stash-home /vagrant/atlassian-stash-2.2.0/bin/start-stash.sh

Under the hood

Now let me explain how all this works in some detail. Under the hood I used an absolutely basic Vagrant setup and a single Puppet manifest. Here is the Vagrantfile:

1
2
3
4
5
6
7
8
Vagrant::Config.run do |config|

  config.vm.box = "base"

  config.vm.forward_port 7990, 7990

  config.vm.provision :puppet, :module_path => "modules" do |puppet|

    puppet.manifests_path = "manifests"

    puppet.manifest_file  = "default.pp"

  end

end

As you can see it only specifies the port forwarding for where Stash will run (port 7990) and Puppet as provisioning system. Nothing more.

Java Installation Blues

The only major requirement (and the complication) of this setup comes from the task of installing Java 7 and automatically accept the Oracle license terms. Java is not included in Ubuntu repositories for various licensing reasons therefore we have to cater for it.

First we need to instruct Puppet about apt; we do this by requiring the library:

1
include apt

This allows us to interact with Ubuntu packages in a more advanced fashion. Then we need to add a repository to the apt sources, one that includes the Java installer:

1
apt::ppa { "ppa:webupd8team/java": }

From there, update the apt infrastructure in two steps, first without the extra ppa repository and then with it:

1
2
3
4
5
6
7
8
9
exec { 'apt-get update':

  command =❯ '/usr/bin/apt-get update',

  before =❯ Apt::Ppa["ppa:webupd8team/java"],

}



exec { 'apt-get update 2':

  command =❯ '/usr/bin/apt-get update',

  require =❯ [ Apt::Ppa["ppa:webupd8team/java"], Package["git-core"] ],

}

After this we automatically accept the Java license:

1
2
3
4
5
6
7
8
9
exec {

  "accept_license":

  command =❯ "echo debconf shared/accepted-oracle-license-v1-1 select true | sudo debconf-set-selections && echo debconf shared/accepted-oracle-license-v1-1 seen true | sudo debconf-set-selections",

  cwd  =❯ "/home/vagrant",

  user =❯ "vagrant",

  path =❯ "/usr/bin/:/bin/",

  before =❯ Package["oracle-java7-installer"],

  logoutput =❯ true,

}

Downloading and Running Stash

The rest is about downloading the Stash installation file:

1
2
3
4
5
6
7
8
9
10
exec {

  "download_stash":

  command =❯ "curl -L http://www.atlassian.com/software/stash/downloads/binary/atlassian-stash-2.2.0.tar.gz | tar zx",

  cwd =❯ "/vagrant",

  user =❯ "vagrant",

  path =❯ "/usr/bin/:/bin/",

  require =❯ Exec["accept_license"],

  logoutput =❯ true,

  creates =❯ "/vagrant/atlassian-stash-2.2.0",

}

Creating its home folder:

1
2
3
4
5
6
7
8
9
10
exec {

  "create_stash_home":

  command =❯ "mkdir -p /vagrant/stash-home",

  cwd  =❯ "/vagrant",

  user =❯ "vagrant",

  path =❯ "/usr/bin/:/bin/",

  require =❯ Exec["download_stash"],

  logoutput =❯ true,

  creates =❯ "/vagrant/stash-home",

}

And kicking it off in the background:

1
2
3
4
5
6
7
8
9
10
11
12
13
exec {

  "start_stash_in_background":

  environment =❯ "STASH_HOME=/vagrant/stash-home",

  command =❯ "/vagrant/atlassian-stash-2.2.0/bin/start-stash.sh &",

  cwd =❯ "/vagrant",

  user =❯ "vagrant",

  path =❯ "/usr/bin/:/bin/",

  require =❯ [ Package["oracle-java7-installer"],

              Exec["accept_license"],

              Exec["download_stash"],

              Exec["create_stash_home"] ],

  logoutput =❯ true,

}

Now we have a system that has all the required packages ready for Stash to run and that actually kicks it off in the background for you. Pretty awesome!

If you are interested in learning more check out the Puppet manifest to see all the magic in context.

Conclusions

In conclusion: Vagrant and Puppet rock and can help any coder or system administrator to assemble development boxes easily. This is great when evaluating solutions or when providing complete setups with all the required dependencies. Oh and don’t forget to try Stash 2.2 out!

Headquartered: Gomel, Belarus
Founded: 2010
Employees: 5
Add-ons developed: 13

StiltSoft developed one of the first add-ons for Atlassian Stash. Their first add-on,  Awesome Graphs for Stash, hit a home run with over 2200 downloads to date. We reached out to Maxim Kuzmich at StiltSoft to ask him about StiltSofts experience with developing add-ons for Stash.

Who are your customers?

It’s hard to say definitely. Half of our time we’re working on custom projects for our clients and the second half we spend for developing our commercial and free add-ons.