apisonator 2.100.0

data/app/api/internal/metrics.rb

@@ -0,0 +1,40 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/metrics' do
+        get '/:id' do |service_id, id|
+          metric = Metric.load service_id, id
+          if metric
+            { status: :found, metric: metric.to_hash }.to_json
+          else
+            [404, headers, { status: :not_found, error: 'metric not found' }.to_json]
+          end
+        end
+
+        post '/:id' do |service_id, id|
+          metric_attrs = api_params Metric 
+          metric_attrs[:service_id] = service_id
+          metric_attrs[:id] = id
+          metric = Metric.save metric_attrs
+          [201, headers, { status: :created, metric: metric.to_hash }.to_json]
+        end
+
+        put '/:id' do |service_id, id|
+          metric_attrs = api_params Metric 
+          metric_attrs[:service_id] = service_id
+          metric_attrs[:id] = id
+          metric = Metric.save metric_attrs
+          { status: :modified, metric: metric.to_hash }.to_json
+        end
+
+        delete '/:id' do |service_id, id|
+          if Metric.delete(service_id, id)
+            { status: :deleted }.to_json
+          else
+            [404, headers, { status: :not_found, error: 'metric not found' }.to_json]
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/service_tokens.rb

@@ -0,0 +1,46 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/service_tokens' do
+
+        head '/:token/:service_id/' do |token, service_id|
+          ServiceToken.exists?(token, service_id) ? 200 : 404
+        end
+
+        post '/' do
+          check_tokens_param!
+
+          token_pairs = @service_tokens.map do |token, token_info|
+            { service_token: token, service_id: token_info[:service_id] }
+          end
+
+          begin
+            ServiceToken.save_pairs(token_pairs)
+            [201, headers, { status: :created }.to_json]
+          rescue ServiceToken::ValidationError => e
+            halt(e.http_code, { status: :error, error: e.message }.to_json)
+          end
+        end
+
+        delete '/' do
+          check_tokens_param!
+
+          deleted = @service_tokens.count do |token|
+            ServiceToken.delete(token[:service_token], token[:service_id]) == 1
+          end
+
+          { status: :deleted, count: deleted }.to_json
+        end
+
+        private
+
+        def check_tokens_param!
+          @service_tokens = params[:service_tokens]
+          unless @service_tokens
+            halt(400, { error: "missing parameter 'service_tokens'".freeze }.to_json)
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/services.rb

@@ -0,0 +1,58 @@
+require '3scale/backend/use_cases/provider_key_change_use_case'
+
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services' do
+        get '/:id' do
+          service = Service.load_by_id(params[:id])
+          if service
+            { status: :found, service: service.to_hash }.to_json
+          else
+            [404, headers, {error: :not_found}.to_json]
+          end
+        end
+
+        post '/' do
+          svc_attrs = api_params Service
+          service = Service.save!(svc_attrs)
+          [201, headers, {service: service.to_hash, status: :created}.to_json]
+        end
+
+        put '/:id' do
+          svc_attrs = api_params Service
+          service = Service.load_by_id(params[:id])
+          if service
+            svc_attrs.each do |attr, value|
+              service.send "#{attr}=", value
+            end
+            service.save!
+          else
+            service = Service.save!(svc_attrs)
+          end
+          {service: service.to_hash, status: :ok}.to_json
+        end
+
+        put '/change_provider_key/:key' do
+          begin
+            ProviderKeyChangeUseCase.new(params[:key], params[:new_key]).process
+            {status: :ok}.to_json
+          rescue InvalidProviderKeys, ProviderKeyExists, ProviderKeyNotFound => e
+            respond_with_400 e
+          end
+        end
+
+        delete '/:id' do
+          begin
+            Service.delete_by_id params[:id]
+            {status: :deleted}.to_json
+          rescue ServiceIsDefaultService => e
+            respond_with_400 e
+          rescue ServiceIdInvalid => e
+            respond_with_404 e
+          end
+        end
+      end
+    end
+  end
+end

data/app/api/internal/stats.rb

@@ -0,0 +1,42 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/stats' do
+        before do
+          respond_with_404('service not found') unless Service.exists?(params[:service_id])
+        end
+
+        # This is very slow and needs to be disabled until the performance
+        # issues are solved. In the meanwhile, the job will just return OK.
+=begin
+        delete '' do |service_id|
+          delete_stats_job_attrs = api_params Stats::DeleteJobDef
+          delete_stats_job_attrs[:service_id] = service_id
+          delete_stats_job_attrs[:from] = delete_stats_job_attrs[:from].to_i
+          delete_stats_job_attrs[:to] = delete_stats_job_attrs[:to].to_i
+          begin
+            Stats::DeleteJobDef.new(delete_stats_job_attrs).run_async
+          rescue DeleteServiceStatsValidationError => e
+            [400, headers, { status: :error, error: e.message }.to_json]
+          else
+            { status: :to_be_deleted }.to_json
+          end
+=end
+
+        # This is an alternative to the above. It just adds the service to a
+        # Redis set to marked is as "to be deleted".
+        # Later a script can read that set and actually delete the keys.
+        # Read the docs of the Stats::Cleaner class for more details.
+        #
+        # Notice that this method ignores the "from" and "to" parameters. When
+        # system calls this method, they're always interested in deleting all
+        # the keys. They were just passing "from" and "to" to make the
+        # implementation of the option above easier.
+        delete '' do |service_id|
+          Stats::Cleaner.mark_service_to_be_deleted(service_id)
+          { status: :to_be_deleted }.to_json
+        end
+      end
+    end
+  end
+end

data/app/api/internal/usagelimits.rb

@@ -0,0 +1,62 @@
+module ThreeScale
+  module Backend
+    module API
+      # Note: ideally this URL should NOT look like this.
+      #
+      # We have it this way because the entities don't fit a hierarchical
+      # scheme since their relations are complex:
+      #
+      # * We don't have UsageLimit ID's per se
+      # * Plan is a denormalized entity in backend
+      # * Metrics need to be loaded from a given Service
+      # * But neither Plan nor Metric are nested wrt each other
+      # * And Service has no other use than being able to load a Metric
+      #
+      # In the end no single URL shape is pleasing enough: specifying some
+      # needed IDs as parameters feels wrong because of the reasons above, but
+      # adding them to the URL makes for really long URLs with no clear
+      # hierarchy for nesting. We chose the latter, but could have chosen almost
+      # any workable form.
+      #
+      internal_api '/services/:service_id/plans/:plan_id/usagelimits' do
+        module UsageLimitsHelper
+          def self.to_hash(service_id, plan_id, metric_id, period, value)
+            {
+              :service_id => service_id,
+              :plan_id => plan_id,
+              :metric_id => metric_id,
+              period.to_sym => value
+            }
+          end
+        end
+
+        get '/:metric_id/:period' do |service_id, plan_id, metric_id, period|
+          value = UsageLimit.load_value(service_id, plan_id, metric_id, period)
+          if value
+            { status: :found, usagelimit: UsageLimitsHelper.to_hash(service_id, plan_id,
+                                                                   metric_id, period,
+                                                                   value) }.to_json
+          else
+            [404, headers, { status: :not_found, error: 'usagelimit not found' }.to_json]
+          end
+        end
+
+        put '/:metric_id/:period' do |service_id, plan_id, metric_id, period|
+          attributes = params[:usagelimit]
+          halt 400, { status: :error, error: 'missing parameter \'usagelimit\'' }.to_json unless attributes
+          value = attributes[period.to_sym]
+          halt 400, { status: :error, error: "missing parameter '#{period}'" }.to_json unless value
+          ul_hash = UsageLimitsHelper.to_hash(service_id, plan_id, metric_id, period, value)
+          UsageLimit.save(ul_hash)
+          { status: :modified, usagelimit: ul_hash }.to_json
+        end
+
+        delete '/:metric_id/:period' do |service_id, plan_id, metric_id, period|
+          UsageLimit.delete(service_id, plan_id, metric_id, period)
+          { status: :deleted }.to_json
+        end
+
+      end
+    end
+  end
+end

data/app/api/internal/utilization.rb

@@ -0,0 +1,23 @@
+module ThreeScale
+  module Backend
+    module API
+      internal_api '/services/:service_id/applications/:app_id/utilization' do
+        before do
+          unless Service.exists?(params[:service_id])
+            respond_with_404('service not found')
+          end
+
+          unless Application.exists?(params[:service_id], params[:app_id])
+            respond_with_404('application not found')
+          end
+        end
+
+        get '/' do |service_id, app_id|
+          utilization = Transactor.utilization(service_id, app_id)
+          usage_reports = utilization.map(&:to_h)
+          { status: :found, utilization: usage_reports }.to_json
+        end
+      end
+    end
+  end
+end

data/bin/3scale_backend

@@ -0,0 +1,223 @@
+#!/usr/bin/env ruby
+require 'gli'
+require '3scale/backend/version'
+
+class Runner
+  class << self
+    def do_exit(code, global, msg='Unknown error')
+      Dir.chdir global[:original_dir]
+      exit_now! msg, code
+    end
+
+    def verbose(global_options, out=STDOUT)
+      out.puts(yield) if global_options[:verbose] || global_options[:'dry-run']
+    end
+
+    def exec(global_options)
+      Process.exec(*yield) unless global_options[:'dry-run']
+    end
+
+
+    def build_cmdline(cmd, global_options, options, args)
+      require '3scale/backend/server'
+      server = ThreeScale::Backend::Server.get global_options[:server]
+      server.send(cmd, global_options, options, args)
+    rescue => e
+      STDERR.puts "Error: #{e.message}#{"\n" + caller_locations(0).join("\n") if global_options[:verbose]}"
+    end
+
+    def do_command(cmd, global_options, options, args)
+      argv = build_cmdline cmd, global_options, options, args
+      do_exit 1, global_options, "can't build command line" unless argv
+      argv << global_options[:'extra-args'] if global_options[:'extra-args']
+      verbose(global_options) { "Executing: #{argv.join ' '}" }
+      exec(global_options) { argv }
+    end
+
+    def add_instance_id_options(c)
+      c.desc 'TCP port number where backend listens for connections'
+      c.arg_name 'NUMBER'
+      c.default_value '3000'
+      c.flag :p, :port
+      c.desc 'Filename where backend writes its PID'
+      c.arg_name 'FILENAME'
+      c.flag :pidfile
+    end
+  end
+
+  extend GLI::App
+
+  program_desc '3scale_backend launcher'
+
+  version ThreeScale::Backend::VERSION
+
+  CONFIG_FILE = '.backend_launcher.rc.yml'
+  EXPANDED_ROOT_PATH = File.expand_path(File.join('..', '..'), __FILE__)
+
+  config_file File.join(ENV['HOME'] || File.join('', 'tmp'), CONFIG_FILE)
+
+  subcommand_option_handling :normal
+  arguments :strict
+
+  desc 'Load Bundler when running'
+  default_value true
+  switch :b, :bundler
+
+  desc 'Do not actually run anything, just print what would be done'
+  default_value false
+  switch :n, :'dry-run'
+
+  desc 'Verbose mode'
+  default_value false
+  switch :v, :verbose
+
+  desc 'Directory where the app server will expect the code to be at'
+  arg_name 'DIRNAME'
+  flag :z, :directory
+
+  desc "Application server to use with backend"
+  default_value 'puma'
+  arg_name 'SERVER'
+  flag :s, :server
+
+  desc 'Environment backend will use'
+  arg_name 'ENVIRONMENT'
+  default_value 'development'
+  flag :e, :environment
+
+  desc 'Extra command arguments'
+  arg_name 'ARGS'
+  flag :X, :'extra-args'
+
+  pre do |global, command, options, args|
+    # Pre logic here
+    # Return true to proceed; false to abort and not call the
+    # chosen command
+    # Use skips_pre before a command to skip this block
+    # on that command only
+    global[:original_dir] = Dir.pwd
+    if global[:directory]
+      Dir.chdir global[:directory]
+    end
+    if global[:bundler]
+      begin
+        require 'bundler/setup'
+        if !Bundler::SharedHelpers.in_bundle?
+          # Gemfile not found, try with relative Gemfile from us
+          ENV['BUNDLE_GEMFILE'] = File.join(EXPANDED_ROOT_PATH, 'Gemfile')
+          require 'bundler'
+          Bundler.setup
+        end
+      rescue LoadError, Bundler::BundlerError => e
+        do_exit 64, global, "Unable to meet requirements: #{e.message}"
+      end
+    end
+    # manifest loading is not strictly necessary, so make it optional
+    begin
+      require '3scale/backend/manifest'
+      global[:manifest] = ThreeScale::Backend::Manifest.report
+    rescue LoadError, NameError, NoMethodError
+    end
+    true
+  end
+
+  post do |global,command,options,args|
+    # Post logic here
+    # Use skips_post before a command to skip this
+    # block on that command only
+    Dir.chdir global[:original_dir]
+  end
+
+  on_error do |exception|
+    # Error logic here
+    # return false to skip default error handling
+    true
+  end
+
+  desc 'Shows the capabilities of backend in its manifest'
+  command :manifest do |c|
+    c.action do |global_options, options, arg|
+      manifest = global_options[:manifest]
+      do_exit 65, global_options, "Could not load manifest: #{e.message}" unless manifest
+      STDOUT.puts(manifest.map do |k, v|
+        "#{"#{k[0..19]}:".ljust(21)} #{v.inspect}"
+      end.join "\n")
+    end
+  end
+
+  desc 'Starts the backend server'
+  command :start do |c|
+    c.desc 'Filename where backend will log requests to (default: stdout)'
+    c.arg_name 'FILENAME'
+    c.flag :l, :logfile
+    c.desc 'Filename where backend will log errors to, defaulting to --logfile value'
+    c.arg_name 'FILENAME'
+    c.flag :x, :errorfile
+    c.desc 'Daemonize the server'
+    c.default_value false
+    c.switch :d, :daemonize
+    add_instance_id_options c
+
+    c.action do |global_options, options, args|
+      options[:logfile] = nil if options[:logfile] == '-'
+      options[:errorfile] ||= options[:logfile]
+      options[:errorfile] = nil if options[:errorfile] == '-'
+      do_command :start, global_options, options, args
+    end
+
+    c.example '3scale_backend start -p 5001 -d --pidfile backend.pid -l /var/log/backend.log -x /var/log/backend.err.log',
+              desc: 'Listen on port 5001, daemonize with pidfile, write separate logs for requests and errors'
+  end
+
+  desc 'Stops the backend server'
+  command :stop do |c|
+    add_instance_id_options c
+
+    c.action do |global_options, options, args|
+      do_command :stop, global_options, options, args
+    end
+
+    c.example '3scale_backend stop --pidfile backend.pid', desc: 'Stop a daemon with a pidfile'
+  end
+
+  desc 'Restarts the backend server'
+  command :restart do |c|
+    add_instance_id_options c
+
+    c.desc 'Perform a phased-restart where available to avoid downtime'
+    c.default_value true
+    c.switch :"phased-restart"
+
+    c.action do |global_options, options, args|
+      do_command :restart, global_options, options, args
+    end
+  end
+
+  desc 'Prints the status of the backend server'
+  command :status do |c|
+    add_instance_id_options c
+
+    c.action do |global_options, options, args|
+      do_command :status, global_options, options, args
+    end
+  end
+
+  desc 'Prints statistics of the backend server'
+  command :stats do |c|
+    add_instance_id_options c
+
+    c.action do |global_options, options, args|
+      do_command :stats, global_options, options, args
+    end
+  end
+
+  desc 'Print extra help from the application server'
+  command :'help-server' do |c|
+    c.action do |global_options, options, args|
+      server = ThreeScale::Backend::Server.get global_options[:server]
+      server.help(global_options, options, args)
+    end
+  end
+end
+
+exit Runner.run(ARGV)