anycable-rails 0.6.3 → 1.0.0.rc1

data/lib/anycable/rails/version.rb

@@ -2,6 +2,6 @@
 
 module AnyCable
   module Rails
-    VERSION = "0.6.3"
+    VERSION = "1.0.0.rc1"
   end
 end

data/lib/generators/anycable/download/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Install AnyCable-Go web server.
+
+Example:
+    rails generate anycable:download
+
+    This will ask:
+        Where to store a binary file.
+    This will create:
+        `<bin_path>/anycable-go`.
+
+    rails generate anycable:download --bin-path=/usr/local/bin
+
+    rails generate anycable:download --version=1.0.0

data/lib/generators/anycable/download/download_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "generators/anycable/with_os_helpers"
+
+module AnyCableRailsGenerators
+  # Downloads anycable-go binary
+  class DownloadGenerator < ::Rails::Generators::Base
+    namespace "anycable:download"
+
+    include WithOSHelpers
+
+    # TODO: change to latest release
+    VERSION = "1.0.0.preview1"
+
+    class_option :bin_path,
+      type: :string,
+      desc: "Where to download AnyCable-Go server binary (default: #{DEFAULT_BIN_PATH})"
+    class_option :version,
+      type: :string,
+      desc: "Specify the AnyCable-Go version (defaults to latest release)"
+
+    def download_bin
+      out = options[:bin_path] || DEFAULT_BIN_PATH
+      version = options[:version] || VERSION
+
+      download_exe(
+        release_url(version),
+        to: out,
+        file_name: "anycable-go"
+      )
+
+      true
+    end
+
+    private
+
+    def release_url(version)
+      if Gem::Version.new(version).segments.first >= 1
+        new_release_url(version)
+      else
+        legacy_release_url(version)
+      end
+    end
+
+    def legacy_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/download/v#{version}/" \
+        "anycable-go-v#{version}-#{os_name}-#{cpu_name}"
+    end
+
+    def new_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/download/v#{version}/" \
+        "anycable-go-#{os_name}-#{cpu_name}"
+    end
+
+    def download_exe(url, to:, file_name:)
+      file_path = File.join(to, file_name)
+
+      run "#{sudo(to)}curl -L #{url} -o #{file_path}", abort_on_failure: true
+      run "#{sudo(to)}chmod +x #{file_path}", abort_on_failure: true
+      run "#{file_path} -v", abort_on_failure: true
+    end
+
+    def sudo(path)
+      sudo = ""
+      unless File.writable?(path)
+        if yes? "Path is not writable 😕. Do you have sudo privileges?"
+          sudo = "sudo "
+        else
+          say_status :error, "❌ Failed to install AnyCable-Go WebSocket server", :red
+          raise StandardError, "Path #{path} is not writable!"
+        end
+      end
+
+      sudo
+    end
+  end
+end

data/lib/generators/anycable/setup/USAGE

@@ -0,0 +1,2 @@
+Description:
+    Configures your application to work with AnyCable interactively.

data/lib/generators/anycable/setup/setup_generator.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "generators/anycable/with_os_helpers"
+
+module AnyCableRailsGenerators
+  # Entry point for interactive installation
+  class SetupGenerator < ::Rails::Generators::Base
+    namespace "anycable:setup"
+    source_root File.expand_path("templates", __dir__)
+
+    DOCS_ROOT = "https://docs.anycable.io/v1/#"
+    DEVELOPMENT_METHODS = %w[skip local docker].freeze
+    SERVER_SOURCES = %w[skip brew binary].freeze
+
+    class_option :devenv,
+      type: :string,
+      desc: "Select your development environment (options: #{DEVELOPMENT_METHODS.join(", ")})"
+    class_option :source,
+      type: :string,
+      desc: "Choose a way of installing AnyCable-Go server (options: #{SERVER_SOURCES.join(", ")})"
+    class_option :skip_heroku,
+      type: :boolean,
+      desc: "Do not copy Heroku configs"
+    class_option :skip_procfile_dev,
+      type: :boolean,
+      desc: "Do not create Procfile.dev"
+
+    include WithOSHelpers
+
+    class_option :bin_path,
+      type: :string,
+      desc: "Where to download AnyCable-Go server binary (default: #{DEFAULT_BIN_PATH})"
+    class_option :version,
+      type: :string,
+      desc: "Specify the AnyCable-Go version (defaults to latest release)"
+
+    def welcome
+      say "👋 Welcome to AnyCable interactive installer."
+    end
+
+    def configs
+      inside("config") do
+        template "cable.yml"
+        template "anycable.yml"
+      end
+    end
+
+    def cable_url
+      environment(nil, env: :development) do
+        <<~SNIPPET
+          # Specify AnyCable WebSocket server URL to use by JS client
+          config.action_cable.url = ENV.fetch("CABLE_URL", "ws://localhost:8080/cable") if AnyCable::Rails.enabled?
+        SNIPPET
+      end
+
+      environment(nil, env: :production) do
+        <<~SNIPPET
+          # Specify AnyCable WebSocket server URL to use by JS client
+          config.action_cable.url = ENV.fetch("CABLE_URL") if AnyCable::Rails.enabled?
+        SNIPPET
+      end
+
+      say_status :info, "✅ 'config.action_cable.url' has been configured"
+      say_status :help, "⚠️  If you're using JS client make sure you have " \
+                        "`action_cable_meta_tag` included before any <script> tag in your application.html"
+    end
+
+    def development_method
+      answer = DEVELOPMENT_METHODS.index(options[:devenv]) || 99
+
+      until DEVELOPMENT_METHODS[answer.to_i]
+        answer = ask "Which environment do you use for development? (1) Local, (2) Docker, (0) Skip"
+      end
+
+      case env = DEVELOPMENT_METHODS[answer.to_i]
+      when "skip"
+        say_status :help, "⚠️  Please, read this guide on how to install AnyCable-Go server 👉 #{DOCS_ROOT}/anycable-go/getting_started", :yellow
+      else
+        send "install_for_#{env}"
+      end
+    end
+
+    def heroku
+      if options[:skip_heroku].nil?
+        return unless yes? "Do you use Heroku for deployment? [Yn]"
+      elsif options[:skip_heroku]
+        return
+      end
+
+      in_root do
+        next unless File.file?("Procfile")
+
+        contents = File.read("Procfile")
+        contents.sub!(/^web: (.*)$/, %q(web: [[ "$ANYCABLE_DEPLOYMENT" == "true" ]] && bundle exec anycable --server-command="anycable-go" || \1))
+        File.write("Procfile", contents)
+        say_status :info, "✅ Procfile updated"
+      end
+
+      say_status :help, "️️⚠️  Please, read the required steps to configure Heroku applications 👉 #{DOCS_ROOT}/deployment/heroku", :yellow
+    end
+
+    def devise
+      in_root do
+        return unless File.file?("config/initializers/devise.rb")
+      end
+
+      inside("config/initializers") do
+        template "anycable.rb"
+      end
+
+      say_status :info, "✅ config/initializers/anycable.rb with Devise configuration has been added"
+    end
+
+    def rubocop_compatibility
+      return unless rubocop?
+
+      say_status :info, "🤖 Running static compatibility checks with RuboCop"
+      res = run "bundle exec rubocop -r 'anycable/rails/compatibility/rubocop' --only AnyCable/InstanceVars,AnyCable/PeriodicalTimers,AnyCable/InstanceVars"
+      say_status :help, "⚠️  Please, take a look at the icompatibilities above and fix them. See https://docs.anycable.io/v1/#/ruby/compatibility" unless res
+    end
+
+    def finish
+      say_status :info, "✅ AnyCable has been configured successfully!"
+    end
+
+    private
+
+    def stimulus_reflex?
+      !!gemfile_lock&.match?(/^\s+stimulus_reflex\b/)
+    end
+
+    def redis?
+      !!gemfile_lock&.match?(/^\s+redis\b/)
+    end
+
+    def rubocop?
+      !!gemfile_lock&.match?(/^\s+rubocop\b/)
+    end
+
+    def gemfile_lock
+      @gemfile_lock ||= begin
+        res = nil
+        in_root do
+          next unless File.file?("Gemfile.lock")
+          res = File.read("Gemfile.lock")
+        end
+        res
+      end
+    end
+
+    def install_for_docker
+      say_status :help, "️️⚠️  Docker development configuration could vary", :yellow
+
+      say "Here is an example snippet for docker-compose.yml:"
+      say <<~YML
+        ─────────────────────────────────────────
+        ws:
+          image: anycable/anycable-go:1.0.0.preview1
+          ports:
+            - '8080:8080'
+          environment:
+            ANYCABLE_REDIS_URL: redis://redis:6379/0
+            ANYCABLE_RPC_HOST: anycable:50051
+          depends_on:
+            - anycable-rpc
+            - redis
+
+        anycable:
+          <<: *backend
+          command: bundle exec anycable
+          environment:
+            <<: *backend_environment
+            ANYCABLE_REDIS_URL: redis://redis:6379/0
+            ANYCABLE_RPC_HOST: 0.0.0.0:50051
+          ports:
+            - '50051'
+        ─────────────────────────────────────────
+      YML
+    end
+
+    def install_for_local
+      install_server
+      template_proc_files
+    end
+
+    def install_server
+      answer = SERVER_SOURCES.index(options[:source]) || 99
+
+      until SERVER_SOURCES[answer.to_i]
+        answer = ask "How do you want to install AnyCable-Go WebSocket server? (1) Homebrew, (2) Download binary, (0) Skip"
+      end
+
+      case answer.to_i
+      when 0
+        say_status :help, "⚠️  Please, read this guide on how to install AnyCable-Go server 👉 #{DOCS_ROOT}/anycable-go/getting_started", :yellow
+        return
+      else
+        return unless send("install_from_#{SERVER_SOURCES[answer.to_i]}")
+      end
+
+      say_status :info, "✅ AnyCable-Go WebSocket server has been successfully installed"
+    end
+
+    def template_proc_files
+      file_name = "Procfile.dev"
+
+      if File.exist?(file_name)
+        append_file file_name, 'anycable: bundle exec anycable --server-command "anycable-go --port 3334"'
+      else
+        say_status :help, "💡 We recommend using Hivemind to manage multiple processes in development 👉 https://github.com/DarthSim/hivemind", :yellow
+
+        if options[:skip_procfile_dev].nil?
+          return unless yes? "Do you want to create a '#{file_name}' file?"
+        elsif options[:skip_procfile_dev]
+          return
+        end
+
+        template file_name
+      end
+    end
+
+    def install_from_brew
+      run "brew install anycable-go", abort_on_failure: true
+      run "anycable-go -v", abort_on_failure: true
+    end
+
+    def install_from_binary
+      bin_path ||= DEFAULT_BIN_PATH if options[:devenv] # User don't want interactive mode
+      bin_path ||= ask "Please, enter the path to download the AnyCable-Go binary to", default: DEFAULT_BIN_PATH, path: true
+
+      generate "anycable:download", download_options(bin_path: bin_path)
+
+      true
+    end
+
+    def download_options(**params)
+      opts = options.merge(params)
+      [].tap do |args|
+        args << "--os #{opts[:os]}" if opts[:os]
+        args << "--cpu #{opts[:cpu]}" if opts[:cpu]
+        args << "--bin-path=#{opts[:bin_path]}" if opts[:bin_path]
+        args << "--version #{opts[:version]}" if opts[:version]
+      end.join(" ")
+    end
+  end
+end

data/lib/generators/anycable/setup/templates/Procfile.dev

@@ -0,0 +1,3 @@
+server: bin/rails server
+assets: bin/webpack-dev-server
+anycable: bundle exec anycable --server-command "anycable-go --port 3334"

data/lib/generators/anycable/setup/templates/config/anycable.yml.tt

@@ -0,0 +1,43 @@
+# This file contains per-environment settings for AnyCable.
+#
+# Since AnyCable config is based on anyway_config (https://github.com/palkan/anyway_config), all AnyCable settings
+# can be set or overridden through the corresponding environment variables.
+# E.g., `rpc_host` is overridden by ANYCABLE_RPC_HOST, `debug` by ANYCABLE_DEBUG etc.
+#
+# Note that AnyCable recognizes REDIS_URL env variable for Redis pub/sub adapter. If you want to
+# use another Redis instance for AnyCable, provide ANYCABLE_REDIS_URL variable.
+#
+# Read more about AnyCable configuration here: <%= DOCS_ROOT %>/ruby/configuration
+#
+default: &default
+  # Turn on/off access logs ("Started..." and "Finished...")
+  access_logs_disabled: false
+  # Persist "dirty" session between RPC calls (might be required for StimulusReflex apps)
+  persistent_session_enabled: <%= stimulus_reflex? %>
+  # This is the host and the port to run AnyCable RPC server on.
+  # You must configure your WebSocket server to connect to it, e.g.:
+  #   $ anycable-go --rpc-host="<rpc hostname>:50051"
+  rpc_host: "127.0.0.1:50051"
+  # Whether to enable gRPC level logging or not
+  log_grpc: false
+  <%- if redis? -%>
+  # Use Redis to broadcast messages to AnyCable server
+  broadcast_adapter: redis
+  <%- else -%>
+  # Use HTTP adapter for a quick start (since redis gem is not present in the project)
+  broadcast_adapter: http
+  <%- end -%>
+  # Use the same channel name for WebSocket server, e.g.:
+  #   $ anycable-go --redis-channel="__anycable__"
+  redis_channel: "__anycable__"
+
+development:
+  <<: *default
+  redis_url: "redis://localhost:6379/1"
+
+production:
+  <<: *default
+  <%- if !redis? -%>
+  # Use Redis in production
+  broadcast_adapter: redis
+  <%- end -%>

data/lib/generators/anycable/setup/templates/config/cable.yml.tt

@@ -0,0 +1,11 @@
+# Make it possible to switch adapters by passing the ACTION_CABLE_ADAPTER env variable.
+# For example, you can use it fallback to the standard Action Cable in staging/review
+# environments (by setting `ACTION_CABLE_ADAPTER=redis`).
+development:
+  adapter: <%%= ENV.fetch("ACTION_CABLE_ADAPTER", "any_cable") %>
+
+test:
+  adapter: test
+
+production:
+  adapter: <%%= ENV.fetch("ACTION_CABLE_ADAPTER", "any_cable") %>

data/lib/generators/anycable/setup/templates/config/initializers/anycable.rb.tt

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Add Warden middkeware to AnyCable stack to allow accessing
+# Devise current user via `env["warden"].user`.
+#
+# See <%= DOCS_ROOT %>/ruby/authentication
+AnyCable::Rails::Rack.middleware.use Warden::Manager do |config|
+  Devise.warden_config = config
+end

data/lib/generators/anycable/with_os_helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module AnyCableRailsGenerators
+  module WithOSHelpers
+    OS_NAMES = %w[linux darwin freebsd win].freeze
+    CPU_NAMES = %w[amd64 arm64 386 arm].freeze
+    DEFAULT_BIN_PATH = "/usr/local/bin"
+
+    def self.included(base)
+      base.class_option :os,
+        type: :string,
+        desc: "Specify the OS for AnyCable-Go server binary (options: #{OS_NAMES.join(", ")})"
+      base.class_option :cpu,
+        type: :string,
+        desc: "Specify the CPU architecturefor AnyCable-Go server binary (options: #{CPU_NAMES.join(", ")})"
+
+      private :current_cpu, :supported_current_cpu, :supported_current_os
+    end
+
+    def current_cpu
+      case Gem::Platform.local.cpu
+      when "x86_64", "x64"
+        "amd64"
+      when "x86_32", "x86", "i386", "i486", "i686"
+        "i386"
+      when "aarch64", "aarch64_be", /armv8/
+        "arm64"
+      when "arm", /armv7/, /armv6/
+        "arm"
+      else
+        "unknown"
+      end
+    end
+
+    def os_name
+      options[:os] ||
+        supported_current_os ||
+        ask("What is your OS name?", limited_to: OS_NAMES)
+    end
+
+    def cpu_name
+      options[:cpu] ||
+        supported_current_cpu ||
+        ask("What is your CPU architecture?", limited_to: CPU_NAMES)
+    end
+
+    def supported_current_cpu
+      CPU_NAMES.find(&current_cpu.method(:==))
+    end
+
+    def supported_current_os
+      OS_NAMES.find(&Gem::Platform.local.os.method(:==))
+    end
+  end
+end