brasa 0.4.2 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8770bfdcdf312ee8493341a83de7356e76dfb6b6cebd4fa4d0155ae2ec8f3425
-  data.tar.gz: e27282ef7d4dd88a159c2463320c7f1393a2bfa9c93a07e0e234ca73b7fb8df8
+  metadata.gz: f58d1ef47800a723afab0a3b260562f7704a4b72e0ac364471a0dcc2b0445078
+  data.tar.gz: c1c9063b7c415605ab60e4bf2deb7274e6780c4bcf7ed7ad755b609c24d2c845
 SHA512:
-  metadata.gz: fdad15d4954607bff0bb6a2737a4be3d8959e7213393cd32ec0ccfb995f0c42d8f416a6046810f9aa8d3ac88fd57dd34989e429be6856a9c5830d1b8d8466580
-  data.tar.gz: 6d2293ceb1e6ab6ae539e6a8f6e28b22bf82b29a64e31d383c103125e9891e7a0287bd0acabd02d2bf02c6ce5ce773c7331b1cd33ef24f6c3a2b6f935680b0bd
+  metadata.gz: 60d66b1edd7299319e0ae56964e9b1595a18f7c49879aca09bdf02f5d023d256a31d3ce0d75719964fef60dfcbc55517497fb715ee2c778feacf3648b118742b
+  data.tar.gz: 10b6eed8ee2bf1236e28c83ab98d0d4151da0d3a59bb6efcfb01af585f92a24339a1a53bd7f7e01f5dfc24d7ef9a718e84b19211afda4e3425d5cd39c3ae7b9a

data/lib/brasa/commands/deploy.rb

@@ -5,7 +5,8 @@ module Brasa
   module Commands
     class Deploy < Base
       POLL_INTERVAL = 5
-      DEPLOY_MAX_POLLS = 360  # 30 minutes
+      DEPLOY_TIMEOUT = 1800
+      DEPLOY_MAX_POLLS = 360
 
       def execute(options = {})
         require_auth!
@@ -13,18 +14,16 @@ module Brasa
 
         info("Empacotando código...")
         archive_path = SourcePacker.pack
-
         size_kb = File.size(archive_path) / 1024
         info("Enviando #{size_kb}KB para o servidor...")
 
-        deploy = api.upload(
-          "/api/v1/apps/#{slug}/deploys",
+        deploy = api.upload("/api/v1/apps/#{slug}/deploys",
           file_path: archive_path,
-          params: { branch: options["branch"] || project_config[:branch] || "main" }
-        )
-        info("Deploy ##{deploy["id"]} criado. Aguardando build e deploy...")
+          params: { branch: options["branch"] || project_config[:branch] || "main" })
+        info("Deploy ##{deploy["id"]} criado.")
+        info("       Na fila...")
 
-        wait_for_deploy(slug, deploy["id"])
+        wait_for_deploy_complete(slug, deploy["id"])
       rescue Api::Client::ApiError => e
         error("Erro: #{e.message}")
       ensure
@@ -33,24 +32,51 @@ module Brasa
 
       private
 
-      def wait_for_deploy(slug, deploy_id)
+      def wait_for_deploy_complete(slug, deploy_id)
+        ws = connect_websocket
+        started = Time.now
+
+        ws.on_log { |msg| print msg["line"] + "\n" if msg["line"] }
+        ws.subscribe("DeployLogChannel", deploy_id: deploy_id)
+
+        status = ws.wait_for("DeployStatusChannel",
+          params: { deploy_id: deploy_id },
+          until_status: %w[live failed],
+          timeout: DEPLOY_TIMEOUT)
+
+        elapsed = (Time.now - started).to_i
+        if status == "live"
+          success("\nDeploy concluído com sucesso! (#{elapsed}s)")
+        else
+          error("\nDeploy falhou.")
+        end
+      rescue Brasa::Websocket::CableClient::ConnectionError => e
+        $stderr.puts "\n       [WebSocket indisponível: #{e.message}. Usando polling...]"
+        wait_for_deploy_polling(slug, deploy_id)
+      ensure
+        ws&.disconnect
+      end
+
+      def connect_websocket
+        require "brasa/websocket/cable_client"
+        Brasa::Websocket::CableClient.new.tap(&:connect!)
+      end
+
+      def wait_for_deploy_polling(slug, deploy_id)
         started = Time.now
         last_status = nil
         DEPLOY_MAX_POLLS.times do |i|
           deploy = api.get("/api/v1/apps/#{slug}/deploys/#{deploy_id}")
-
           case deploy["status"]
           when "live"
-            elapsed = (Time.now - started).to_i
-            success("\nDeploy concluído com sucesso! (#{elapsed}s)")
+            success("\nDeploy concluído com sucesso! (#{(Time.now - started).to_i}s)")
             return
           when "failed"
             error("\nDeploy falhou.")
             return
           end
-
           if deploy["status"] != last_status
-            print "\n       #{status_label(deploy["status"])}" if last_status
+            print "\n       #{status_label(deploy["status"])}"
             last_status = deploy["status"]
           end
           print "."
@@ -60,21 +86,17 @@ module Brasa
           print "!"
           sleep(POLL_INTERVAL)
         end
-        elapsed = (Time.now - started).to_i
-        error("\nTimeout aguardando deploy (#{elapsed}s). O processo pode ainda estar rodando — verifique com: brasa status")
+        error("\nTimeout (#{(Time.now - started).to_i}s). Verifique com: brasa status")
       end
 
       def status_label(status)
-        { "queued" => "Na fila...",
-          "building" => "Construindo imagem...",
+        { "queued" => "Na fila...", "building" => "Construindo imagem...",
           "deploying" => "Deployando..." }[status] || status
       end
 
       def show_elapsed(started)
         elapsed = (Time.now - started).to_i
-        min = elapsed / 60
-        sec = elapsed % 60
-        print " (#{min}m#{sec}s)"
+        print " (#{elapsed / 60}m#{elapsed % 60}s)"
       end
     end
   end

data/lib/brasa/commands/up.rb

@@ -5,8 +5,10 @@ module Brasa
   module Commands
     class Up < Base
       POLL_INTERVAL = 5
-      PROVISION_MAX_POLLS = 240   # 20 minutes (cloud-init + readiness checks + managed DB)
-      DEPLOY_MAX_POLLS = 360     # 30 minutes (docker build + push + deploy)
+      PROVISION_TIMEOUT = 1200
+      DEPLOY_TIMEOUT = 1800
+      PROVISION_MAX_POLLS = 240
+      DEPLOY_MAX_POLLS = 360
 
       def execute(options = {})
         require_auth!
@@ -19,7 +21,8 @@ module Brasa
           info("Iniciando deploy...")
         else
           info("Provisionando infraestrutura...")
-          unless wait_for_provisioning(slug)
+          trigger_provision(slug) if %w[pending error].include?(@app["status"])
+          unless wait_for_provisioning(@app["id"], slug)
             return
           end
           success("Infraestrutura provisionada!")
@@ -27,8 +30,9 @@ module Brasa
         end
 
         deploy = trigger_deploy(slug)
+        info("       Na fila...")
 
-        if wait_for_deploy(slug, deploy["id"])
+        if wait_for_deploy_complete(slug, deploy["id"])
           subdomain = @app["subdomain"] || slug
           success("Deploy concluído! App disponível em https://#{subdomain}.usebrasa.com.br")
         end
@@ -50,23 +54,22 @@ module Brasa
         create_app(config)
       end
 
+      def trigger_provision(slug)
+        api.post("/api/v1/apps/#{slug}/provision")
+      rescue Api::Client::ApiError
+      end
+
       def ensure_repo_url(slug)
         repo = detect_git_remote
         return unless repo
-
         api.patch("/api/v1/apps/#{slug}", body: { app: { repo_url: repo } })
       rescue Api::Client::ApiError
-        # Não bloquear o fluxo se falhar ao atualizar repo
       end
 
       def create_app(config)
         app_params = {
-          name: config[:app],
-          stack: config[:stack],
-          preset: config[:preset],
-          region: config[:region],
-          repo_url: detect_git_remote,
-          repo_branch: config[:branch]
+          name: config[:app], stack: config[:stack], preset: config[:preset],
+          region: config[:region], repo_url: detect_git_remote, repo_branch: config[:branch]
         }
         app_params[:database_engine] = config[:database_engine] if config[:database_engine]
         api.post("/api/v1/apps", body: { app: app_params })
@@ -77,13 +80,8 @@ module Brasa
         archive_path = SourcePacker.pack
         size_kb = File.size(archive_path) / 1024
         info("Enviando #{size_kb}KB para o servidor...")
-
-        deploy = api.upload(
-          "/api/v1/apps/#{slug}/deploys",
-          file_path: archive_path,
-          params: { branch: project_config[:branch] || "main" }
-        )
-        deploy
+        api.upload("/api/v1/apps/#{slug}/deploys", file_path: archive_path,
+                   params: { branch: project_config[:branch] || "main" })
       ensure
         FileUtils.rm_f(archive_path) if archive_path
       end
@@ -93,18 +91,73 @@ module Brasa
         remote.empty? ? nil : remote
       end
 
-      def wait_for_provisioning(slug)
+      # ── WebSocket methods ──
+
+      def wait_for_provisioning(app_id, slug)
+        ws = connect_websocket
+        status = ws.wait_for("ProvisionStatusChannel",
+          params: { app_id: app_id },
+          until_status: %w[active error],
+          timeout: PROVISION_TIMEOUT)
+
+        if status == "active"
+          true
+        else
+          error("\nErro no provisionamento.")
+          false
+        end
+      rescue Brasa::Websocket::CableClient::ConnectionError => e
+        warn_fallback(e)
+        wait_for_provisioning_polling(slug)
+      ensure
+        ws&.disconnect
+      end
+
+      def wait_for_deploy_complete(slug, deploy_id)
+        ws = connect_websocket
+        started = Time.now
+
+        ws.on_log { |msg| print msg["line"] + "\n" if msg["line"] }
+        ws.subscribe("DeployLogChannel", deploy_id: deploy_id)
+
+        status = ws.wait_for("DeployStatusChannel",
+          params: { deploy_id: deploy_id },
+          until_status: %w[live failed],
+          timeout: DEPLOY_TIMEOUT)
+
+        if status == "live"
+          true
+        else
+          error("\nDeploy falhou.")
+          false
+        end
+      rescue Brasa::Websocket::CableClient::ConnectionError => e
+        warn_fallback(e)
+        wait_for_deploy_polling(slug, deploy_id)
+      ensure
+        ws&.disconnect
+      end
+
+      def connect_websocket
+        require "brasa/websocket/cable_client"
+        Brasa::Websocket::CableClient.new.tap(&:connect!)
+      end
+
+      def warn_fallback(err)
+        $stderr.puts "\n       [WebSocket indisponível: #{err.message}. Usando polling...]"
+      end
+
+      # ── Fallback polling ──
+
+      def wait_for_provisioning_polling(slug)
         started = Time.now
         last_status = nil
         PROVISION_MAX_POLLS.times do |i|
           app = api.get("/api/v1/apps/#{slug}")
           return true if app["status"] == "active"
-          if app["status"] == "error"
-            error("\nErro no provisionamento.")
-            return false
-          end
+          return (error("\nErro no provisionamento."); false) if app["status"] == "error"
           if app["status"] != last_status
-            print "\n       #{status_label(app["status"])}" if last_status
+            print "\n       #{status_label(app["status"])}"
             last_status = app["status"]
           end
           print "."
@@ -114,23 +167,19 @@ module Brasa
           print "!"
           sleep(POLL_INTERVAL)
         end
-        elapsed = (Time.now - started).to_i
-        error("\nTimeout aguardando provisionamento (#{elapsed}s). O processo pode ainda estar rodando no servidor — verifique com: brasa status")
+        error("\nTimeout (#{(Time.now - started).to_i}s). Verifique com: brasa status")
         false
       end
 
-      def wait_for_deploy(slug, deploy_id)
+      def wait_for_deploy_polling(slug, deploy_id)
         started = Time.now
         last_status = nil
         DEPLOY_MAX_POLLS.times do |i|
           deploy = api.get("/api/v1/apps/#{slug}/deploys/#{deploy_id}")
           return true if deploy["status"] == "live"
-          if deploy["status"] == "failed"
-            error("\nDeploy falhou.")
-            return false
-          end
+          return (error("\nDeploy falhou."); false) if deploy["status"] == "failed"
           if deploy["status"] != last_status
-            print "\n       #{status_label(deploy["status"])}" if last_status
+            print "\n       #{status_label(deploy["status"])}"
             last_status = deploy["status"]
           end
           print "."
@@ -140,24 +189,19 @@ module Brasa
           print "!"
           sleep(POLL_INTERVAL)
         end
-        elapsed = (Time.now - started).to_i
-        error("\nTimeout aguardando deploy (#{elapsed}s). O processo pode ainda estar rodando no servidor — verifique com: brasa status")
+        error("\nTimeout (#{(Time.now - started).to_i}s). Verifique com: brasa status")
         false
       end
 
       def status_label(status)
-        { "pending" => "Aguardando...",
-          "provisioning" => "Provisionando VM...",
-          "queued" => "Na fila...",
-          "building" => "Construindo imagem...",
+        { "pending" => "Aguardando...", "provisioning" => "Provisionando VM...",
+          "queued" => "Na fila...", "building" => "Construindo imagem...",
           "deploying" => "Deployando..." }[status] || status
       end
 
       def show_elapsed(started)
         elapsed = (Time.now - started).to_i
-        min = elapsed / 60
-        sec = elapsed % 60
-        print " (#{min}m#{sec}s)"
+        print " (#{elapsed / 60}m#{elapsed % 60}s)"
       end
     end
   end

data/lib/brasa/version.rb

@@ -1,3 +1,3 @@
 module Brasa
-  VERSION = "0.4.2"
+  VERSION = "0.5.1"
 end

data/lib/brasa/websocket/cable_client.rb

@@ -0,0 +1,146 @@
+require "websocket-client-simple"
+require "json"
+
+module Brasa
+  module Websocket
+    class CableClient
+      class ConnectionError < StandardError; end
+
+      RECONNECT_DELAYS = [1, 3, 10].freeze
+
+      def initialize(api_url: nil, token: nil)
+        @api_url = api_url || Brasa::Config.api_url
+        @token = token || Brasa::Config.token
+        @subscriptions = {}
+        @connected = false
+        @log_callback = nil
+      end
+
+      def connect!
+        raise ConnectionError, "Token nao encontrado. Execute `brasa login`." unless @token
+
+        ws_url = @api_url.sub(%r{^https?://}, "wss://").chomp("/") + "/cable"
+        @ws = WebSocket::Client::Simple.connect(ws_url, headers: {
+          "Authorization" => "Bearer #{@token}",
+          "Origin" => @api_url
+        })
+
+        setup_handlers
+        wait_for_welcome
+        self
+      end
+
+      def subscribe(channel, params = {}, &callback)
+        identifier = { channel: channel }.merge(params).to_json
+        @subscriptions[identifier] = callback
+        send_command("subscribe", identifier)
+        identifier
+      end
+
+      def wait_for(channel, params: {}, until_status: [], timeout: 1800)
+        result = nil
+        identifier = subscribe(channel, params) do |msg|
+          status = msg["status"]
+          result = status if until_status.include?(status)
+        end
+
+        deadline = Time.now + timeout
+        loop do
+          return result if result
+          raise ConnectionError, "Timeout aguardando status (#{timeout}s)" if Time.now > deadline
+
+          unless @connected
+            reconnect!
+            # Re-subscribe after reconnect
+            @subscriptions.each_key { |id| send_command("subscribe", id) }
+          end
+
+          sleep 0.2
+        end
+      ensure
+        send_command("unsubscribe", identifier) if identifier && @connected
+      end
+
+      def on_log(&block)
+        @log_callback = block
+      end
+
+      def disconnect
+        @ws&.close
+        @connected = false
+      end
+
+      private
+
+      def setup_handlers
+        client = self
+
+        @ws.on :message do |msg|
+          begin
+            data = JSON.parse(msg.data)
+            client.send(:handle_message, data)
+          rescue JSON::ParserError
+            $stderr.puts "[WS] Mensagem malformada ignorada: #{msg.data.to_s.truncate(100)}" if ENV["BRASA_DEBUG"]
+          end
+        end
+
+        @ws.on :close do |_|
+          client.instance_variable_set(:@connected, false)
+        end
+
+        @ws.on :error do |_|
+          client.instance_variable_set(:@connected, false)
+        end
+      end
+
+      def handle_message(data)
+        case data["type"]
+        when "welcome"
+          @connected = true
+        when "ping"
+          # keepalive — noop
+        when "confirm_subscription"
+          # confirmed
+        when "reject_subscription"
+          @connected = false
+        else
+          identifier = data["identifier"]
+          message = data["message"]
+          return unless message
+
+          callback = @subscriptions[identifier]
+          callback&.call(message)
+
+          @log_callback&.call(message) if message["line"]
+        end
+      end
+
+      def wait_for_welcome
+        deadline = Time.now + 10
+        loop do
+          return if @connected
+          raise ConnectionError, "Timeout na conexao WebSocket" if Time.now > deadline
+          sleep 0.1
+        end
+      end
+
+      def reconnect!
+        RECONNECT_DELAYS.each do |delay|
+          sleep delay
+          begin
+            connect!
+            return
+          rescue StandardError
+            next
+          end
+        end
+        raise ConnectionError, "Falha na reconexao apos #{RECONNECT_DELAYS.size} tentativas"
+      end
+
+      def send_command(command, identifier)
+        return unless @ws&.open?
+        @ws.send({ command: command, identifier: identifier }.to_json)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brasa
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.1
 platform: ruby
 authors:
 - Brasa
@@ -107,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -168,6 +182,7 @@ files:
 - lib/brasa/config.rb
 - lib/brasa/source_packer.rb
 - lib/brasa/version.rb
+- lib/brasa/websocket/cable_client.rb
 homepage: https://usebrasa.com.br
 licenses:
 - MIT