fly.io-rails 0.0.8-x64-mingw32 → 0.0.9-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51cda4c6db485a0353af506f6832e5c0865cf7e93cd37f4af3bffbb36f9961ce
-  data.tar.gz: 1a378871a6e08b9aa66e88afa41fdc240b359564e8443b81811e0d03cd84c69a
+  metadata.gz: 1b5bb5da64268060f271756bb097f2bdde3879ab963b77f303616b661afa2f71
+  data.tar.gz: '0108eb3bb6a924d52e7ee03f66deb126005f1d50b09320910649eb8ef312a2b0'
 SHA512:
-  metadata.gz: e3233ace9bb288ba700478546dfa2c42b627f3f19ef25bcc149174ae4c6dc1c4511c27bbcf749ac36abc52e53f9dad815223e2ab0001de01a7a46b56982ec3da
-  data.tar.gz: 92f28e2010b5bca3a698f843f949f57889a977660e9278f2124ac75614478c1cc226e4652e484b7554547a9174a9623ca9e02df3f51adf24cfa144cbe465008a
+  metadata.gz: d079a398a6c9bb1a3cb3dbc66be2d5859756050673081ba11ba24eeb1ae63b7fdcc35b0d8daeefdfaa18387039c7d6f9999d0f9930b1e9287b88da24a4d0e2bd
+  data.tar.gz: f7e1032d3183a7ebb54f28a4e0de8bcfa464aa8d63140ac62d064ce95fcefaa8a0b7a3d0c2ca1b892a36fe29b21efce0ef11c1c8e7386898a0a78653b994a00e

data/lib/fly.io-rails/hcl.rb

@@ -0,0 +1,99 @@
+require 'strscan'
+
+module Fly
+  # a very liberal HCL scanner
+  module HCL
+    def self.parse(string)
+      result = []
+      name = nil
+      stack = []
+      block = {}
+      cursor = block
+      result.push block
+
+      hcl = StringScanner.new(string)
+      until hcl.eos?
+	hcl.scan(%r{\s*(\#.*|//.*|/\*[\S\s]*?\*/)*})
+
+	if hcl.scan(/[a-zA-Z]\S*|\d[.\d]*|"[^"]*"/)
+	  if cursor.is_a? Array
+	    cursor.push token(hcl.matched)
+	  elsif name == nil
+	    name = token(hcl.matched)
+	  else
+	    hash = {}
+	    cursor[name] = hash
+	    name = token(hcl.matched)
+	    cursor = hash
+	  end
+	elsif hcl.scan(/=/)
+	  hcl.scan(/\s*/)
+	  if hcl.scan(/\[/)
+	    list = []
+	    cursor[name] = list
+            name = nil
+	    stack.push cursor
+	    cursor = list
+	  elsif hcl.scan(/\{/)
+	    hash = {}
+	    cursor[name] = hash
+	    name = nil
+	    stack.push cursor
+	    cursor = hash
+	  elsif hcl.scan(/.*/)
+	    cursor[name] = token(hcl.matched)
+	    name = nil
+	  end
+	elsif hcl.scan(/\{/)
+	  hash = {}
+	  if cursor.is_a? Array
+	    cursor << hash
+	  else
+	    cursor[name] = hash
+	  end
+	  name = nil
+	  stack.push cursor
+	  cursor = hash
+	elsif hcl.scan(/\[/)
+	  list = []
+	  stack.push cursor
+	  cursor = list
+	elsif hcl.scan(/\}|\]/)
+	  cursor = stack.pop
+
+	  if stack.empty?
+	    block = {}
+	    cursor = block
+	    result.push block
+	  end
+	elsif hcl.scan(/[,=:]/)
+          nil
+	elsif hcl.scan(/.*/)
+          unless hcl.matched.empty?
+	    STDERR.puts "unexpected input: #{hcl.matched.inspect}"
+          end
+	end
+      end
+
+      result.pop if result.last.empty?
+      result
+    end
+
+  private
+    def self.token(match)
+      if match =~ /^\d/
+	if match =~ /^\d+$/
+	  match.to_i
+	else
+	  match.to_f
+	end
+      elsif match =~ /^\w+$/
+	match.to_sym
+      elsif match =~ /^"(.*)"$/
+	$1
+      else
+	match
+      end
+    end
+  end
+end

data/lib/fly.io-rails/machines.rb

@@ -0,0 +1,192 @@
+require 'net/http'
+require 'json'
+
+module Fly
+  # Thin wrapper over https://fly.io/docs/reference/machines/
+  #
+  # *** WARNING ***
+  #
+  # No validation or escaping is done by this code.  It is assuming that
+  # the caller is trusted and does pass through unsanitized user input.
+  #
+  module Machines
+    @@api_token = nil
+    @@fly_api_hostname = nil
+
+    # determine fly api hostname.  Returns nil if no proxy is running
+    def self.fly_api_hostname
+      return @@fly_api_hostname if @@fly_api_hostname
+
+      Net::HTTP.get URI('http://_api.internal:4280')
+      @@fly_api_hostname = '_api.internal:4280'
+    rescue
+      begin
+	Net::HTTP.get URI('http://127.0.0.1:4280')
+	@@fly_api_hostname = '127.0.0.1:4280'
+      rescue
+	nil
+      end
+    end
+
+    # determine fly api hostname.  Starts proxy if necessary
+    def self.fly_api_hostname!
+      hostname = fly_api_hostname
+      return hostname if hostname
+
+      org = 'personal'
+
+      if File.exist? 'fly.toml'
+	require 'toml'
+	app = TOML.load_file('fly.toml')['app']
+
+	apps = JSON.parse(`flyctl list apps --json`) rescue []
+
+	apps.each do |info|
+	  org = info['Organization'] if info['ID'] == app
+	end
+      end
+
+      pid = fork { exec "flyctl machines api-proxy --org #{org}" }
+      at_exit { Process.kill "INT", pid }
+
+      # wait up to 12.7 seconds for the proxy to start
+      wait = 0.1
+      6.times do
+        sleep wait
+        begin
+          Net::HTTP.get URI('http://127.0.0.1:4280')
+          @@fly_api_hostname = '127.0.0.1:4280'
+          break
+        rescue
+          wait *= 2
+        end
+      end
+
+      @@fy_api_hostname
+    end
+
+    # create_fly_application app_name: 'user-functions', org_slug: 'personal'
+    def self.create_fly_application options
+      post '/v1/apps', options
+    end
+
+    # get_application_details 'user-functions'
+    def self.get_application_details app
+      get "/v1/apps/#{app}"
+    end
+
+    # create_start_machine 'user-functions', name: 'quirky_machine', config: {
+    #   image: 'flyio/fastify-functions',
+    #   env: {'APP_ENV' => 'production'},
+    #   services: [
+    #     {
+    #       ports: [
+    #         {port: 443, handlers: ['tls', 'http']},
+    #         {port: 80, handlers: ['http']}
+    #       ],
+    #       protocol: 'tcp',
+    #       internal_protocol: 'tcp',
+    #     }
+    #   ]
+    # }
+    def self.create_start_machine app, options
+      post "/v1/apps/#{app}/machines", options
+    end
+
+    # wait_for_machine_to_start 'user-functions', '73d8d46dbee589'
+    def self.wait_for_machine_to_start app, machine, timeout=60
+      get "/v1/apps/#{app}/machines/#{machine}/wait?timeout=#{timeout}"
+    end
+
+    # get_a_machine machine 'user-functions', '73d8d46dbee589'
+    def self.get_a_machine app, machine
+      get "/v1/apps/#{app}/machines/#{machine}"
+    end
+
+    # update_a_machine 'user-functions', '73d8d46dbee589', config: {
+    #   image: 'flyio/fastify-functions',
+    #   guest: { memory_mb: 512, cpus: 2 }
+    # }
+    def self.update_a_machine app, machine, options
+      post "/v1/apps/#{app}/machines/#{machine}", options
+    end
+
+    # stop_machine machine 'user-functions', '73d8d46dbee589'
+    def self.stop_machine app, machine
+      post "/v1/apps/#{app}/machines/#{machine}/stop"
+    end
+
+    # start_machine machine 'user-functions', '73d8d46dbee589'
+    def self.start_machine app, machine
+      post "/v1/apps/#{app}/machines/#{machine}/stop"
+    end
+
+    # delete_machine machine 'user-functions', '73d8d46dbee589'
+    def self.delete_machine app, machine
+      delete "/v1/apps/#{app}/machines/#{machine}"
+    end
+
+    # list_machines machine 'user-functions'
+    def self.list_machines app, machine
+      get "/v1/apps/#{app}/machines"
+    end
+
+    # delete_application 'user-functions'
+    def self.delete_application app, force=false
+      delete "/v1/apps/#{app}?force=#{force}"
+    end
+
+    # generic get
+    def self.get(path)
+      api(path) {|uri| request = Net::HTTP::Get.new(uri) }
+    end
+
+    # generic post
+    def self.post(path, hash=nil)
+      api(path) do |uri|
+        request = Net::HTTP::Post.new(uri)
+        request.body = hash.to_json if hash
+        request
+      end
+    end
+
+    # generic delete
+    def self.delete(path)
+      api(path) {|uri| request = Net::HTTP::Delete.new(uri) }
+    end
+
+    # common processing for all APIs
+    def self.api(path, &make_request)
+      uri = URI("http://#{fly_api_hostname}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      request = make_request.call(uri.request_uri)
+
+      @@api_token ||= `fly auth token`.chomp
+      headers = {
+        "Authorization" => "Bearer #{@@api_token}",
+        "Content-Type" => "application/json",
+        "Accept" => "application/json"
+      }
+      headers.each {|header, value| request[header] = value}
+
+      response = http.request(request)
+
+      if response.is_a? Net::HTTPSuccess
+        JSON.parse response.body, symbolize_names: true
+      else
+        body = response.body
+        begin
+          error = JSON.parse(body)
+        rescue
+          error = {body: body}
+        end
+
+        error[:status] = response.code
+        error[:message] = response.message
+
+        error
+      end
+    end
+  end
+end

data/lib/fly.io-rails/version.rb

@@ -1,3 +1,3 @@
 module Fly_io
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/lib/tasks/fly.rake

@@ -1,16 +1,84 @@
+require 'fly.io-rails/machines'
+require 'fly.io-rails/hcl'
+
 namespace :fly do
   desc 'Deploy fly application'
   task :deploy do
+    # build and push an image
     out = FlyIoRails::Utils.tee 'fly deploy --build-only --push'
     image = out[/image:\s+(.*)/, 1]
 
-    if image
-      tf = IO.read('main.tf')
-      tf[/^\s*image\s*=\s*"(.*?)"/, 1] = image.strip
-      IO.write 'main.tf', tf
+    exit 1 unless image
+
+    # update main.tf with the image name
+    tf = IO.read('main.tf')
+    tf[/^\s*image\s*=\s*"(.*?)"/, 1] = image.strip
+    IO.write 'main.tf', tf
+
+    # find first machine in terraform config file
+    machines = Fly::HCL.parse IO.read('main.tf').find {|block|
+      block.keys.first == :resource and
+      block.values.first.keys.first == 'fly_machine'}
+
+    # extract HCL configuration for the machine
+    config = machines.values.first.values.first.values.first
+
+    # extract fly application name
+    app = config[:app]
+
+    # delete HCL specific configuration items
+    %i(services for_each region app name depends_on).each do |key|
+       config.delete key
+    end
+
+    # move machine configuration into guest object
+    config[:guest] = {
+      cpus: config.delete(:cpus),
+      memory_mb: config.delete(:memorymb),
+      cpu_kind: config.delete(:cputype)
+    }
+
+    # release machines should have no services or mounts
+    config.delete :services
+    config.delete :mounts
+
+    # override start command
+    config[:env]['SERVER_COMMAND'] = 'bin/rails fly:release'
+
+    # start release machine
+    start = Fly::Machines.create_start_machine(app, config: config)
+    machine = start[:id]
+
+    if !machine
+      STDERR.puts 'Error starting release machine'
+      PP.pp start, STDERR
+      exit 1
+    end
+
+    # wait for release to copmlete
+    event = nil
+    90.times do
+      sleep 1
+      status = Fly::Machines.get_a_machine app, machine
+      event = status[:events]&.first
+      break if event && event[:type] == 'exit'
+    end
+
+    # extract exit code
+    exit_code = event.dig(:request, :exit_event, :exit_code)
+	     
+    if exit_code == 0
+      # delete release machine
+      Fly::Machines.delete_machine app, machine
 
+      # use terraform apply to deploy
       ENV['FLY_API_TOKEN'] = `flyctl auth token`.chomp
       system 'terraform apply -auto-approve'
+    else
+      STDERR.puts 'Error performing release'
+      STDERR.puts (exit_code ? {exit_code: exit_code} : event).inspect
+      STDERR.puts "run 'flyctl logs --instance #{machine}' for more information"
+      exit 1
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fly.io-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: x64-mingw32
 authors:
 - Sam Ruby
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-17 00:00:00.000000000 Z
+date: 2022-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fly-ruby
@@ -39,6 +39,8 @@ files:
 - exe/x64-mingw32/wintun.dll
 - lib/fly.io-rails.rb
 - lib/fly.io-rails/generators.rb
+- lib/fly.io-rails/hcl.rb
+- lib/fly.io-rails/machines.rb
 - lib/fly.io-rails/platforms.rb
 - lib/fly.io-rails/utils.rb
 - lib/fly.io-rails/version.rb