What are truffle migrations?

Question

As written in Truffle docs:

Migrations are Javascript files that help you deploy contracts to the Ethereum network. These files are responsible for staging your deployment tasks, and they're written under the assumption that your deployment needs will change over time. As your project evolves, you'll create new migration scripts to further this evolution on the blockchain. A history of previously run migrations is recorded on-chain through a special Migrations contract, detailed below.

But what does it really mean? What are the use cases of migrations?

I'm also trying to understand the Migrations.sol file, which is given in Truffle tutorial:

contract Migrations {
  address public owner;
  uint public last_completed_migration;

  modifier restricted() {
    if (msg.sender == owner) _
  }

  function Migrations() {
    owner = msg.sender;
  }

  function setCompleted(uint completed) restricted {
    last_completed_migration = completed;
  }

  function upgrade(address new_address) restricted {
    Migrations upgraded = Migrations(new_address);
    upgraded.setCompleted(last_completed_migration);
  }
}

Answer 1

The Migrations contract stores (in last_completed_migration) a number that corresponds to the last applied "migration" script, found in the migrations folder. Deploying this Migrations contract is always the first such step anyway. The numbering convention is x_script_name.js, with x starting at 1. Your real-meat contracts would typically come in scripts starting at 2_....

So, as this Migrations contract stores the number of the last deployment script applied, Truffle will not run those scripts again. On the other hand, in the future, your app may need to have a modified, or new, contract deployed. For that to happen, you create a new script with an increased number that describes the steps that need to take place. Then, again, after they have run once, they will not run again.

And yes, the last 2 lines are true Solidity. Look at http://solidity.readthedocs.io/en/latest/contracts.html#creating-contracts inside contract OwnedToken {.

Answer 2

Here is an example of a real use case of Truffle migrations.

I have a storage contract and an interface contract. The interface needs to know where the storage is and the storage needs to grant permissions to the interface.

So in the second migration (the first one is reserved for Truffle housekeeping) I'm deploying the storage:

var MEStorage = artifacts.require("./MEStorage.sol");

module.exports = function(deployer) {
  deployer.deploy(MEStorage);
};

And in the 3rd I'm getting Storage address and deploying interface with this address as a parameter. And after I have the interface address, I grant permissions to it in the Storage:

var MEInterface = artifacts.require("./MEInterface.sol");
var MEStorage = artifacts.require("./MEStorage.sol");

module.exports = function(deployer) {
  deployer.deploy(MEInterface, MEStorage.address).then(() => {
    MEStorage.deployed().then(storageInstance => {
        return storageInstance.setPermissions(MEInterface.address, 2);
        // 2 - is FULL access
    });
  });
};

Here is a video, explaining this use case and an article about storage pattern I'm using.

Answer 3

Migrations are a bunch of boilerplate that Truffle requires and which you will copy-paste and then forget you ever did it.