Class: Mikoshi::Cli

Inherits:
Object
  • Object
show all
Defined in:
lib/mikoshi/cli.rb

Constant Summary collapse

TASK_DEFINITION_PATH = 
'task_definitions'
SERVICE_PATH = 
'services'
PLAN_EXT = 
'.yml.erb'
FETCH_INTERVAL = 
10
DEPLOY_TIMEOUT = 
300

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(argv: nil) ⇒ Cli

Returns a new instance of Cli.

Raises:

  • (ArgumentError) 


22
23
24
25
26
27
 
# File 'lib/mikoshi/cli.rb', line 22

def initialize(argv: nil)
  raise ArgumentError, 'argv is required.' if argv.nil?

  @argv = argv
  @options = { region: nil, command: nil, config: {} }
end

Instance Attribute Details

#options ⇒ Object (readonly)

Returns the value of attribute options.



14
15
16
 
# File 'lib/mikoshi/cli.rb', line 14

def options
  @options
end

Instance Method Details

#aws_client ⇒ Object 



184
185
186
187
188
189
190
191
192
 
# File 'lib/mikoshi/cli.rb', line 184

def aws_client
  opt =
    if @options[:region].nil?
      {}
    else
      { region: @options[:region] }
    end
  Aws::ECS::Client.new(opt)
end

#command_is_unkown(command: nil) ⇒ Object 



180
181
182
 
# File 'lib/mikoshi/cli.rb', line 180

def command_is_unkown(command: nil)
  warn "'#{command}' is unknown command. Please see help by `mikoshi help`."
end

#deploy ⇒ Object 



172
173
174
175
176
177
178
 
# File 'lib/mikoshi/cli.rb', line 172

def deploy
  task_def_name = @options[:config][:group] || @options[:config][:task_definition]
  service_name = @options[:config][:group] || @options[:config][:service]

  update_task_definition(task_def_name) if task_def_name
  update_service(service_name) if service_name
end

#exit_when_flag ⇒ Object 



67
68
69
70
71
 
# File 'lib/mikoshi/cli.rb', line 67

def exit_when_flag
  usage if @options[:config][:help]
  version if @options[:config][:version]
  exit if @options[:config][:help] || @options[:config][:version]
end

#parse ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/mikoshi/cli.rb', line 51

def parse
  opt = OptionParser.new

  opt.on('-r', '--region=REGION')                   { |v| @options[:region] = v }
  opt.on('-s', '--service=SERVICE')                 { |v| @options[:config][:service] = v }
  opt.on('-t', '--task-definition=TASK_DEFINITION') { |v| @options[:config][:task_definition] = v }
  opt.on('--potdr')                                 { |v| @options[:config][:potdr] = v }
  opt.on('-g', '--group=GROUP')                     { |v| @options[:config][:group] = v }
  opt.on('-h', '--help')                            { |v| @options[:config][:help] = v }
  opt.on('-v', '--version')                         { |v| @options[:config][:version] = v }
  opt.on('--cluster=CLUSTER')                       { |v| @options[:config][:cluster] = v }

  opt.permute!(@argv)
  @options[:command] = @argv.first.to_sym unless @argv.first.nil?
end

#runtask(task_def_name, cluster) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/mikoshi/cli.rb', line 140

def runtask(task_def_name, cluster)
  if task_def_name.nil?
    warn '--task-definition=TASK_DEFINITION is require option.'
    abort
  end

  task = ::Mikoshi::Plan::TaskDefinition.new(
    yaml_path: File.join(TASK_DEFINITION_PATH, task_def_name + PLAN_EXT),
    client:    aws_client,
  )

  puts "Run task: #{task_def_name}"
  task.runtask(cluster: cluster)
  puts "Invoked task: #{task_def_name}"
end

#start ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/mikoshi/cli.rb', line 29

def start
  parse
  exit_when_flag

  case @options[:command]
  when :update_task_definition
    update_task_definition(@options[:config][:task_definition] || @argv[1])
  when :update_service
    update_service(@options[:config][:service] || @argv[1])
  when :runtask
    runtask(@options[:config][:task_definition] || @argv[1], @options[:config][:cluster])
  when :deploy
    deploy
  when :version
    version
  when :help
    usage
  else
    command_is_unkown(command: @options[:command])
  end
end

#update_service(service_name) ⇒ Object 



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/mikoshi/cli.rb', line 156

def update_service(service_name)
  if service_name.nil?
    warn '--service=SERVICE is require option.'
    abort
  end

  service = ::Mikoshi::Plan::Service.new(
    yaml_path: File.join(SERVICE_PATH, service_name + PLAN_EXT),
    client:    aws_client,
  )

  puts "Update service: #{service_name}"
  service.deploy_service(message: true)
  puts "Done update service #{service_name}"
end

#update_task_definition(task_def_name) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/mikoshi/cli.rb', line 120

def update_task_definition(task_def_name)
  if task_def_name.nil?
    warn '--task-definition=TASK_DEFINITION is require option.'
    abort
  end

  task = ::Mikoshi::Plan::TaskDefinition.new(
    yaml_path: File.join(TASK_DEFINITION_PATH, task_def_name + PLAN_EXT),
    client:    aws_client,
  )

  # print only task definition revision
  potdr = @options[:config][:potdr]

  puts "Update task definition: #{task_def_name}" unless potdr
  task.register_task_definition
  puts "Done update task definition: #{task_def_name} revision: #{ENV['TASK_DEF_REVISION']}" unless potdr
  puts ENV['TASK_DEF_REVISION'] if potdr
end

#usage ⇒ Object 



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
 
# File 'lib/mikoshi/cli.rb', line 73

def usage
  puts <<~USAGE
    Usage of the mikoshi

    Global option
      -r, --region=REGION : Set aws region
      -h, --help          : Print this help message
      -v, --version       : Print mikoshi version

    Subcommands
      update_task_definition
        Update task definition to given task definition yaml file.
        Set TASK_DEF_REVISION to updated task definition revision number.

        Option
          --potdr
            Acronym of the "Print Only Task Definition Revision".

      runtask
        Invoke new task using specified task definition.

        Option
          --cluster
            Set cluster to run task. (required)

      update_service
        Update service to given service yaml file.
        Wait for success to update the service. (Maximum 300 min)

      deploy
        invoke update_task_definition and update_service.

        Option
          -g, --group=GROUP
            If task definition file name and service file name are
            same, that a shorthand of pass both.

      Common options
        -s, --service=SERVICE
        -t, --task-definition=TASK_DEFINITION
  USAGE
end

#version ⇒ Object 



116
117
118
 
# File 'lib/mikoshi/cli.rb', line 116

def version
  puts "mikoshi version #{Mikoshi::VERSION}"
end