p4_web_api 2014.2.0.pre2 → 2014.2.0.pre4

data/lib/p4_web_api/app/streams.rb

@@ -0,0 +1,76 @@
+module P4WebAPI
+  # 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).
+  class App < Sinatra::Base
+    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
+
+    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
+
+    patch '/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
+  end
+end

data/lib/p4_web_api/app/triggers.rb

@@ -0,0 +1,31 @@
+module P4WebAPI
+  # Add methods for triggers resources.
+  #
+  # Like protections, there is no singular 'trigger' resource in the Perforce
+  # system, just the list of all of them.
+  class App < Sinatra::Base
+    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
+
+    put '/v1/triggers' do
+      triggers = {
+        'Triggers' => params['Triggers']
+      }
+
+      open_p4 do |p4|
+        p4.input = triggers
+        p4.run_triggers('-i')
+      end
+
+      ''
+    end
+  end
+end

data/lib/p4_web_api/app/users.rb

@@ -0,0 +1,78 @@
+module P4WebAPI
+  # Methods for user resources.
+  #
+  # Users are a little different from standard specs, since deleting users
+  # can require removing session data, etc.
+  class App < Sinatra::Base
+    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
+
+    post '/v1/users' do
+      open_p4 do |p4|
+        p4.save_user(params, '-f')
+      end
+
+      user = params['User']
+
+      redirect "/v1/users/#{user}"
+    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
+
+    patch '/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 '/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
+  end
+end

data/lib/p4_web_api/auth.rb

@@ -134,7 +134,7 @@ module P4WebAPI
     # Takes an array with [login, password], and returns true if the password
     # is a legal token for that login, or looks like a p4 ticket.
     def self.credentials_valid?(credentials, settings)
-      login = credentials.first
+      user = credentials.first
       password = credentials.last
       # Can't really determine much at this point, just return true. If we're
       # a token, it's a UUID and we'll learn more about that later.
@@ -142,7 +142,7 @@ module P4WebAPI
 
       user_info = read_token(password, settings)
       if user_info
-        return user_info['login'] == login
+        return user_info['user'] == user
       else
         false
       end
@@ -258,7 +258,7 @@ module P4WebAPI
 
     def self.user_info(p4, results, ticket)
       {
-        login: p4.user,
+        user: p4.user,
         email: results[0]['Email'],
         full_name: results[0]['FullName'],
         ticket: ticket

data/lib/p4_web_api/change_helper.rb

@@ -0,0 +1,149 @@
+require 'base64'
+
+module P4WebAPI
+  # This class assists in creating changelists based on an array of file
+  # changes, some of which may be file uploads.
+  #
+  # This is the implementation for file uploads and change creation.
+  class ChangeHelper
+    # The P4 connection we're using, that should already be logged in for a
+    # particular user.
+    attr_reader :p4
+
+    # The name of the temporary client
+    attr_reader :client_name
+
+    # The root directory of the temporary client
+    attr_reader :client_root
+
+    # Array of ChangeHelper::File instances.
+    attr_reader :files
+
+    # The change description
+    attr_reader :description
+
+    def initialize(p4: nil, client_name: nil, client_root: nil, files: [],
+                   description: 'Updating files')
+      @p4 = p4
+      @client_name = client_name
+      @client_root = client_root
+      @files = files.map { |f| ChangeHelper::File.new(f) }
+      @description = description
+    end
+
+    def call
+      change_id = P4Util.init_changelist(p4, description)
+
+      begin
+        collect_file_results
+
+        files.each { |f| f.call(p4, change_id, client_root) }
+
+        p4.run_submit('-c', change_id)
+
+      rescue StandardError => ex
+        # Delete the changelist
+        p4.at_exception_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
+
+    # Handles tracking 'file modification' operations on a single file for a
+    # change.
+    #
+    # One important aspect of initializing these files is assigning a 'files'
+    # result. The ChangeHelper pretty much grabs the output of 'p4 files' for
+    # all file changes, which lets us know if a file exists or not in the
+    # system, which changes downstream behavior during an upload process.
+    #
+    # Note that this will use our 'normalized' data style, where cases
+    class File
+      attr_accessor :depot_file
+
+      attr_accessor :action
+
+      # This should be a base64-encoded string
+      attr_accessor :content_base64
+
+      # For *some* actions, like a move, we need this indicated by the user.
+      attr_accessor :from_depot_file
+
+      # The output of p4 files on this depot_file path, if it exists.
+      attr_accessor :file_result
+
+      # Notice how the file *must* be specified using our 'external normalized'
+      # data style.
+      def initialize(obj = {})
+        @depot_file = obj['DepotFile'] if obj.key?('DepotFile')
+        @action = obj['Action'] if obj.key?('Action')
+        @from_depot_file = obj['FromDepotFile'] if obj.key?('FromDepotFile')
+        @content_base64 = obj['Content'] if obj.key?('Content')
+      end
+
+      def exists?
+        !file_result.nil?
+      end
+
+      #
+      # This really should only be called by ChangeHelper::call to do work
+      # once we have associated any file_result and from_file properties.
+      def call(p4, change_id, client_root)
+        case action
+        when 'upload'
+          upload_file(p4, change_id, client_root)
+        when 'branch'
+          integrate_file(p4, change_id)
+        when 'move'
+          move_file(p4, change_id)
+        end
+      end
+
+      def upload_file(p4, change_id, client_root)
+        if exists?
+          P4Util.mark_change('edit', p4, change_id, client_root, depot_file)
+          P4Util.save_content(client_root, depot_file, content)
+        else
+          P4Util.save_content(client_root, depot_file, content)
+          P4Util.mark_change('add', p4, change_id, client_root, depot_file)
+        end
+      end
+
+      def integrate_file(p4, change_id)
+        p4.run_integrate('-c', change_id, from_depot_file, depot_file)
+      end
+
+      def move_file(p4, change_id)
+        p4.run_move('-c', change_id, from_depot_file, depot_file)
+      end
+
+      def content
+        Base64.decode64(content_base64)
+      end
+    end
+
+    private
+
+    # Runs p4 files on all our depot paths, then updates each file model
+    # that exists.
+    def collect_file_results
+      file_results = p4.run_files(depot_files)
+      file_results.each do |file_result|
+        file = file_for_depot_file(file_result['depotFile'])
+        file.file_result = file_result if file
+      end
+    end
+
+    def depot_files
+      files.map(&:depot_file)
+    end
+
+    def file_for_depot_file(depot_file)
+      files.find { |f| f.depot_file == depot_file }
+    end
+  end
+end

data/lib/p4_web_api/helpers.rb

@@ -0,0 +1,84 @@
+require 'p4_web_api/p4_util'
+
+module P4WebAPI
+  # Defines Sinatra helper methods in the main application.
+  module Helpers
+    # 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
+
+    private
+
+    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
+  end
+end