Assort/index.coffee at master · RootPanel/Assort · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
semver = require 'semver'
async = require 'async'
fs = require 'fs'
_ = require 'underscore'

logger = ->
  args = _.toArray arguments
  args.unshift '[Assort]'
  console.log.apply @, args

versionFromFile = (filename = '.version', name = 'version') ->
  return {
    name: name

    readVersion: (callback) ->
      fs.exists filename, (exists) ->
        if exists
          fs.readFile filename, (err, body) ->
            if err
              callback err
            else
              callback err, JSON.parse(body.toString())[name]

        else
          callback null, null

    saveVersion: (version, callback) ->
      writeVersion = (config) ->
        config ?= {}
        config[name] = version

        fs.writeFile filename, JSON.stringify(config), callback

      fs.exists filename, (exists) ->
        if exists
          fs.readFile filename, (err, body) ->
            if err
              callback err
            else
              writeVersion JSON.parse body.toString()

        else
          writeVersion()
  }

versionFromMongoDB = (uri, collection = '_version', name = 'version') ->
  {MongoClient} = require 'mongodb'

  return {
    name: name

    readVersion: (callback) ->
      MongoClient.connect uri, (err, db) ->
        return callback err if err
        db.collection(collection).findOne
          name: name
        , (err, doc) ->
          if err
            callback err

          else if doc
            callback err, doc?.version

          else
            callback err, null

    saveVersion: (version, callback) ->
      MongoClient.connect uri, (err, db) ->
        return callback err if err
        db.collection(collection).update
          name: name
        ,
          $set:
            version: version
        ,
          upsert: true
        , (err, doc) ->
          if err
            callback err

          else if doc
            callback err, doc?[name]

          else
            callback err, null

  }

class Assort
  tasks: []

  # storage: readVersion(callback(err)), saveVersion(version, callback(err))
  constructor: (storage) ->
    _.extend @,
      storage: storage

  # callback(err)
  migrate: (latest_version, resource, callback) ->
    {storage, tasks} = @

    unless latest_version
      return callback 'missing latest_version'

    logger "start migrate: #{storage.name}, latest_version: #{latest_version}"

    storage.readVersion (err, current_version) ->
      return callback err if err

      logger "read version, current_version: #{current_version}"

      async.eachSeries tasks, (task, callback) ->
        if current_version and task.version and !semver.satisfies(current_version, task.version)
          logger "skip task #{task.name}(#{task.version})"
          return callback()

        logger "run task #{task.name}(#{task.version}) ..."
        task.worker resource, callback

      , (err) ->
        if err
          logger 'migrate error', err
          callback err
        else
          logger "save version, current_version: #{latest_version}"
          storage.saveVersion latest_version, callback

  # worker(resource, callback(err))
  task: (name, version, worker) ->
    @tasks.push
      name: name
      version: version
      worker: worker

module.exports = _.extend Assort,
  fromFile: versionFromFile
  fromMongoDB: versionFromMongoDB