openvox 8.19.0

data/lib/puppet/ffi/windows/structs.rb

@@ -0,0 +1,339 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative '../../../puppet/ffi/windows'
+
+module Puppet::FFI::Windows
+  module Structs
+    extend FFI::Library
+    extend Puppet::FFI::Windows::APITypes
+
+    # https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/aa379560(v=vs.85)
+    # typedef struct _SECURITY_ATTRIBUTES {
+    #   DWORD  nLength;
+    #   LPVOID lpSecurityDescriptor;
+    #   BOOL   bInheritHandle;
+    # } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
+    class SECURITY_ATTRIBUTES < FFI::Struct
+      layout(
+        :nLength, :dword,
+        :lpSecurityDescriptor, :lpvoid,
+        :bInheritHandle, :win32_bool
+      )
+    end
+
+    private_constant :SECURITY_ATTRIBUTES
+
+    # sizeof(STARTUPINFO) == 68
+    # https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoa
+    # typedef struct _STARTUPINFOA {
+    #   DWORD  cb;
+    #   LPSTR  lpReserved;
+    #   LPSTR  lpDesktop;
+    #   LPSTR  lpTitle;
+    #   DWORD  dwX;
+    #   DWORD  dwY;
+    #   DWORD  dwXSize;
+    #   DWORD  dwYSize;
+    #   DWORD  dwXCountChars;
+    #   DWORD  dwYCountChars;
+    #   DWORD  dwFillAttribute;
+    #   DWORD  dwFlags;
+    #   WORD   wShowWindow;
+    #   WORD   cbReserved2;
+    #   LPBYTE lpReserved2;
+    #   HANDLE hStdInput;
+    #   HANDLE hStdOutput;
+    #   HANDLE hStdError;
+    # } STARTUPINFOA, *LPSTARTUPINFOA;
+    class STARTUPINFO < FFI::Struct
+      layout(
+        :cb, :dword,
+        :lpReserved, :lpcstr,
+        :lpDesktop, :lpcstr,
+        :lpTitle, :lpcstr,
+        :dwX, :dword,
+        :dwY, :dword,
+        :dwXSize, :dword,
+        :dwYSize, :dword,
+        :dwXCountChars, :dword,
+        :dwYCountChars, :dword,
+        :dwFillAttribute, :dword,
+        :dwFlags, :dword,
+        :wShowWindow, :word,
+        :cbReserved2, :word,
+        :lpReserved2, :pointer,
+        :hStdInput, :handle,
+        :hStdOutput, :handle,
+        :hStdError, :handle
+      )
+    end
+
+    private_constant :STARTUPINFO
+
+    # https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-process_information
+    # typedef struct _PROCESS_INFORMATION {
+    #   HANDLE hProcess;
+    #   HANDLE hThread;
+    #   DWORD  dwProcessId;
+    #   DWORD  dwThreadId;
+    # } PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
+    class PROCESS_INFORMATION < FFI::Struct
+      layout(
+        :hProcess, :handle,
+        :hThread, :handle,
+        :dwProcessId, :dword,
+        :dwThreadId, :dword
+      )
+    end
+
+    private_constant :PROCESS_INFORMATION
+
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379261(v=vs.85).aspx
+    # typedef struct _LUID {
+    #   DWORD LowPart;
+    #   LONG  HighPart;
+    # } LUID, *PLUID;
+    class LUID < FFI::Struct
+      layout :LowPart, :dword,
+             :HighPart, :win32_long
+    end
+
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379263(v=vs.85).aspx
+    # typedef struct _LUID_AND_ATTRIBUTES {
+    #   LUID  Luid;
+    #   DWORD Attributes;
+    # } LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
+    class LUID_AND_ATTRIBUTES < FFI::Struct
+      layout :Luid, LUID,
+             :Attributes, :dword
+    end
+
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379630(v=vs.85).aspx
+    # typedef struct _TOKEN_PRIVILEGES {
+    #   DWORD               PrivilegeCount;
+    #   LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY];
+    # } TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;
+    class TOKEN_PRIVILEGES < FFI::Struct
+      layout :PrivilegeCount, :dword,
+             :Privileges, [LUID_AND_ATTRIBUTES, 1] # placeholder for offset
+    end
+
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/bb530717(v=vs.85).aspx
+    # typedef struct _TOKEN_ELEVATION {
+    #   DWORD TokenIsElevated;
+    # } TOKEN_ELEVATION, *PTOKEN_ELEVATION;
+    class TOKEN_ELEVATION < FFI::Struct
+      layout :TokenIsElevated, :dword
+    end
+
+    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_service_status_process
+    # typedef struct _SERVICE_STATUS_PROCESS {
+    #   DWORD dwServiceType;
+    #   DWORD dwCurrentState;
+    #   DWORD dwControlsAccepted;
+    #   DWORD dwWin32ExitCode;
+    #   DWORD dwServiceSpecificExitCode;
+    #   DWORD dwCheckPoint;
+    #   DWORD dwWaitHint;
+    #   DWORD dwProcessId;
+    #   DWORD dwServiceFlags;
+    # } SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS;
+    class SERVICE_STATUS_PROCESS < FFI::Struct
+      layout(
+        :dwServiceType, :dword,
+        :dwCurrentState, :dword,
+        :dwControlsAccepted, :dword,
+        :dwWin32ExitCode, :dword,
+        :dwServiceSpecificExitCode, :dword,
+        :dwCheckPoint, :dword,
+        :dwWaitHint, :dword,
+        :dwProcessId, :dword,
+        :dwServiceFlags, :dword
+      )
+    end
+
+    # https://docs.microsoft.com/en-us/windows/win32/api/winsvc/ns-winsvc-service_delayed_auto_start_info
+    # typedef struct _SERVICE_DELAYED_AUTO_START_INFO {
+    #   BOOL fDelayedAutostart;
+    # } SERVICE_DELAYED_AUTO_START_INFO, *LPSERVICE_DELAYED_AUTO_START_INFO;
+    class SERVICE_DELAYED_AUTO_START_INFO < FFI::Struct
+      layout(:fDelayedAutostart, :int)
+      alias aset []=
+      # Intercept the accessor so that we can handle either true/false or 1/0.
+      # Since there is only one member, there’s no need to check the key name.
+      def []=(key, value)
+        [0, false].include?(value) ? aset(key, 0) : aset(key, 1)
+      end
+    end
+
+    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_enum_service_status_processw
+    # typedef struct _ENUM_SERVICE_STATUS_PROCESSW {
+    #   LPWSTR                 lpServiceName;
+    #   LPWSTR                 lpDisplayName;
+    #   SERVICE_STATUS_PROCESS ServiceStatusProcess;
+    # } ENUM_SERVICE_STATUS_PROCESSW, *LPENUM_SERVICE_STATUS_PROCESSW;
+    class ENUM_SERVICE_STATUS_PROCESSW < FFI::Struct
+      layout(
+        :lpServiceName, :pointer,
+        :lpDisplayName, :pointer,
+        :ServiceStatusProcess, SERVICE_STATUS_PROCESS
+      )
+    end
+
+    # typedef struct _SERVICE_STATUS {
+    #   DWORD dwServiceType;
+    #   DWORD dwCurrentState;
+    #   DWORD dwControlsAccepted;
+    #   DWORD dwWin32ExitCode;
+    #   DWORD dwServiceSpecificExitCode;
+    #   DWORD dwCheckPoint;
+    #   DWORD dwWaitHint;
+    # } SERVICE_STATUS, *LPSERVICE_STATUS;
+    class SERVICE_STATUS < FFI::Struct
+      layout(
+        :dwServiceType, :dword,
+        :dwCurrentState, :dword,
+        :dwControlsAccepted, :dword,
+        :dwWin32ExitCode, :dword,
+        :dwServiceSpecificExitCode, :dword,
+        :dwCheckPoint, :dword,
+        :dwWaitHint, :dword
+      )
+    end
+
+    # typedef struct _QUERY_SERVICE_CONFIGW {
+    #   DWORD  dwServiceType;
+    #   DWORD  dwStartType;
+    #   DWORD  dwErrorControl;
+    #   LPWSTR lpBinaryPathName;
+    #   LPWSTR lpLoadOrderGroup;
+    #   DWORD  dwTagId;
+    #   LPWSTR lpDependencies;
+    #   LPWSTR lpServiceStartName;
+    #   LPWSTR lpDisplayName;
+    # } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
+    class QUERY_SERVICE_CONFIGW < FFI::Struct
+      layout(
+        :dwServiceType, :dword,
+        :dwStartType, :dword,
+        :dwErrorControl, :dword,
+        :lpBinaryPathName, :pointer,
+        :lpLoadOrderGroup, :pointer,
+        :dwTagId, :dword,
+        :lpDependencies, :pointer,
+        :lpServiceStartName, :pointer,
+        :lpDisplayName, :pointer
+      )
+    end
+
+    # typedef struct _SERVICE_TABLE_ENTRYW {
+    #   LPWSTR                   lpServiceName;
+    #   LPSERVICE_MAIN_FUNCTIONW lpServiceProc;
+    # } SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
+    class SERVICE_TABLE_ENTRYW < FFI::Struct
+      layout(
+        :lpServiceName, :pointer,
+        :lpServiceProc, :pointer
+      )
+    end
+
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724834%28v=vs.85%29.aspx
+    # typedef struct _OSVERSIONINFO {
+    #   DWORD dwOSVersionInfoSize;
+    #   DWORD dwMajorVersion;
+    #   DWORD dwMinorVersion;
+    #   DWORD dwBuildNumber;
+    #   DWORD dwPlatformId;
+    #   TCHAR szCSDVersion[128];
+    # } OSVERSIONINFO;
+    class OSVERSIONINFO < FFI::Struct
+      layout(
+        :dwOSVersionInfoSize, :dword,
+        :dwMajorVersion, :dword,
+        :dwMinorVersion, :dword,
+        :dwBuildNumber, :dword,
+        :dwPlatformId, :dword,
+        :szCSDVersion, [:wchar, 128]
+      )
+    end
+
+    MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16_384
+
+    # SYMLINK_REPARSE_DATA_BUFFER
+    # https://msdn.microsoft.com/en-us/library/cc232006.aspx
+    # https://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
+    # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
+    class SYMLINK_REPARSE_DATA_BUFFER < FFI::Struct
+      layout :ReparseTag, :win32_ulong,
+             :ReparseDataLength, :ushort,
+             :Reserved, :ushort,
+             :SubstituteNameOffset, :ushort,
+             :SubstituteNameLength, :ushort,
+             :PrintNameOffset, :ushort,
+             :PrintNameLength, :ushort,
+             :Flags, :win32_ulong,
+             # max less above fields dword / uint 4 bytes, ushort 2 bytes
+             # technically a WCHAR buffer, but we care about size in bytes here
+             :PathBuffer, [:byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 20]
+    end
+
+    # MOUNT_POINT_REPARSE_DATA_BUFFER
+    # https://msdn.microsoft.com/en-us/library/cc232007.aspx
+    # https://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
+    # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
+    class MOUNT_POINT_REPARSE_DATA_BUFFER < FFI::Struct
+      layout :ReparseTag, :win32_ulong,
+             :ReparseDataLength, :ushort,
+             :Reserved, :ushort,
+             :SubstituteNameOffset, :ushort,
+             :SubstituteNameLength, :ushort,
+             :PrintNameOffset, :ushort,
+             :PrintNameLength, :ushort,
+             # max less above fields dword / uint 4 bytes, ushort 2 bytes
+             # technically a WCHAR buffer, but we care about size in bytes here
+             :PathBuffer, [:byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 16]
+    end
+
+    # SHFILEINFO
+    # https://docs.microsoft.com/en-us/windows/win32/api/shellapi/ns-shellapi-shfileinfow
+    # typedef struct _SHFILEINFOW {
+    #   HICON hIcon;
+    #   int   iIcon;
+    #   DWORD dwAttributes;
+    #   WCHAR szDisplayName[MAX_PATH];
+    #   WCHAR szTypeName[80];
+    # } SHFILEINFOW;
+    class SHFILEINFO < FFI::Struct
+      layout(
+        :hIcon, :ulong,
+        :iIcon, :int,
+        :dwAttributes, :ulong,
+        :szDisplayName, [:char, 256],
+        :szTypeName, [:char, 80]
+      )
+    end
+
+    # REPARSE_JDATA_BUFFER
+    class REPARSE_JDATA_BUFFER < FFI::Struct
+      layout(
+        :ReparseTag, :ulong,
+        :ReparseDataLength, :ushort,
+        :Reserved, :ushort,
+        :SubstituteNameOffset, :ushort,
+        :SubstituteNameLength, :ushort,
+        :PrintNameOffset, :ushort,
+        :PrintNameLength, :ushort,
+        :PathBuffer, [:char, 1024]
+      )
+
+      # The REPARSE_DATA_BUFFER_HEADER_SIZE which is calculated as:
+      #
+      # sizeof(ReparseTag) + sizeof(ReparseDataLength) + sizeof(Reserved)
+      #
+      def header_size
+        FFI::Type::ULONG.size + FFI::Type::USHORT.size + FFI::Type::USHORT.size
+      end
+    end
+  end
+end

data/lib/puppet/ffi/windows.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Puppet
+  module FFI
+    module Windows
+      require_relative 'windows/api_types'
+      require_relative 'windows/constants'
+      require_relative 'windows/structs'
+      require_relative 'windows/functions'
+    end
+  end
+end

data/lib/puppet/file_bucket/dipper.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../../puppet/file_bucket'
+require_relative '../../puppet/file_bucket/file'
+require_relative '../../puppet/indirector/request'
+require_relative '../../puppet/util/diff'
+require 'tempfile'
+
+class Puppet::FileBucket::Dipper
+  include Puppet::Util::Checksums
+  # This is a transitional implementation that uses REST
+  # to access remote filebucket files.
+
+  attr_accessor :name
+
+  # Creates a bucket client
+  def initialize(hash = {})
+    # Emulate the XMLRPC client
+    server      = hash[:Server]
+    port        = hash[:Port] || Puppet[:serverport]
+
+    if hash.include?(:Path)
+      @local_path = hash[:Path]
+      @rest_path  = nil
+    else
+      @local_path = nil
+      @rest_path = "filebucket://#{server}:#{port}/"
+    end
+    @checksum_type = Puppet[:digest_algorithm].to_sym
+    @digest = method(@checksum_type)
+  end
+
+  def local?
+    !!@local_path
+  end
+
+  # Backs up a file to the file bucket
+  def backup(file)
+    file_handle = Puppet::FileSystem.pathname(file)
+    raise(ArgumentError, _("File %{file} does not exist") % { file: file }) unless Puppet::FileSystem.exist?(file_handle)
+
+    begin
+      file_bucket_file = Puppet::FileBucket::File.new(file_handle, :bucket_path => @local_path)
+      files_original_path = absolutize_path(file)
+      dest_path = "#{@rest_path}#{file_bucket_file.name}/#{files_original_path}"
+      file_bucket_path = "#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"
+
+      # Make a HEAD request for the file so that we don't waste time
+      # uploading it if it already exists in the bucket.
+      unless Puppet::FileBucket::File.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)
+        Puppet::FileBucket::File.indirection.save(file_bucket_file, dest_path)
+      end
+
+      file_bucket_file.checksum_data
+    rescue => detail
+      message = _("Could not back up %{file}: %{detail}") % { file: file, detail: detail }
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message, detail.backtrace
+    end
+  end
+
+  # Diffs two filebucket files identified by their sums
+  def diff(checksum_a, checksum_b, file_a, file_b)
+    raise RuntimeError, _("Diff is not supported on this platform") if Puppet[:diff] == ""
+
+    if checksum_a
+      source_path = "#{@rest_path}#{@checksum_type}/#{checksum_a}"
+      if checksum_b
+        file_diff = Puppet::FileBucket::File.indirection.find(
+          source_path,
+          :bucket_path => @local_path,
+          :diff_with => checksum_b
+        )
+      elsif file_b
+        tmp_file = ::Tempfile.new('diff')
+        begin
+          restore(tmp_file.path, checksum_a)
+          file_diff = Puppet::Util::Diff.diff(tmp_file.path, file_b)
+        ensure
+          tmp_file.close
+          tmp_file.unlink
+        end
+      else
+        raise Puppet::Error, _("Please provide a file or checksum to diff with")
+      end
+    elsif file_a
+      if checksum_b
+        tmp_file = ::Tempfile.new('diff')
+        begin
+          restore(tmp_file.path, checksum_b)
+          file_diff = Puppet::Util::Diff.diff(file_a, tmp_file.path)
+        ensure
+          tmp_file.close
+          tmp_file.unlink
+        end
+      elsif file_b
+        file_diff = Puppet::Util::Diff.diff(file_a, file_b)
+      end
+    end
+    raise Puppet::Error, _("Failed to diff files") unless file_diff
+
+    file_diff.to_s
+  end
+
+  # Retrieves a file by sum.
+  def getfile(sum)
+    get_bucket_file(sum).to_s
+  end
+
+  # Retrieves a FileBucket::File by sum.
+  def get_bucket_file(sum)
+    source_path = "#{@rest_path}#{@checksum_type}/#{sum}"
+    file_bucket_file = Puppet::FileBucket::File.indirection.find(source_path, :bucket_path => @local_path)
+
+    raise Puppet::Error, _("File not found") unless file_bucket_file
+
+    file_bucket_file
+  end
+
+  # Restores the file
+  def restore(file, sum)
+    restore = true
+    file_handle = Puppet::FileSystem.pathname(file)
+    if Puppet::FileSystem.exist?(file_handle)
+      cursum = Puppet::FileBucket::File.new(file_handle).checksum_data()
+
+      # if the checksum has changed...
+      # this might be extra effort
+      if cursum == sum
+        restore = false
+      end
+    end
+
+    if restore
+      newcontents = get_bucket_file(sum)
+      if newcontents
+        newsum = newcontents.checksum_data
+        changed = nil
+        if Puppet::FileSystem.exist?(file_handle) and !Puppet::FileSystem.writable?(file_handle)
+          changed = Puppet::FileSystem.stat(file_handle).mode
+          ::File.chmod(changed | 0o200, file)
+        end
+        ::File.open(file, ::File::WRONLY | ::File::TRUNC | ::File::CREAT) { |of|
+          of.binmode
+          newcontents.stream do |source_stream|
+            FileUtils.copy_stream(source_stream, of)
+          end
+        }
+        ::File.chmod(changed, file) if changed
+      else
+        Puppet.err _("Could not find file with checksum %{sum}") % { sum: sum }
+        return nil
+      end
+      newsum
+    else
+      nil
+    end
+  end
+
+  # List Filebucket content.
+  def list(fromdate, todate)
+    raise Puppet::Error, _("Listing remote file buckets is not allowed") unless local?
+
+    source_path = "#{@rest_path}#{@checksum_type}/"
+    file_bucket_list = Puppet::FileBucket::File.indirection.find(
+      source_path,
+      :bucket_path => @local_path,
+      :list_all => true,
+      :fromdate => fromdate,
+      :todate => todate
+    )
+    raise Puppet::Error, _("File not found") unless file_bucket_list
+
+    file_bucket_list.to_s
+  end
+
+  private
+
+  def absolutize_path(path)
+    Pathname.new(path).realpath
+  end
+end

data/lib/puppet/file_bucket/file.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/file_bucket'
+require_relative '../../puppet/indirector'
+require_relative '../../puppet/util/checksums'
+require 'digest/md5'
+require 'stringio'
+
+class Puppet::FileBucket::File
+  # This class handles the abstract notion of a file in a filebucket.
+  # There are mechanisms to save and load this file locally and remotely in puppet/indirector/filebucketfile/*
+  # There is a compatibility class that emulates pre-indirector filebuckets in Puppet::FileBucket::Dipper
+  extend Puppet::Indirector
+  indirects :file_bucket_file, :terminus_class => :selector
+
+  attr_reader :bucket_path
+
+  def self.supported_formats
+    [:binary]
+  end
+
+  def initialize(contents, options = {})
+    case contents
+    when String
+      @contents = StringContents.new(contents)
+    when Pathname
+      @contents = FileContents.new(contents)
+    else
+      raise ArgumentError, _("contents must be a String or Pathname, got a %{contents_class}") % { contents_class: contents.class }
+    end
+
+    @bucket_path = options.delete(:bucket_path)
+    @checksum_type = Puppet[:digest_algorithm].to_sym
+    raise ArgumentError, _("Unknown option(s): %{opts}") % { opts: options.keys.join(', ') } unless options.empty?
+  end
+
+  # @return [Num] The size of the contents
+  def size
+    @contents.size()
+  end
+
+  # @return [IO] A stream that reads the contents
+  def stream(&block)
+    @contents.stream(&block)
+  end
+
+  def checksum_type
+    @checksum_type.to_s
+  end
+
+  def checksum
+    "{#{checksum_type}}#{checksum_data}"
+  end
+
+  def checksum_data
+    @checksum_data ||= @contents.checksum_data(@checksum_type)
+  end
+
+  def to_s
+    to_binary
+  end
+
+  def to_binary
+    @contents.to_binary
+  end
+
+  def contents
+    to_binary
+  end
+
+  def name
+    "#{checksum_type}/#{checksum_data}"
+  end
+
+  def self.from_binary(contents)
+    new(contents)
+  end
+
+  class StringContents
+    def initialize(content)
+      @contents = content;
+    end
+
+    def stream(&block)
+      s = StringIO.new(@contents)
+      begin
+        block.call(s)
+      ensure
+        s.close
+      end
+    end
+
+    def size
+      @contents.size
+    end
+
+    def checksum_data(base_method)
+      Puppet.info(_("Computing checksum on string"))
+      Puppet::Util::Checksums.method(base_method).call(@contents)
+    end
+
+    def to_binary
+      # This is not so horrible as for FileContent, but still possible to mutate the content that the
+      # checksum is based on... so semi horrible...
+      @contents;
+    end
+  end
+
+  class FileContents
+    def initialize(path)
+      @path = path
+    end
+
+    def stream(&block)
+      Puppet::FileSystem.open(@path, nil, 'rb', &block)
+    end
+
+    def size
+      Puppet::FileSystem.size(@path)
+    end
+
+    def checksum_data(base_method)
+      Puppet.info(_("Computing checksum on file %{path}") % { path: @path })
+      Puppet::Util::Checksums.method(:"#{base_method}_file").call(@path)
+    end
+
+    def to_binary
+      Puppet::FileSystem.binread(@path)
+    end
+  end
+end

data/lib/puppet/file_bucket.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# stub
+module Puppet::FileBucket
+  class BucketError < RuntimeError; end
+end