Class: Sunshine::DefaultCommand

Inherits:
Object
  • Object
show all
Defined in:
lib/commands/default.rb

Overview

Default sunshine behavior when no command is passed. Outputs help.

Direct Known Subclasses

ListCommand, RunCommand

Class Method Summary collapse

Class Method Details

.build_response(status, data) ⇒ Object

Build a Sunshine command response



193
194
195
 
# File 'lib/commands/default.rb', line 193

def self.build_response status, data
  {'status' => status, 'data' => data}.to_yaml
end

.copy_middleware(path) ⇒ Object

Copy middleware to specified location.



41
42
43
44
45
46
47
 
# File 'lib/commands/default.rb', line 41

def self.copy_middleware path
  middleware_dir = "#{Sunshine::ROOT}/templates/sunshine/middleware/."

  FileUtils.cp_r middleware_dir, path

  puts "Copied Sunshine middleware to #{path}"
end

.copy_rakefile(path) ⇒ Object

Copy template rakefile to specified location.



29
30
31
32
33
34
35
 
# File 'lib/commands/default.rb', line 29

def self.copy_rakefile path
  template_rakefile = "#{Sunshine::ROOT}/templates/sunshine/sunshine.rake"

  FileUtils.cp template_rakefile, path

  puts "Copied Sunshine template rakefile to #{path}"
end

.exec(argv, config) ⇒ Object

Takes an array and a hash, runs the command and returns:

true: success
false: failed
exitcode:
  code == 0: success
  code != 0: failed

and optionally an accompanying message.



17
18
19
20
21
22
23
 
# File 'lib/commands/default.rb', line 17

def self.exec argv, config

  copy_rakefile(config['rakefile'])     if config.has_key? 'rakefile'
  copy_middleware(config['middleware']) if config.has_key? 'middleware'

  return true
end

.opt_parser(options = nil) ⇒ Object

Base option parser constructor used by all commands.



53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/commands/default.rb', line 53

def self.opt_parser options=nil
  OptionParser.new do |opt|
    opt.program_name = File.basename $0
    opt.version = Sunshine::VERSION
    opt.release = nil

    yield opt if block_given?

    opt.on('-S', '--sudo [USER]',
           'Run remote commands using sudo or sudo -u USER.') do |value|
      options['sudo'] = value || true
    end if options
  end
end

.parse_args(argv) ⇒ Object

Returns the main sunshine help when no arguments are passed.



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
 
# File 'lib/commands/default.rb', line 72

def self.parse_args argv
  options = {}

  opts = opt_parser do |opt|
    opt.banner = <<-EOF

Sunshine is an object oriented deploy tool for rack applications. 

  Usage:
#{opt.program_name} -h/--help
#{opt.program_name} -v/--version
#{opt.program_name} command [arguments...] [options...]

  Examples:
#{opt.program_name} deploy deploy_script.rb
#{opt.program_name} restart myapp -r [email protected],[email protected]
#{opt.program_name} list myapp myotherapp --health -r [email protected]
#{opt.program_name} list myapp --status

  Commands:
add       Register an app with #{opt.program_name}
deploy    Run a deploy script
list      Display deployed apps
restart   Restart a deployed app
rm        Unregister an app with #{opt.program_name}
start     Start a deployed app
stop      Stop a deployed app

   Options:
    EOF

    opt.on('--rakefile [PATH]',
           'Copy the Sunshine template rakefile.') do |path|
      options['rakefile'] = path || File.join(Dir.pwd, "sunshine.rake")
    end

    opt.on('--middleware [PATH]',
           'Copy Sunshine rack middleware files.') do |path|
      options['middleware'] =
        path || File.join(Dir.pwd, ".")
    end

    opt.separator nil
    opt.separator "For more help on sunshine commands, "+
                  "use '#{opt.program_name} COMMAND --help'"
    opt.separator nil
  end


  opts.parse! argv

  if options.empty?
    puts opts
    exit 1
  end

  options
end

.parse_remote_args(argv, &block) ⇒ Object

Parse arguments for a command that acts remotely.



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
 
# File 'lib/commands/default.rb', line 135

def self.parse_remote_args argv, &block
  options = {}

  opts = opt_parser(options) do |opt|
    opt.separator nil
    opt.separator "Options:"

    yield(opt, options) if block_given?

    opt.on('-u', '--user USER',
           'User to use for ssh login. Use with -r.') do |value|
      options['user'] = value
    end

    opt.on('-r', '--remote server1,server2', Array,
           'Run on one or more remote servers.') do |servers|
      options['servers'] = servers
    end

    formats = %w{txt yml json}
    opt.on('-f', '--format FORMAT', formats,
           "Set the output format (#{formats.join(', ')})") do |format|
      options['format'] = "#{format}_format".to_sym
    end

    opt.on('-v', '--verbose',
           'Run in verbose mode.') do
      options['verbose'] = true
    end
  end

  opts.parse! argv


  if options['servers']
    options['servers'].map! do |host|
      RemoteShell.new host, :user => options['user']
    end
  else
    options['servers'] = [Sunshine.shell]
  end

  options['format'] ||= :txt_format


  if options['sudo']
    options['servers'].each do |ds|
      ds.sudo = options['sudo']
    end
  end

  options
end