fly.io-rails 0.0.21-arm64-darwin → 0.1.1-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f173785bd8b4b709b0c35c2c339d576d42ad8874abf0e37237f12b0fa8dd153d
-  data.tar.gz: 924210805c7a4023087882c1645411bb61608f420ae8ade16941e637148aa0c2
+  metadata.gz: 1fd535a7501f08c7e1314a14b6a2875b334182fca732dd994df20ac2979e0bf9
+  data.tar.gz: e9667f63230a373fd8feb431ca7a551e74a6b17a118418f2f13f37da80086964
 SHA512:
-  metadata.gz: 4dc311c231af69a08ed89182f7593501576c07b15f7e098250b103108a3f2909f0563fc16b3fe77803937ef504f0eee93854d7597505f6e4c1c0276183e88349
-  data.tar.gz: b56078f2ba98e8a8486043b518f2da121989590f9fd8672c2c216e32f4a2ad0c43689f8ff9216626f39be29501000f049bb5c2c1cc1bdb2681346dd9bb9dacdd
+  metadata.gz: dafa2169129603c071bcf199f215074e66ae166c4fd7cf78feb081276d14f1460c3fb3f81186a0aa1cf0708fdc47ca5e62dd0ce4fe742002369abfe4eb043f34
+  data.tar.gz: 75d78bab12736653419348eca68f94fdcd4bd20532e6310ade12fc96f8a78065d973ebfcf7fd276972da28b44701251c31421421928c64a5d716fce70521301c

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

@@ -2,11 +2,13 @@ require 'thor'
 require 'active_support'
 require 'active_support/core_ext/string/inflections'
 require 'fly.io-rails/machines'
+require 'fly.io-rails/utils'
 
 module Fly
   class Actions < Thor::Group
     include Thor::Actions
     include Thor::Base
+    include Thor::Shell
     attr_accessor :options
 
     def initialize(app = nil)
@@ -36,6 +38,11 @@ module Fly
 
     source_paths.push File::expand_path('../generators/templates', __dir__)
 
+    def generate_toml
+      app
+      template 'fly.toml.erb', 'fly.toml'
+    end
+
     def generate_dockerfile
       app
       template 'Dockerfile.erb', 'Dockerfile'
@@ -62,5 +69,282 @@ module Fly
       generate_terraform
       generate_raketask
     end
+
+    def generate_ipv4
+      cmd = 'flyctl ips allocate-v4'
+      say_status :run, cmd
+      system cmd
+    end
+
+    def generate_ipv6
+      cmd = 'flyctl ips allocate-v6'
+      say_status :run, cmd
+      system cmd
+    end
+
+    def create_volume(app, region, size)
+      volume = "#{app.gsub('-', '_')}_volume"
+      volumes = JSON.parse(`flyctl volumes list --json`).
+        map {|volume| volume['Name']}
+
+      unless volumes.include? volume
+        cmd = "flyctl volumes create #{volume} --app #{app} --region #{region} --size #{size}"
+        say_status :run, cmd
+        system cmd
+      end
+
+      volume
+    end
+
+    def create_postgres(app, org, region, vm_size, volume_size, cluster_size)
+      cmd = "flyctl postgres create --name #{app}-db --org #{org} --region #{region} --vm-size #{vm_size} --volume-size #{volume_size} --initial-cluster-size #{cluster_size}"
+      say_status :run, cmd
+      output = FlyIoRails::Utils.tee(cmd)
+      output[%r{postgres://\S+}]
+   end
+
+    def create_redis(app, org, region, eviction)
+      # see if redis is already defined
+      name = `flyctl redis list`.lines[1..-2].map(&:split).
+        find {|tokens| tokens[1] == org}&.first
+
+      if name
+        secret = `flyctl redis status #{name}`[%r{redis://\S+}]
+        return secret if secret
+      end
+
+      # create a new redis
+      cmd = "flyctl redis create --org #{org} --name #{app}-redis --region #{region} --no-replicas #{eviction} --plan Free"
+      say_status :run, cmd
+      output = FlyIoRails::Utils.tee(cmd)
+      output[%r{redis://\S+}]
+    end
+
+    def release(app, config)
+      start = Fly::Machines.create_and_start_machine(app, config: config)
+      machine = start[:id]
+
+      if !machine
+	STDERR.puts 'Error starting release machine'
+	PP.pp start, STDERR
+	exit 1
+      end
+
+      status = Fly::Machines.wait_for_machine app, machine,
+        timeout: 60, state: 'started'
+
+      # wait for release to copmlete
+      status = nil
+      5.times do
+        status = Fly::Machines.wait_for_machine app, machine,
+          timeout: 60, state: 'stopped'
+        return machine if status[:ok]
+      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
+	return machine if event && event[:type] == 'exit'
+      end
+
+      STDERR.puts event.to_json
+      exit 1
+    end
+
+    def deploy(app, image) 
+      regions = JSON.parse(`flyctl regions list --json`)['Regions'].
+        map {|region| region['Code']} rescue []
+      region = regions.first || 'iad'
+
+      secrets = JSON.parse(`flyctl secrets list --json`).
+        map {|secret| secret["Name"]}
+
+      config = {
+        region: region,
+        app: app,
+        name: "#{app}-machine",
+        image: image,
+        guest: {
+          cpus: 1,
+          cpu_kind: "shared",
+          memory_mb: 256,
+        },
+        services: [
+	  {
+	    ports: [
+	      {port: 443, handlers: ["tls", "http"]},
+	      {port: 80, handlers: ["http"]}
+	    ],
+	    protocol: "tcp",
+	    internal_port: 8080
+	  } 
+        ]
+      }
+
+      database = YAML.load_file('config/database.yml').
+        dig('production', 'adapter') rescue nil
+      cable = YAML.load_file('config/cable.yml').
+        dig('production', 'adapter') rescue nil
+
+      if database == 'sqlite3'
+        volume = create_volume(app, region, 3) 
+
+        config[:mounts] = [
+          { volume: volume, path: '/mnt/volume' }
+        ]
+
+        config[:env] = {
+          "DATABASE_URL" => "sqlite3:///mnt/volume/production.sqlite3"
+        }
+      elsif database == 'postgresql' and not secrets.include? 'DATABASE_URL'
+        secret = create_postgres(app, @org, region, 'shared-cpu-1x', 1, 1)
+
+        if secret
+          cmd = "flyctl secrets set --stage DATABASE_URL=#{secret}"
+          say_status :run, cmd
+          system cmd
+        end
+      end
+
+      # Enable redis if mentioned as a cache provider or a cable provider.
+      # Set eviction policy to true if a cache provider, else false.
+      eviction = nil
+
+      if (YAML.load_file('config/cable.yml').dig('production', 'adapter') rescue false)
+        eviction = '--disable-eviction'
+      end
+
+      if (IO.read('config/environments/production.rb') =~ /redis/i rescue false)
+        eviction = '--enable-eviction'
+      end
+
+      if eviction and not secrets.include? 'REDIS_URL'
+        secret = create_redis(app, @org, region, eviction)
+
+        if secret
+          cmd = "flyctl secrets set --stage REDIS_URL=#{secret}"
+          say_status :run, cmd
+          system cmd
+        end
+      end
+
+      # build config for release machine, overriding server command
+      release_config = config.dup
+      release_config.delete :services
+      release_config.delete :mounts
+      release_config[:env] = { 'SERVER_COMMAND' => 'bin/rails fly:release' }
+
+      # perform release
+      say_status :fly, release_config[:env]['SERVER_COMMAND']
+      machine = release(app, release_config)
+      Fly::Machines.delete_machine app, machine if machine
+
+      # start proxy, if necessary
+      endpoint = Fly::Machines::fly_api_hostname!
+
+      # stop previous instances
+      JSON.parse(`fly machines list --json`).each do |list|
+        next if list['id'] == machine
+        system "fly machines remove --force #{list['id']}"
+      end
+
+      # start app
+      say_status :fly, "start #{app}"
+      start = Fly::Machines.create_and_start_machine(app, config: config)
+      machine = start[:id]
+
+      if !machine
+	STDERR.puts 'Error starting application'
+	PP.pp start, STDERR
+	exit 1
+      end
+
+      5.times do
+	status = Fly::Machines.wait_for_machine app, machine,
+          timeout: 60, status: 'started'
+	return if status[:ok]
+      end
+
+      STDERR.puts 'Timeout waiting for application to start'
+    end
+
+    def terraform(app, 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
+
+      # 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] ||= {}
+      config[:env]['SERVER_COMMAND'] = 'bin/rails fly:release'
+
+      # start proxy, if necessary
+      endpoint = Fly::Machines::fly_api_hostname!
+
+      # start release machine
+      STDERR.puts "--> #{config[:env]['SERVER_COMMAND']}"
+      start = Fly::Machines.create_and_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
+	ENV['FLY_HTTP_ENDPOINT'] = endpoint if endpoint
+	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
 end

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

@@ -80,7 +80,7 @@ module Fly
       get "/v1/apps/#{app}"
     end
 
-    # create_start_machine 'user-functions', name: 'quirky_machine', config: {
+    # create_and_start_machine 'user-functions', name: 'quirky_machine', config: {
     #   image: 'flyio/fastify-functions',
     #   env: {'APP_ENV' => 'production'},
     #   services: [
@@ -94,13 +94,13 @@ module Fly
     #     }
     #   ]
     # }
-    def self.create_start_machine app, options
+    def self.create_and_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}"
+    # 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'

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

@@ -1,3 +1,3 @@
 module Fly_io
-  VERSION = '0.0.21'
+  VERSION = '0.1.1'
 end

data/lib/generators/terraform_generator.rb

@@ -1,7 +1,7 @@
 require 'open3'
 require 'fly.io-rails/actions'
 
-class TerraformGenerator < Rails::Generators::Base
+class Fly::Generators::TerraformGenerator < Rails::Generators::Base
   include FlyIoRails::Utils
 
   class_option :name, type: :string, required: false

data/lib/tasks/fly.rake

@@ -1,90 +1,45 @@
 require 'fly.io-rails/machines'
 require 'fly.io-rails/hcl'
+require 'fly.io-rails/actions'
+require 'toml'
 
 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]
-
-    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
+    include FlyIoRails::Utils
 
-    # 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
+    # Get app name, creating one if necessary
+    if File.exist? 'fly.toml'
+      app = TOML.load_file('fly.toml')['app']
+    else
+      output = FlyIoRails::Utils.tee(
+        "flyctl apps create --generate-name --org personal --machines"
+      )
 
-    # extract fly application name
-    app = config[:app]
+      exit 1 unless output =~ /^New app created: /
 
-    # delete HCL specific configuration items
-    %i(services for_each region app name depends_on).each do |key|
-       config.delete key
+      @app = app = output.split.last
     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] ||= {}
-    config[:env]['SERVER_COMMAND'] = 'bin/rails fly:release'
+    # ensure fly.toml and Dockerfile are present
+    action = Fly::Actions.new(app)
+    action.generate_toml if @app
+    action.generate_dockerfile unless File.exist? 'Dockerfile'
+    action.generate_dockerignore unless File.exist? '.dockerignore'
+    action.generate_raketask unless File.exist? 'lib/tasks/fly.rake'
 
-    # start proxy, if necessary
-    endpoint = Fly::Machines::fly_api_hostname!
-
-    # start release machine
-    STDERR.puts "--> #{config[:env]['SERVER_COMMAND']}"
-    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
+    # build and push an image
+    out = FlyIoRails::Utils.tee 'fly deploy --build-only --push'
+    image = out[/image:\s+(.*)/, 1].strip
 
-    # 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
+    exit 1 unless image
 
-      # use terraform apply to deploy
-      ENV['FLY_API_TOKEN'] = `flyctl auth token`.chomp
-      ENV['FLY_HTTP_ENDPOINT'] = endpoint if endpoint
-      system 'terraform apply -auto-approve'
+    if File.exist? 'main.tf'
+      action.terraform(app, image)
     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
+      action.generate_ipv4 if @app
+      action.generate_ipv6 if @app
+      action.deploy(app, image)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fly.io-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.1.1
 platform: arm64-darwin
 authors:
 - Sam Ruby
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-23 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fly-ruby