示例#1
0
    def __mount_iso(self, filename):

        fromPath = os.path.join(self.temp_path, "aptoncd-mnt-image/")
        print "mount point = ", fromPath
        print "iso image = ", filename
        utils.mkdir(fromPath, True)

        command = (
            "gksu --desktop "
            + constants.DESKTOP_FILE
            + " 'mount -o loop %s %s'" % (filename.replace(" ", "\ "), fromPath.replace(" ", "\ "))
        )
        ret = utils.run_command(command)

        # wait a few seconds so mount would complete
        time.sleep(0.1)

        result, msgError = self.is_aptoncd_media(fromPath)
        if not result:
            self.__umount_iso(fromPath)
            return False, msgError
        else:
            return True, fromPath
示例#2
0
 def scan_packages(self, isoFileList, tmpdir):
     
     self.time_start = 1
     self.steps.set_current(1)
     self.progress.update_progress(0)
     self.progress.progress_widget.set_text( '')
     self.progress.progress_text = constants.MESSAGE_0019
     gui.processEvents()
     
     for cds in isoFileList.keys():
         #cd destination folder
         media_folder_name = self.values['media_type'] + str(cds)
         
         current_msg = constants.MESSAGE_0021 + ' (' + media_folder_name + ')'
         self.steps.set_current_text(1,current_msg )
         
         tmpmetapackageDir = utils.join_path(tmpdir , 'metapackage/' + media_folder_name)
         tmppackages = utils.join_path(tmpdir , 'packages')
     
         destination = utils.join_path(tmppackages, media_folder_name)
         pkg_destination = utils.join_path(destination , 'packages')
         
         controlFile =  utils.join_path(tmpmetapackageDir, 'DEBIAN/control')
         #create the deb file for metapackage
         if self.values['createmeta']:
             command = 'dpkg-deb -b %s  %s > /dev/null 2> /dev/null' % \
                     (tmpmetapackageDir.replace(' ','\ '), utils.join_path(pkg_destination.replace(' ','\ '), self.mPack.get_mtFileName()) )
             result = utils.run_command(command)
             #remove the file needed to create the metapackage
             utils.del_file(controlFile)
         
         packages_files = utils.join_path(destination.replace(' ','\ ') , 'Packages')
         command = 'apt-ftparchive packages packages/'
         if self.progress.cancel_status:
             errorMsg = constants.MESSAGE_0027
             return False, errorMsg
                 
         apt_ftp = AptFtpArchive()
         self.progress.stop = 100
         apt_ftp.set_progress_hook(self.on_update)
         apt_ftp.execute(command, destination, packages_files)
         if self.progress.cancel_status:
             errorMsg = constants.MESSAGE_0027
             return False, errorMsg
                 
         #creates a tar file using bz2 compression
         result, path = utils.compress(packages_files)
         result, msg = utils.zip_file(utils.join_path(destination,'Packages.gz'), utils.join_path(destination,'Packages'))
         
         packages_files = utils.join_path(destination.replace(' ','\ ') , 'Release')
         command = 'apt-ftparchive release  .'
         apt_ftp.set_progress_hook(self.on_update)
         apt_ftp.execute(command, destination, packages_files)
         if self.progress.cancel_status:
             errorMsg = constants.MESSAGE_0027
             return False, errorMsg
                 
         #Create aptoncd.inf file
         infoFile = utils.join_path(destination, 'aptoncd.info')
         info = mediainfo.MediaInfo(infoFile)
         info.write()
         if self.progress.cancel_status:
             errorMsg = constants.MESSAGE_0027
             return False, errorMsg
         #Creates .disk/info
         diskinfodir = utils.join_path(destination ,'.disk')
         utils.mkdir(diskinfodir, True)
         infoDiskFile = utils.join_path(diskinfodir,'info')
         infoDisk = mediainfo.aptDiskInfo(infoDiskFile, media_folder_name)
         infoDisk.write()
         
         #write README.diskdefines
         infoDiskDefinesFile = utils.join_path(destination, 'README.diskdefines')
         infoDiskDefines = mediainfo.aptDiskDefines(infoDiskDefinesFile,media_folder_name)
         infoDiskDefines.write()
         
         gui.processEvents()
         
         utils.removePath(tmpmetapackageDir)
         
     self.progress.cancel_pulse()
     self.steps.set_current_text(1,constants.MESSAGE_0021)
     self.steps.set_done(1)
     self.progress.update_progress(0)
     return True, None
示例#3
0
    def create_aptoncd(self):
        
        #this will hold error information.
        errorMsg = ""
        
        self.progress = ProgressDialog(self.get_main_window())
        self.progress.can_cancel_progress = True
        self.progress.title = constants.MESSAGE_0024 
        self.progress.description = constants.MESSAGE_0025 

        #defines the steps to create this iso.
        process = [constants.MESSAGE_0020, constants.MESSAGE_0021, \
                   constants.MESSAGE_0022, constants.MESSAGE_0023]
        self.steps = stepswidget.ProgressSteps(process)
        self.progress.add_widget(self.steps)
        
        #set temp variables for packages locations
        tmpdir = utils.join_path(self.temp_path, 'aptoncd') #"/tmp/aptoncd/"
        tmpmetapackageDir = utils.join_path(tmpdir , 'metapackage')
        tmppackages = utils.join_path(tmpdir , 'packages')
        
        #creates a temporary location to work with .deb files
        utils.mkdir(tmpdir, True)
        
        #get what files will be on each cd
        if self.values['media_type'] == 'CD':
            isoFileList = self.CreateIsoList(constants.CD)
        else:
            isoFileList = self.CreateIsoList(constants.DVD)
        #we will starting changing here to break process in parts
        # first, copy files from cds to locations
        
        result, msg = self.copy_files(isoFileList,tmpdir)
        # the user clicked cancel button
        if not result :
            self.get_main_window().set_sensitive(True)
            return False
            
        result, msg = self.scan_packages(isoFileList,tmpdir)
        if not result :
            self.get_main_window().set_sensitive(True)
            return False 
        
        self.create_iso(isoFileList,tmpdir)
        
        self.steps.set_current(3)
        gui.processEvents()
        #clean folders created previously    
        utils.removePath(tmpdir)
        self.steps.set_done(3)
        
        burn_list = {}
        index=0
        for indx, burns in enumerate(utils.get_burn_applications(constants.BURNS_DATA)):
        	item = utils.whereis(burns[0])
        	
        	if item:
        		burn_list[index]= { 'name':burns[0], 'location':item , 'parameter':burns[1]}
        		index += 1
        		        
        if index >= 1:
        	dlgburn = FinishedDialog(self, burn_list)
        	self.progress.destroy()
        	result, index = dlgburn.run()
        	
        	if result == 1:
        		for iso in self.isos:
        			command = burn_list[index]['location'] + ' '+ burn_list[index]['parameter'] + iso + ' &'
        			utils.run_command(command)
        	dlgburn.destroy()  
        
        self.get_main_window().set_sensitive(True)
        
        self.main_window = gui.get_glade(constants.MAIN_GUI, 'main')
        self.notebook = gui.get_widget(self.main_window, 'notebook')
        self.notebook.set_current_page(0)
示例#4
0
    def copy_files(self, isoFileList, tmpdir):
        """
            this will copy each package from every cd to the destination.
        """
        self.controlFile = {}
        #start mounting the cd/dvd layout
        for cds in isoFileList.keys():
            #show the first step in bold with an arrow at its left
            self.steps.set_current(0)
            media_folder_name = self.values['media_type'] + str(cds)
            current_msg = constants.MESSAGE_0020 + ' (' + media_folder_name + ')'
            self.steps.set_current_text(0,current_msg )
            self.progress.progress_text = constants.MESSAGE_0002
            
            tmpmetapackageDir = utils.join_path(tmpdir , 'metapackage/' + media_folder_name)
            tmppackages = utils.join_path(tmpdir , 'packages')

            #if we are creating a metapackage
            #we must create a DEBIAN folder
            print 'Create Meta:', self.values['createmeta']
            if self.values['createmeta']:
                utils.mkdir(utils.join_path(tmpmetapackageDir, 'DEBIAN'),True)
                controlFile =  utils.join_path(tmpmetapackageDir, 'DEBIAN/control')
                utils.del_file(controlFile)
                self.mPack = MetaPackage(controlFile)
            else:
                utils.removePath(tmpmetapackageDir )
                
            #cd destination folder
            destination = utils.join_path(tmppackages, media_folder_name)
            utils.mkdir(destination, True)
            
            #destination for each package inside this media
            pkg_destination = utils.join_path(destination , 'packages')
            utils.mkdir(pkg_destination, True)
            
            #start to copy files from source to destination
            self.progress.stop = len(isoFileList[cds])
            
            for index, pkg in enumerate(isoFileList[cds]):
                #update the progress bar
                self.progress.update_progress(index + 1)
                
                #if we must create metapackage we will add this
                #package to the meta list
                if self.values['createmeta']:
                    self.mPack.appendPackage(pkg.package)
                
                #set the folder destination of the package
                filedestination = utils.join_path(pkg_destination, pkg.deb_filename)
                
                #if user has canceled
                #stop iterating
                if self.progress.cancel_status:
                    errorMsg = constants.MESSAGE_0027
                    return False, errorMsg
                
                #copy file to destination
                pkg.copy_to(filedestination )
                
                #update the progress message
                self.progress.progress_text = constants.MESSAGE_0029 % pkg.package
                gui.processEvents()
            
            #close the packfile for this cd
            if self.values['createmeta']:
                self.mPack.write()
                
        #update processes
        #marking first as done and starting a new one
        self.steps.set_current_text(0,constants.MESSAGE_0020)
        self.steps.set_done(0)
            
        return True, None