/stdhome

# deployment.py

#

# Copyright (C) 2013 to 2014 Tim Marston <tim@edm.am>

#

# This file is part of stdhome (hereafter referred to as "this program").

# See http://ed.am/dev/stdhome for more information.

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os, re, shutil, filecmp

import the, util

class Deployment:

	def __init__( self ):

		self.load_deployment_state()

		self.conflicts_checked = False

	def load_deployment_state( self ):

		# list of files that were copied-in (or at least given the opportunity

        # to be) and updated through the vcs update.  This means that, while

        # there may have been conflicts during the update (which will be dealt

        # with in the repo), any arising conflicts with the filesystem are now

        # assumed to be because of the vcs update and can be ignored (that is to

        # say, we no longer care about the file in the home directory).  In

        # short, this is a list of files that it is safe to deploy, regardless

        # of the state of the filesystem.

		self.deploy_files = None

		# do we have a repo?

		if not os.path.exists( the.repo.full_dir ): return

		# if no file list exists, we're done

		file = os.path.join( the.full_mddir, "deploy.%s" % the.repo.name )

		if not os.path.isfile( file ):

			if the.verbose: print "no deployment state found"

			return

		# read the file list

		if the.verbose: print "loading deployment state"

		f = open( file, 'r' )

		self.deploy_files = f.read().splitlines()

	def save_deployment_state( self ):

		if the.verbose: print "saving deployment state"

		# create metadata directory, as necessary

		if not os.path.isdir( the.full_mddir ):

			os.mkdir( the.full_mddir )

		# create file

		file = os.path.join( the.full_mddir, "deploy.%s" % the.repo.name )

		f = open( file, 'w' )

		f.write( '\n'.join( self.deploy_files ) + '\n' )

	def remove_deployment_state( self ):

		# delete it, if it exists

		file = os.path.join( the.full_mddir, "deploy.%s" % the.repo.name )

		if( os.path.isfile( file ) ):

			os.unlink( file )

	def is_ongoing( self ):

		return False if self.deploy_files is None else True

	def check_ongoing( self, ongoing = True ):

		if( ongoing ):

			if self.deploy_files is None:

				raise self.DeploymentOngoing( False )

		else:

			if self.deploy_files is not None:

				raise self.DeploymentOngoing( True )

	def confirm( self, message ):

		# TODO: write interactive confirmation routine

		return False

	def walk_repo( self, dir_func = None, file_func = None, link_func = None,

				   relative_dir = '', ignore_errors = False ):

		"""Walk through all files and directories in the repo, passing the relative path

		to each to the provided functions.

		"""

		full_dir = os.path.join( the.repo.full_dir, relative_dir )

		for file in os.listdir( full_dir ):

			relative_file = os.path.join( relative_dir, file )

			# skip some stuff

			if relative_file == '.bzr': continue

			repo_file = os.path.join( the.repo.full_dir, relative_file )

			fs_file = os.path.join( the.full_fsdir, relative_file )

			if os.path.islink( repo_file ):

				if link_func is not None:

					link_func( relative_file, repo_file, fs_file )

			elif os.path.isfile( repo_file ):

				if file_func is not None:

					file_func( relative_file, repo_file, fs_file )

			elif os.path.isdir( repo_file ):

				if dir_func is not None:

					dir_func( relative_path, repo_file, fs_file )

				# recurse in directories

				self.walk_repo( dir_func, file_func, link_func, relative_dir,

								ignore_errors )

			elif not ignore_errors:

				raise RuntimeError(

					'repo contains unknown/missing entity' )

	def copy_in( self ):

		def copy_in_dir( relative_file, dst, src ):

			self.deploy_files.append( relative_file )

			# if src doesn't exist, delete it from the repo

			if not os.path.lexists( src ):

				if the.verbose: print " _<d " + relative_file

				shutil.rmtree( dst )

			# if src is a directory, copy permissions, as necessary

			elif os.path.isdir( src ):

				# TODO: should check permissions and only do as necessary

				if the.verbose: print " d<d " + relative_file

				shutil.copystat( src, dst )

			# TODO: serious differences in between ~/ and repo (e.g., files in

			# one that are directories in the other) should be ignored (e.g.,

			# not copied-in).  And the stuff that is ignored during copy-in

			# should also be ignored during copy-out and must not be added to

			# the deploy_files list.  Since these ignored files/directories are

			# transparent to the user, they should have to explicitly permit

			# them via an ignore file (e.g., ~/.stdhome/.ignore, akin to bzr's

			# .bzrignore file).  If these serious differences are not matched by

			# the ignore file, an error should show (which will requie a

			# separate "check" walk of the repo, as is done in copy_out).

			else:

				raise self.Conflict( "%s differs too severely from the repo" %

									 os.path.join( the.fsdir, relative_file ) )

		def copy_in_file( relative_file, dst, src ):

			self.deploy_files.append( relative_file )

			# if src doesn't exist, delete it in the repo

			if not os.path.lexists( src ):

				if the.verbose: print " ?<f " + relative_file

				os.unlink( dst )

			# if src is a symlink, replace it in repo

			elif os.path.islink( src ):

				if the.verbose: print " l<f " + relative_file

				os.unlink( dst )

				os.symlink( os.readlink( src ), dst )

			# if src is a file, replace it if different

			elif os.path.isfile( src ):

				if not filecmp.cmp( src, dst ):

					if the.verbose: print " f<f " + relative_file

					os.unlink( dst )

					shutil.copy( src, dst )

					shutil.copystat( src, dst )

				else:

					if the.verbose: print " f=f " + relative_file

			# TODO: serious differences in between ~/ and repo (e.g., files in

			# one that are directories in the other) should be ignored (e.g.,

			# not copied-in).  And the stuff that is ignored during copy-in

			# should also be ignored during copy-out and must not be added to

			# the deploy_files list.  Since these ignored files/directories are

			# transparent to the user, they should have to explicitly permit

			# them via an ignore file (e.g., ~/.stdhome/.ignore, akin to bzr's

			# .bzrignore file).  If these serious differences are not matched by

			# the ignore file, an error should show (which will requie a

			# separate "check" walk of the repo, as is done in copy_out).

			else:

				raise self.Conflict( "%s differs too severely from the repo" %

									 os.path.join( the.fsdir, relative_file ) )

		def copy_in_link( relative_file, dst, src ):

			self.deploy_files.append( relative_file )

			# if src doesn't exist, delete it in the repo

			if not os.path.lexists( src ):

				if the.verbose: print " _<l " + relative_file

				os.unlink( dst )

			# if src is a symlink, replace it if different in repo

			elif os.path.islink( src ):

				if os.readlink( src ) != os.readlink( dst ):

					if the.verbose: print " l<l " + relative_file

					os.unlink( dst )

					os.symlink( os.readlink( src ), dst )

				else:

					if the.verbose: print " l=l " + relative_file

			# if src is a file, replace it in repo

			elif os.path.isfile( src ):

				if the.verbose: print " f<l " + relative_file

				os.unlink( dst )

				shutil.copy( src, dst )

				shutil.copystat( src, dst )

			# TODO: serious differences in between ~/ and repo (e.g., files in

			# one that are directories in the other) should be ignored (e.g.,

			# not copied-in).  And the stuff that is ignored during copy-in

			# should also be ignored during copy-out and must not be added to

			# the deploy_files list.  Since these ignored files/directories are

			# transparent to the user, they should have to explicitly permit

			# them via an ignore file (e.g., ~/.stdhome/.ignore, akin to bzr's

			# .bzrignore file).  If these serious differences are not matched by

			# the ignore file, an error should show (which will requie a

			# separate "check" walk of the repo, as is done in copy_out).

			else:

				raise self.Conflict( "%s differs too severely from the repo" %

									 os.path.join( the.fsdir, relative_file ) )

		# check we don't already have a file list

		self.check_ongoing( False )

		# new file list

		self.deploy_files = list()

		# if the repo doesn't exist, we're done

		if not os.path.exists( the.repo.full_dir ): return

		# copy in

		if the.verbose: print "importing files"

		self.walk_repo( dir_func = copy_in_dir, file_func = copy_in_file,

					   link_func = copy_in_link, ignore_errors = True )

		# save state

		self.save_deployment_state()

	def copy_out( self ):

		def copy_out_dir( relative_file, src, dst ):

			# if dst doesn't exist, create it

			if not os.path.lexists( dst ):

				if the.verbose: print " d>_ " + relative_file

				os.mkdir( dst )

				shutil.copystat( src, dst )

			# if dst is a file/symlink, replace it

			elif os.path.isfile( dst ):

				if the.verbose: print " d>f " + relative_file

				os.unlink( dst )

				os.mkdir( dst )

				shutil.copystat( src, dst )

			# if dst is a directory, copy permissions as required

			elif os.path.isdir( dst ):

				# TODO: should check permission and only do as necessary

				if the.verbose: print " d>d " + relative_file

				shutil.copystat( src, dst )

			else:

				raise NotImplementedError()

		def copy_out_file( relative_file, src, dst ):

			# if dst doesn't exist, copy

			if not os.path.lexists( dst ):

				if the.verbose: print " f>_ " + relative_file

				shutil.copy( src, dst )

				shutil.copystat( src, dst )

			# if dst is a symlink, replace it

			elif os.path.islink( dst ):

				if the.verbose: print " f>l " + relative_file

				os.unlink( dst )

				shutil.copy( src, dst )

				shutil.copystat( src, dst )

			# if dst is a file, replace it if different

			elif os.path.isfile( dst ):

				if not filecmp.cmp( src, dst ):

					if the.verbose: print " f>f " + relative_file

					os.unlink( dst )

					shutil.copy( src, dst )

					shutil.copystat( src, dst )

				else:

					if the.verbose: print " f=f " + relative_file

			# if dst is a directory, replace it

			elif os.path.isdir( dst ):

				if the.verbose: print " f>d " + relative_file

				shutil.rmtree( dst )

				shutil.copy( src, dst )

				shutil.copystat( src, dst )

			else:

				raise NotImplementedError()

		def copy_out_link( relative_file, src, dst ):

			# if dst doesn't exist, copy

			if not os.path.lexists( dst ):

				if the.verbose: print " l>_ " + relative_file

				os.symlink( os.readlink( src ), dst )

			# if dst is a symlink, replace it if different

			elif os.path.islink( dst ):

				if os.readlink( src ) != os.readlink( dst ):

					if the.verbose: print " l>l " + relative_file

					os.unlink( dst )

					os.symlink( os.readlink( src ), dst )

				else:

					if the.verbose: print " l=l " + relative_file

			# if dst is a file, replace it

			elif os.path.isfile( dst ):

				if the.verbose: print " l>f " + relative_file

				os.unlink( dst )

				os.symlink( os.readlink( src ), dst )

			# if dst is a directory, replace it

			elif os.path.isdir( dst ):

				if the.verbose: print " l>d " + relative_file

				shutil.rmtree( dst )

				os.symlink( os.readlink( src ), dst )

			else:

				raise NotImplementedError()

		# check we have a file list

		self.check_ongoing( True )

		# we should already have handled conflicts

		if not self.conflicts_checked:

			raise RuntimeError(

				'logic error: conflicts should have been checked!' )

		# copy out

		if the.verbose: print "exporting files"

		self.walk_repo( dir_func = copy_out_dir, file_func = copy_out_file,

					   link_func = copy_out_link, ignore_errors = True )

		# clear state

		self.remove_deployment_state()

	def get_conflicts( self ):

		def check_dir( relative_file, src, dst ):

			# files that existed at copy-in can be copied-out and overwritten

			if self.deploy_files is not None and \

			   relative_file in self.deploy_files: return

			# files that don't exist in the filesystem can be copied-out

			if not os.path.lexists( dst ): return

			# accept/reject existing files

			if os.path.islink( dst ):

				self.files.append( "%s already exists (as a symlink)" %

								   os.path.join( the.fsdir, relative_file ) )

			elif os.path.isfile( dst ):

				self.files.append( "%s already exists (as a file)" %

								   os.path.join( the.fsdir, relative_file ) )

			elif os.path.isdir( dst ):

				return

			else:

				self.files.append( "%s already exists" %

								   os.path.join( the.fsdir, relative_file ) )

		def check_file( relative_file, src, dst ):

			# files that existed at copy-in can be copied-out and overwritten

			if self.deploy_files is not None and \

			   relative_file in self.deploy_files: return

			# files that don't exist in the filesystem can be copied-out

			if not os.path.lexists( dst ): return

			# accept/reject existing files

			if os.path.isfile( dst ):

				self.files.append( "%s already exists" %

								   os.path.join( the.fsdir, relative_file ) )

			elif os.path.isdir( dst ):

				self.files.append( "%s already exists (as a directory)" %

								   os.path.join( the.fsdir, relative_file ) )

			else:

				self.files.append( "%s already exists" %

								   os.path.join( the.fsdir, relative_file ) )

		self.conflicts_checked = True

		# check for conflicts

		self.files = list()

		self.walk_repo( dir_func = check_dir, file_func = check_file,

					   link_func = check_file )

		return self.files

	class DeploymentOngoing( the.program.FatalError ):

		def __init__( self, ongoing ):

			if( ongoing ):

				self.msg = "there is an ongoing deployment"

			else:

				self.msg = "there is no ongoing deployment"

	class Conflict( Exception ):

		def __init__( self, message ):

			self.msg = message