Announcement

Collapse
No announcement yet.

FreeBSD Still Working On Next-Gen Package Manager

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • FreeBSD Still Working On Next-Gen Package Manager

    Phoronix: FreeBSD Still Working On Next-Gen Package Manager

    The FreeBSD camp continues to develop pkgng, a next-generation binary package manager for the operating system...

    http://www.phoronix.com/vr.php?view=MTM3NTE

  • #2
    I tried it with PC BSD a while ago. Reminds me a bit of pacman, but it's not very good to be honest. Quite slow too.

    Comment


    • #3
      One could always use PC-BSD's repos while the FreeBSD rebuild is going on, instructions can be found in the "Switching to PC-BSD" section @ http://wiki.pcbsd.org/index.php/Turn...D_into_PC-BSDŽ

      If you have a quick machine, pkgng with poudriere is probably the best setup.

      Comment


      • #4
        If the BSDs get a decent binary package manager, I might switch to them from Arch.

        Comment


        • #5
          Originally posted by blackout23 View Post
          I tried it with PC BSD a while ago. Reminds me a bit of pacman, but it's not very good to be honest. Quite slow too.
          Not only that, but it's a ripoff and a violation of the GPL.

          http://aboutthebsds.wordpress.com/20...bians-apt-get/

          And it creates more problems then solutions. Package conflicts, views installed ports with custom compile options with outdated and tries to install standard ones and produces conflicts as it does.

          It's just an example of how little the devs at the BSD projects care about their uses.

          Originally posted by blackout23 View Post
          Reminds me a bit of pacman
          Which shows just how incapable BSD fucks are at coming up with original works which let them being sued by AT&T.

          Comment


          • #6
            Originally posted by a2r-l View Post
            If the BSDs get a decent binary package manager, I might switch to them from Arch.
            But pkgng is not a decent package manager, it's shit and cause more work. You'll be far better of staying with ArchLinux.

            Comment


            • #7
              Originally posted by i386reaper View Post
              Not only that, but it's a ripoff and a violation of the GPL.

              http://aboutthebsds.wordpress.com/20...bians-apt-get/

              And it creates more problems then solutions. Package conflicts, views installed ports with custom compile options with outdated and tries to install standard ones and produces conflicts as it does.

              It's just an example of how little the devs at the BSD projects care about their uses.



              Which shows just how incapable BSD fucks are at coming up with original works which let them being sued by AT&T.
              Watch it Reaper, keep a civil tongue in that mouth or the mods will step in. They've been putting up with the hatecomments less and less lately.

              Comment


              • #8
                Originally posted by rpmcmurphy View Post
                One could always use PC-BSD's repos while the FreeBSD rebuild is going on, instructions can be found in the "Switching to PC-BSD" section @ http://wiki.pcbsd.org/index.php/Turn...D_into_PC-BSDŽ
                That site talks nothing but shit that comes out of Kris Moore's mouth/ass. No sane person would ever take the time reading it.

                If you have a quick machine, pkgng with poudriere is probably the best setup.
                yeah, classic BSD apologist response to having no binary repository:
                http://aboutthebsds.wordpress.com/20...bians-apt-get/

                Comment


                • #9
                  Originally posted by Ericg View Post
                  Watch it Reaper, keep a civil tongue in that mouth or the mods will step in. They've been putting up with the hatecomments less and less lately.
                  These are not hate comments, they are facts and in phoronix forums, facts are respected unlike some other forums *cough*BSD forums*cough*.

                  Comment


                  • #10
                    Banned as LinuxAnalsBSD, BSDSucksDick, systemdrulez, OpenSLOWlaris and more I have forgotten, now back as i386reaper with the same moronic lies, linking to his own blog full of lies and accusations, guilty of accusing the OpenBSD developers to be the Boston Bombers and recently even accusing them to being part in the 9/11 attacks.

                    And still allowed to spread his hate here. Michael, can we get rid of this one already? The mods already know that this is one guy with many accounts, why are they not allowed to ban them all?

                    Comment


                    • #11
                      Originally posted by i386reaper View Post
                      These are not hate comments, they are facts and in phoronix forums, facts are respected unlike some other forums *cough*BSD forums*cough*.
                      It became a hatecomment when you called them "BSD Fucks." Keep it civil.

                      Comment


                      • #12
                        even if that would be true at least the contribute to the open source world. Now let us see your contributions, hopefully released under the GPL. If I remember correctly in one of your previous accounts on Phoronix you claimed to be a software developer, so you surely have something to show, don't you?

                        Comment


                        • #13
                          Originally posted by i386reaper View Post
                          Not only that, but it's a ripoff and a violation of the GPL.

                          http://aboutthebsds.wordpress.com/20...bians-apt-get/

                          And it creates more problems then solutions. Package conflicts, views installed ports with custom compile options with outdated and tries to install standard ones and produces conflicts as it does.

                          It's just an example of how little the devs at the BSD projects care about their uses.



                          Which shows just how incapable BSD fucks are at coming up with original works which let them being sued by AT&T.
                          This thread is now in the most popular list, thanks to you! Keep it up so more people can find out what's new in FreeBSD. Thanks!

                          Comment


                          • #14
                            Obviously, someone doesn't even know how to read basic C, let alone how to compare it to C++...there is no justification for confusing this:
                            Code:
                            // TryToInstall - Mark a package for installation			/*{{{*/
                            struct TryToInstall {
                               pkgCacheFile* Cache;
                               pkgProblemResolver* Fix;
                               bool FixBroken;
                               unsigned long AutoMarkChanged;
                               APT::PackageSet doAutoInstallLater;
                            
                               TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
                            			FixBroken(FixBroken), AutoMarkChanged(0) {};
                            
                               void operator() (pkgCache::VerIterator const &Ver) {
                                  pkgCache::PkgIterator Pkg = Ver.ParentPkg();
                            
                                  Cache->GetDepCache()->SetCandidateVersion(Ver);
                                  pkgDepCache::StateCache &State = (*Cache)[Pkg];
                            
                                  // Handle the no-upgrade case
                                  if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
                            	 ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
                            		  Pkg.FullName(true).c_str());
                                  // Ignore request for install if package would be new
                                  else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
                            	 ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
                            		  Pkg.FullName(true).c_str());
                                  else {
                            	 if (Fix != NULL) {
                            	    Fix->Clear(Pkg);
                            	    Fix->Protect(Pkg);
                            	 }
                            	 Cache->GetDepCache()->MarkInstall(Pkg,false);
                            
                            	 if (State.Install() == false) {
                            	    if (_config->FindB("APT::Get::ReInstall",false) == true) {
                            	       if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
                            		  ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
                            			   Pkg.FullName(true).c_str());
                            	       else
                            		  Cache->GetDepCache()->SetReInstall(Pkg, true);
                            	    } else
                            	       ioprintf(c1out,_("%s is already the newest version.\n"),
                            			Pkg.FullName(true).c_str());
                            	 }
                            
                            	 // Install it with autoinstalling enabled (if we not respect the minial
                            	 // required deps or the policy)
                            	 if (FixBroken == false)
                            	    doAutoInstallLater.insert(Pkg);
                                  }
                            
                                  // see if we need to fix the auto-mark flag
                                  // e.g. apt-get install foo
                                  // where foo is marked automatic
                                  if (State.Install() == false &&
                            	  (State.Flags & pkgCache::Flag::Auto) &&
                            	  _config->FindB("APT::Get::ReInstall",false) == false &&
                            	  _config->FindB("APT::Get::Only-Upgrade",false) == false &&
                            	  _config->FindB("APT::Get::Download-Only",false) == false)
                                  {
                            	 ioprintf(c1out,_("%s set to manually installed.\n"),
                            		  Pkg.FullName(true).c_str());
                            	 Cache->GetDepCache()->MarkAuto(Pkg,false);
                            	 AutoMarkChanged++;
                                  }
                               }
                            with this:
                            Code:
                            int
                            pkg_add(struct pkgdb *db, const char *path, unsigned flags, struct pkg_manifest_key *keys)
                            {
                            	const char	*arch;
                            	const char	*myarch;
                            	const char	*origin;
                            	const char	*name;
                            	struct archive	*a;
                            	struct archive_entry *ae;
                            	struct pkg	*pkg = NULL;
                            	struct pkg_dep	*dep = NULL;
                            	struct pkg      *pkg_inst = NULL;
                            	bool		 extract = true;
                            	bool		 handle_rc = false;
                            	char		 dpath[MAXPATHLEN + 1];
                            	const char	*basedir;
                            	const char	*ext;
                            	char		*mtree;
                            	char		*prefix;
                            	int		 retcode = EPKG_OK;
                            	int		 ret;
                            
                            	assert(path != NULL);
                            
                            	/*
                            	 * Open the package archive file, read all the meta files and set the
                            	 * current archive_entry to the first non-meta file.
                            	 * If there is no non-meta files, EPKG_END is returned.
                            	 */
                            	ret = pkg_open2(&pkg, &a, &ae, path, keys, 0);
                            	if (ret == EPKG_END)
                            		extract = false;
                            	else if (ret != EPKG_OK) {
                            		retcode = ret;
                            		goto cleanup;
                            	}
                            	if ((flags & PKG_ADD_UPGRADE) == 0)
                            		pkg_emit_install_begin(pkg);
                            
                            	if (pkg_is_valid(pkg) != EPKG_OK) {
                            		pkg_emit_error("the package is not valid");
                            		return (EPKG_FATAL);
                            	}
                            
                            	if (flags & PKG_ADD_AUTOMATIC)
                            		pkg_set(pkg, PKG_AUTOMATIC, (int64_t)true);
                            
                            	/*
                            	 * Check the architecture
                            	 */
                            
                            	pkg_config_string(PKG_CONFIG_ABI, &myarch);
                            	pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin, PKG_NAME, &name);
                            
                            	if (fnmatch(myarch, arch, FNM_CASEFOLD) == FNM_NOMATCH &&
                            	    strncmp(arch, myarch, strlen(myarch)) != 0) {
                            		pkg_emit_error("wrong architecture: %s instead of %s",
                            		    arch, myarch);
                            		if ((flags & PKG_ADD_FORCE) == 0) {
                            			retcode = EPKG_FATAL;
                            			goto cleanup;
                            		}
                            	}
                            
                            	/*
                            	 * Check if the package is already installed
                            	 */
                            
                            	ret = pkg_try_installed(db, origin, &pkg_inst, PKG_LOAD_BASIC);
                            	if (ret == EPKG_OK) {
                            		if ((flags & PKG_FLAG_FORCE) == 0) {
                            			pkg_emit_already_installed(pkg_inst);
                            			retcode = EPKG_INSTALLED;
                            			pkg_free(pkg_inst);
                            			goto cleanup;
                            		}
                            		else {
                            			pkg_emit_notice("package %s is already installed, forced install", name);
                            			pkg_free(pkg_inst);
                            		}
                            	} else if (ret != EPKG_END) {
                            		retcode = ret;
                            		goto cleanup;
                            	}
                            
                            	/*
                            	 * Check for dependencies
                            	 */
                            
                            	basedir = dirname(path);
                            	if ((ext = strrchr(path, '.')) == NULL) {
                            		pkg_emit_error("%s has no extension", path);
                            		retcode = EPKG_FATAL;
                            		goto cleanup;
                            	}
                            
                            	while (pkg_deps(pkg, &dep) == EPKG_OK) {
                            		if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) {
                            			const char *dep_name = pkg_dep_name(dep);
                            			const char *dep_ver = pkg_dep_version(dep);
                            
                            			snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
                            			    dep_name, dep_ver, ext);
                            
                            			if ((flags & PKG_ADD_UPGRADE) == 0 &&
                            			    access(dpath, F_OK) == 0) {
                            				ret = pkg_add(db, dpath, PKG_ADD_AUTOMATIC, keys);
                            				if (ret != EPKG_OK) {
                            					retcode = EPKG_FATAL;
                            					goto cleanup;
                            				}
                            			} else {
                            				retcode = EPKG_FATAL;
                            				pkg_emit_missing_dep(pkg, dep);
                            				goto cleanup;
                            			}
                            		}
                            	}
                            
                            	/* register the package before installing it in case there are
                            	 * problems that could be caught here. */
                            	retcode = pkgdb_register_pkg(db, pkg, flags & PKG_ADD_UPGRADE, flags & PKG_FLAG_FORCE);
                            
                            	if (retcode != EPKG_OK)
                            		goto cleanup;
                            
                            	pkg_get(pkg, PKG_PREFIX, &prefix, PKG_MTREE, &mtree);
                            	if ((retcode = do_extract_mtree(mtree, prefix)) != EPKG_OK)
                            		goto cleanup_reg;
                            
                            	/*
                            	 * Execute pre-install scripts
                            	 */
                            	if ((flags & (PKG_ADD_NOSCRIPT | PKG_ADD_USE_UPGRADE_SCRIPTS)) == 0)
                            		pkg_script_run(pkg, PKG_SCRIPT_PRE_INSTALL);
                            
                            	/* add the user and group if necessary */
                            	/* pkg_add_user_group(pkg); */
                            
                            	/*
                            	 * Extract the files on disk.
                            	 */
                            	if (extract && (retcode = do_extract(a, ae)) != EPKG_OK) {
                            		/* If the add failed, clean up */
                            		pkg_delete_files(pkg, 1);
                            		pkg_delete_dirs(db, pkg, 1);
                            		goto cleanup_reg;
                            	}
                            
                            	/*
                            	 * Execute post install scripts
                            	 */
                            	if ((flags & PKG_ADD_NOSCRIPT) == 0) {
                            		if (flags & PKG_ADD_USE_UPGRADE_SCRIPTS)
                            			pkg_script_run(pkg, PKG_SCRIPT_POST_UPGRADE);
                            		else
                            			pkg_script_run(pkg, PKG_SCRIPT_POST_INSTALL);
                            	}
                            
                            	/*
                            	 * start the different related services if the users do want that
                            	 * and that the service is running
                            	 */
                            
                            	pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
                            	if (handle_rc)
                            		pkg_start_stop_rc_scripts(pkg, PKG_RC_START);
                            
                            	cleanup_reg:
                            	if ((flags & PKG_ADD_UPGRADE) == 0)
                            		pkgdb_register_finale(db, retcode);
                            
                            	if (retcode == EPKG_OK && (flags & PKG_ADD_UPGRADE) == 0)
                            		pkg_emit_install_finished(pkg);
                            
                            	cleanup:
                            	if (a != NULL)
                            		archive_read_free(a);
                            
                            	pkg_free(pkg);
                            	pkg_free(pkg_inst);
                            
                            	return (retcode);
                            }
                            Those are the two most comparable sections in apt and pkgng, AFAICT.
                            Anyhow, I wonder why i386reaper hasn't reported this purported GPL violation to the copyright holders, if he actually believes what he's saying.

                            Comment


                            • #15
                              Originally posted by Ibidem View Post
                              Obviously, someone doesn't even know how to read basic C, let alone how to compare it to C++...there is no justification for confusing this:
                              Code:
                              // TryToInstall - Mark a package for installation			/*{{{*/
                              struct TryToInstall {
                                 pkgCacheFile* Cache;
                                 pkgProblemResolver* Fix;
                                 bool FixBroken;
                                 unsigned long AutoMarkChanged;
                                 APT::PackageSet doAutoInstallLater;
                              
                                 TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
                              			FixBroken(FixBroken), AutoMarkChanged(0) {};
                              
                                 void operator() (pkgCache::VerIterator const &Ver) {
                                    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
                              
                                    Cache->GetDepCache()->SetCandidateVersion(Ver);
                                    pkgDepCache::StateCache &State = (*Cache)[Pkg];
                              
                                    // Handle the no-upgrade case
                                    if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
                              	 ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
                              		  Pkg.FullName(true).c_str());
                                    // Ignore request for install if package would be new
                                    else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
                              	 ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
                              		  Pkg.FullName(true).c_str());
                                    else {
                              	 if (Fix != NULL) {
                              	    Fix->Clear(Pkg);
                              	    Fix->Protect(Pkg);
                              	 }
                              	 Cache->GetDepCache()->MarkInstall(Pkg,false);
                              
                              	 if (State.Install() == false) {
                              	    if (_config->FindB("APT::Get::ReInstall",false) == true) {
                              	       if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
                              		  ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
                              			   Pkg.FullName(true).c_str());
                              	       else
                              		  Cache->GetDepCache()->SetReInstall(Pkg, true);
                              	    } else
                              	       ioprintf(c1out,_("%s is already the newest version.\n"),
                              			Pkg.FullName(true).c_str());
                              	 }
                              
                              	 // Install it with autoinstalling enabled (if we not respect the minial
                              	 // required deps or the policy)
                              	 if (FixBroken == false)
                              	    doAutoInstallLater.insert(Pkg);
                                    }
                              
                                    // see if we need to fix the auto-mark flag
                                    // e.g. apt-get install foo
                                    // where foo is marked automatic
                                    if (State.Install() == false &&
                              	  (State.Flags & pkgCache::Flag::Auto) &&
                              	  _config->FindB("APT::Get::ReInstall",false) == false &&
                              	  _config->FindB("APT::Get::Only-Upgrade",false) == false &&
                              	  _config->FindB("APT::Get::Download-Only",false) == false)
                                    {
                              	 ioprintf(c1out,_("%s set to manually installed.\n"),
                              		  Pkg.FullName(true).c_str());
                              	 Cache->GetDepCache()->MarkAuto(Pkg,false);
                              	 AutoMarkChanged++;
                                    }
                                 }
                              with this:
                              Code:
                              int
                              pkg_add(struct pkgdb *db, const char *path, unsigned flags, struct pkg_manifest_key *keys)
                              {
                              	const char	*arch;
                              	const char	*myarch;
                              	const char	*origin;
                              	const char	*name;
                              	struct archive	*a;
                              	struct archive_entry *ae;
                              	struct pkg	*pkg = NULL;
                              	struct pkg_dep	*dep = NULL;
                              	struct pkg      *pkg_inst = NULL;
                              	bool		 extract = true;
                              	bool		 handle_rc = false;
                              	char		 dpath[MAXPATHLEN + 1];
                              	const char	*basedir;
                              	const char	*ext;
                              	char		*mtree;
                              	char		*prefix;
                              	int		 retcode = EPKG_OK;
                              	int		 ret;
                              
                              	assert(path != NULL);
                              
                              	/*
                              	 * Open the package archive file, read all the meta files and set the
                              	 * current archive_entry to the first non-meta file.
                              	 * If there is no non-meta files, EPKG_END is returned.
                              	 */
                              	ret = pkg_open2(&pkg, &a, &ae, path, keys, 0);
                              	if (ret == EPKG_END)
                              		extract = false;
                              	else if (ret != EPKG_OK) {
                              		retcode = ret;
                              		goto cleanup;
                              	}
                              	if ((flags & PKG_ADD_UPGRADE) == 0)
                              		pkg_emit_install_begin(pkg);
                              
                              	if (pkg_is_valid(pkg) != EPKG_OK) {
                              		pkg_emit_error("the package is not valid");
                              		return (EPKG_FATAL);
                              	}
                              
                              	if (flags & PKG_ADD_AUTOMATIC)
                              		pkg_set(pkg, PKG_AUTOMATIC, (int64_t)true);
                              
                              	/*
                              	 * Check the architecture
                              	 */
                              
                              	pkg_config_string(PKG_CONFIG_ABI, &myarch);
                              	pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin, PKG_NAME, &name);
                              
                              	if (fnmatch(myarch, arch, FNM_CASEFOLD) == FNM_NOMATCH &&
                              	    strncmp(arch, myarch, strlen(myarch)) != 0) {
                              		pkg_emit_error("wrong architecture: %s instead of %s",
                              		    arch, myarch);
                              		if ((flags & PKG_ADD_FORCE) == 0) {
                              			retcode = EPKG_FATAL;
                              			goto cleanup;
                              		}
                              	}
                              
                              	/*
                              	 * Check if the package is already installed
                              	 */
                              
                              	ret = pkg_try_installed(db, origin, &pkg_inst, PKG_LOAD_BASIC);
                              	if (ret == EPKG_OK) {
                              		if ((flags & PKG_FLAG_FORCE) == 0) {
                              			pkg_emit_already_installed(pkg_inst);
                              			retcode = EPKG_INSTALLED;
                              			pkg_free(pkg_inst);
                              			goto cleanup;
                              		}
                              		else {
                              			pkg_emit_notice("package %s is already installed, forced install", name);
                              			pkg_free(pkg_inst);
                              		}
                              	} else if (ret != EPKG_END) {
                              		retcode = ret;
                              		goto cleanup;
                              	}
                              
                              	/*
                              	 * Check for dependencies
                              	 */
                              
                              	basedir = dirname(path);
                              	if ((ext = strrchr(path, '.')) == NULL) {
                              		pkg_emit_error("%s has no extension", path);
                              		retcode = EPKG_FATAL;
                              		goto cleanup;
                              	}
                              
                              	while (pkg_deps(pkg, &dep) == EPKG_OK) {
                              		if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) {
                              			const char *dep_name = pkg_dep_name(dep);
                              			const char *dep_ver = pkg_dep_version(dep);
                              
                              			snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
                              			    dep_name, dep_ver, ext);
                              
                              			if ((flags & PKG_ADD_UPGRADE) == 0 &&
                              			    access(dpath, F_OK) == 0) {
                              				ret = pkg_add(db, dpath, PKG_ADD_AUTOMATIC, keys);
                              				if (ret != EPKG_OK) {
                              					retcode = EPKG_FATAL;
                              					goto cleanup;
                              				}
                              			} else {
                              				retcode = EPKG_FATAL;
                              				pkg_emit_missing_dep(pkg, dep);
                              				goto cleanup;
                              			}
                              		}
                              	}
                              
                              	/* register the package before installing it in case there are
                              	 * problems that could be caught here. */
                              	retcode = pkgdb_register_pkg(db, pkg, flags & PKG_ADD_UPGRADE, flags & PKG_FLAG_FORCE);
                              
                              	if (retcode != EPKG_OK)
                              		goto cleanup;
                              
                              	pkg_get(pkg, PKG_PREFIX, &prefix, PKG_MTREE, &mtree);
                              	if ((retcode = do_extract_mtree(mtree, prefix)) != EPKG_OK)
                              		goto cleanup_reg;
                              
                              	/*
                              	 * Execute pre-install scripts
                              	 */
                              	if ((flags & (PKG_ADD_NOSCRIPT | PKG_ADD_USE_UPGRADE_SCRIPTS)) == 0)
                              		pkg_script_run(pkg, PKG_SCRIPT_PRE_INSTALL);
                              
                              	/* add the user and group if necessary */
                              	/* pkg_add_user_group(pkg); */
                              
                              	/*
                              	 * Extract the files on disk.
                              	 */
                              	if (extract && (retcode = do_extract(a, ae)) != EPKG_OK) {
                              		/* If the add failed, clean up */
                              		pkg_delete_files(pkg, 1);
                              		pkg_delete_dirs(db, pkg, 1);
                              		goto cleanup_reg;
                              	}
                              
                              	/*
                              	 * Execute post install scripts
                              	 */
                              	if ((flags & PKG_ADD_NOSCRIPT) == 0) {
                              		if (flags & PKG_ADD_USE_UPGRADE_SCRIPTS)
                              			pkg_script_run(pkg, PKG_SCRIPT_POST_UPGRADE);
                              		else
                              			pkg_script_run(pkg, PKG_SCRIPT_POST_INSTALL);
                              	}
                              
                              	/*
                              	 * start the different related services if the users do want that
                              	 * and that the service is running
                              	 */
                              
                              	pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
                              	if (handle_rc)
                              		pkg_start_stop_rc_scripts(pkg, PKG_RC_START);
                              
                              	cleanup_reg:
                              	if ((flags & PKG_ADD_UPGRADE) == 0)
                              		pkgdb_register_finale(db, retcode);
                              
                              	if (retcode == EPKG_OK && (flags & PKG_ADD_UPGRADE) == 0)
                              		pkg_emit_install_finished(pkg);
                              
                              	cleanup:
                              	if (a != NULL)
                              		archive_read_free(a);
                              
                              	pkg_free(pkg);
                              	pkg_free(pkg_inst);
                              
                              	return (retcode);
                              }
                              Those are the two most comparable sections in apt and pkgng, AFAICT.
                              Anyhow, I wonder why i386reaper hasn't reported this purported GPL violation to the copyright holders, if he actually believes what he's saying.
                              I'm a little upset at how much nicer the pkgng code looks compared to the apt-get sources >.> Maybe apt-get could use a good spring cleaning & refactoring to clean it up

                              Comment

                              Working...
                              X