summaryrefslogtreecommitdiff
path: root/bin/feature-flag
blob: 46d93a11ebd9e8d05fc5e68768536df2e3394341 (plain)
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
#!/usr/bin/env ruby
#
# Generate a feature flag entry file in the correct location.
#
# Automatically stages the file and amends the previous commit if the `--amend`
# argument is used.

require 'optparse'
require 'yaml'
require 'fileutils'
require 'cgi'

require_relative '../lib/feature/shared' unless defined?(Feature::Shared)

module FeatureFlagHelpers
  Abort = Class.new(StandardError)
  Done = Class.new(StandardError)

  def capture_stdout(cmd)
    output = IO.popen(cmd, &:read)
    fail_with "command failed: #{cmd.join(' ')}" unless $?.success?
    output
  end

  def fail_with(message)
    raise Abort, "\e[31merror\e[0m #{message}"
  end
end

class FeatureFlagOptionParser
  extend FeatureFlagHelpers
  extend ::Feature::Shared

  Options = Struct.new(
    :name,
    :type,
    :group,
    :ee,
    :amend,
    :dry_run,
    :force,
    :introduced_by_url,
    :rollout_issue_url
  )

  class << self
    def parse(argv)
      options = Options.new

      parser = OptionParser.new do |opts|
        opts.banner = "Usage: #{__FILE__} [options] <feature-flag>\n\n"

        # Note: We do not provide a shorthand for this in order to match the `git
        # commit` interface
        opts.on('--amend', 'Amend the previous commit') do |value|
          options.amend = value
        end

        opts.on('-f', '--force', 'Overwrite an existing entry') do |value|
          options.force = value
        end

        opts.on('-m', '--introduced-by-url [string]', String, 'URL to Merge Request introducing Feature Flag') do |value|
          options.introduced_by_url = value
        end

        opts.on('-i', '--rollout-issue-url [string]', String, 'URL to Issue rolling out Feature Flag') do |value|
          options.rollout_issue_url = value
        end

        opts.on('-n', '--dry-run', "Don't actually write anything, just print") do |value|
          options.dry_run = value
        end

        opts.on('-g', '--group [string]', String, "The group introducing a feature flag, like: `group::apm`") do |value|
          options.group = value if value.start_with?('group::')
        end

        opts.on('-t', '--type [string]', String, "The category of the feature flag, valid options are: #{TYPES.keys.map(&:to_s).join(', ')}") do |value|
          options.type = value.to_sym if TYPES[value.to_sym]
        end

        opts.on('-e', '--ee', 'Generate a feature flag entry for GitLab EE') do |value|
          options.ee = value
        end

        opts.on('-h', '--help', 'Print help message') do
          $stdout.puts opts
          raise Done.new
        end
      end

      parser.parse!(argv)

      unless argv.one?
        $stdout.puts parser.help
        $stdout.puts
        raise Abort, 'Feature flag name is required'
      end

      # Name is a first name
      options.name = argv.first

      options
    end

    def read_group
      $stdout.puts ">> Please specify the group introducing feature flag, like `group::apm`:"

      loop do
        $stdout.print "\n?> "
        group = $stdin.gets.strip
        group = nil if group.empty?
        return group if group.nil? || group.start_with?('group::')

        $stderr.puts "Group needs to include `group::`"
      end
    end

    def read_type
      $stdout.puts ">> Please specify the type of your feature flag:"
      $stdout.puts
      TYPES.each do |type, data|
        $stdout.puts "#{type.to_s.rjust(15)}#{' '*6}#{data[:description]}"
      end

      loop do
        $stdout.print "\n?> "

        type = $stdin.gets.strip.to_sym
        return type if TYPES[type]

        $stderr.puts "Invalid type specified '#{type}'"
      end
    end

    def read_issue_url(options)
      return unless TYPES.dig(options.type, :rollout_issue)

      url = "https://gitlab.com/gitlab-org/gitlab/-/issues/new"
      title = "[Feature flag] Rollout of `#{options.name}`"
      description = File.read('.gitlab/issue_templates/Feature Flag Roll Out.md')
      description.sub!(':feature_name', options.name)

      issue_new_url = url + "?" +
        "issue[title]=" + CGI.escape(title) + "&"
        # TODO: We should be able to pick `issueable_template`
        # + "issue[description]=" + CGI.escape(description)

      $stdout.puts ">> Open this URL and fill the rest of details:"
      $stdout.puts issue_new_url
      $stdout.puts

      $stdout.puts ">> Paste URL here, or enter to skip:"

      loop do
        $stdout.print "\n?> "
        created_url = $stdin.gets.strip
        created_url = nil if created_url.empty?
        return created_url if created_url.nil? || created_url.start_with?('https://')

        $stderr.puts "URL needs to start with https://"
      end
    end
  end
end

class FeatureFlagCreator
  include FeatureFlagHelpers

  attr_reader :options

  def initialize(options)
    @options = options
  end

  def execute
    assert_feature_branch!
    assert_name!
    assert_existing_feature_flag!

    # Read type from $stdin unless is already set
    options.type ||= FeatureFlagOptionParser.read_type
    options.group ||= FeatureFlagOptionParser.read_group
    options.rollout_issue_url ||= FeatureFlagOptionParser.read_issue_url(options)

    $stdout.puts "\e[32mcreate\e[0m #{file_path}"
    $stdout.puts contents

    unless options.dry_run
      write
      amend_commit if options.amend
    end

    if editor
      system("#{editor} '#{file_path}'")
    end
  end

  private

  def contents
    YAML.dump(
      'name'              => options.name,
      'introduced_by_url' => options.introduced_by_url,
      'rollout_issue_url' => options.rollout_issue_url,
      'group'             => options.group.to_s,
      'type'              => options.type.to_s,
      'default_enabled'   => false
    ).strip
  end

  def write
    FileUtils.mkdir_p(File.dirname(file_path))
    File.write(file_path, contents)
  end

  def editor
    ENV['EDITOR']
  end

  def amend_commit
    fail_with "git add failed" unless system(*%W[git add #{file_path}])

    Kernel.exec(*%w[git commit --amend])
  end

  def assert_feature_branch!
    return unless branch_name == 'master'

    fail_with "Create a branch first!"
  end

  def assert_existing_feature_flag!
    existing_path = all_feature_flag_names[options.name]
    return unless existing_path
    return if options.force

    fail_with "#{existing_path} already exists! Use `--force` to overwrite."
  end

  def assert_name!
    return if options.name.match(/\A[a-z0-9_-]+\Z/)

    fail_with "Provide a name for the feature flag that is [a-z0-9_-]"
  end

  def file_path
    feature_flags_paths.last
      .sub('**', options.type.to_s)
      .sub('*.yml', options.name + '.yml')
  end

  def all_feature_flag_names
    @all_feature_flag_names ||=
      feature_flags_paths.map do |glob_path|
        Dir.glob(glob_path).map do |path|
          [File.basename(path, '.yml'), path]
        end
      end.flatten(1).to_h
  end

  def feature_flags_paths
    paths = []
    paths << File.join('config', 'feature_flags', '**', '*.yml')
    paths << File.join('ee', 'config', 'feature_flags', '**', '*.yml') if ee?
    paths
  end

  def ee?
    options.ee
  end

  def branch_name
    @branch_name ||= capture_stdout(%w[git symbolic-ref --short HEAD]).strip
  end
end

if $0 == __FILE__
  begin
    options = FeatureFlagOptionParser.parse(ARGV)
    FeatureFlagCreator.new(options).execute
  rescue FeatureFlagHelpers::Abort => ex
    $stderr.puts ex.message
    exit 1
  rescue FeatureFlagHelpers::Done
    exit
  end
end

# vim: ft=ruby