Announcement

Collapse
No announcement yet.

FreeBSD Still Working On Next-Gen Package Manager

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

  • #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.
    All opinions are my own not those of my employer if you know who they are.

    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
            All opinions are my own not those of my employer if you know who they are.

            Comment


            • #16
              Originally posted by Vim_User View Post
              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?
              Every good Linux developer knows to use git; it's written by Torvalds and is what the kernel, systemd, X, util-linux, and many other key packages use. SVN is Apache (permissive), and CVS is a lame solution used by BSD distros with a BSD-licensed clone. And Bazaar is a Canonical project.
              So I would expect to see his github/repo.or.cz/gitorious/kernel.org account, which should have most of the projects...

              Comment


              • #17
                Originally posted by Ericg View Post
                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
                I hate to say it, but I agree. About the elegance of the code, that is. As for spring cleaning apt-get, there's the Raptorial project that a Debian derivative was working, that sounded really promising. I think replacing apt-get altogether might be the more interesting approach.

                Comment


                • #18
                  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.
                  That's only a small section of the codes, you can't just conclusion at the whole thing is different all because a tiny section doesn't match.

                  Comment


                  • #19
                    Originally posted by Ibidem View Post
                    Every good Linux developer knows to use git; it's written by Torvalds and is what the kernel, systemd, X, util-linux, and many other key packages use. SVN is Apache (permissive), and CVS is a lame solution used by BSD distros with a BSD-licensed clone. And Bazaar is a Canonical project.
                    So I would expect to see his github/repo.or.cz/gitorious/kernel.org account, which should have most of the projects...
                    That's why Git is better then SVN or CVS or especially OpenCVS. Those who don't use Git are mentality insane.

                    Comment


                    • #20
                      Originally posted by Ericg View Post
                      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
                      Are you fucking me ?

                      The pkgng is clearly more bloated (more SLOC) and it looks like it's been written by a bunch of kids with down syndrome.

                      It clearly does doesn't make use of the advance memory management offered by C with apt-get does. No wander why pkgng and all things BSD are slower then apt-get and Linux.

                      That's why blackout23 is correct, PKGN(OT)G(OOD) is so much slower that every Linux package manager.

                      Just goes to show how shitty BSD fucks are at programming. As what kraftman said about them:

                      What a bunch of crap
                      Last edited by i386reaper; 21 May 2013, 06:43 AM.

                      Comment

                      Working...
                      X