fly.io-rails 0.0.8-x86_64-darwin → 0.0.9-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 186b2eacaa96f600d3079b40d140625c594cef6ec0130335be85f5f8d24606de
-  data.tar.gz: 7249e30ab10251bef2b7798fcf263971886b6711088f3de8718993772a6f169a
+  metadata.gz: d622a5b51f10f261b059832d1f4b5413a513bb01bd6f8228dd5bebbf35f4a0b1
+  data.tar.gz: fc30f4acd2b22efeb09bb62713829c915a91db94d4e9b0300b807032c8c4ca19
 SHA512:
-  metadata.gz: 9cf7bfde07503c0fbfb87a65fae521811e62438c86d631a8d7afa70c8c572e49140549318744539506c9ff944e8ca4a18a58a36f5721d67e9975fcca5e83f7d7
-  data.tar.gz: 38e3833d26dc30a7e7afe1bf558f99d7ee204f2e7a159813ddeebb85d7247ff8e5c28018d2c097bead29bc96e5515f84fde16df88c032d85769c4093adaa0312
+  metadata.gz: fe60d5d89639fdb5ad0126d0ba4786bd6147eb41fe224fdab9f8e7cba848002aa74e2afb90d0c1c8949eecf928d9d4f04fa628647609fdab133c3d8681bd1b34
+  data.tar.gz: 8e36510e35a2a182e7b9e82965c2b7900c3ce3d4e024866c7f75579c78ae71cfc1377a73f01abdfacb69898c180e545c053b3536e662db1b2f05faadf8ee4e9d

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: x86_64-darwin
 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
@@ -38,6 +38,8 @@ files:
 - exe/x86_64-darwin/flyctl
 - 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