p4_web_api 2014.2.0.pre2 → 2014.2.0.pre4

data/lib/p4_web_api/app/changes.rb

@@ -0,0 +1,73 @@
+require 'p4_web_api/change_helper'
+
+module P4WebAPI
+  # Add methods related to changelist resources.
+  class App < Sinatra::Base
+    # Convenience method to list changelist metadata with some common filtering
+    # options.
+    #
+    # parameters:
+    # - `max` = number
+    # - `status` = pending|submitted|shelved
+    # - `user` = perforce login
+    # - `files` = pattern
+    get '/v1/changes' do
+      max = params['max'] if params.key?('max')
+      status = params['status'] if params.key?('status')
+      user = params['user'] if params.key?('user')
+      files = params['files'] if params.key?('files')
+
+      results = nil
+
+      open_p4 do |p4|
+        args = ['changes']
+
+        args.push('-m', max) if max
+        args.push('-s', status) if status
+        args.push('-u', user) if user
+        args.push(files) if files
+
+        results = p4.run(*args)
+      end
+
+      normalize_changes(results) if settings.normalize_output
+
+      results.to_json
+    end
+
+    # Create a new changelist with edits to multiple files.
+    post '/v1/changes' do
+      description = params['Description'] || 'Edited files'
+      files = params['Files']
+
+      depot_paths = files.map { |f| f['DepotFile'] }
+
+      open_p4_temp_client(depot_paths) do |p4, client_root, client_name|
+        helper = ChangeHelper.new(p4: p4,
+                                  client_root: client_root,
+                                  client_name: client_name,
+                                  description: description,
+                                  files: files)
+        helper.call
+      end
+    end
+
+    # Uses describe to produce the list of opened files regardless of client.
+    #
+    # There is a little bit of an open question regarding performance. The
+    # p4ruby usage here does *not* generate diffs of changes, which the base
+    # command line seems to want to do. If the output accumulates a lot of RAM
+    # for large diffs, we could be in trouble.
+    get '/v1/changes/:change' do |change|
+      results = nil
+
+      open_p4 do |p4|
+        results = p4.run_describe('-S', change)
+      end
+
+      normalize_describe(results) if settings.normalize_output
+
+      results.to_json
+    end
+  end
+end

data/lib/p4_web_api/app/commands.rb

@@ -0,0 +1,58 @@
+require 'sinatra/base'
+
+module P4WebAPI
+  # Methods for executing generic Perforce commands.
+  #
+  # These do not actually map to any particular 'resource', but are just a
+  # bucket for random things you can try out.
+  #
+  # thj: I would prefer to remove these methods, and replace them with
+  # 'resources' we would define for people.
+  class App < Sinatra::Base
+    get '/v1/commands/:cmd' do |cmd|
+      args = params.select { |k, _| k.start_with?('arg') }.map { |_, v| v }
+
+      if settings.run_get_blacklist.include?(cmd)
+        halt 403, { MessageCode: 15_360,
+                    MessageText: "#{cmd} not allowed in web api",
+                    MessageSeverity: :ERROR }.to_json
+      end
+
+      results = nil
+      messages = nil
+
+      open_p4 do |p4|
+        results = p4.run(cmd, *args)
+        messages = p4.messages
+      end
+
+      if messages && messages.length > 0
+        messages.map { |m| to_msg(m) }.to_json
+      elsif results
+        results.to_json
+      end
+    end
+
+    post '/v1/commands/:cmd' do |cmd|
+      args = params.select { |key, _| key.start_with?('arg') }.map { |_, x| x }
+
+      # Uses the same blacklist as GET which generally makes sense, since we'll
+      # only really be concerned about client workspace usage on this server.
+      if settings.run_get_blacklist.include?(cmd)
+        halt 403, { MessageCode: 15_360,
+                    MessageText: "#{cmd} not allowed in web api",
+                    MessageSeverity: :ERROR }.to_json
+      end
+
+      messages = nil
+
+      open_p4 do |p4|
+        p4.input = filter_params(params)
+        p4.run(cmd, args)
+        messages = p4.messages
+      end
+
+      messages.map { |m| to_msg(m) }.to_json if messages
+    end
+  end
+end

data/lib/p4_web_api/app/files.rb

@@ -0,0 +1,166 @@
+require 'base64'
+require 'p4_web_api/change_helper'
+require 'p4_web_api/p4_util'
+require 'sinatra/base'
+
+module P4WebAPI
+  # Add 'file' methods
+  #
+  # 'files' are actually a combination of path metadata. There are three
+  # major kinds of file resources: depots, dirs, and files. The true file
+  # resources can be a combination of details, along with the file content.
+  class App < Sinatra::Base
+    # Special depots only variant to match no path
+    get '/v1/files' do
+      results = nil
+
+      open_p4 do |p4|
+        results = p4.run_depots
+      end
+
+      normalize_depots(results) if settings.normalize_output
+
+      results.to_json
+    end
+
+    # General browsing variation.
+    #
+    # Since we want this to be able to fetch file content in the case you
+    # specify a file, versus a directory listing, we actually execute the
+    # 'p4 files' command on the file. If we get a single result back, we then
+    # add the base64'd content. If the file does not exist, we treat it like
+    # a directory request. Thus, you'll never really get a 404, just an empty
+    # array.
+    get '/v1/files/*' do
+      dirs = params[:splat].select { |x| !x.empty? }
+
+      results = nil
+
+      open_p4 do |p4|
+        if dirs.empty?
+          results = p4.run_depots
+          normalize_depots(results) if settings.normalize_output
+        else
+          file_selector = '//' + dirs.join('/')
+          files_results = nil
+          p4.at_exception_level(P4::RAISE_NONE) do
+            files_results = p4.run_files(file_selector)
+          end
+          files_results = [] unless files_results
+
+          if files_results.length == 1 &&
+             files_results.first.key?('depotFile') &&
+             files_results.first['depotFile'] == file_selector
+            # Treat request like a single file GET
+            normalize_files(files_results) if settings.normalize_output
+            results = files_results[0]
+
+            print_results = p4.run_print(file_selector)
+
+            results['Content'] = Base64.encode64(print_results[1])
+
+          else
+
+            # Treat request like a directory list
+            selector = '//' + dirs.join('/') + '/*'
+
+            files_results = p4.run_files('-e', selector)
+            normalize_files(files_results) if settings.normalize_output
+
+            dirs_results = p4.run_dirs(selector)
+            normalize_dirs(dirs_results) if settings.normalize_output
+
+            results = files_results + dirs_results
+          end
+        end
+      end
+
+      results.to_json
+    end
+
+    # File upload mechanism
+    #
+    # This allows for multi-file patching based on particular directory level.
+    # Because sinatra doesn't really support JSON array bodies, this must be
+    # specified via a 'Files' parameter. If that parameter exists, we consider
+    # this to be a directory upload.
+    #
+    # If this is a directory upload, we expect the following parameters on each
+    # array object:
+    #
+    # - 'Content' - The base64 content
+    # - 'DepotFile' - the *relative* path from the main splat
+    #
+    # Otherwise, we mostly just care about the 'Content'
+    # fields for single file uploads.
+    #
+    # In both cases, a 'Description' field can be used to indicate a release
+    # message.
+    patch '/v1/files/*' do
+      path_parts = params[:splat].select { |x| !x.empty? }
+      description = params['Description'] || 'Uploaded files'
+      is_dir = params.key?('Files')
+
+      files = nil
+      if is_dir
+        # TODO: 'clean' the directory path, avoiding refs like '...'
+        dir_root = "//#{path_parts.join('/')}"
+
+        files = params['Files'].map do |f|
+          {
+            'DepotFile' => "#{dir_root}/#{f['DepotFile']}",
+            'Content' => f['Content']
+          }
+        end
+      else
+        # TODO: 'sanitize' this file path
+        files = [
+          {
+            'DepotFile' => "//#{path_parts.join('/')}",
+            'Content' => params[:Content]
+          }
+        ]
+      end
+      files.each { |f| f['Action'] = 'upload' }
+
+      depot_paths = files.map { |f| f['DepotFile'] }
+
+      open_p4_temp_client(depot_paths) do |p4, client_root, client_name|
+        helper = ChangeHelper.new(p4: p4,
+                                  client_root: client_root,
+                                  client_name: client_name,
+                                  description: description,
+                                  files: files)
+        helper.call
+      end
+
+      ''
+    end
+
+    # Delete a single file.
+    delete '/v1/files/*' do
+      description = params['Description'] || 'Deleting file'
+      path_parts = params[:splat].select { |x| !x.empty? }
+
+      # TODO: 'sanitize' this file path?
+      file_path = "//#{path_parts.join('/')}"
+
+      open_p4_temp_client([file_path]) do |p4|
+        change_id = P4Util.init_changelist(p4, description)
+        begin
+          p4.run_delete('-c', change_id, file_path)
+          p4.run_submit('-c', change_id)
+        rescue StandardError => ex
+          p4.at_exeception_level(P4::RAISE_NONE) do
+            p4.run_change('-d', '-f', change_id)
+            if P4Util.error?(p4)
+              puts "possible issues deleting change #{change_id}: " \
+                     "#{p4.messages}"
+            end
+          end
+          raise ex
+        end
+      end
+    end
+  end
+end

data/lib/p4_web_api/app/protections.rb

@@ -0,0 +1,33 @@
+module P4WebAPI
+  # Methods to manipulate protections table.
+  #
+  # The 'protections' resource in our system is the complete list, so you don't
+  # fetch or manipulate any single 'protection'. It's all or nothing.
+  class App < Sinatra::Base
+    # Just list all protections
+    get '/v1/protections' do
+      protects = nil
+      open_p4 do |p4|
+        protects = p4.run_protect('-o').first
+      end
+
+      normalize_protections(results) if settings.normalize_output
+
+      protects.to_json
+    end
+
+    # Update protections
+    put '/v1/protections' do
+      protects = {
+        'Protections' => params['Protections']
+      }
+
+      open_p4 do |p4|
+        p4.input = protects
+        p4.run_protect('-i')
+      end
+
+      ''
+    end
+  end
+end

data/lib/p4_web_api/app/sessions.rb

@@ -0,0 +1,45 @@
+require 'p4_web_api/auth'
+
+module P4WebAPI
+  # Authentication methods
+  # See also: https://confluence.perforce.com:8443/display/WS/Authentication+in+Web+Services
+  class App < Sinatra::Base
+    # Creates a sign-in session for the user.
+    #
+    # This session returns a token that should be used as the password in basic
+    # authentication for the user later.
+    post '/v1/sessions' do
+      user = params[:user]
+      password = params[:password] # may be a p4 ticket
+
+      token = nil
+
+      options = {
+        user: user,
+        password: password,
+        host: settings.p4['host'],
+        port: settings.p4['port']
+      }
+      options[:charset] = settings.p4['charset'] if settings.p4.key?('charset')
+
+      P4Util.open(options) do |p4|
+        token = Auth.create_session(p4, password, settings)
+      end
+
+      # We signal a 401 when login/passwords are generally invalid. Since this
+      # is an unauthenticated request, you shouldn't be able to tell if the
+      # login doesn't exist or the password is incorrect.
+      halt 401 unless token
+
+      content_type 'text/plain'
+      return token
+    end
+
+    # I'm not sure if we should ensure the token being deleted is the token
+    # being authenticated against. That's not being checked for the time being.
+    delete '/v1/sessions/:token' do |token|
+      P4WebAPI::Auth.delete_session(token, settings)
+      ''
+    end
+  end
+end

data/lib/p4_web_api/app/specs.rb

@@ -0,0 +1,114 @@
+module P4WebAPI
+  # Generic CRUD behavior for most of our spec types.
+  class App < Sinatra::Base
+    set(:is_spec) do |_x|
+      condition do
+        path_info = env['PATH_INFO']
+
+        matches = %r{^/v1/(?<spec_type>\w+)}.match(path_info)
+        if matches
+          spec_type = matches[:spec_type]
+          return (spec_type == 'branches' ||
+            spec_type == 'clients' ||
+            spec_type == 'depots' ||
+            spec_type == 'groups' ||
+            spec_type == 'jobs' ||
+            spec_type == 'labels' ||
+            spec_type == 'servers'
+          )
+        end
+        false
+      end
+    end
+
+    # Provide a generic collection accessor for each of the specs.
+    get '/v1/:spec_type', is_spec: true do |spec_type|
+      results = nil
+
+      open_p4 do |p4|
+        results = p4.run(spec_type)
+      end
+
+      send("normalize_#{spec_type}", results) if settings.normalize_output
+      P4Util.collate_group_results(results) if settings.normalize_output &&
+                                               spec_type == 'groups'
+
+      results.to_json
+    end
+
+    # Provide a generic output accessor for each spec
+    get '/v1/:spec_type/:id', is_spec: true do |spec_type, id|
+      results = nil
+
+      open_p4 do |p4|
+        results = p4.run(P4Util.singular(spec_type), '-o', id)
+      end
+
+      send("normalize_#{spec_type}", results) if settings.normalize_output
+
+      results[0].to_json
+    end
+
+    # This is our generic "add" mechanism for each type.
+    #
+    # It's assumed that the client understands the requirements of each spec
+    # type.
+    post '/v1/:spec_type', is_spec: true do |spec_type|
+      results = nil
+
+      open_p4 do |p4|
+        method_name = "save_#{P4Util.singular(spec_type)}".to_sym
+        results = p4.send(method_name, params)
+      end
+
+      # In general, the params use the name of the spec as a capitalized
+      # parameter in the singular form.
+      if spec_type == 'servers'
+        id_prop = 'ServerID'
+      else
+        id_prop = P4Util.singular(spec_type).capitalize
+      end
+      id = nil
+      if results.is_a?(Array) &&
+         results.length > 0 &&
+         /Job .* saved/.match(results[0])
+        # special "Job" variant to grab the ID out of the results output
+        id = /Job (.*) saved/.match(results[0])[1]
+      elsif params.key?(id_prop)
+        id = params[id_prop]
+      elsif params.key?(id_prop.to_sym)
+        id = params[id_prop.to_sym]
+      end
+
+      if id
+        redirect "/v1/#{spec_type}/#{id}"
+      else
+        halt 400, "Did not locate #{id_prop} in params"
+      end
+    end
+
+    # An 'update' mechanism for each spec type.
+    patch '/v1/:spec_type/:id', is_spec: true do |spec_type, id|
+      open_p4 do |p4|
+        singular = P4Util.singular(spec_type)
+        spec = p4.run(singular, '-o', id)[0]
+
+        spec = spec.merge(filter_params(params))
+
+        method_name = "save_#{singular}".to_sym
+        p4.send(method_name, spec)
+      end
+
+      ''
+    end
+
+    delete '/v1/:spec_type/:id', is_spec: true do |spec_type, id|
+      open_p4 do |p4|
+        method_name = "delete_#{P4Util.singular(spec_type)}".to_sym
+        p4.send(method_name, id)
+      end
+
+      ''
+    end
+  end
+end