aur.rb 0.1.0 → 0.2.0

data/lib/aur/config.rb

@@ -0,0 +1,330 @@
+require 'aur/helpers'
+require 'aur/packages'
+require 'aur/install_packages'
+require 'aur/makepkg'
+
+module Archlinux
+
+	class Config
+		def self.create(v)
+			v.is_a?(self) ? v : self.new(v)
+		end
+
+		attr_accessor :opts
+		Archlinux.delegate_h(self, :@opts)
+		include SH::ShConfig
+		include DR::PPHelper
+
+		# pass nil to prevent loading a config file
+		def initialize(file="aur.rb", **opts)
+			@file=file
+			if file
+				file=Pathname.new(file)
+				file=Pathname.new(ENV["XDG_CONFIG_HOME"] || "#{ENV['HOME']}/.config") + file if file.relative?
+			end
+			file_config= file&.readable? ? file.read : (SH.logger.error "Error: Config file '#{file}' unreadable" unless file.nil?; '{}')
+			wrap=eval("Proc.new { |config| #{file_config} }")
+			@opts=default_config.deep_merge(opts)
+			user_conf=wrap.call(self)
+			@opts.deep_merge!(user_conf) if user_conf.is_a?(Hash)
+		end
+
+		def to_pp
+			@file.to_s
+		end
+
+		def sh_config
+			@opts[:sh_config]
+		end
+
+		def default_config
+			{
+				cache: "arch_aur", #where we dl PKGBUILDs; if relative will be in XDG_CACHE_HOME
+				db: 'aur', #if relative the db will be in cache dir
+				aur_url: "https://aur.archlinux.org/", #base aur url
+				chroot: {
+					root: "/var/lib/aurbuild/x86_64", #chroot root
+					active: false, #do we use the chroot?
+					update: 'pacman -Syu --noconfirm', #how to update an existing chroot
+					packages: ['base-devel'], #the packages that are installed in the chroto
+					# It can make sense to add %w(python ruby nodejs go-pie rust git)...
+				},
+				default_packages_class: PackageList,
+				# default_install_list_class: AurMakepkgCache,
+				default_install_packages_class: AurPackageList,
+				default_install_list_class: AurCache,
+				default_get_class: Git, #we use git to fetch PKGBUILD from aur
+				sign: true, #can be made more atomic, cf the sign method
+				config_files: {
+					default: {
+						pacman: "/etc/pacman.conf", #default pacman-conf
+						makepkg: "/etc/makepkg.conf",
+					},
+					chroot: {
+						pacman: "/usr/share/devtools/pacman-extra.conf", #pacman.conf for chroot build
+						makepkg: "/usr/share/devtools/makepkg-x86_64.conf",
+					},
+					local: {
+						pacman: "/etc/pacman.conf", # pacman-conf for local makepkg build
+					},
+				},
+				sh_config: { #default programs options, called each time
+					makepkg: {default_opts: []},
+					makechrootpkg: {default_opts: ["-cu"]},
+					# So on fist thought, we do not need -u since we update 'root' before ourselves; but if we build several packages we may need the previous ones in the db, and since we only update 'root' once, they won't be available on 'copy'; so we still need '-u'
+				},
+				makepkg: {
+					build_args: ["-crs", "--needed"], #only used when building
+				},
+				view: "vifm -c view! -c tree -c 0", #can also be a Proc
+				sudo_loop: {
+					command: "sudo -v",
+					interval: 30,
+					active: true,
+				}
+			}
+		end
+
+		# packages to check
+		def default_packages(use_db: db != false, use_foreign: true)
+			if @default_packages.nil?
+				# by default this is the db packages + foreign packages
+				default=use_db ? db.packages : to_packages([]) 
+				default.merge(RepoPkgs.new(Repo.foreign_list, config: self).packages) if use_foreign
+				default=yield default if block_given?
+				@default_packages=to_packages(default.l, install: true)
+			else
+				@default_packages
+			end
+		end
+
+		def get_config_file(name, type: :default)
+			dig(:config_files, type, name) || dig(:config_files, :default, name)
+		end
+
+		def view(dir)
+			view=@opts[:view]
+			SH.sh_or_proc(view, dir)
+		end
+
+		def cachedir
+			global_cache=Pathname.new(ENV["XDG_CACHE_HOME"] || "#{ENV['HOME']}/.cache")
+			cache=global_cache+@opts[:cache]
+			cache.mkpath
+			cache
+		end
+
+		# add our default db to the list of repos
+		private def setup_pacman_conf(conf)
+			pacman=PacmanConf.create(conf, config: self)
+			aur=self.db(false)
+			if aur and !pacman[:repos].include?(aur.repo_name)
+				require 'uri'
+				pacman[:repos][aur.repo_name]={Server: ["file://#{DR::URIEscape.escape(aur.dir.to_s)}"]}
+			end
+			pacman
+		end
+
+		def default_pacman_conf
+			@default_pacman_conf ||= if (conf=get_config_file(:pacman))
+				PacmanConf.new(conf, config: self)
+			else
+				PacmanConf.new(config: self)
+			end
+		end
+
+		def chroot_devtools
+			unless @chroot_devtools
+				devtools_pacman=PacmanConf.new(get_config_file(:pacman, type: :chroot))
+				makepkg_conf=get_config_file(:makepkg, type: :chroot)
+				my_pacman=default_pacman_conf
+				devtools_pacman[:repos].merge!(my_pacman.non_official_repos)
+				devtools_pacman=setup_pacman_conf(devtools_pacman)
+				@chroot_devtools = Devtools.new(pacman_conf: devtools_pacman, makepkg_conf: makepkg_conf, config: self)
+			end
+			@chroot_devtools
+		end
+
+		def local_devtools
+			unless @local_devtools
+				makepkg_pacman=get_config_file(:pacman, type: :local)
+				makepkg_conf=get_config_file(:makepkg, type: :local)
+				makepkg_pacman=setup_pacman_conf(makepkg_pacman)
+				@local_devtools = Devtools.new(pacman_conf: makepkg_pacman, makepkg_conf: makepkg_conf, config: self)
+			end
+			@local_devtools
+		end
+
+		def db=(name)
+			case name
+			when DB
+				@db=name
+			when Pathname
+				@db=DB.new(name, config: self)
+			when String
+				if DB.db_file?(name)
+					@db=DB.new(name, config: self)
+				else
+					@db=DB.new(cachedir+".db"+"#{name}.db.tar.gz", config: self)
+				end
+			when true
+				@db=DB.new(cachedir+".db"+"aur.db.tar.gz", config: self)
+			when false, nil
+				@db=name #false for false, nil to reset
+			else
+				SH.logger.warn("Database name #{name} not suitable, fallback to default")
+				@db=nil
+			end
+			# reset these so the pacman_conf gets the correct db name
+			@makepkg_config=nil
+			@devtools_config=nil
+		end
+
+		def db(create=true)
+			@db.nil? and self.db=@opts[:db]
+			if create and @db
+				@db.create
+			end
+			@db
+		end
+
+		# if changing a setting, we may need to reset the rest
+		def reset
+			self.db=nil
+		end
+
+		# note: since 'true' is frozen, we cannot extend it and keep a
+		# @sudo_loop_thread. Moreover we only want one sudo loop active, so we
+		# will call it ourselves
+		def sudo(arg=true)
+			if dig(:sudo_loop, :active)
+				opts=dig(:sudo_loop).clone
+				opts.delete(:active)
+				self.extend(SH::SudoLoop.configure(**opts))
+				self.sudo_loop
+			end
+			arg
+		end
+
+		def stop_sudo_loop
+			stop_sudo_loop if respond_to?(:stop_sudo_loop)
+		end
+
+		def to_packages(l=[], install: false)
+			Archlinux.create_class(
+				install ? @opts[:default_install_packages_class] :
+				@opts[:default_packages_class],
+				l, config: self)
+		end
+
+		#:package, :db
+		def use_sign?(mode)
+			opt_sign=@opts[:sign]
+			if opt_sign.is_a?(Hash)
+				opt_sign[mode]
+			else
+				opt_sign
+			end
+		end
+
+		# output a list of sign names, or [] if we want to sign with the default sign name, false if we don't
+		def sign_names
+			opt_sign=@opts[:sign]
+			signs=if opt_sign.is_a?(Hash)
+					opt_sign.values
+				else
+					[*opt_sign]
+				end
+			names=signs.select {|s| s.is_a?(String)}
+			names = false if names.empty? and ! signs.any?
+			return names
+		end
+
+		# return the files that were signed
+		def sign(*files, sign_name: nil, force: false)
+			sign_name=use_sign?(sign_name) if sign_name.is_a?(Symbol)
+			files.map do |file|
+				sig="#{file}.sig"
+				if !Pathname.new(file).file?
+					SH.logger.error "Invalid file to sign #{file}"
+					next
+				end
+				if Pathname.new(sig).file?
+					if force
+						SH.logger.verbose2 "Signature #{sig} already exits, overwriting"
+					else
+						SH.logger.verbose2 "Signature #{sig} already exits, skipping"
+						next
+					end
+				end
+				args=['--detach-sign', '--no-armor']
+				args+=['-u', sign_name] if sign_name.is_a?(String)
+				launch(:gpg, *args, file) do |*args|
+					suc, _r=SH.sh(*args)
+					suc ? file : nil
+				end
+			end.compact
+		end
+
+		def verify_sign(*files)
+			args=['--verify']
+			files.map do |file|
+				file="#{file}.sig" unless file.to_s =~ /(.sig|.asc)/
+				launch(:gpg, *args, file) do |*args|
+					suc, _r=SH.sh(*args)
+					[file, suc]
+				end
+			end.to_h
+		end
+
+		def install_list
+			@install_list ||= Archlinux.create_class(@opts[:default_install_list_class], config: self)
+		end
+
+		def pre_install(*args, **opts)
+			names=sign_names
+			if names
+				cargs=["--detach-sign", "-o", "/dev/null", "/dev/null"]
+				if names.empty?
+					launch(:gpg, *cargs)
+				else
+					args=names.map { |name| ['-u', name] }.flatten+cargs
+					launch(:gpg, *args)
+				end
+			end
+		end
+
+		def post_install(pkgs, install: false, **opts)
+			if (db=self.db)
+				if install
+					tools=local_devtools
+					# info=opts[:pkgs_info]
+					# to_install=info[:all_pkgs].select {|_k,v| v[:op]==:install}.
+					# 	map {|_k,v| v[:out_pkg]}
+					# tools.sync_db(db.repo_name, install: to_install)
+
+					# Let's just install anything and let pacman handle it
+					m=opts[:makepkg_list]
+					if m
+						# we need to update the package versions with the ones
+						# provided by the current makepkg (which may be more recent than
+						# the one from aur's rpc in case of devel packages)
+						ipkgs=pkgs.map do |pkg|
+							found=m.packages.find(Query.strip(pkg))
+							found || pkg
+						end
+					else
+						ipkgs=pkgs
+					end
+					tools.sync_db(db.repo_name, install: %w(--needed) + ipkgs)
+				end
+			end
+		end
+
+		def parser(parser) #to add cli options in the config file
+		end
+	end
+
+	self.singleton_class.attr_accessor :config
+	@config ||= Config.new("aur.rb")
+end

data/lib/aur/db.rb

@@ -0,0 +1,328 @@
+require 'aur/config'
+require 'aur/packages'
+require 'aur/repos'
+require 'time'
+
+module Archlinux
+	class DB
+		extend CreateHelper
+
+		def self.db_file?(name)
+			case name
+			when Pathname
+				true
+			when String
+				if name.include?('/') or name.match(/\.db(\..*)?$/)
+					true
+				else
+					false #Usually we assume this is a repo name
+				end
+			end
+		end
+
+		attr_accessor :file, :config
+		def initialize(file, config: Archlinux.config)
+			@orig_file=Pathname.new(file)
+			@file=@orig_file.realdirpath rescue @orig_file.abs_path
+			@config=config
+		end
+
+		def mkpath
+			@file.dirname.mkpath
+		end
+
+		def path
+			if file.exist?
+				file.realpath
+			else
+				file
+			end
+		end
+
+		def repo_name
+			@file.basename.to_s.sub(/\.db(\..*)?$/,'')
+		end
+
+		def create
+			mkpath
+			unless @file.exist?
+				call(:'repo-add', path)
+			end
+			self
+		end
+
+		def to_s
+			@file.to_s
+		end
+
+		# a db is a tar.gz archive of packages/desc, like yay-8.998-1/descr
+		def bsdcat_list
+			res= SH.run_simple("bsdcat #{@file.shellescape}", chomp: :lines) {return nil}
+			list=[]; pkg={}; mode=nil
+			flush = lambda do
+				# catch old deps files which don't specify the full infos
+				unless pkg[:name].nil? and pkg[:base].nil?
+					pkg[:repo]||=path
+					list << pkg 
+				end
+			end
+			res.each do |l|
+				next if l.empty? or l.match(/^\u0000*$/)
+				if (m=l.match(/(\u0000+.*\u0000+)?%([A-Z0-9]*)%$/))
+					mode=m[2].downcase.to_sym
+					if m[1] #new db entry
+						flush.call #store old db entry
+						pkg={}
+					end
+				else
+					l=l.to_i if mode==:csize or mode==:isize
+					l=Time.at(l.to_i) if mode==:builddate
+					Archlinux.add_to_hash(pkg, mode, l)
+				end
+			end
+			flush.call #don't forget the last one
+			list
+		end
+
+		def list
+			res= SH.run_simple("bsdtar -xOf #{@file.shellescape} '*/desc'", chomp: :lines) {return nil}
+			list=[]; pkg={}; mode=nil
+			flush = lambda do
+				unless pkg.empty?
+					pkg[:repo]||=path
+					list << pkg
+				end
+			end
+			res.each do |l|
+				next if l.empty?
+				if (m=l.match(/^%([A-Z0-9]*)%$/))
+					mode=m[1].downcase.to_sym
+					if mode==:filename #new db entry
+						flush.call #store old db entry
+						pkg={}
+					end
+				else
+					l=l.to_i if mode==:csize or mode==:isize
+					l=Time.at(l.to_i) if mode==:builddate
+					Archlinux.add_to_hash(pkg, mode, l)
+				end
+			end
+			flush.call #don't forget the last one
+			list
+		end
+
+		def files(absolute=true)
+			list.map do |pkg|
+				file=Pathname.new(pkg[:filename])
+				absolute ? dir + file : file
+			end
+		end
+		# def files
+		# 	packages.l.map {|pkg| dir+Pathname.new(pkg[:filename])}
+		# end
+
+		def dir
+			# # we memoize this because if we get called again in a dir.chdir
+			# # call, then the realpath will fail
+			# @dir ||= @file.dirname.realpath
+			@file.dirname
+		end
+
+		def call(*args, **opts)
+			@config.launch(*args, **opts) do |*a, **o|
+				dir.chdir do
+					SH.sh(*a, **o)
+				end
+			end
+		end
+
+		def move_to_db(*files, op: :mv)
+			files=files.map {|f| Pathname.new(f).realpath}
+			dir=self.dir
+			SH.logger.verbose "#{op}: #{files.join(', ')} to #{dir}"
+			files.map do |f|
+				if f.dirname == dir
+					SH.logger.verbose2 "! #{f} already exists in #{dir}"
+					f
+				else
+					new=dir+f.basename
+					SH.logger.verbose2 "-> #{op} #{f} to #{new}"
+					f.send(op, new)
+					sig=Pathname.new(f.to_s+".sig") #mv .sig too
+					if sig.exist?
+						newsig=dir+sig.basename
+						SH.logger.verbose2 "-> #{op} #{sig} to #{newsig}"
+						sig.send(op, newsig)
+					end
+					new
+				end
+			end
+		end
+
+		def add(*files, cmd: :'repo-add', default_opts:[], sign: @config&.use_sign?(:db), force_sign: false, **opts)
+			default_opts+=['-s', '-v'] if sign
+			default_opts+=['--key', sign] if sign.is_a?(String)
+			dir.chdir do
+				files.map! {|f| Pathname.new(f)}
+				existing_files=files.select {|f| f.file?}
+				missing_files = files-existing_files
+				SH.logger.warn "In #{cmd}, missing files: #{missing_files.join(', ')}" unless missing_files.empty?
+				unless existing_files.empty?
+					sign_files = @config&.use_sign?(:package)
+					PackageFiles.new(*existing_files, config: @config).sign(sign_name: sign_files, force: force_sign) if sign_files
+					call(cmd, path, *existing_files, default_opts: default_opts, **opts)
+					@packages=nil #we need to refresh the list
+				end
+			end
+			files
+		end
+
+		def remove(*pkgnames, cmd: :'repo-remove', default_opts:[], sign: @config&.use_sign?(:db), **opts)
+			default_opts+=['-s', '-v'] if sign
+			default_opts+=['--key', sign] if sign.is_a?(String)
+			dir.chdir do
+				call(cmd, path, *pkgnames, default_opts: default_opts, **opts)
+				@packages=nil #we need to refresh the list
+			end
+			pkgnames
+		end
+
+		def packages(refresh=false)
+			@packages=nil if refresh
+			# @packages||=PackageList.new(list, config: @config)
+			@packages||=@config.to_packages(list)
+		end
+
+		def dir_packages_cls
+			PackageFiles.from_dir(dir, config: @config)
+		end
+		def dir_packages
+			dir_packages_cls.packages
+		end
+
+		def package_files_cls
+			PackageFiles.new(*files, config: @config)
+		end
+		def package_files
+			package_files_cls.packages
+		end
+
+		# sign the files in the db (return the list of signed file, by default
+		# unless force: true is passed this won't resign already signed files)
+		def sign_files(sign_name: :package, **opts)
+			@config&.sign(*files, sign_name: sign_name, **opts)
+		end
+		def sign_db(sign_name: :db, **opts)
+			@config&.sign(@file, sign_name: sign_name, **opts) if @file.file?
+		end
+
+		def verify_sign_db
+			@config&.verify_sign(@file)
+		end
+		def verify_sign_files
+			@config&.verify_sign(*files)
+		end
+		# check the inline signatures
+		def verify_sign_pkgs(*pkgs)
+			packages.get_packages(*pkgs).map do |pkg|
+				pgpsign=pkg[:pgpsig]
+				if pgpsign
+					require 'base64'
+					sig=Base64.decode64(pgpsign)
+					filename=dir+pkg[:filename]
+					@config.launch(:gpg, "--enable-special-filenames", "--verify", "-", filename, mode: :capture, stdin_data: sig) do |*args|
+						suc, _r=SH.sh(*args)
+						[pkg.name, suc]
+					end
+				else
+					[pkg.name, false]
+				end
+			end.to_h
+		end
+
+		# if we missed some signatures, resign them (and add them back to the
+		# db to get the signatures in the db). This override the sign:false
+		# config options.
+		def resign(**opts)
+			signed_files=sign_files(**opts)
+			add(*signed_files) #note that this may try to sign again, but since the signature exists it won't launch gpg
+			sign_db(**opts) #idem, normally the db will be signed by repo-add -v, but in case the signature was turned off in the config, this forces the signature
+		end
+
+		def check
+			packages.same?(package_files)
+		end
+
+		def check_update(other=dir_packages)
+			self.packages.check_updates(other)
+			# yield up if block_given?
+			# refresh=up.select {|_k, u| u[:op]==:upgrade or u[:op]==:downgrade}
+			# add=up.select {|_k, u| u[:op]==:install}
+			# remove=up.select {|_k, u| u[:op]==:obsolete}
+			# return {refresh: refresh, add: add, remove: remove}
+		end
+
+		def show_updates(other=dir_packages, **showopts)
+			c=check_update(other)
+			packages.show_updates(c, **showopts)
+			c
+		end
+
+		def update(other=dir_packages, add_for: %i(upgrade downgrade install), rm_for: %i(obsolete), **showopts)
+			c=show_updates(other, **showopts)
+			to_add=c.select {|_k, u| add_for.include?(u[:op])}
+			to_rm=c.select {|_k, u| rm_for.include?(u[:op])}
+			add(*to_add.map { |_k,v| other[v[:out_pkg]].path })
+			# remove(*(r[:remove].map {|_k,v| packages[v[:in_pkg]].file.shellescape}))
+			remove(* to_rm.map {|_k,v| Query.strip(v[:in_pkg])})
+			c
+		end
+
+		# move/copy files to db and add them
+		# if update==true, only add more recent packages
+		# pkgs should be a PackageFiles or a PackageList or a list of files
+		def add_to_db(pkgs, update: true, op: :cp)
+			if update
+				pkgs=PackageFiles.create(pkgs).packages unless pkgs.is_a? PackageList
+				up=self.packages.check_updates(pkgs)
+				pkgs=up.select {|_k, u| u[:op]==:upgrade or u[:op]==:install}.map do |_k,v|
+					pkgs[v[:out_pkg]].path
+				end
+			else
+				pkgs=pkgs.map {|_k,v| v.path } if pkgs.is_a?(PackageList)
+			end
+			SH.logger.mark "Updating #{pkgs} in #{self}"
+			cp_pkgs=move_to_db(*pkgs, op: op)
+			add(*cp_pkgs)
+		end
+
+		#remove from db and also remove the package files
+		def rm_from_db(*pkgs)
+			to_rm=packages.get_packages(*pkgs)
+			PackageFiles.rm_files(*to_rm.map {|pkg| pkg.path}, dir: self.dir)
+			remove(*pkgs)
+		end
+
+		# in clean_dir, we clean the dir packages which have a newer
+		# version (in the dir).
+		def clean_dir(dry_run: true)
+			files=dir_packages_cls
+			files.clean(dry_run: dry_run)
+		end
+
+		# In clean, we clean the dir packages which are newer or not present in
+		# the db. This is like the reverse of `update`. In particular be
+		# careful that this will delete newer versions or added versions
+		def clean(dry_run: true)
+			dir_pkgs=dir_packages_cls
+			dir_files=dir_pkgs.files
+			db_files=files
+			to_remove=dir_files - db_files
+			if dry_run
+				to_remove
+			else
+				PackageFiles.rm_files(*to_remove, dir: self.dir)
+			end
+		end
+	end
+end