A short time ago, I discovered the LinuxFromScratch project. After getting a system up and working (after much struggling), I realized that if I wanted to continue using LFS, some sort of package management would be quite nice. Of course I could have installed Pacman, apt-get, rpm, etc. like any sane person, perhaps. Instead, I was interested in creating my own simple 'package management' system that would keep track of files that belonged to a certain package, etc.

I have attached two files:

1. **package.py** – a class that describes information about a package such as its name, its version, what its dependencies are, etc
2. **fakeroot.py** – this file is in charge of installing all of a package's files to the filesystem from a fakeroot, adding records of the installed files to a table in a database called Files, etc.

**package.py**:

    class Package:
        crate_extension = '.crate'
        database_location = 'proto.db'
    
    	def __init__(self, name, verbosity = 0, fp = '/home/duncan/Documents/fakeroot', rp = '/home/duncan/Documents/install', ap = '/usr/src/archive/', cp = '/home/duncan/Documents/package/'):
    		# Setup database stuff
    		self.connection = sqlite3.connect(self.database_location)
    		self.connection.text_factory = str
    		self.db_cursor = self.connection.cursor()
    		
    		# Setup path and name
    		self.name = name
    		self.fakeroot_path = os.path.join(fp, self.name)
    		self.root = rp
    		self.archive_path = ap
    		self.crate_path = os.path.join(cp, self.name) + self.crate_extension
    		
    		# Setup description taken from .crate file
    		crate_contents = io_crate.read_crate(self.crate_path)
    		self.description = crate_contents[0][1]
    		self.homepage = crate_contents[1][1]
    		self.optional_deps = crate_contents[2][1]
    		self.recommended_deps = crate_contents[3][1]
    		self.required_deps = crate_contents[4][1]
    		
    		self.verbosity = verbosity
    
    	def add_to_db(self):
    		"""Adds self.name to the package database."""
    		if self.is_in_db():
    			return 0
    		else:
    			# no need to try..except this because is_in_db.
    			self.db_cursor.execute('INSERT INTO Packages VALUES(?, ?);', (self.name, datetime.datetime.today()))
    			io_output.vbprint(self.verbosity, '{} added to the databased'.format(self.name))
    			return 1
    		
    	def remove_from_db(self):
    		"""Removes self from the database of packages."""
    		if self.is_in_db():
    			self.db_cursor.execute('DELETE FROM Packages WHERE Package=?;', (self.name,))
    			io_output.vbprint(self.verbosity, '{} removed from database'.format(self.name))
    			return 1
    		return 0
    	
    	def is_in_db(self):
     		"""Checks if the name of self is contained in the packages database."""
     		try:
    			self.db_cursor.execute('SELECT * FROM Packages WHERE Package=?;', (self.name,))
    		except:
    			print 'Couldn\'t read the database at {}'.format(self.database_location)
    
    		if not self.db_cursor.fetchone():
    			return 0
    		return 1
    	
    	def __del__(self):
    		self.connection.commit()
    		self.connection.close()

**fakeroot.py**:

    class Fakeroot():
    	def __init__(self, package):
    		self.dirs = [] # A list based on the files in the fakeroot.
    		self.files = [] # A list of all the directories to be created in package.root.
    		self.links = [] # A list of links from the fakeroot
    		self.package = package
    		
    		for root, dirs, files in os.walk(package.fakeroot_path):
    			for f in files:
    				new_dir = os.path.normpath(os.path.join(package.root, root[len(package.fakeroot_path) + 1:len(root)]))
    				src = os.path.join(root, f)
    				dest = os.path.join(new_dir, f) 
    				
    				if (os.path.islink(src)):
    					self.links.append([root, new_dir, f])
    				else:
    					self.files.append([src, dest])
    			for d in dirs:
    				self.dirs.append(os.path.join(package.root, root[len(package.fakeroot_path) + 1: len(root)], d))
    
    	def create_dirs(self):
    	# Go through self.dirs and check to see if a directory exists. If it does not, create it.
    		for d in self.dirs:
    			if not os.path.exists(d): # If the directory does not exist, run the equivalent of
    				os.makedirs(d) # mkdir -p on it.
    				io_output.vbprint(self.package.verbosity, 'DD {}'.format(d))
    			else:
    				io_output.vbprint(self.package.verbosity, 'UU {}'.format(d))
    				continue
    
    	def remove_dirs(self):
    		for d in reversed(self.dirs): # remove the directories that are the highest in the tree first.
    			if os.path.isdir(d): # If the directory exists
    				if not os.listdir(d): # and is empty...
    					os.rmdir(d) # remove it.
    					io_output.vbprint(self.package.verbosity, '-- {}'.format(d))
    				else: # If it is not empty.
    					io_output.vbprint(self.package.verbosity, 'UU {}'.format(d))
    			else: # If it does not exist.
    				io_output.vbprint(self.package.verbosity, '?? {}'.format(d))
    
    	def copy_files(self):
    		for f in self.files:
    			if os.path.exists(f[1]): # If the file exists, show that it is being used.
    				print 'Overwrite {}???'.format(f[1])
    				# TODO
    				# TODO: "Code" for overwiting stuff goes here.
    				# TODO: If yes, copy the file and add it to the DB.
    				# TODO: Perhaps an option to overwrite all files could be useful?
    				# TODO
    				continue
    			else: # If it does not exist,
    				try: # try...
    					shutil.copy2(f[0], f[1]) # copying it!
    					self.add_to_db(f)
    					io_output.vbprint(self.package.verbosity, '++ {}'.format(f[1]))
    				except:
    					io_output.vbprint(self.package.verbosity, 'Failed to copy a file...rolling back changes.')
    					#self.remove_files()
    					break
    
    	def remove_files(self):
    		for f in self.files:
    			if os.path.exists(f[1]):
    				os.remove(f[1])
    				self.remove_from_db(f)
    				io_output.vbprint(self.package.verbosity, '-- {}'.format(f[1]))
    			else:
    				io_output.vbprint(self.package.verbosity, '?? {}'.format(f[1]))
    
    	def create_links(self):
    		for l in self.links:
    			try:
    				if not os.path.exists(os.path.join(l[1], l[2])):
    					linkto = os.path.join(l[1], os.readlink(os.path.join(l[0], l[2])))
    					os.symlink(linkto, os.path.join(l[1], l[2]))
    					io_output.vbprint(self.package.verbosity, 'LL {}'.format(l[2]))
    				else:
    					print 'Overwrite existing link {}??'.format(l[2])
    					# TODO: See above todo for more info. ^^^^
    			except:
     				print 'Couldn\'t find the specified fakeroot!'
     				break
    				
    	def remove_links(self):
    		for l in self.links:
    			try:
    				os.remove(os.path.join(l[1], l[2]))
    				io_output.vbprint(self.package.verbosity, '-- {}.'.format(l))
    			except:
    				raise OSError('\nFailed to remove the link `{}`'.format(os.path.join(l[1], l[2])))
    
    	def add_to_db(self, f):
    		"""Returns 0 if the db can't be read, 1 if the file is added."""	
    		try:
    			self.package.db_cursor.execute('INSERT INTO Files VALUES(?, ?, ?, ?);', (f[1], md5_gen.generate(f[1]), 
    													os.path.getsize(f[1]),
    													self.package.name))
    			return 1
    		except:
    			return 0
    
    	def remove_from_db(self, f):
    		self.package.db_cursor.execute('DELETE FROM Files WHERE Path=?;', (f[1],))

In regard to these two files, I feel that my design is somewhat crappy. In particular, the design of the Package and Fakeroot objects seems `bad`. Additionally, the many similar methods in **fakeroot.py** for copying files / removing files seem somewhat redundant. What do you think?