cpl 1.3.0 → 2.0.0.rc.0

data/lib/core/controlplane.rb

@@ -19,19 +19,17 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   def profile_exists?(profile)
     cmd = "cpln profile get #{profile} -o yaml"
-    perform_yaml(cmd).length.positive?
+    perform_yaml!(cmd).length.positive?
   end
 
   def profile_create(profile, token)
     sensitive_data_pattern = /(?<=--token )(\S+)/
     cmd = "cpln profile create #{profile} --token #{token}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd, sensitive_data_pattern: sensitive_data_pattern)
   end
 
   def profile_delete(profile)
     cmd = "cpln profile delete #{profile}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -58,31 +56,31 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     image_push(image) if push
   end
 
+  def fetch_image_details(image)
+    api.fetch_image_details(org: org, image: image)
+  end
+
   def image_delete(image)
     api.image_delete(org: org, image: image)
   end
 
   def image_login(org_name = config.org)
     cmd = "cpln image docker-login --org #{org_name}"
-    cmd += " > /dev/null 2>&1" if Shell.should_hide_output?
-    perform!(cmd)
+    perform!(cmd, output_mode: :none)
   end
 
   def image_pull(image)
     cmd = "docker pull #{image}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
-    perform!(cmd)
+    perform!(cmd, output_mode: :none)
   end
 
   def image_tag(old_tag, new_tag)
     cmd = "docker tag #{old_tag} #{new_tag}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
   def image_push(image)
     cmd = "docker push #{image}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -98,7 +96,7 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     op = config.should_app_start_with?(app_name) ? "~" : "="
 
     cmd = "cpln gvc query --org #{org} -o yaml --prop name#{op}#{app_name}"
-    perform_yaml(cmd)
+    perform_yaml!(cmd)
   end
 
   def fetch_gvc(a_gvc = gvc, a_org = org)
@@ -145,41 +143,38 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     api.query_workloads(org: a_org, gvc: a_gvc, workload: workload, gvc_op_type: gvc_op, workload_op_type: workload_op)
   end
 
-  def workload_get_replicas(workload, location:)
-    cmd = "cpln workload get-replicas #{workload} #{gvc_org} --location #{location} -o yaml"
+  def fetch_workload_replicas(workload, location:)
+    cmd = "cpln workload replica get #{workload} #{gvc_org} --location #{location} -o yaml"
     perform_yaml(cmd)
   end
 
-  def workload_get_replicas_safely(workload, location:)
-    cmd = "cpln workload get-replicas #{workload} #{gvc_org} --location #{location} -o yaml"
-    cmd += " 2> /dev/null" if Shell.should_hide_output?
-
-    Shell.debug("CMD", cmd)
-
-    result = `#{cmd}`
-    $CHILD_STATUS.success? ? YAML.safe_load(result) : nil
+  def stop_workload_replica(workload, replica, location:)
+    cmd = "cpln workload replica stop #{workload} #{gvc_org} --replica-name #{replica} --location #{location}"
+    perform(cmd, output_mode: :none)
   end
 
   def fetch_workload_deployments(workload)
     api.workload_deployments(workload: workload, gvc: gvc, org: org)
   end
 
-  def workload_deployment_version_ready?(version, next_version, expected_status:)
+  def workload_deployment_version_ready?(version, next_version)
     return false unless version["workload"] == next_version
 
     version["containers"]&.all? do |_, container|
-      ready = container.dig("resources", "replicas") == container.dig("resources", "replicasReady")
-      expected_status == true ? ready : !ready
+      container.dig("resources", "replicas") == container.dig("resources", "replicasReady")
     end
   end
 
-  def workload_deployments_ready?(workload, expected_status:)
+  def workload_deployments_ready?(workload, location:, expected_status:)
+    deployed_replicas = fetch_workload_replicas(workload, location: location)["items"].length
+    return deployed_replicas.zero? if expected_status == false
+
     deployments = fetch_workload_deployments(workload)["items"]
     deployments.all? do |deployment|
       next_version = deployment.dig("status", "expectedDeploymentVersion")
 
       deployment.dig("status", "versions")&.all? do |version|
-        workload_deployment_version_ready?(version, next_version, expected_status: expected_status)
+        workload_deployment_version_ready?(version, next_version)
       end
     end
   end
@@ -187,7 +182,6 @@ class Controlplane # rubocop:disable Metrics/ClassLength
   def workload_set_image_ref(workload, container:, image:)
     cmd = "cpln workload update #{workload} #{gvc_org}"
     cmd += " --set spec.containers.#{container}.image=/org/#{config.org}/image/#{image}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -215,7 +209,6 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   def workload_force_redeployment(workload)
     cmd = "cpln workload force-redeployment #{workload} #{gvc_org}"
-    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -227,14 +220,29 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     cmd = "cpln workload connect #{workload} #{gvc_org} --location #{location}"
     cmd += " --container #{container}" if container
     cmd += " --shell #{shell}" if shell
-    perform!(cmd)
+    perform!(cmd, output_mode: :all)
   end
 
-  def workload_exec(workload, location:, container: nil, command: nil)
-    cmd = "cpln workload exec #{workload} #{gvc_org} --location #{location}"
+  def workload_exec(workload, replica, location:, container: nil, command: nil)
+    cmd = "cpln workload exec #{workload} #{gvc_org} --replica #{replica} --location #{location}"
     cmd += " --container #{container}" if container
     cmd += " -- #{command}"
-    perform!(cmd)
+    perform!(cmd, output_mode: :all)
+  end
+
+  def start_cron_workload(workload, job_start_yaml, location:)
+    Tempfile.create do |f|
+      f.write(job_start_yaml)
+      f.rewind
+
+      cmd = "cpln workload cron start #{workload} #{gvc_org} --file #{f.path} --location #{location} -o yaml"
+      perform_yaml(cmd)
+    end
+  end
+
+  def fetch_cron_workload(workload, location:)
+    cmd = "cpln workload cron get #{workload} #{gvc_org} --location #{location} -o yaml"
+    perform_yaml(cmd)
   end
 
   # volumeset
@@ -291,13 +299,34 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   # logs
 
-  def logs(workload:)
-    cmd = "cpln logs '{workload=\"#{workload}\"}' --org #{org} -t -o raw --limit 200"
-    perform!(cmd)
+  def logs(workload:, limit:, since:, replica: nil)
+    query_parts = ["gvc=\"#{gvc}\"", "workload=\"#{workload}\""]
+    query_parts.push("replica=\"#{replica}\"") if replica
+    query = "{#{query_parts.join(',')}}"
+
+    cmd = "cpln logs '#{query}' --org #{org} -t -o raw --limit #{limit} --since #{since}"
+    perform!(cmd, output_mode: :all)
+  end
+
+  def log_get(workload:, from:, to:, replica: nil)
+    api.log_get(org: org, gvc: gvc, workload: workload, replica: replica, from: from, to: to)
+  end
+
+  # identities
+
+  def fetch_identity(identity, a_gvc = gvc)
+    api.fetch_identity(org: org, gvc: a_gvc, identity: identity)
+  end
+
+  # policies
+
+  def fetch_policy(policy)
+    api.fetch_policy(org: org, policy: policy)
   end
 
-  def log_get(workload:, from:, to:)
-    api.log_get(org: org, gvc: gvc, workload: workload, from: from, to: to)
+  def bind_identity_to_policy(identity_link, policy)
+    cmd = "cpln policy add-binding #{policy} --org #{org} --identity #{identity_link} --permission reveal"
+    perform!(cmd)
   end
 
   # apply
@@ -311,13 +340,17 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
         Shell.debug("CMD", cmd)
 
-        result = `#{cmd}`
-        $CHILD_STATUS.success? ? parse_apply_result(result) : false
+        result = Shell.cmd(cmd)
+        parse_apply_result(result[:output]) if result[:success]
       else
         Shell.debug("CMD", cmd)
 
-        result = `#{cmd}`
-        $CHILD_STATUS.success? ? parse_apply_result(result) : exit(false)
+        result = Shell.cmd(cmd)
+        if result[:success]
+          parse_apply_result(result[:output])
+        else
+          Shell.abort("Command exited with non-zero status.")
+        end
       end
     end
   end
@@ -361,23 +394,69 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   private
 
-  def perform(cmd)
-    Shell.debug("CMD", cmd)
+  # `output_mode` can be :all, :errors_only or :none.
+  # If not provided, it will be determined based on the `HIDE_COMMAND_OUTPUT` env var
+  # or the return value of `Shell.should_hide_output?`.
+  def build_command(cmd, output_mode: nil) # rubocop:disable Metrics/MethodLength
+    output_mode ||= determine_command_output_mode
+
+    case output_mode
+    when :all
+      cmd
+    when :errors_only
+      "#{cmd} > /dev/null"
+    when :none
+      "#{cmd} > /dev/null 2>&1"
+    else
+      raise "Invalid command output mode '#{output_mode}'."
+    end
+  end
 
-    system(cmd)
+  def determine_command_output_mode
+    if ENV.fetch("HIDE_COMMAND_OUTPUT", nil) == "true"
+      :none
+    elsif Shell.should_hide_output?
+      :errors_only
+    else
+      :all
+    end
   end
 
-  def perform!(cmd, sensitive_data_pattern: nil)
+  def perform(cmd, output_mode: nil, sensitive_data_pattern: nil)
+    cmd = build_command(cmd, output_mode: output_mode)
+
     Shell.debug("CMD", cmd, sensitive_data_pattern: sensitive_data_pattern)
 
-    system(cmd) || exit(false)
+    kernel_system_with_pid_handling(cmd)
+  end
+
+  # NOTE: full analogue of Kernel.system which returns pids and saves it to child_pids for proper killing
+  def kernel_system_with_pid_handling(cmd)
+    pid = Process.spawn(cmd)
+    $child_pids << pid # rubocop:disable Style/GlobalVars
+
+    _, status = Process.wait2(pid)
+    $child_pids.delete(pid) # rubocop:disable Style/GlobalVars
+
+    status.exited? ? status.success? : nil
+  rescue SystemCallError
+    nil
+  end
+
+  def perform!(cmd, output_mode: nil, sensitive_data_pattern: nil)
+    success = perform(cmd, output_mode: output_mode, sensitive_data_pattern: sensitive_data_pattern)
+    success || Shell.abort("Command exited with non-zero status.")
   end
 
   def perform_yaml(cmd)
     Shell.debug("CMD", cmd)
 
-    result = `#{cmd}`
-    $CHILD_STATUS.success? ? YAML.safe_load(result) : exit(false)
+    result = Shell.cmd(cmd)
+    YAML.safe_load(result[:output], permitted_classes: [Time]) if result[:success]
+  end
+
+  def perform_yaml!(cmd)
+    perform_yaml(cmd) || Shell.abort("Command exited with non-zero status.")
   end
 
   def gvc_org

data/lib/core/controlplane_api.rb

@@ -25,18 +25,24 @@ class ControlplaneApi # rubocop:disable Metrics/ClassLength
     query("/org/#{org}/image", terms)
   end
 
+  def fetch_image_details(org:, image:)
+    api_json("/org/#{org}/image/#{image}", method: :get)
+  end
+
   def image_delete(org:, image:)
     api_json("/org/#{org}/image/#{image}", method: :delete)
   end
 
-  def log_get(org:, gvc:, workload: nil, from: nil, to: nil)
+  def log_get(org:, gvc:, workload: nil, replica: nil, from: nil, to: nil) # rubocop:disable Metrics/ParameterLists
     query = { gvc: gvc }
     query[:workload] = workload if workload
+    query[:replica] = replica if replica
     query = query.map { |k, v| %(#{k}="#{v}") }.join(",").then { "{#{_1}}" }
 
     params = { query: query }
     params[:from] = "#{from}000000000" if from
     params[:to] = "#{to}000000000" if to
+    params[:limit] = "5000"
     # params << "delay_for=0"
     # params << "limit=30"
     # params << "direction=forward"
@@ -106,6 +112,14 @@ class ControlplaneApi # rubocop:disable Metrics/ClassLength
     api_json("/org/#{org}/domain/#{domain}", method: :patch, body: data)
   end
 
+  def fetch_identity(org:, gvc:, identity:)
+    api_json("/org/#{org}/gvc/#{gvc}/identity/#{identity}", method: :get)
+  end
+
+  def fetch_policy(org:, policy:)
+    api_json("/org/#{org}/policy/#{policy}", method: :get)
+  end
+
   private
 
   def fetch_query_pages(result)

data/lib/core/controlplane_api_cli.rb

@@ -2,9 +2,9 @@
 
 class ControlplaneApiCli
   def call(url, method:)
-    response = `cpln rest #{method} #{url} -o json`
-    raise(response) unless $CHILD_STATUS.success?
+    result = Shell.cmd("cpln", "rest", method, url, "-o", "json", capture_stderr: true)
+    raise(result[:output]) unless result[:success]
 
-    JSON.parse(response)
+    JSON.parse(result[:output])
   end
 end

data/lib/core/controlplane_api_direct.rb

@@ -16,6 +16,7 @@ class ControlplaneApiDirect
   # ).freeze
 
   API_TOKEN_REGEX = /^[\w\-._]+$/.freeze
+  API_TOKEN_EXPIRY_SECONDS = 300
 
   class << self
     attr_accessor :trace
@@ -26,7 +27,10 @@ class ControlplaneApiDirect
     uri = URI("#{api_host(host)}#{url}")
     request = API_METHODS[method].new(uri)
     request["Content-Type"] = "application/json"
-    request["Authorization"] = api_token
+
+    refresh_api_token if should_refresh_api_token?
+
+    request["Authorization"] = api_token[:token]
     request.body = body.to_json if body
 
     Shell.debug(method.upcase, "#{uri} #{body&.to_json}")
@@ -62,17 +66,41 @@ class ControlplaneApiDirect
   end
 
   # rubocop:disable Style/ClassVars
-  def api_token
+  def api_token # rubocop:disable Metrics/MethodLength
     return @@api_token if defined?(@@api_token)
 
-    @@api_token = ENV.fetch("CPLN_TOKEN", nil)
-    @@api_token = `cpln profile token`.chomp if @@api_token.nil?
-    return @@api_token if @@api_token.match?(API_TOKEN_REGEX)
+    @@api_token = {
+      token: ENV.fetch("CPLN_TOKEN", nil),
+      comes_from_profile: false
+    }
+    if @@api_token[:token].nil?
+      @@api_token = {
+        token: Shell.cmd("cpln", "profile", "token")[:output].chomp,
+        comes_from_profile: true
+      }
+    end
+    return @@api_token if @@api_token[:token].match?(API_TOKEN_REGEX)
 
     raise "Unknown API token format. " \
           "Please re-run 'cpln profile login' or set the correct CPLN_TOKEN env variable."
   end
 
+  # Returns `true` when the token is about to expire in 5 minutes
+  def should_refresh_api_token?
+    return false unless api_token[:comes_from_profile]
+
+    payload, = JWT.decode(api_token[:token], nil, false)
+    difference_in_seconds = payload["exp"] - Time.now.to_i
+
+    difference_in_seconds <= API_TOKEN_EXPIRY_SECONDS
+  rescue JWT::DecodeError
+    false
+  end
+
+  def refresh_api_token
+    @@api_token[:token] = `cpln profile token`.chomp
+  end
+
   def self.reset_api_token
     remove_class_variable(:@@api_token) if defined?(@@api_token)
   end

data/lib/core/shell.rb

@@ -9,10 +9,6 @@ class Shell
     @shell ||= Thor::Shell::Color.new
   end
 
-  def self.stderr
-    @stderr ||= $stderr
-  end
-
   def self.use_tmp_stderr
     @tmp_stderr = Tempfile.create
 
@@ -40,15 +36,16 @@ class Shell
   end
 
   def self.warn(message)
-    stderr.puts(color("WARNING: #{message}", :yellow))
+    Kernel.warn(color("WARNING: #{message}", :yellow))
   end
 
   def self.warn_deprecated(message)
-    stderr.puts(color("DEPRECATED: #{message}", :yellow))
+    Kernel.warn(color("DEPRECATED: #{message}", :yellow))
   end
 
-  def self.abort(message)
-    Kernel.abort(color("ERROR: #{message}", :red))
+  def self.abort(message, exit_status = ExitCode::ERROR_DEFAULT)
+    Kernel.warn(color("ERROR: #{message}", :red))
+    exit(exit_status)
   end
 
   def self.verbose_mode(verbose)
@@ -59,13 +56,22 @@ class Shell
     return unless verbose
 
     filtered_message = hide_sensitive_data(message, sensitive_data_pattern)
-    stderr.puts("\n[#{color(prefix, :red)}] #{filtered_message}")
+    Kernel.warn("\n[#{color(prefix, :red)}] #{filtered_message}")
   end
 
   def self.should_hide_output?
     tmp_stderr && !verbose
   end
 
+  def self.cmd(*cmd_to_run, capture_stderr: false)
+    output, status = capture_stderr ? Open3.capture2e(*cmd_to_run) : Open3.capture2(*cmd_to_run)
+
+    {
+      output: output,
+      success: status.success?
+    }
+  end
+
   #
   # Hide sensitive data based on the passed pattern
   #

data/lib/cpl/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Cpl
-  VERSION = "1.3.0"
+  VERSION = "2.0.0.rc.0"
   MIN_CPLN_VERSION = "0.0.71"
 end

data/lib/cpl.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require "date"
 require "dotenv/load"
 require "cgi"
 require "json"
+require "jwt"
 require "net/http"
+require "open3"
 require "pathname"
 require "tempfile"
 require "thor"
 require "yaml"
 
+require_relative "constants/exit_code"
+
 # We need to require base before all commands, since the commands inherit from it
 require_relative "command/base"
 
@@ -17,6 +22,14 @@ modules = Dir["#{__dir__}/**/*.rb"].reject do |file|
 end
 modules.sort.each { require(_1) }
 
+# NOTE: this snippet combines all subprocesses into a group and kills all on exit to avoid hanging orphans
+$child_pids = [] # rubocop:disable Style/GlobalVars
+at_exit do
+  $child_pids.each do |pid| # rubocop:disable Style/GlobalVars
+    Process.kill("TERM", pid)
+  end
+end
+
 # Fix for https://github.com/erikhuda/thor/issues/398
 # Copied from https://github.com/rails/thor/issues/398#issuecomment-622988390
 class Thor
@@ -57,9 +70,9 @@ module Cpl
 
       @checked_cpln_version = true
 
-      result = `cpln --version 2>/dev/null`
-      if $CHILD_STATUS.success?
-        data = JSON.parse(result)
+      result = ::Shell.cmd("cpln", "--version", capture_stderr: true)
+      if result[:success]
+        data = JSON.parse(result[:output])
 
         version = data["npm"]
         min_version = Cpl::MIN_CPLN_VERSION
@@ -77,10 +90,10 @@ module Cpl
 
       @checked_cpl_version = true
 
-      result = `gem search ^cpl$ --remote 2>/dev/null`
-      return unless $CHILD_STATUS.success?
+      result = ::Shell.cmd("gem", "search", "^cpl$", "--remote", capture_stderr: true)
+      return unless result[:success]
 
-      matches = result.match(/cpl \((.+)\)/)
+      matches = result[:output].match(/cpl \((.+)\)/)
       return unless matches
 
       version = Cpl::VERSION
@@ -133,6 +146,9 @@ module Cpl
       ::Command::Base.all_commands.merge(deprecated_commands)
     end
 
+    @commands_with_required_options = []
+    @commands_with_extra_options = []
+
     all_base_commands.each do |command_key, command_class| # rubocop:disable Metrics/BlockLength
       deprecated = deprecated_commands[command_key]
 
@@ -159,12 +175,20 @@ module Cpl
       long_desc(long_description)
 
       command_options.each do |option|
-        method_option(option[:name], **option[:params])
+        params = option[:params]
+
+        # Ensures that if no value is provided for a non-boolean option (e.g., `cpl command --option`),
+        # it defaults to an empty string instead of the option name (which is the default Thor behavior)
+        params[:lazy_default] ||= "" if params[:type] != :boolean
+
+        method_option(option[:name], **params)
       end
 
       # We'll handle required options manually in `Config`
       required_options = command_options.select { |option| option[:params][:required] }.map { |option| option[:name] }
-      disable_required_check! name_for_method.to_sym if required_options.any?
+      @commands_with_required_options.push(name_for_method.to_sym) if required_options.any?
+
+      @commands_with_extra_options.push(name_for_method.to_sym) if accepts_extra_options
 
       define_method(name_for_method) do |*provided_args| # rubocop:disable Metrics/MethodLength
         if deprecated
@@ -184,6 +208,8 @@ module Cpl
         end
 
         begin
+          Cpl::Cli.validate_options!(options, command_options)
+
           config = Config.new(args, options, required_options)
 
           Cpl::Cli.show_info_header(config) if with_info_header
@@ -197,6 +223,21 @@ module Cpl
       ::Shell.abort("Unable to load command: #{e.message}")
     end
 
+    disable_required_check!(*@commands_with_required_options)
+    check_unknown_options!(except: @commands_with_extra_options)
+    stop_on_unknown_option!
+
+    def self.validate_options!(options, command_options)
+      options.each do |name, value|
+        raise "No value provided for option '#{name}'." if value.to_s.strip.empty?
+
+        params = command_options.find { |option| option[:name].to_s == name }[:params]
+        next unless params[:valid_regex]
+
+        raise "Invalid value provided for option '#{name}'." unless value.match?(params[:valid_regex])
+      end
+    end
+
     def self.show_info_header(config) # rubocop:disable Metrics/MethodLength
       return if @showed_info_header
 
@@ -221,5 +262,5 @@ end
 # nice Ctrl+C
 trap "INT" do
   puts
-  exit(1)
+  exit(ExitCode::INTERRUPT)
 end

data/lib/deprecated_commands.json

@@ -3,6 +3,7 @@
   "cleanup_old_images": "cleanup-images",
   "promote": "deploy-image",
   "promote_image": "deploy-image",
-  "runner": "run:detached",
+  "run:detached": "run",
+  "runner": "run",
   "setup": "apply-template"
 }

data/lib/generator_templates/controlplane.yml

@@ -19,10 +19,15 @@ aliases:
     one_off_workload: rails
 
     # Workloads that are for the application itself and are using application Docker images.
+    # These are updated with the new image when running the `deploy-image` command,
+    # and are also used by the `info` and `ps:` commands in order to get all of the defined workloads.
+    # On the other hand, if you have a workload for Redis, that would NOT use the application Docker image
+    # and not be listed here.
     app_workloads:
       - rails
 
     # Additional "service type" workloads, using non-application Docker images.
+    # These are only used by the `info` and `ps:` commands in order to get all of the defined workloads.
     additional_workloads:
       - postgres
 

data/lib/generator_templates/templates/{gvc.yml → app.yml}

@@ -1,15 +1,15 @@
 # Template setup of the GVC, roughly corresponding to a Heroku app
 kind: gvc
-name: APP_GVC
+name: {{APP_NAME}}
 spec:
   # For using templates for test apps, put ENV values here, stored in git repo.
   # Production apps will have values configured manually after app creation.
   env:
     - name: DATABASE_URL
-      # Password does not matter because host postgres.APP_GVC.cpln.local can only be accessed
+      # Password does not matter because host postgres.{{APP_NAME}}.cpln.local can only be accessed
       # locally within CPLN GVC, and postgres running on a CPLN workload is something only for a
       # test app that lacks persistence.
-      value: 'postgres://the_user:the_password@postgres.APP_GVC.cpln.local:5432/APP_GVC'
+      value: 'postgres://the_user:the_password@postgres.{{APP_NAME}}.cpln.local:5432/{{APP_NAME}}'
     - name: RAILS_ENV
       value: production
     - name: RAILS_SERVE_STATIC_FILES
@@ -18,4 +18,4 @@ spec:
   # Part of standard configuration
   staticPlacement:
     locationLinks:
-      - /org/APP_ORG/location/APP_LOCATION
+      - {{APP_LOCATION_LINK}}