@govuk-pay/cli 0.0.2 → 0.0.4

package/resources/legacy-ruby-cli/lib/pay_cli/commands/local/app_client.rb

@@ -0,0 +1,216 @@
+module PayCLI::Commands::Local::AppClient
+  Config = PayCLI::Commands::Local::Config
+
+  def self.create_account(service_id = nil, email_settings = { email_collection_mode: 'MANDATORY' })
+    gateway_account_data = {
+        payment_provider: 'sandbox',
+        service_name: 'My service',
+        type: 'test',
+        service_id: service_id
+    }
+
+
+    patch_email_collection_mode_data = {
+        op: 'replace',
+        path: 'email_collection_mode',
+        value: email_settings[:email_collection_mode]
+    }
+
+    account = post("#{base_url 'connector'}/v1/api/accounts", gateway_account_data)
+
+    patch("#{base_url 'connector'}/v1/api/accounts/#{account["gateway_account_id"]}", patch_email_collection_mode_data)
+    patch("#{base_url 'adminusers'}/v1/api/services/#{service_id}", {
+      op: 'add',
+      path: 'gateway_account_ids',
+      value: [ account.fetch('gateway_account_id') ]
+    })
+
+    return account
+
+  end
+
+  def self.create_token(gateway_account_id)
+    token_data = {
+        account_id: gateway_account_id,
+        description: 'my token',
+        created_by: 'system generated',
+        token_type: 'CARD'
+    }
+
+    post("#{base_url 'publicauth'}/v1/frontend/auth", token_data)
+        .fetch('token')
+  end
+
+  def self.create_payment(api_token)
+    payment_data = {
+        amount: 1000,
+        description: 'my payment',
+        reference: 'my payment reference',
+        return_url: 'https://www.payments.service.gov.uk'
+    }
+
+    post_with_token("#{base_url('publicapi')}/v1/payments", payment_data, api_token)
+  end
+
+  def self.create_user(gateway_account_ids: [], role_name: 'admin')
+    username = SecureRandom.hex
+    user_data = {
+        gateway_account_ids: gateway_account_ids,
+        email: "#{username}@example.com",
+        password: 'aaaaaaaaaa',
+        telephone_number: '01134960000',
+        role_name: role_name
+    }
+
+    post("#{base_url 'adminusers'}/v1/api/users", user_data)
+        .merge(user_data)
+  end
+
+  def self.create_payment_link(api_token)
+    product_data = {
+        pay_api_token: api_token,
+        name: 'exampleName',
+        price: 100,
+        gateway_account_id: 1,
+        return_url: 'https://test.test/some_reference',
+        service_name: 'aServiceName',
+        type: 'ADHOC',
+        service_name_path: 'aServiceNamePath',
+        product_name_path: SecureRandom.hex,
+        reference_enabled: false
+    }
+
+    post("#{base_url 'products'}/v1/api/products/", product_data)
+  end
+
+  def self.create_service()
+    service_data = {
+        service_name: 'My service'
+    }
+
+    post("#{base_url 'adminusers'}/v1/api/services", service_data)
+  end
+
+  def self.post(url, data, custom_headers={}, exit_on_error = true)
+    headers = {content_type: :json, accept: :json}.merge(custom_headers)
+    begin
+      [url]
+          .map {|url| RestClient.post(url, data.to_json, headers).body}
+          .map {|response| JSON.parse(response)}
+          .first
+    rescue => e
+      begin
+        STDERR.puts "😬  Calling #{url} got error #{e.response}... sssorry about that"
+      rescue
+        STDERR.puts "🤔  Hmm, seems we cannot connect to #{url}. Here is what's up at the moment:"
+        report_state Config::all, false
+      end
+      exit 1 if exit_on_error
+    end
+  end
+
+    def self.patch(url, data, custom_headers={}, exit_on_error = true)
+      headers = {content_type: :json, accept: :json}.merge(custom_headers)
+      begin
+        RestClient.patch(url, data.to_json, headers)
+      rescue => e
+        begin
+          STDERR.puts "😬  Calling #{url} got error #{e.response}... sssorry about that"
+        rescue
+          STDERR.puts "🤔  Hmm, seems we cannot connect to #{url}. Here is what's up at the moment:"
+          report_state Config::all, false
+        end
+        exit 1 if exit_on_error
+      end
+    end
+
+  def self.wait_for_apps(apps)
+    timeout = 0
+    app_states = list_app_states apps
+
+    until all_up_states?(app_states) || timeout > 60 do
+      STDERR.print [
+         '🙄  Waiting for',
+         app_states
+             .reject {|app_state| app_state[:healthy]}
+             .map {|app_state| ' ' + app_state[:app_name]}.join(','),
+         + "                              \r"
+      ].join('')
+
+      $stdout.flush
+      timeout += 1
+      app_states = list_app_states apps
+      sleep 1
+    end
+    STDERR.puts "\n\n"
+  end
+
+  def self.report_state(apps, summarise = true)
+    app_states = list_app_states apps
+    STDERR.puts app_states.map {|app_state| "#{app_state[:healthy] ? '✅' : '🔴'}      #{app_state[:app_name]}"}
+    if all_up_states?(app_states)
+      STDERR.puts "\n🎉  Ready to roll\n\n"
+    else
+      STDERR.puts "\n💥  Hmmm, something not quite right"
+      STDERR.puts "ℹ️   It may have just timed out waiting so you could just try again"
+      STDERR.puts "ℹ️   Make sure you have the latest pay-infra"
+      STDERR.puts "ℹ️   docker logs <app> should tell you if an app failed to launch"
+      STDERR.puts "ℹ️   docker inspect <app> may give some clues under State"
+      STDERR.puts "ℹ️   pay local nuke is drastic but may help"
+      STDERR.puts "ℹ️   docker system prune --all is also drastic but may get things working"
+      STDERR.puts "ℹ️   You may need to increase the memory in Docker Desktop settings\n\n"
+
+
+    end if summarise
+  end
+
+  def self.get(url)
+    RestClient::Request.execute(
+        :url => url,
+        :method => :get,
+        :headers => {accept: :json},
+        :verify_ssl => false
+    )
+  end
+
+  def self.post_with_token(url, data, token, exit_on_error = true)
+    post(url, data, {authorization: "Bearer #{token}"}, exit_on_error)
+  end
+
+  def self.is_app_up?(app_name)
+    return true unless Config::has_healthcheck(app_name)
+    begin
+      get("#{base_url app_name}/healthcheck").code.equal? 200
+    rescue
+      false
+    end
+  end
+
+  def self.is_proxy_up?(app_name)
+    begin
+      get("#{base_proxy_url app_name}/healthcheck").code.equal? 200
+    rescue
+      false
+    end
+  end
+
+  def self.all_up?(apps)
+    all_up_states? list_app_states apps
+  end
+
+  def self.all_up_states?(app_states)
+    app_states.reject {|app| app[:healthy]}.length.equal? 0
+  end
+
+  def self.list_app_states(apps)
+    apps.map {|app| {app_name: app[:name], healthy: is_app_up?(app[:name])}}
+  end
+
+  def self.base_url(app_name)
+    "http://localhost:#{Config::port app_name}"
+    end
+
+  def self.base_proxy_url(app_name)
+    "https://localhost:#{Config::proxy_port app_name}"
+  end
+end

package/resources/legacy-ruby-cli/lib/pay_cli/commands/local/config.rb

@@ -0,0 +1,138 @@
+module PayCLI::Commands::Local::Config
+  @apps = ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file("#{File.dirname(__FILE__)}/config.yaml")).values
+
+  def self.all
+    @apps
+  end
+
+  def self.boring
+    @apps.select {|app| app[:experimental] != true }
+  end
+
+  def self.port(app_name)
+    self.get_config app_name, :port
+  end
+
+  def self.admin_port(app_name)
+    self.get_config app_name, :admin_port
+  end
+
+  def self.get_config(app_name, field)
+    @apps.select {|app| app[:name] == app_name}.map {|app| app[field]}.first
+  end
+
+  def self.has_healthcheck(app_name)
+    @apps.select {|app| app[:name] == app_name}.map {|app| app[:healthcheck]}.first
+  end
+
+  def self.uses_redis(app_name)
+    @apps.select {|app| app[:name] == app_name}.any? {|app| app.fetch(:uses_redis, false)}
+  end
+
+  def self.proxy_port(app_name)
+    @apps.select {|app| app[:name] == app_name}.map {|app| app[:proxy_port]}.first
+  end
+
+  def self.cluster( cluster, apps)
+    apps.select {|app| app[:clusters].include?(cluster)}
+  end
+
+  def self.local(local_app_names, apps)
+    apps.select {|app| local_app_names.include? app[:name]}
+  end
+
+  def self.remote(local_app_names, apps)
+    apps.select {|app| !local_app_names.include? app[:name]}
+  end
+
+  def self.filter(app_names, apps)
+    apps.select {|app| app_names.include? app[:name]}
+  end
+
+  def self.node(apps)
+    apps.select { |app| app[:type] == 'node'}
+  end
+
+  def self.java(apps)
+    apps.select { |app| app[:type] == 'java'}
+  end
+
+  def self.has_db(apps)
+    apps.select {|app| app[:db]}
+  end
+
+  def self.has_proxy(apps)
+    apps.select {|app| app[:proxy]}
+  end
+
+  def self.has_queue(apps) 
+    apps.select {|app| app[:queues]}
+  end
+
+  def self.has_sns_topics(apps)
+    apps.select { |app| app[:sns_topics] }
+  end
+
+  def self.uses_localstack(apps)
+    has_queue(apps).any? || has_sns_topics(apps).any?
+  end
+
+  def self.db_configs(apps)
+    apps.map {|app| {
+        name: app[:name] + '_db',
+        port: app[:db_port]
+    }}
+  end
+
+  def self.app_by_name(name)
+    @apps.select do |app|
+      app[:name] == name
+    end
+  end
+
+  def self.proxy_configs(apps)
+    apps.map {|app|
+      if app[:naxsi]
+        md5 = copy_naxsi_rules(app).hexdigest
+      end
+      {
+          name: app[:name] + '-proxy',
+          port: app[:proxy_port],
+          proxy_port: app[:port],
+          proxy_host: app[:name],
+          naxsi_md5: md5
+      }
+    }
+  end
+  
+  def self.copy_naxsi_rules(app)
+    naxsi_rule_dest = File.join(
+    File.dirname(__FILE__),
+    "files/naxsi/#{app[:name]}.rules")
+
+    naxsi_rule_source = File.join(
+    File.dirname(__FILE__),
+    '..', '..', '..', '..', '..',
+    'provisioning',
+    'terraform',
+    'modules',
+    'pay_microservices_v2',
+    app[:name],
+    'files',
+    "#{app[:name]}.naxsi")
+
+    FileUtils.copy(naxsi_rule_source, naxsi_rule_dest)
+
+    Digest::MD5.file naxsi_rule_dest
+  end
+
+  def self.write_end_to_end_config(binding)
+    erb = ERB.new(File.read(File.join(
+        File.dirname(__FILE__),
+        'files',
+        'end-to-end.erb')), trim_mode: '-')
+
+    erb.result(binding)
+  end
+
+end

package/resources/legacy-ruby-cli/lib/pay_cli/commands/local/config.yaml

@@ -0,0 +1,192 @@
+adminusers:
+  name: adminusers
+  type: java
+  db: true
+  db_port: 19700
+  port: 9700
+  admin_port: 9701
+  healthcheck: true
+  queues:
+    AWS_SQS_CONNECTOR_TASKS_QUEUE_URL: connector_tasks_queue
+  clusters:
+    - admin
+    - paymentlinks
+    - card
+    - endtoend
+    - java
+    - toolbox
+connector:
+  name: connector
+  type: java
+  db: true
+  db_port: 19300
+  port: 9300
+  admin_port: 9301
+  healthcheck: true
+  queues:
+    AWS_SQS_CAPTURE_QUEUE_URL: pay_capture_queue
+    AWS_SQS_PAYMENT_EVENT_QUEUE_URL: pay_event_queue
+    AWS_SQS_PAYOUT_RECONCILE_QUEUE_URL: payout_reconcile_queue
+    AWS_SQS_CONNECTOR_TASKS_QUEUE_URL: connector_tasks_queue
+  clusters:
+    - admin
+    - paymentlinks
+    - card
+    - endtoend
+    - java
+    - toolbox
+cardid:
+  name: cardid
+  type: java
+  port: 9900
+  admin_port: 9901
+  healthcheck: true
+  clusters:
+    - paymentlinks
+    - card
+    - endtoend
+    - java
+publicauth:
+  name: publicauth
+  type: java
+  db: true
+  db_port: 19600
+  port: 9600
+  admin_port: 9601
+  healthcheck: true
+  clusters:
+    - admin
+    - paymentlinks
+    - card
+    - endtoend
+    - java
+    - toolbox
+publicapi:
+  name: publicapi
+  type: java
+  port: 9100
+  admin_port: 9101
+  healthcheck: true
+  uses_redis: true
+  environment_overrides:
+    REDIS_URL: "redis"
+  clusters:
+    - paymentlinks
+    - card
+    - endtoend
+    - java
+products:
+  name: products
+  type: java
+  db: true
+  db_port: 19800
+  port: 18000
+  admin_port: 18001
+  healthcheck: true
+  clusters:
+    - admin
+    - paymentlinks
+    - endtoend
+    - java
+    - toolbox
+frontend:
+  name: frontend
+  proxy: true
+  naxsi: true
+  type: node
+  db: false
+  port: 9000
+  debug_port: 9001
+  proxy_port: 29000
+  healthcheck: true
+  clusters:
+    - paymentlinks
+    - card
+    - endtoend
+selfservice:
+  proxy: true
+  naxsi: true
+  name: selfservice
+  type: node
+  db: false
+  port: 9400
+  debug_port: 9401
+  healthcheck: true
+  proxy_port: 39000
+  clusters:
+    - admin
+    - endtoend
+    - webhooks
+products-ui:
+  name: products-ui
+  proxy: true
+  type: node
+  db: false
+  port: 10400
+  debug_port: 10401
+  proxy_port: 19000
+  healthcheck: true
+  clusters:
+    - paymentlinks
+    - endtoend
+stubs:
+  name: stubs
+  proxy: true
+  type: node
+  db: false
+  port: 3030
+  debug_port: 3031
+  proxy_port: 29100
+  healthcheck: false
+  clusters:
+    - endtoend
+ledger:
+  name: ledger
+  type: java
+  db: true
+  db_port: 20700
+  port: 10700
+  admin_port: 10701
+  healthcheck: true
+  queues:
+    AWS_SQS_PAYMENT_EVENT_QUEUE_URL: pay_event_queue
+  sns_topics:
+    SNS_TOPIC_CARD_PAYMENT_EVENTS: card-payment-events-topic
+    SNS_TOPIC_CARD_PAYMENT_DISPUTE_EVENTS: card-payment-dispute-events-topic
+  environment_overrides:
+    SNS_ENABLED: "true"
+    PUBLISH_CARD_PAYMENT_EVENTS_TO_SNS: "true"
+    PUBLISH_CARD_PAYMENT_DISPUTE_EVENTS_TO_SNS: "true"
+  clusters:
+    - admin
+    - card
+    - endtoend
+    - java
+    - toolbox
+toolbox:
+  name: toolbox
+  type: node
+  db: false
+  port: 3040
+  debug_port: 3041
+  healthcheck: true
+  entrypoint_override_local: 'sh -c "npm run build:copy && npm --inspect=0.0.0.0:3041 start"'
+  clusters:
+    - toolbox
+webhooks:
+  name: webhooks
+  type: java
+  db: true
+  db_port: 20800
+  port: 10800
+  admin_port: 10801
+  healthcheck: true
+  queues:
+    AWS_SQS_PAYMENT_EVENT_QUEUE_URL: webhooks-events-subscriber-queue
+  clusters:
+    - admin
+    - card
+    - endtoend
+    - java
+    - toolbox
+    - webhooks

package/resources/legacy-ruby-cli/lib/pay_cli/commands/local/docker.rb

@@ -0,0 +1,36 @@
+module PayCLI::Commands::Local::Docker
+  def self.remove(app, force=true)
+    `docker rm #{'-f' if force} -v #{app}  2>/dev/null`
+    STDERR.puts " 💀 #{app}"
+  end
+
+  def self.write_compose_file(cluster, binding)
+    compose_file = compose_file cluster
+
+    erb = ERB.new(File.read(File.join(
+        File.dirname(__FILE__),
+        'files',
+        'docker-compose.erb')), trim_mode: '-')
+
+    File.write(compose_file, erb.result(binding))
+  end
+
+  def self.pull(cluster)
+    `docker-compose -f #{compose_file cluster} pull`
+  end
+
+  def self.up(cluster)
+    `docker-compose -f #{compose_file cluster} up --detach`
+  end
+
+  def self.down(cluster)
+    `docker-compose --log-level ERROR -f #{compose_file cluster} down`
+  end
+
+  def self.compose_file(cluster)
+    File.join(
+        File.dirname(__FILE__),
+        'files',
+        "#{cluster}.yaml")
+  end
+end