Module: MorphCLI

Defined in:
lib/morph-cli.rb,
lib/morph-cli/version.rb

Constant Summary collapse

DEFAULT_CONFIG = 
{
  development: {
    base_url: "http://127.0.0.1:3000"
  },
  production: {
    base_url: "https://morph.io"
  }
}
VERSION = 
"0.2.4"

Class Method Summary collapse

Class Method Details

.all_paths(directory) ⇒ Object

Relative paths to all the files in the given directory (recursive) (except for anything below a directory starting with “.”)



107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/morph-cli.rb', line 107

def self.all_paths(directory)
  result = []
  Find.find(directory) do |path|
    if FileTest.directory?(path)
      if File.basename(path)[0] == ?.
        Find.prune
      end
    else
      result << Pathname.new(path).relative_path_from(Pathname.new(directory)).to_s
    end
  end
  result
end

.config_path ⇒ Object 



55
56
57
 
# File 'lib/morph-cli.rb', line 55

def self.config_path
  File.join(Dir.home, ".morph")
end

.create_tar(directory, paths) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/morph-cli.rb', line 89

def self.create_tar(directory, paths)
  tempfile = File.new('/tmp/out', 'wb')

  in_directory(directory) do
    begin
      tar = Archive::Tar::Minitar::Output.new("/tmp/out")
      paths.each do |entry|
        Archive::Tar::Minitar.pack_file(entry, tar)
      end
    ensure
      tar.close
    end
  end
  File.new('/tmp/out', 'r')
end

.database_path(directory) ⇒ Object

Relative path of database file (if it exists)



122
123
124
125
 
# File 'lib/morph-cli.rb', line 122

def self.database_path(directory)
  path = "data.sqlite"
  path if File.exists?(File.join(directory, path))
end

.execute(directory, development, env_config) ⇒ Object 



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

def self.execute(directory, development, env_config)
  puts "Uploading and running..."
  file = MorphCLI.create_tar(directory, MorphCLI.all_paths(directory))
  buffer = ""
  block = Proc.new do |http_response|
    if http_response.code == "200"
      http_response.read_body do |line|
        before, match, after = line.rpartition("\n")
        buffer += before + match
        buffer.split("\n").each do |l|
          log(l)
        end
        buffer = after
      end
    elsif http_response.code == "401"
      raise RestClient::Unauthorized
    else
      puts http_response.body
      exit(1)
    end
  end
  if env_config.key?(:timeout)
    timeout = env_config[:timeout]
  else
    timeout = 600 # 10 minutes should be "enough for everyone", right?
                  # Setting to nil will disable the timeout entirely.
                  # Default is 60 seconds.
  end
  result = RestClient::Request.execute(:method => :post, :url => "#{env_config[:base_url]}/run",
    :payload => {:api_key => env_config[:api_key], :code => file}, :block_response => block,
    :timeout => timeout)
end

.in_directory(directory) ⇒ Object 



81
82
83
84
85
86
87
 
# File 'lib/morph-cli.rb', line 81

def self.in_directory(directory)
  cwd = FileUtils.pwd
  FileUtils.cd(directory)
  yield
ensure
  FileUtils.cd(cwd)
end

.load_config ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/morph-cli.rb', line 73

def self.load_config
  if File.exists?(config_path)
    YAML.load(File.read(config_path))
  else
    DEFAULT_CONFIG
  end
end

.log(line) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/morph-cli.rb', line 39

def self.log(line)
  unless line.empty?
    a = JSON.parse(line)
    s = case a["stream"]
    when "stdout", "internalout"
      $stdout
    when "stderr"
      $stderr
    else
      raise "Unknown stream"
    end

    s.puts a["text"]
  end
end

.save_config(config) ⇒ Object 



59
60
61
62
 
# File 'lib/morph-cli.rb', line 59

def self.save_config(config)
  File.open(config_path, "w") {|f| f.write config.to_yaml}
  File.chmod(0600, config_path)
end