p4_web_api 2014.2.0.pre2 → 2014.2.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 069a887b3fabfbb41e4014f0351e9ad79e699ee9
-  data.tar.gz: 6fc582c57a30740878523f1265eade7bd6d24749
+  metadata.gz: 7928b3bca740696b9fb622b838ad6dfa0eb06857
+  data.tar.gz: abca39306fb28d24b7c986f19d11dcf041973904
 SHA512:
-  metadata.gz: a055d9ca2f41db3f61c9f8d3969d8b5ef506759671437d157eec182af6eb8ff18ff0567704203b4c4755b2deff87806cc2867ac98e0f161de93c52245f3c24e2
-  data.tar.gz: fa442bde271cf8387ac423ae2ba3fc9b8a88d38bd396478998990a8c1c74fb14f37065700acdf0e2276a89562143a25705038a8a85ba95bae5813de9382595da
+  metadata.gz: 4f8f49dec8c3fcb072354ae86c4ce6e3f5ea46ece96c4a5052e8a24a7cf43499332374149dd8792302c5152026d2d908f20bac6ce4e1306025342a78c3207c21
+  data.tar.gz: b1f84f8cc8e6c1d192b769ca9066d415571349d3f182b49c492605e5c58b3b37511f9e5565dfb8ee584105014d3d1f0f30cdd73a65048b16e84ec4c46bdd6b36

data/bin/p4_web_api

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
-lib_path = File.expand_path('../../lib/p4_web_api.rb', __FILE__)
-require lib_path
+
+ENV['RACK_ENV'] = 'production' unless ENV.key?('RACK_ENV')
+
+lib_dir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib_dir)
+
+require 'p4_web_api'
+
 P4WebAPI::App.run!

data/lib/p4_web_api.rb

@@ -18,9 +18,10 @@ require 'sinatra/json'
 require 'sinatra/config_file'
 require 'rack/parser'
 
-require 'p4_web_api/version'
 require 'p4_web_api/auth'
+require 'p4_web_api/helpers'
 require 'p4_web_api/p4_util'
+require 'p4_web_api/version'
 
 # The P4WebAPI is our namespace for the web application.
 #
@@ -95,84 +96,6 @@ module P4WebAPI
 
     P4WebAPI::Auth.validate_token_dir(settings.token_path)
 
-    helpers do
-      # A block helper that uses the authentication credentials to create the p4
-      # connection
-      def open_p4(&block)
-        options = {
-          user: env['AUTH_CREDENTIALS'].first,
-          password: P4Util.resolve_password(env, settings),
-          host: P4Util.resolve_host(env, settings),
-          port: P4Util.resolve_port(env, settings)
-        }
-
-        charset = P4Util.resolve_charset(env, settings)
-        options[:charset] = charset if charset
-
-        P4Util.open(options, &block)
-      end
-
-      # Block helper to open a p4 handle with a temporary client workspace.
-      # The client workspace will map the series of depot path expressions
-      # directly into the client workspace.
-      #
-      # The depot_paths are generally expected to be complete file path
-      # expressions, e.g., '//depot/dir1/dir2/file'. They'll be mapped directly
-      # to the temporary working area: '//client/depot/dir/1/dir2/file'
-      #
-      # The block handler here will be called with the arguments (p4, root),
-      # where root is the temporary client's root directory.
-      def open_p4_temp_client(depot_paths, &block)
-        open_p4 do |p4|
-          name = (0...8).map { (65 + rand(26)).chr }.join
-          dir = init_temp_workspace_dir(name)
-          init_temp_client(p4, name, dir, depot_paths)
-
-          ex = nil
-          begin
-            block.call(p4, dir)
-          rescue StandardError => e
-            ex = e
-          end
-
-          delete_temp_client(p4, name, dir)
-
-          fail ex unless ex.nil?
-        end
-      end
-    end
-
-    def init_temp_workspace_dir(name)
-      dir = File.join(settings.workspace_folder, name)
-      unless Dir.exist?(dir)
-        FileUtils.mkpath(dir)
-        FileUtils.chmod(0700, dir)
-      end
-      dir
-    end
-
-    def init_temp_client(p4, name, dir, depot_paths)
-      spec = p4.fetch_client
-      spec._root = dir
-      spec._client = name
-      spec._description = 'p4_web_api temp client'
-
-      spec._view = depot_paths.map do |path|
-        stripped = path.gsub(/^[\/]*/, '')
-        "\"//#{stripped}\" \"//#{name}/#{stripped}\""
-      end
-
-      p4.save_client(spec)
-      p4.client = name
-
-      p4.run_sync('//...')
-    end
-
-    def delete_temp_client(p4, name, dir)
-      p4.run_client('-d', '-f', name)
-      FileUtils.rmtree(dir)
-    end
-
     error do
       err = env['sinatra.error']
 
@@ -201,6 +124,16 @@ module P4WebAPI
       fail err
     end
 
+    not_found do
+      return {
+        # This is not an application error, so I'm using error code 0 to mean
+        # 'use HTTP status'
+        MessageCode: 0,
+        MessageSeverity: 3,
+        MessageText: 'Resource not found'
+      }.to_json
+    end
+
     def to_msg(message)
       {
         MessageCode: message.msgid,
@@ -209,6 +142,8 @@ module P4WebAPI
       }
     end
 
+    helpers Helpers
+
     # Will fetch the system offset based on the server date.
     #
     # If allow_env_p4_config is true, we don't cache. Each request could come
@@ -249,597 +184,6 @@ module P4WebAPI
       self.class.normalizers[spec_type].call(*args)
     end
 
-    # Authentication methods
-    # See also: https://confluence.perforce.com:8443/display/WS/Authentication+in+Web+Services
-
-    # 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
-      login = params[:login]
-      password = params[:password] # may be a p4 ticket
-
-      token = nil
-
-      options = {
-        user: login,
-        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
-
-    # Generic 'do a perforce command' methods.
-    #
-    # These do not ensure true REST-ful style behavior, but are really just
-    # "hey use HTTP to interact with Perforce".
-
-    get '/v1/run' do
-
-      cmd = params[:cmd]
-
-      args = params.select { |key, _| key.start_with?('arg') }
-             .map { |_, value| value }
-
-      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/run' do
-      cmd = params[:cmd]
-
-      args = params.select { |key, _| key.start_with?('arg') }
-             .map { |_, value| value }
-
-      # 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
-
-    # Convenience method to the 'run' mechanism for typical browsing purposes.
-    #
-    # Unlike just standard run commands, this will select either the 'depots' or
-    # 'files' and 'dirs' commands for a single directory level at a time.
-
-    # Special depots only variant
-    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.
-    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
-          selector = '//' + dirs.join('/') + '/*'
-          files_results = p4.run_files(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
-
-      results.to_json
-    end
-
-    # Convenience method to list changelist metadata with some common filtering
-    # options.
-    #
-    # parameters:
-    # - `max` = number
-    # - `status` = pending|submitted|shelved
-    # - `user` = [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
-
-    # Methods to manipulate the protections table. This blindly assumes you
-    # indeed have superuser privileges.
-
-    # 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
-
-    # Methods to adjust the triggers table.
-
-    get '/v1/triggers' do
-      triggers = nil
-      open_p4 do |p4|
-        triggers = p4.run_triggers('-o').first
-      end
-
-      normalize_triggers(results) if settings.normalize_output
-
-      triggers.to_json
-    end
-
-    # Update protections
-    put '/v1/triggers' do
-      triggers = {
-        'Triggers' => params['Triggers']
-      }
-
-      open_p4 do |p4|
-        p4.input = triggers
-        p4.run_triggers('-i')
-      end
-
-      ''
-    end
-
-    # Generate CRUD methods for each 'spec' type
-    #
-
-    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' ||
-              # No protects here: the usage is pretty different from the other
-              # spec mechanisms
-              spec_type == 'servers'
-          # No streams, triggers, or users here: it does not work like other
-          # specs, so these method implementations don't quite work.
-          )
-        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.
-    put '/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
-
-    # List all users registered in the server
-    get '/v1/users' do
-      results = nil
-
-      open_p4 do |p4|
-        results = p4.run_users
-      end
-
-      normalize_users(results) if settings.normalize_output
-
-      results.to_json
-    end
-
-    # Create a new user
-    post '/v1/users' do
-      open_p4 do |p4|
-        p4.save_user(params, '-f')
-      end
-
-      login = params['User']
-
-      redirect "/v1/users/#{login}"
-    end
-
-    get '/v1/users/:user' do |user|
-      results = nil
-
-      open_p4 do |p4|
-        results = p4.run_user('-o', user)
-      end
-
-      normalize_users(results) if settings.normalize_output
-
-      if results.empty?
-        halt 404
-      else
-        results[0].to_json
-      end
-    end
-
-    # 'Update' the user.
-    put '/v1/users/:user' do |user|
-      open_p4 do |p4|
-        results = p4.run_user('-o', user)
-
-        if results.empty?
-          halt 404
-          return
-        end
-
-        spec = results[0]
-        spec = spec.merge(filter_params(params))
-
-        spec['User'] = user unless spec.key?('User')
-
-        p4.save_user(spec, '-f')
-      end
-
-      # Avoid 'user jdoe saved' message from going out
-      ''
-    end
-
-    # Delete the user.
-    delete '/v1/users/:user' do |user|
-      open_p4 do |p4|
-        p4.run_user('-f', '-d', user)
-      end
-
-      # If you're deleting yourself (ragequitting via API) remove thy session
-      if user == env['AUTH_CREDENTIALS'].first
-        token = env['AUTH_CREDENTIALS'].last
-        P4WebAPI::Auth.delete_session(token, settings)
-      end
-    end
-
-    # Stream manipulation
-    #
-    # Streams are a little different from other spec types, in that the singluar
-    # 'stream' is identified by a depot-style path, as opposed to kind of a
-    # name. (And since our paths start with two slashes, we ignore those).
-
-    get '/v1/streams' do
-      streams = nil
-
-      open_p4 do |p4|
-        streams = p4.run_streams
-      end
-
-      normalize_streams(streams) if settings.normalize_output
-
-      streams.to_json
-    end
-
-    # Creates a new stream
-    post '/v1/streams' do
-      open_p4 do |p4|
-        p4.save_stream(filter_params(params))
-      end
-
-      stream = params['Stream']
-
-      sub_path = stream[2..-1]
-
-      redirect "/v1/streams/#{sub_path}"
-    end
-
-    get '/v1/streams/*' do
-      sub_path = params[:splat].join('')
-
-      stream = "//#{sub_path}"
-
-      results = nil
-
-      open_p4 do |p4|
-        results = p4.run_stream('-o', stream)
-      end
-
-      normalize_streams(results) if settings.normalize_output
-
-      results[0].to_json
-    end
-
-    put '/v1/streams/*' do
-      sub_path = params[:splat].join('')
-
-      stream = "//#{sub_path}"
-
-      open_p4 do |p4|
-        spec = p4.run_stream('-o', stream)[0]
-
-        spec = spec.merge(filter_params(params))
-
-        p4.save_stream(spec, '-f')
-      end
-
-      ''
-    end
-
-    delete '/v1/streams/*' do
-      sub_path = params[:splat].join('')
-
-      stream = "//#{sub_path}"
-
-      open_p4 do |p4|
-        p4.run_stream('-d', stream)
-      end
-
-      ''
-    end
-
-    # The print method uses the print command underneath to output file content.
-    #
-    # Unlike most of the other methods, this does not output application/json.
-    # If the type contains 'text' we set the Content-Type to 'text/plain',
-    # otherwise it's 'application/octet-stream'.
-    get '/v1/print/*' do
-      path = params[:splat].join('')
-      path = "//#{path}"
-
-      results = nil
-      open_p4 do |p4|
-        results = p4.run_print(path)
-      end
-
-      file_type = results[0]
-      content = results[1]
-
-      if file_type['type'] =~ /text/
-        content_type 'text/plain'
-      else
-        content_type 'application/octet-stream'
-      end
-
-      content
-    end
-
-    # The upload method adds new file revisions.
-    #
-    # This is a multipart method that accepts and array of files, plus,
-    # a 'mappings' array to indicate the target depot path for each file.
-    # This should be a JSON encoded array of strings.
-    #
-    # An optional 'description' attribute can describe the changes to be made.
-    post '/v1/upload' do
-      # if mappings[] and files[] do not have equivalent lengths, the error
-      # might be kind of lame.
-      mappings = params[:mappings]
-      files = []
-      mappings.each_index { |idx| files << params["file_#{idx}".to_sym] }
-
-      open_p4_temp_client(mappings) do |p4, root|
-        message = params[:description] || 'Uploaded files'
-        change_id = init_changelist(p4, message)
-
-        # Information used to determine if the new rev should be an add or edit
-        files_results = p4.run_files(mappings)
-
-        (0...mappings.length).each do |idx|
-          type = existing_path?(files_results, mappings[idx]) ? 'edit' : 'add'
-
-          if type == 'edit'
-            mark_change('edit', p4, change_id, root, mappings[idx])
-            save_content(root, mappings[idx], files[idx])
-          else
-            save_content(root, mappings[idx], files[idx])
-            mark_change('add', p4, change_id, root, mappings[idx])
-          end
-        end
-
-        p4.run_submit('-c', change_id)
-      end
-    end
-
-    def init_changelist(p4, description)
-      change_spec = p4.fetch_change
-      change_spec._description = description
-      results = p4.save_change(change_spec)
-      results[0].gsub(/^Change (\d+) created./, '\1')
-    end
-
-    def save_content(root, depot_path, file)
-      local_file = local_path(depot_path, root)
-      dir = File.dirname(local_file)
-      FileUtils.mkpath(dir) unless Dir.exist?(dir)
-
-      IO.write(local_file, file[:tempfile].read)
-    end
-
-    def existing_path?(existing_results, depot_path)
-      existing_results.any? do |result|
-        result['depotFile'] == depot_path
-      end
-    end
-
-    def mark_change(type, p4, change_id, root, depot_path)
-      local_file = local_path(depot_path, root)
-      p4.run(type, '-c', change_id, local_file)
-    end
-
-    def local_path(depot_path, root)
-      stripped = depot_path.gsub(/^\/+/, '')
-      File.join(root, stripped)
-    end
-
     # Basically a "blacklist" of things we know the frameworks going to add to
     # the params array we don't want to pass on to the p4 command sets for spec
     # input
@@ -852,3 +196,16 @@ module P4WebAPI
     run! if app_file == $PROGRAM_NAME
   end
 end
+
+# Reopen up the P4WebAPI::App class and add most of our method handling. This
+# is done in lieu of having multiple Sinatra apps, so we can have the same
+# configuration and error handling.
+require 'p4_web_api/app/changes'
+require 'p4_web_api/app/commands'
+require 'p4_web_api/app/files'
+require 'p4_web_api/app/protections'
+require 'p4_web_api/app/sessions'
+require 'p4_web_api/app/specs'
+require 'p4_web_api/app/streams'
+require 'p4_web_api/app/triggers'
+require 'p4_web_api/app/users'