fly-rails 0.3.5

data/lib/fly-rails/dsl.rb

@@ -0,0 +1,92 @@
+require 'rake'
+
+module Fly
+  module DSL
+    class Base
+      include Rake::DSL
+
+      @@blocks = {}
+
+      def initialize
+        @value = {}
+      end
+
+      def self.block name, kind
+        @@blocks[name] = kind
+
+        define_method name do |&block| 
+          @config[name] ||= kind.new
+          @config[name].instance_eval(&block) if block
+          @config[name]
+        end
+      end
+      
+      def self.blocks
+        @@blocks
+      end
+
+      def self.option name, default=nil
+        @options ||= {}
+        @options[name] = default
+
+        define_method name do |*args|
+          if args.length == 1
+            @value[name] =  args.first
+          elsif args.length > 1
+            raise ArgumentError.new("wrong number of arguments (given #{args.length}, expected 0..1)")
+          end
+
+          @value.include?(name) ? @value[name] : default
+        end
+      end
+
+      def self.options
+        @options ||= {}
+      end
+    end
+
+    #############################################################
+
+    class Machine < Base
+      option :cpus, 1
+      option :cpu_kind, 'shared'
+      option :memory_mb, 256
+    end
+
+    class Postgres < Base
+      option :vm_size, 'shared-cpu-1x'
+      option :volume_size, 1
+      option :initial_cluster_size, 1
+    end
+
+    class Redis < Base
+      option :plan, "Free"
+    end
+
+    class Sqlite3 < Base
+      option :size, 3
+    end
+
+    class Deploy < Base
+      option :swap_mb, 0
+    end
+
+    #############################################################
+
+    class Config < Base
+
+      def initialize
+        @config = {}
+        super
+      end
+
+      option :image, nil
+
+      block :machine, Machine
+      block :postgres, Postgres
+      block :redis, Redis
+      block :sqlite3, Sqlite3
+      block :deploy, Deploy
+    end
+  end
+end

data/lib/fly-rails/generators.rb

@@ -0,0 +1,3 @@
+require 'rails/generators'
+require 'rails/generators/channel/channel_generator'
+require 'rails/generators/job/job_generator'

data/lib/fly-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-rails/machines.rb

@@ -0,0 +1,209 @@
+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 = ENV['FLY_API_TOKEN']
+    @@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 application's organization
+    def self.org
+      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
+
+      org
+    end
+
+    # determine fly api hostname.  Starts proxy if necessary
+    def self.fly_api_hostname!
+      hostname = fly_api_hostname
+      return hostname if hostname
+
+      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
+
+      @@fly_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_and_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_and_start_machine app, options
+      post "/v1/apps/#{app}/machines", options
+    end
+
+    # wait_for_machine 'user-functions', '73d8d46dbee589'
+    def self.wait_for_machine app, machine, options = {timeout:60, status: 'started'}
+      get "/v1/apps/#{app}/machines/#{machine}/wait?#{options.to_query}"
+    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
+
+    # graphql -- see https://til.simonwillison.net/fly/undocumented-graphql-api
+    def self.graphql(query)
+      api('/graphql', 'https://api.fly.io/') do |path|
+        request = Net::HTTP::Post.new(path)
+        request.body = { query: query }.to_json
+        request
+      end
+    end
+
+    # common processing for all APIs
+    def self.api(path, host=nil, &make_request)
+      host ||= "http://#{fly_api_hostname}"
+      uri = URI.join(host, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.set_debug_output $stderr if ENV['TRACE'] 
+      http.use_ssl = true if uri.instance_of? URI::HTTPS
+
+      request = make_request.call(uri.request_uri)
+
+      @@api_token ||= `flyctl 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-rails/platforms.rb

@@ -0,0 +1,10 @@
+module Fly
+  PLATFORMS = {
+    'Linux_arm64' => 'aarch64-linux',
+    'Linux_x86_64' => 'x86-linux',
+    'macOS_arm64' => 'arm64-darwin',
+    'macOS_x86_64' => 'x86_64-darwin',
+    'Windows_arm64' => nil, # Can't find a match
+    'Windows_x86_64' => 'x64-mingw32'
+  }
+end

data/lib/fly-rails/scanner.rb

@@ -0,0 +1,68 @@
+module Fly
+  module Scanner
+    # scan for major features - things that if present will likely affect
+    # more than one artifact that is generated.
+    def scan_rails_app
+
+      ### database ###
+
+      database = YAML.load_file('config/database.yml').
+        dig('production', 'adapter') rescue nil
+
+      if database == 'sqlite3'
+        @sqlite3 = true
+      elsif database == 'postgresql'
+        @postgresql = true
+      elsif database == 'mysql' or database == 'mysql2'
+        @mysql = true
+      end
+
+      ### ruby gems ###
+
+      @gemfile = []
+
+      if File.exist? 'Gemfile.lock'
+        parser = Bundler::LockfileParser.new(Bundler.read_file('Gemfile.lock'))
+        @gemfile += parser.specs.map { |spec, version| spec.name }
+      end
+      
+      if File.exist? 'Gemfile'
+        @gemfile += Bundler::Definition.build('Gemfile', nil, []).dependencies.map(&:name)
+      end
+
+      @sidekiq = @gemfile.include? 'sidekiq'
+      @anycable = @gemfile.include? 'anycable-rails'
+      @rmagick = @gemfile.include? 'rmagick'
+      @image_processing = @gemfile.include? 'image_processing'
+      @bootstrap = @gemfile.include? 'bootstrap'
+      @puppeteer = @gemfile.include? 'puppeteer'
+
+      ### node modules ###
+
+      @package_json = []
+
+      if File.exist? 'package.json'
+        @package_json += JSON.load_file('package.json')['dependencies'].keys rescue []
+      end
+
+      @puppeteer ||= @package_json.include? 'puppeteer'
+
+      ### cable/redis ###
+
+      @cable = ! Dir['app/channels/*.rb'].empty?
+
+      if @cable
+        @redis_cable = true
+        if (YAML.load_file('config/cable.yml').dig('production', 'adapter') rescue '').include? 'any_cable'
+          @anycable = true
+        end
+      end
+
+      if (IO.read('config/environments/production.rb') =~ /redis/i rescue false)
+        @redis_cache = true
+      end
+
+      @redis = @redis_cable || @redis_cache || @sidekiq
+    end
+  end
+end

data/lib/fly-rails/utils.rb

@@ -0,0 +1,66 @@
+begin
+  require 'pty'
+rescue LoadError
+  # Presumably Windows
+end
+
+module FlyIoRails
+  module Utils
+
+    def tee cmd
+      say_status :run, cmd if defined? say_status
+      FlyIoRails::Utils.tee cmd
+    end
+    
+    def self.tee cmd
+      data = []
+
+      if defined? PTY
+        begin
+          # PTY supports ANSI cursor control and colors
+          PTY.spawn(cmd) do |read, write, pid|
+            begin
+              read.each do |line|
+                print line
+                data << line
+              end
+            rescue Errno::EIO
+            end
+          end
+        rescue PTY::ChildExited
+        end
+      else
+        # no support for ANSI cursor control and colors
+        Open3.popen2e(cmd) do |stdin, out, thread|
+          out.each do |line|
+            print line
+            data << line
+          end
+        end
+      end
+
+      data.join
+    end
+
+    def create_app(name: nil, org: 'personal', regions: [], nomad: false, **rest)
+      cmd = if name
+        "flyctl apps create #{name.inspect} --org #{org.inspect} --machines"
+      else
+        "flyctl apps create --generate-name --org #{org.inspect} --machines"
+      end
+
+      cmd.sub! ' --machines', '' if nomad
+  
+      output = tee cmd
+      exit 1 unless output =~ /^New app created: /
+  
+      @app = output.split.last
+  
+      unless regions.empty?
+        @regions = regions.flatten
+      end
+
+      @app
+    end
+  end
+end

data/lib/fly-rails/version.rb

@@ -0,0 +1,3 @@
+module Fly
+  VERSION = '0.3.5'
+end

data/lib/fly-rails.rb

@@ -0,0 +1,27 @@
+require 'rails'
+require 'fly-rails/generators'
+require 'fly-rails/utils'
+
+class FlyIoRailtie < Rails::Railtie
+  # load rake tasks
+  rake_tasks do
+    Dir[File.expand_path('tasks/*.rake', __dir__)].each do |file|
+      load file
+    end
+  end
+
+  # set FLY_IMAGE_NAME on Nomad VMs
+  if not ENV['FLY_IMAGE_REF'] and ENV['FLY_APP_NAME'] and ENV['FLY_API_TOKEN']
+    require 'fly-rails/machines'
+
+    ENV['FLY_IMAGE_REF'] = Fly::Machines.graphql(%{
+      query {
+	app(name: "#{ENV['FLY_APP_NAME']}") {
+	  currentRelease {
+	    imageRef
+	  }
+	}
+      }
+    }).dig(:data, :app, :currentRelease, :imageRef)
+  end
+end

data/lib/generators/fly/app_generator.rb

@@ -0,0 +1,72 @@
+require 'fly-rails/actions'
+
+module Fly::Generators
+class AppGenerator < Rails::Generators::Base
+  include FlyIoRails::Utils
+
+  class_option :name, type: :string, required: false
+  class_option :org, type: :string, default: 'personal'
+  class_option :region, type: :array, repeatable: true, default: []
+  class_option :nomad, type: :boolean, default: false
+  class_option :eject, type: :boolean, default: nil
+
+  class_option :anycable, type: :boolean, default: false
+  class_option :avahi, type: :boolean, default: false
+  class_option :litefs, type: :boolean, default: false
+  class_option :nats, type: :boolean, default: false
+  class_option :redis, type: :boolean, default: false
+  class_option :passenger, type: :boolean, default: false
+  class_option :serverless, type: :boolean, default: false
+
+  def generate_app
+    source_paths.push File.expand_path('../templates', __dir__)
+
+    # the plan is to make eject an option, default to false, but until
+    # that is ready, have generate fly:app always eject
+    opts = options.to_h.symbolize_keys
+    opts[:eject] = opts[:nomad] if opts[:eject] == nil
+
+    if File.exist? 'fly.toml'
+      toml = TOML.load_file('fly.toml')
+      opts[:name] ||= toml['app']
+      apps = JSON.parse(`flyctl list apps --json`) rescue []
+
+      if toml.keys.length == 1
+        if opts[:name] != toml['app']
+          # replace existing fly.toml
+          File.unlink 'fly.toml'
+          create_app(**opts.symbolize_keys)
+        elsif not apps.any? {|item| item['ID'] == opts[:name]}
+          create_app(**opts.symbolize_keys)
+        end
+      elsif opts[:name] != toml['app']
+        say_status "fly:app", "Using the name in the existing toml file", :red
+        opts[:name] = toml['app']
+      end
+    else
+      create_app(**opts.symbolize_keys)
+    end
+
+    action = Fly::Actions.new(@app, opts)
+
+    action.generate_toml
+    action.generate_fly_config unless File.exist? 'config/fly.rb'
+
+    if opts[:eject]
+      action.generate_dockerfile
+      action.generate_dockerignore unless File.exist? '.dockerignore'
+      action.generate_nginx_conf unless File.exist? 'config/nginx.conf'
+      action.generate_raketask unless File.exist? 'lib/tasks/fly.rake'
+      action.generate_procfile unless File.exist? 'Procfile.rake'
+      action.generate_litefs if opts[:litefs] and not File.exist? 'config/litefs'
+      action.generate_patches
+    end
+
+    ips = `flyctl ips list`.strip.lines[1..].map(&:split).map(&:first)
+    action.generate_ipv4 unless ips.include? 'v4'
+    action.generate_ipv6 unless ips.include? 'v6'
+
+    action.launch(action.app)
+  end
+end
+end

data/lib/generators/fly/config_generator.rb

@@ -0,0 +1,19 @@
+require 'fly-rails/actions'
+
+module Fly::Generators
+class ConfigGenerator < Rails::Generators::Base
+  include FlyIoRails::Utils
+
+  # despite its name, this is a debug tool that will dump the config
+  def generate_config
+    action = Fly::Actions.new(@app, options)
+
+    config = {}
+    action.instance_variables.sort.each do |name|
+      config[name] = action.instance_variable_get(name)
+    end
+
+    pp config
+  end
+end
+end