[DEV] generic package generation on Linux is back

lutin/depend.py

@@ -11,12 +11,31 @@ import os
 from . import debug
 from . import env
 
-def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
+def _file_size(path):
-	debug.extreme_verbose("Resuest check of dependency of :")
+	if not os.path.isfile(path):
+		return 0
+	statinfo = os.stat(path)
+	return statinfo.st_size
+
+def _file_read_data(path, binary=False):
+	if not os.path.isfile(path):
+		return ""
+	if binary == True:
+		file = open(path, "rb")
+	else:
+		file = open(path, "r")
+	data_file = file.read()
+	file.close()
+	return data_file
+
+
+def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine="", force_identical=False):
+	debug.extreme_verbose("Request check of dependency of :")
 	debug.extreme_verbose("		dst='" + str(dst) + "'")
 	debug.extreme_verbose("		str='" + str(src) + "'")
 	debug.extreme_verbose("		dept='" + str(dependFile) + "'")
 	debug.extreme_verbose("		cmd='" + str(file_cmd) + "'")
+	debug.extreme_verbose("		force_identical='" + str(force_identical) + "'")
 	# if force mode selected ==> just force rebuild ...
 	if env.get_force_mode():
 		debug.extreme_verbose("			==> must rebuild (force mode)")
@@ -33,7 +52,7 @@ def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
 	   and os.path.exists(src) == False:
 		debug.warning("			==> unexistant file :'" + src + "'")
 		return True
-	# chek the basic date if the 2 files
+	# Check the basic date if the 2 files
 	if     dst != "" \
 	   and dst != None \
 	   and os.path.getmtime(src) > os.path.getmtime(dst):
@@ -100,6 +119,19 @@ def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
 					return True
 		# close the current file :
 		file.close()
+	# check the 2 files are identical:
+	if force_identical == True:
+		# check if the 2 cmdline are similar :
+		size_src = _file_size(src)
+		size_dst = _file_size(dst)
+		if size_src != size_dst:
+			debug.extreme_verbose("			Force Rewrite not the same size     size_src=" + str(size_src) + " != size_dest=" + str(size_dst))
+			return True
+		data_src = _file_read_data(src, binary=True)
+		data_dst = _file_read_data(dst, binary=True)
+		if data_src != data_dst:
+			debug.extreme_verbose("			Force Rewrite not the same data")
+			return True
 	
 	debug.extreme_verbose("			==> Not rebuild (all dependency is OK)")
 	return False

lutin/module.py

@@ -100,6 +100,8 @@ class Module:
 		                     }
 		self.sub_heritage_list = None
 	
+	def get_type(self):
+		return self.type
 	##
 	## @brief add Some copilation flags for this module (and only this one)
 	##
@@ -200,66 +202,6 @@ class Module:
 	
 	
 	
-	
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	##
-	## @brief Commands for copying files
-	## @deprecated
-	##
-	def image_to_staging(self, binary_name, target):
-		for source, destination, sizeX, sizeY in self.image_to_copy:
-			extension = source[source.rfind('.'):]
-			if     extension != ".png" \
-			   and extension != ".jpg" \
-			   and sizeX > 0:
-				debug.error("Can not manage image other than .png and jpg to resize : " + source);
-			display_source = source
-			source = self.origin_path + "/" + source
-			if destination == "":
-				destination = source[source.rfind('/')+1:]
-				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binary_name, self.name, self.origin_path, destination, "image")[0]
-			if sizeX > 0:
-				debug.verbose("Image file : " + display_source + " ==> " + destination + " resize=(" + str(sizeX) + "," + str(sizeY) + ")")
-				fileName, fileExtension = os.path.splitext(self.origin_path+"/" + source)
-				target.add_image_staging(source, destination, sizeX, sizeY, file_cmd)
-			else:
-				debug.verbose("Might copy file : " + display_source + " ==> " + destination)
-				target.add_file_staging(source, destination, file_cmd)
-	
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	##
-	## @brief Commands for copying files
-	## @deprecated
-	##
-	def files_to_staging(self, binary_name, target):
-		for source, destination in self.files:
-			display_source = source
-			source = self.origin_path + "/" + source
-			if destination == "":
-				destination = source[source.rfind('/')+1:]
-				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binary_name, self.name, self.origin_path, destination, "image")[0]
-			# TODO : when destination is missing ...
-			debug.verbose("Might copy file : " + display_source + " ==> " + destination)
-			target.add_file_staging(source, destination, file_cmd)
-	
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	##
-	## @brief Commands for copying files
-	## @deprecated
-	##
-	def paths_to_staging(self, binary_name, target):
-		for source, destination in self.paths:
-			debug.debug("Might copy path : " + source + "==>" + destination)
-			tools.copy_anything_target(target, self.origin_path + "/" + source, destination)
-	
 	def gcov(self, target, generate_output=False):
 		if self.type == 'PREBUILD':
 			debug.error("Can not generate gcov on prebuid system ... : '" + self.name + "'");
@@ -597,7 +539,7 @@ class Module:
 		self.image_to_build(target)
 		self.files_to_build(target)
 		self.paths_to_build(target)
-		# TODO : do sothing that create a list of file set in this directory and remove it if necessary ... ==> if not needed anymore ...&
+		# TODO : do sothing that create a list of file set in this directory and remove it if necessary ... ==> if not needed anymore ...
 		
 		# ----------------------------------------------------
 		# -- create package                                 --
@@ -615,26 +557,6 @@ class Module:
 		# return local dependency ...
 		return self.sub_heritage_list
 	
-	
-	
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	# TODO : REMOVE ........................
-	# call here to build the module
-	def build_tree(self, target, package_name):
-		# ckeck if not previously build
-		if target.is_module_build_tree(self.name)==True:
-			return
-		debug.verbose("build tree of " + self.name)
-		# add all the elements (first added only one keep ==> permit to everload sublib element)
-		self.image_to_staging(package_name, target)
-		self.files_to_staging(package_name, target)
-		self.paths_to_staging(package_name, target)
-		#build tree of all submodules
-		for dep in self.depends:
-			inherit = target.build_tree(dep, package_name)
-	
-	
 	# call here to clean the module
 	def clean(self, target):
 		if self.type=='PREBUILD':
@@ -688,9 +610,6 @@ class Module:
 	def add_optionnal_module_depend(self, module_name, compilation_flags=["", ""], export=False):
 		self.append_and_check(self.depends_optionnal, [module_name, compilation_flags, export], True)
 	
-	def add_export_path(self, list, type='c'):
-		self.append_to_internal_list2(self.path["export"], type, list)
-	
 	def add_path(self, list, type='c'):
 		self.append_to_internal_list2(self.path["local"], type, list)
 	
@@ -734,8 +653,14 @@ class Module:
 	def add_src_file(self, list):
 		self.append_to_internal_list(self.src, list, True)
 	
-	def add_header_file(self, list):
+	def add_header_file(self, list, rm_path=""):
+		if rm_path != "":
+			debug.warning("remove the basic path ...")
 		self.append_to_internal_list(self.header, list, True)
+	# TODO : Maybe do sothing with this ...
+	def add_export_path(self, list, type='c'):
+		self.append_to_internal_list2(self.path["export"], type, list)
+	
 	
 	def copy_image(self, source, destination='', sizeX=-1, sizeY=-1):
 		self.image_to_copy.append([source, destination, sizeX, sizeY])

lutin/target.py

@@ -274,7 +274,7 @@ class Target:
 		list=[]
 		if (type=="bin"):
 			list.append(file)
-			list.append(os.path.join(self.get_build_path(binary_name), self.path_bin, module_name + self.suffix_binary))
+			list.append(self.get_build_file_bin(binary_name))
 			list.append(os.path.join(self.get_build_path(module_name), module_name + self.suffix_dependence))
 			list.append(os.path.join(self.get_build_path(binary_name), self.path_bin, module_name + self.suffix_binary + self.suffix_cmd_line))
 			list.append(os.path.join(self.get_build_path(binary_name), self.path_bin, module_name + self.suffix_binary + self.suffix_warning))
@@ -321,7 +321,7 @@ class Target:
 		return os.path.join(self.get_build_path(binary_name), self.path_object)
 	
 	def get_build_path_bin(self, binary_name):
-		return os.path.join(self.get_build_path(binary_name), self.path_bin, binary_name)
+		return os.path.join(self.get_build_path(binary_name), self.path_bin)
 	
 	def get_build_path_lib(self, binary_name):
 		return os.path.join(self.get_build_path(binary_name), self.path_lib, binary_name)
@@ -333,17 +333,29 @@ class Target:
 		return os.path.join(self.get_build_path(binary_name), self.path_include)
 	
 	
-	def get_staging_path_bin(self, binary_name):
+	def get_build_file_bin(self, binary_name):
-		return os.path.join(self.get_staging_path(binary_name), self.path_bin, binary_name)
+		return os.path.join(self.get_build_path_bin(binary_name), binary_name + self.suffix_binary)
 	
-	def get_staging_path_lib(self, binary_name):
-		return os.path.join(self.get_staging_path(binary_name), self.path_lib, binary_name)
 	
-	def get_staging_path_data(self, binary_name):
-		return os.path.join(self.get_staging_path(binary_name), self.path_data, binary_name)
 	
-	def get_staging_path_include(self, binary_name):
+	
-		return os.path.join(self.get_staging_path(binary_name), self.path_include)
+	def get_staging_path_bin(self, package_name):
+		return os.path.join(self.get_staging_path(package_name), self.path_bin)
+	
+	def get_staging_path_lib(self, package_name):
+		return os.path.join(self.get_staging_path(package_name), self.path_lib, package_name)
+	
+	def get_staging_path_data(self, package_name):
+		return os.path.join(self.get_staging_path(package_name), self.path_data, package_name)
+	
+	def get_staging_path_include(self, package_name):
+		return os.path.join(self.get_staging_path(package_name), self.path_include)
+	
+	"""
+	def get_staging_file_bin(self, package_name, binary_name):
+		return os.path.join(self.get_staging_path_bin(package_name), binary_name + self.suffix_binary)
+	"""
+	
 	
 	
 	def get_doc_path(self, module_name):
@@ -369,7 +381,7 @@ class Target:
 		self.module_list.append(newModule)
 	
 	def get_module(self, name):
-		for mod in self.build_done:
+		for mod in self.module_list:
 			if mod.name == name:
 				return mod
 		debug.error("the module '" + str(name) + "'does not exist/already build")

lutin/tools.py

@@ -97,69 +97,58 @@ def add_prefix(prefix,list):
 				result.append(prefix+elem)
 			return result
 
-def copy_file(src, dst, cmd_file=None, force=False, executable=False):
+def copy_file(src, dst, cmd_file=None, force=False, force_identical=False):
 	if os.path.exists(src) == False:
 		debug.error("Request a copy a file that does not existed : '" + src + "'")
 	cmd_line = "copy \"" + src + "\" \"" + dst + "\""
 	if     force == False \
-	   and depend.need_re_build(dst, src, file_cmd=cmd_file , cmdLine=cmd_line) == False:
+	   and depend.need_re_build(dst, src, file_cmd=cmd_file , cmdLine=cmd_line, force_identical=force_identical) == False:
+		debug.verbose ("no need to copy ...")
 		return
-	debug.print_element("copy file", src, "==>", dst)
+	debug.print_element("copy file ", os.path.relpath(src), "==>", os.path.relpath(dst))
 	create_directory_of_file(dst)
 	shutil.copyfile(src, dst)
-	if executable == True:
+	# copy property of the permition of the file ... 
-		os.chmod(dst, stat.S_IRWXU + stat.S_IRGRP + stat.S_IXGRP + stat.S_IROTH + stat.S_IXOTH);
+	stat_info = os.stat(src)
+	os.chmod(dst, stat_info.st_mode)
 	store_command(cmd_line, cmd_file)
 
 
-def copy_anything(src, dst, recursive = False, executable=False):
+def copy_anything(src, dst, recursive = False, force_identical=False):
 	debug.verbose(" copy anything : '" + str(src) + "'")
 	debug.verbose("            to : '" + str(dst) + "'")
-	tmpPath = os.path.dirname(os.path.realpath(src))
+	if os.path.isdir(os.path.realpath(src)):
-	tmpRule = os.path.basename(src)
+		tmp_path = os.path.realpath(src)
-	debug.verbose("    " + str(tmpPath) + ":")
+		tmp_rule = ""
-	for root, dirnames, filenames in os.walk(tmpPath):
+	else:
-		deltaRoot = root[len(tmpPath):]
+		tmp_path = os.path.dirname(os.path.realpath(src))
+		tmp_rule = os.path.basename(src)
+	
+	debug.verbose("    " + str(tmp_path) + ":")
+	for root, dirnames, filenames in os.walk(tmp_path):
+		deltaRoot = root[len(tmp_path):]
 		if     recursive == False \
 		   and deltaRoot != "":
 			return
-		debug.verbose("     root='" + str(deltaRoot) + "'") # dir='" + str(dirnames) + "' filenames=" + str(filenames))
+		debug.verbose("     root='" + str(deltaRoot) + "'")
+		debug.verbose("         files=" + str(filenames))
 		tmpList = filenames
-		if len(tmpRule) > 0:
+		if len(tmp_rule) > 0:
-			tmpList = fnmatch.filter(filenames, tmpRule)
+			tmpList = fnmatch.filter(filenames, tmp_rule)
 		# Import the module :
 		for cycleFile in tmpList:
 			#for cycleFile in filenames:
 			debug.verbose("        '" + cycleFile + "'")
-			debug.extreme_verbose("Might copy : '" + tmpPath + "/" + deltaRoot + "/" + cycleFile + "' ==> '" + dst + "'")
+			debug.extreme_verbose("Might copy : '" + tmp_path + "/" + deltaRoot + "/" + cycleFile + "' ==> '" + dst + "'")
-			copy_file(tmpPath + "/" + deltaRoot + "/" + cycleFile,
+			copy_file(tmp_path + "/" + deltaRoot + "/" + cycleFile,
-			          dst     + "/" + deltaRoot + "/" + cycleFile,
+			          dst      + "/" + deltaRoot + "/" + cycleFile,
-			          executable=True)
+			          force_identical=force_identical)
-
+			""" TODO : Might be better, but does not work ...
-## @deprecated ...
+			debug.extreme_verbose("Might copy : '" + os.path.join(tmp_path, deltaRoot, cycleFile) + "' ==> '" + dst + "'")
-def copy_anything_target(target, src, dst):
+			copy_file(os.path.join(tmp_path, deltaRoot, cycleFile),
-	tmpPath = os.path.dirname(os.path.realpath(src))
+			          os.path.join(dst,      deltaRoot, cycleFile),
-	tmpRule = os.path.basename(src)
+			          force_identical=force_identical)
-	for root, dirnames, filenames in os.walk(tmpPath):
+			"""
-		debug.verbose(" root='" + str(root) + "' dir='" + str(dirnames) + "' filenames=" + str(filenames))
-		tmpList = filenames
-		if len(tmpRule)>0:
-			tmpList = fnmatch.filter(filenames, tmpRule)
-		# Import the module :
-		for cycleFile in tmpList:
-			#for cycleFile in filenames:
-			newDst = dst
-			if     len(newDst) != 0 \
-			   and newDst[-1] != "/":
-				newDst += "/"
-			if root[len(src)-1:] != "":
-				newDst += root[len(src)-1:]
-				if     len(newDst) != 0 \
-				   and newDst[-1] != "/":
-					newDst += "/"
-			debug.verbose("Might copy : '" + root+"/"+cycleFile + "' ==> '" + newDst+cycleFile + "'" )
-			target.add_file_staging(root+"/"+cycleFile, newDst+cycleFile)
-
 
 def filter_extention(list_files, extentions, invert=False):
 	out = []

lutin/z_builder/lutinBuilder_binary.py

@@ -88,7 +88,7 @@ def link(file, binary, target, depancy, name, basic_path):
 	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
 		return file_dst
 	tools.create_directory_of_file(file_dst)
-	debug.print_element("Executable", name, "==>", file_dst)
+	debug.print_element("Executable", name, "==>", os.path.relpath(file_dst))
 	
 	multiprocess.run_command(cmdLine, store_output_file=file_warning)
 	if    target.config["mode"] == "release"\

lutin/z_builder/lutinBuilder_libraryDynamic.py

@@ -81,7 +81,7 @@ def link(file, binary, target, depancy, name, basic_path):
 	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
 		return file_dst
 	tools.create_directory_of_file(file_dst)
-	debug.print_element("SharedLib", name, "==>", file_dst)
+	debug.print_element("SharedLib", name, "==>", os.path.relpath(file_dst))
 	multiprocess.run_command(cmdLine, store_output_file=file_warning)
 	# strip the output file:
 	if    target.config["mode"] == "release" \

lutin/z_builder/lutinBuilder_libraryStatic.py

@@ -66,7 +66,7 @@ def link(file, binary, target, depancy, name, basic_path):
 	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
 		return file_dst
 	tools.create_directory_of_file(file_dst)
-	debug.print_element("StaticLib", name, "==>", file_dst)
+	debug.print_element("StaticLib", name, "==>", os.path.relpath(file_dst))
 	# explicitly remove the destination to prevent error ...
 	if os.path.exists(file_dst) and os.path.isfile(file_dst):
 		os.remove(file_dst)

lutin/z_target/lutinTarget_Linux.py

@@ -49,11 +49,180 @@ class Target(target.Target):
 		return result
 	
 	def make_package(self, pkgName, pkgProperties, basePkgPath, heritage_list, type="generic"):
+		#The package generated depend of the type of the element:
+		end_point_module_name = heritage_list.list_heritage[-1].name
+		module = self.get_module(end_point_module_name)
+		if module == None:
+			debug.error("can not create package ... ");
+		if module.get_type() == 'PREBUILD':
+			#nothing to do ...
+			return
+		if    module.get_type() == 'LIBRARY' \
+		   or module.get_type() == 'LIBRARY_DYNAMIC' \
+		   or module.get_type() == 'LIBRARY_STATIC':
+			debug.info("Can not create package for library");
+			return
+		if    module.get_type() == 'BINARY' \
+		   or module.get_type() == 'BINARY_STAND_ALONE' \
+		   or module.get_type() == 'BINARY_SHARED':
+			self.make_package_generic_binary(pkgName, pkgProperties, basePkgPath, heritage_list)
+		if module.get_type() == 'PACKAGE':
+			debug.info("Can not create package for package");
+			return
+		return
+		
 		if type == "debian":
 			self.make_package_debian(pkgName, pkgProperties, basePkgPath, heritage_list)
 		elif type == "generic":
 			self.make_package_generic(pkgName, pkgProperties, basePkgPath, heritage_list)
 	
+	
+	"""
+	.local/application
+	    *--> applName -> applName.app/bin/applName
+	    *--> applName.app
+	        *--> appl_description.txt
+	        *--> appl_name.txt
+	        *--> changelog.txt
+	        *--> copyright.txt
+	        *--> readme.txt
+	        *--> version.txt
+	        *--> website.txt
+	        *--> icon.png
+	        *--> bin
+	        *    *--> applName
+	        *--> doc
+	        *    *--> applName
+	        *--> lib
+	        *    *--> XX.so
+	        *    *--> YY.so
+	        *--> license
+	        *    *--> applName.txt
+	        *    *--> libXX.txt
+	        *    *--> libYY.txt
+	        *--> man
+	        *--> share
+	        *    *--> applName
+	        *    *--> XX
+	        *    *--> YY
+	        *--> sources
+	"""
+	def make_package_generic_binary(self, pkgName, pkgProperties, basePkgPath, heritage_list):
+		debianPkgName = re.sub("_", "-", pkgName)
+		
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate generic '" + debianPkgName + "' v"+pkgProperties["VERSION"])
+		debug.debug("------------------------------------------------------------------------")
+		#output path
+		target_outpath = os.path.join(self.get_staging_path(pkgName), pkgName + ".app")
+		tools.create_directory_of_file(target_outpath)
+		
+		## Create share datas
+		target_outpath_data = os.path.join(target_outpath, "share")
+		tools.create_directory_of_file(target_outpath_data)
+		debug.debug("heritage for " + str(pkgName) + ":")
+		for heritage in heritage_list.list_heritage:
+			debug.debug("sub elements: " + str(heritage.name))
+			path_src = self.get_build_path_data(heritage.name)
+			debug.verbose("      has directory: " + path_src)
+			if os.path.isdir(path_src):
+				# TODO : Add os.path.dirname( for shared elements ... (like this, this add all element in a single os.path.dirname(path_src)
+				debug.debug("      need copy: " + path_src + " to " + target_outpath_data)
+				#copy all data:
+				# TODO : We can have a problem when writing over library files ...
+				tools.copy_anything(path_src, target_outpath_data, recursive=True, force_identical=True)
+		
+		## Create share datas
+		target_outpath_bin = os.path.join(target_outpath, "bin")
+		tools.create_directory_of_file(target_outpath_bin)
+		path_src = self.get_build_file_bin(pkgName)
+		path_dst = os.path.join(target_outpath_bin, pkgName + self.suffix_binary)
+		debug.warning("path_dst: " + str(path_dst))
+		tools.copy_file(path_src, path_dst)
+		## Create libraries
+		
+		
+		## Create version file
+		tmpFile = open(target_outpath + "/version.txt", 'w')
+		tmpFile.write(pkgProperties["VERSION"])
+		tmpFile.flush()
+		tmpFile.close()
+		
+		## Create maintainer file
+		tmpFile = open(target_outpath + "/maintainer.txt", 'w')
+		tmpFile.write(self.generate_list_separate_coma(pkgProperties["MAINTAINER"]))
+		tmpFile.flush()
+		tmpFile.close()
+		
+		## Create appl_name file
+		tmpFile = open(target_outpath + "/appl_name.txt", 'w')
+		tmpFile.write("en_EN:" + pkgProperties["NAME"])
+		tmpFile.flush()
+		tmpFile.close()
+		
+		## Create appl_description file
+		tmpFile = open(target_outpath + "/appl_description.txt", 'w')
+		tmpFile.write("en_EN:" + pkgProperties["DESCRIPTION"])
+		tmpFile.flush()
+		tmpFile.close()
+		
+		## Create Readme file
+		readmeFileDest = target_outpath + "/readme.txt"
+		if os.path.exists(basePkgPath + "/os-Linux/README")==True:
+			tools.copy_file(basePkgPath + "/os-Linux/README", readmeFileDest)
+		elif os.path.exists(basePkgPath + "/README")==True:
+			tools.copy_file(basePkgPath + "/README", readmeFileDest)
+		elif os.path.exists(basePkgPath + "/README.md")==True:
+			tools.copy_file(basePkgPath + "/README.md", readmeFileDest)
+		else:
+			debug.info("no file 'README', 'README.md' or 'os-Linux/README' ==> generate an empty one")
+			tmpFile = open(readmeFileDest, 'w')
+			tmpFile.write("No documentation for " + pkgName + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		
+		## Create licence file
+		licenseFileDest = target_outpath + "/license/"+ debianPkgName + ".txt"
+		tools.create_directory_of_file(licenseFileDest)
+		if os.path.exists(basePkgPath + "/license.txt")==True:
+			tools.copy_file(basePkgPath + "/license.txt", licenseFileDest)
+		else:
+			debug.info("no file 'license.txt' ==> generate an empty one")
+			tmpFile = open(licenseFileDest, 'w')
+			tmpFile.write("No license define by the developper for " + pkgName + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		
+		## Create changeLog file
+		changeLogFileDest = target_outpath + "/changelog.txt"
+		if os.path.exists(basePkgPath + "/changelog") == True:
+			tools.copy_file(basePkgPath + "/changelog", changeLogFileDest)
+		else:
+			debug.info("no file 'changelog' ==> generate an empty one")
+			tmpFile = open(changeLogFileDest, 'w')
+			tmpFile.write("No changelog data " + pkgName + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		
+		## copy share path
+		#debug.info("plop:" + self.get_staging_path(pkgName) + self.path_data)
+		if os.path.exists(self.get_staging_path(pkgName) + self.path_data) == True:
+			tools.copy_anything(self.get_staging_path(pkgName) + self.path_data + "/*", target_outpath + self.path_data, recursive=True)
+		
+		## Create binary path:
+		bin_path = target_outpath + self.path_bin
+		#tools.create_directory_of_file(bin_path)
+		tools.copy_anything(self.get_staging_path(pkgName) + self.path_bin + "/*",
+		                    bin_path)
+		
+		## create the package:
+		debug.debug("package : " + self.get_staging_path(pkgName) + "/" + debianPkgName + ".app.pkg")
+		os.system("cd " + self.get_staging_path(pkgName) + " ; tar -czf " + pkgName + ".app.tar.gz " + pkgName + ".app")
+		#multiprocess.run_command("cd " + self.get_staging_path(pkgName) + " ; tar -czf " + pkgName + ".app.tar.gz " + pkgName + ".app")
+		tools.create_directory_of_file(self.get_final_path())
+		tools.copy_file(self.get_staging_path(pkgName) + "/" + pkgName + ".app.tar.gz", self.get_final_path() + "/" + pkgName + ".app.gpkg")
+		
+	
 	def make_package_debian(self, pkgName, pkgProperties, basePkgPath, heritage_list):
 		# http://alp.developpez.com/tutoriels/debian/creer-paquet/
 		debianPkgName = re.sub("_", "-", pkgName)
@@ -61,9 +230,9 @@ class Target(target.Target):
 		debug.info("Generate package '" + debianPkgName + "' v"+pkgProperties["VERSION"])
 		debug.debug("------------------------------------------------------------------------")
 		self.get_staging_path(pkgName)
-		targetOutpathDebian = self.get_staging_path(pkgName) + "/DEBIAN/"
+		target_outpathDebian = self.get_staging_path(pkgName) + "/DEBIAN/"
-		finalFileControl = targetOutpathDebian + "control"
+		finalFileControl = target_outpathDebian + "control"
-		finalFilepostRm = targetOutpathDebian + "postrm"
+		finalFilepostRm = target_outpathDebian + "postrm"
 		# create the paths :
 		tools.create_directory_of_file(finalFileControl)
 		tools.create_directory_of_file(finalFilepostRm)
@@ -186,30 +355,30 @@ class Target(target.Target):
 		debug.debug("------------------------------------------------------------------------")
 		debug.info("Generate generic '" + debianPkgName + "' v"+pkgProperties["VERSION"])
 		debug.debug("------------------------------------------------------------------------")
-		targetOutpath = self.get_staging_path(pkgName) + "/edn.app/"
+		target_outpath = self.get_staging_path(pkgName) + "/edn.app/"
-		tools.create_directory_of_file(targetOutpath)
+		tools.create_directory_of_file(target_outpath)
 		## Create version file
-		tmpFile = open(targetOutpath + "/version.txt", 'w')
+		tmpFile = open(target_outpath + "/version.txt", 'w')
 		tmpFile.write(pkgProperties["VERSION"])
 		tmpFile.flush()
 		tmpFile.close()
 		## Create maintainer file
-		tmpFile = open(targetOutpath + "/maintainer.txt", 'w')
+		tmpFile = open(target_outpath + "/maintainer.txt", 'w')
 		tmpFile.write(self.generate_list_separate_coma(pkgProperties["MAINTAINER"]))
 		tmpFile.flush()
 		tmpFile.close()
 		## Create appl_name file
-		tmpFile = open(targetOutpath + "/appl_name.txt", 'w')
+		tmpFile = open(target_outpath + "/appl_name.txt", 'w')
 		tmpFile.write("en_EN:" + pkgProperties["NAME"])
 		tmpFile.flush()
 		tmpFile.close()
 		## Create appl_description file
-		tmpFile = open(targetOutpath + "/appl_description.txt", 'w')
+		tmpFile = open(target_outpath + "/appl_description.txt", 'w')
 		tmpFile.write("en_EN:" + pkgProperties["DESCRIPTION"])
 		tmpFile.flush()
 		tmpFile.close()
 		## Create Readme file
-		readmeFileDest = targetOutpath + "/readme.txt"
+		readmeFileDest = target_outpath + "/readme.txt"
 		if os.path.exists(basePkgPath + "/os-Linux/README")==True:
 			tools.copy_file(basePkgPath + "/os-Linux/README", readmeFileDest)
 		elif os.path.exists(basePkgPath + "/README")==True:
@@ -223,7 +392,7 @@ class Target(target.Target):
 			tmpFile.flush()
 			tmpFile.close()
 		## Create licence file
-		licenseFileDest = targetOutpath + "/license/"+ debianPkgName + ".txt"
+		licenseFileDest = target_outpath + "/license/"+ debianPkgName + ".txt"
 		tools.create_directory_of_file(licenseFileDest)
 		if os.path.exists(basePkgPath + "/license.txt")==True:
 			tools.copy_file(basePkgPath + "/license.txt", licenseFileDest)
@@ -234,7 +403,7 @@ class Target(target.Target):
 			tmpFile.flush()
 			tmpFile.close()
 		## Create changeLog file
-		changeLogFileDest = targetOutpath + "/changelog.txt"
+		changeLogFileDest = target_outpath + "/changelog.txt"
 		if os.path.exists(basePkgPath + "/changelog") == True:
 			tools.copy_file(basePkgPath + "/changelog", changeLogFileDest)
 		else:
@@ -246,14 +415,13 @@ class Target(target.Target):
 		## copy share path
 		#debug.info("plop:" + self.get_staging_path(pkgName) + self.path_data)
 		if os.path.exists(self.get_staging_path(pkgName) + self.path_data) == True:
-			tools.copy_anything(self.get_staging_path(pkgName) + self.path_data + "/*", targetOutpath + self.path_data, recursive=True)
+			tools.copy_anything(self.get_staging_path(pkgName) + self.path_data + "/*", target_outpath + self.path_data, recursive=True)
 		
 		## Create binary path:
-		bin_path = targetOutpath + self.path_bin
+		bin_path = target_outpath + self.path_bin
 		#tools.create_directory_of_file(bin_path)
 		tools.copy_anything(self.get_staging_path(pkgName) + self.path_bin + "/*",
-		                    bin_path,
+		                    bin_path)
-		                    executable=True)
 		
 		## create the package:
 		debug.debug("package : " + self.get_staging_path(pkgName) + "/" + debianPkgName + ".app.pkg")